kernel/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 #include "intlist.h"
  19 #include "header.h"
  20
  21 #include <elf.h>
  22 #include <limits.h>
  23 #include <symbol/kallsyms.h>
  24 #include <sys/utsname.h>
  25
  26 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
  27                                 symbol_filter_t filter);
  28 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
  29                         symbol_filter_t filter);
  30 int vmlinux_path__nr_entries;
  31 char **vmlinux_path;
  32
  33 struct symbol_conf symbol_conf = {
  34         .use_modules            = true,
  35         .try_vmlinux_path       = true,
  36         .annotate_src           = true,
  37         .demangle               = true,
  38         .demangle_kernel        = false,
  39         .cumulate_callchain     = true,
  40         .show_hist_headers      = true,
  41         .symfs                  = "",
  42 };
  43
  44 static enum dso_binary_type binary_type_symtab[] = {
  45         DSO_BINARY_TYPE__KALLSYMS,
  46         DSO_BINARY_TYPE__GUEST_KALLSYMS,
  47         DSO_BINARY_TYPE__JAVA_JIT,
  48         DSO_BINARY_TYPE__DEBUGLINK,
  49         DSO_BINARY_TYPE__BUILD_ID_CACHE,
  50         DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
  51         DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
  52         DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
  53         DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
  54         DSO_BINARY_TYPE__GUEST_KMODULE,
  55         DSO_BINARY_TYPE__GUEST_KMODULE_COMP,
  56         DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
  57         DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP,
  58         DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
  59         DSO_BINARY_TYPE__NOT_FOUND,
  60 };
  61
  62 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
  63
  64 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
  65 {
  66         symbol_type = toupper(symbol_type);
  67
  68         switch (map_type) {
  69         case MAP__FUNCTION:
  70                 return symbol_type == 'T' || symbol_type == 'W';
  71         case MAP__VARIABLE:
  72                 return symbol_type == 'D';
  73         default:
  74                 return false;
  75         }
  76 }
  77
  78 static int prefix_underscores_count(const char *str)
  79 {
  80         const char *tail = str;
  81
  82         while (*tail == '_')
  83                 tail++;
  84
  85         return tail - str;
  86 }
  87
  88 #define SYMBOL_A 0
  89 #define SYMBOL_B 1
  90
  91 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
  92 {
  93         s64 a;
  94         s64 b;
  95         size_t na, nb;
  96
  97         /* Prefer a symbol with non zero length */
  98         a = syma->end - syma->start;
  99         b = symb->end - symb->start;
 100         if ((b == 0) && (a > 0))
 101                 return SYMBOL_A;
 102         else if ((a == 0) && (b > 0))
 103                 return SYMBOL_B;
 104
 105         /* Prefer a non weak symbol over a weak one */
 106         a = syma->binding == STB_WEAK;
 107         b = symb->binding == STB_WEAK;
 108         if (b && !a)
 109                 return SYMBOL_A;
 110         if (a && !b)
 111                 return SYMBOL_B;
 112
 113         /* Prefer a global symbol over a non global one */
 114         a = syma->binding == STB_GLOBAL;
 115         b = symb->binding == STB_GLOBAL;
 116         if (a && !b)
 117                 return SYMBOL_A;
 118         if (b && !a)
 119                 return SYMBOL_B;
 120
 121         /* Prefer a symbol with less underscores */
 122         a = prefix_underscores_count(syma->name);
 123         b = prefix_underscores_count(symb->name);
 124         if (b > a)
 125                 return SYMBOL_A;
 126         else if (a > b)
 127                 return SYMBOL_B;
 128
 129         /* Choose the symbol with the longest name */
 130         na = strlen(syma->name);
 131         nb = strlen(symb->name);
 132         if (na > nb)
 133                 return SYMBOL_A;
 134         else if (na < nb)
 135                 return SYMBOL_B;
 136
 137         /* Avoid "SyS" kernel syscall aliases */
 138         if (na >= 3 && !strncmp(syma->name, "SyS", 3))
 139                 return SYMBOL_B;
 140         if (na >= 10 && !strncmp(syma->name, "compat_SyS", 10))
 141                 return SYMBOL_B;
 142
 143         return SYMBOL_A;
 144 }
 145
 146 void symbols__fixup_duplicate(struct rb_root *symbols)
 147 {
 148         struct rb_node *nd;
 149         struct symbol *curr, *next;
 150
 151         nd = rb_first(symbols);
 152
 153         while (nd) {
 154                 curr = rb_entry(nd, struct symbol, rb_node);
 155 again:
 156                 nd = rb_next(&curr->rb_node);
 157                 next = rb_entry(nd, struct symbol, rb_node);
 158
 159                 if (!nd)
 160                         break;
 161
 162                 if (curr->start != next->start)
 163                         continue;
 164
 165                 if (choose_best_symbol(curr, next) == SYMBOL_A) {
 166                         rb_erase(&next->rb_node, symbols);
 167                         symbol__delete(next);
 168                         goto again;
 169                 } else {
 170                         nd = rb_next(&curr->rb_node);
 171                         rb_erase(&curr->rb_node, symbols);
 172                         symbol__delete(curr);
 173                 }
 174         }
 175 }
 176
 177 void symbols__fixup_end(struct rb_root *symbols)
 178 {
 179         struct rb_node *nd, *prevnd = rb_first(symbols);
 180         struct symbol *curr, *prev;
 181
 182         if (prevnd == NULL)
 183                 return;
 184
 185         curr = rb_entry(prevnd, struct symbol, rb_node);
 186
 187         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 188                 prev = curr;
 189                 curr = rb_entry(nd, struct symbol, rb_node);
 190
 191                 if (prev->end == prev->start && prev->end != curr->start)
 192                         prev->end = curr->start;
 193         }
 194
 195         /* Last entry */
 196         if (curr->end == curr->start)
 197                 curr->end = roundup(curr->start, 4096);
 198 }
 199
 200 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 201 {
 202         struct map *prev, *curr;
 203         struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 204
 205         if (prevnd == NULL)
 206                 return;
 207
 208         curr = rb_entry(prevnd, struct map, rb_node);
 209
 210         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 211                 prev = curr;
 212                 curr = rb_entry(nd, struct map, rb_node);
 213                 prev->end = curr->start;
 214         }
 215
 216         /*
 217          * We still haven't the actual symbols, so guess the
 218          * last map final address.
 219          */
 220         curr->end = ~0ULL;
 221 }
 222
 223 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
 224 {
 225         size_t namelen = strlen(name) + 1;
 226         struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 227                                         sizeof(*sym) + namelen));
 228         if (sym == NULL)
 229                 return NULL;
 230
 231         if (symbol_conf.priv_size)
 232                 sym = ((void *)sym) + symbol_conf.priv_size;
 233
 234         sym->start   = start;
 235         sym->end     = len ? start + len : start;
 236         sym->binding = binding;
 237         sym->namelen = namelen - 1;
 238
 239         pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 240                   __func__, name, start, sym->end);
 241         memcpy(sym->name, name, namelen);
 242
 243         return sym;
 244 }
 245
 246 void symbol__delete(struct symbol *sym)
 247 {
 248         free(((void *)sym) - symbol_conf.priv_size);
 249 }
 250
 251 size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 252 {
 253         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 254                        sym->start, sym->end,
 255                        sym->binding == STB_GLOBAL ? 'g' :
 256                        sym->binding == STB_LOCAL  ? 'l' : 'w',
 257                        sym->name);
 258 }
 259
 260 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
 261                                     const struct addr_location *al, FILE *fp)
 262 {
 263         unsigned long offset;
 264         size_t length;
 265
 266         if (sym && sym->name) {
 267                 length = fprintf(fp, "%s", sym->name);
 268                 if (al) {
 269                         if (al->addr < sym->end)
 270                                 offset = al->addr - sym->start;
 271                         else
 272                                 offset = al->addr - al->map->start - sym->start;
 273                         length += fprintf(fp, "+0x%lx", offset);
 274                 }
 275                 return length;
 276         } else
 277                 return fprintf(fp, "[unknown]");
 278 }
 279
 280 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
 281 {
 282         return symbol__fprintf_symname_offs(sym, NULL, fp);
 283 }
 284
 285 void symbols__delete(struct rb_root *symbols)
 286 {
 287         struct symbol *pos;
 288         struct rb_node *next = rb_first(symbols);
 289
 290         while (next) {
 291                 pos = rb_entry(next, struct symbol, rb_node);
 292                 next = rb_next(&pos->rb_node);
 293                 rb_erase(&pos->rb_node, symbols);
 294                 symbol__delete(pos);
 295         }
 296 }
 297
 298 void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 299 {
 300         struct rb_node **p = &symbols->rb_node;
 301         struct rb_node *parent = NULL;
 302         const u64 ip = sym->start;
 303         struct symbol *s;
 304
 305         while (*p != NULL) {
 306                 parent = *p;
 307                 s = rb_entry(parent, struct symbol, rb_node);
 308                 if (ip < s->start)
 309                         p = &(*p)->rb_left;
 310                 else
 311                         p = &(*p)->rb_right;
 312         }
 313         rb_link_node(&sym->rb_node, parent, p);
 314         rb_insert_color(&sym->rb_node, symbols);
 315 }
 316
 317 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 318 {
 319         struct rb_node *n;
 320
 321         if (symbols == NULL)
 322                 return NULL;
 323
 324         n = symbols->rb_node;
 325
 326         while (n) {
 327                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 328
 329                 if (ip < s->start)
 330                         n = n->rb_left;
 331                 else if (ip >= s->end)
 332                         n = n->rb_right;
 333                 else
 334                         return s;
 335         }
 336
 337         return NULL;
 338 }
 339
 340 static struct symbol *symbols__first(struct rb_root *symbols)
 341 {
 342         struct rb_node *n = rb_first(symbols);
 343
 344         if (n)
 345                 return rb_entry(n, struct symbol, rb_node);
 346
 347         return NULL;
 348 }
 349
 350 static struct symbol *symbols__next(struct symbol *sym)
 351 {
 352         struct rb_node *n = rb_next(&sym->rb_node);
 353
 354         if (n)
 355                 return rb_entry(n, struct symbol, rb_node);
 356
 357         return NULL;
 358 }
 359
 360 struct symbol_name_rb_node {
 361         struct rb_node  rb_node;
 362         struct symbol   sym;
 363 };
 364
 365 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 366 {
 367         struct rb_node **p = &symbols->rb_node;
 368         struct rb_node *parent = NULL;
 369         struct symbol_name_rb_node *symn, *s;
 370
 371         symn = container_of(sym, struct symbol_name_rb_node, sym);
 372
 373         while (*p != NULL) {
 374                 parent = *p;
 375                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 376                 if (strcmp(sym->name, s->sym.name) < 0)
 377                         p = &(*p)->rb_left;
 378                 else
 379                         p = &(*p)->rb_right;
 380         }
 381         rb_link_node(&symn->rb_node, parent, p);
 382         rb_insert_color(&symn->rb_node, symbols);
 383 }
 384
 385 static void symbols__sort_by_name(struct rb_root *symbols,
 386                                   struct rb_root *source)
 387 {
 388         struct rb_node *nd;
 389
 390         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 391                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 392                 symbols__insert_by_name(symbols, pos);
 393         }
 394 }
 395
 396 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 397                                             const char *name)
 398 {
 399         struct rb_node *n;
 400         struct symbol_name_rb_node *s;
 401
 402         if (symbols == NULL)
 403                 return NULL;
 404
 405         n = symbols->rb_node;
 406
 407         while (n) {
 408                 int cmp;
 409
 410                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 411                 cmp = strcmp(name, s->sym.name);
 412
 413                 if (cmp < 0)
 414                         n = n->rb_left;
 415                 else if (cmp > 0)
 416                         n = n->rb_right;
 417                 else
 418                         break;
 419         }
 420
 421         if (n == NULL)
 422                 return NULL;
 423
 424         /* return first symbol that has same name (if any) */
 425         for (n = rb_prev(n); n; n = rb_prev(n)) {
 426                 struct symbol_name_rb_node *tmp;
 427
 428                 tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
 429                 if (strcmp(tmp->sym.name, s->sym.name))
 430                         break;
 431
 432                 s = tmp;
 433         }
 434
 435         return &s->sym;
 436 }
 437
 438 struct symbol *dso__find_symbol(struct dso *dso,
 439                                 enum map_type type, u64 addr)
 440 {
 441         return symbols__find(&dso->symbols[type], addr);
 442 }
 443
 444 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
 445 {
 446         return symbols__first(&dso->symbols[type]);
 447 }
 448
 449 struct symbol *dso__next_symbol(struct symbol *sym)
 450 {
 451         return symbols__next(sym);
 452 }
 453
 454 struct symbol *symbol__next_by_name(struct symbol *sym)
 455 {
 456         struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym);
 457         struct rb_node *n = rb_next(&s->rb_node);
 458
 459         return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL;
 460 }
 461
 462  /*
 463   * Teturns first symbol that matched with @name.
 464   */
 465 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 466                                         const char *name)
 467 {
 468         return symbols__find_by_name(&dso->symbol_names[type], name);
 469 }
 470
 471 void dso__sort_by_name(struct dso *dso, enum map_type type)
 472 {
 473         dso__set_sorted_by_name(dso, type);
 474         return symbols__sort_by_name(&dso->symbol_names[type],
 475                                      &dso->symbols[type]);
 476 }
 477
 478 size_t dso__fprintf_symbols_by_name(struct dso *dso,
 479                                     enum map_type type, FILE *fp)
 480 {
 481         size_t ret = 0;
 482         struct rb_node *nd;
 483         struct symbol_name_rb_node *pos;
 484
 485         for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 486                 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 487                 fprintf(fp, "%s\n", pos->sym.name);
 488         }
 489
 490         return ret;
 491 }
 492
 493 int modules__parse(const char *filename, void *arg,
 494                    int (*process_module)(void *arg, const char *name,
 495                                          u64 start))
 496 {
 497         char *line = NULL;
 498         size_t n;
 499         FILE *file;
 500         int err = 0;
 501
 502         file = fopen(filename, "r");
 503         if (file == NULL)
 504                 return -1;
 505
 506         while (1) {
 507                 char name[PATH_MAX];
 508                 u64 start;
 509                 char *sep;
 510                 ssize_t line_len;
 511
 512                 line_len = getline(&line, &n, file);
 513                 if (line_len < 0) {
 514                         if (feof(file))
 515                                 break;
 516                         err = -1;
 517                         goto out;
 518                 }
 519
 520                 if (!line) {
 521                         err = -1;
 522                         goto out;
 523                 }
 524
 525                 line[--line_len] = '\0'; /* \n */
 526
 527                 sep = strrchr(line, 'x');
 528                 if (sep == NULL)
 529                         continue;
 530
 531                 hex2u64(sep + 1, &start);
 532
 533                 sep = strchr(line, ' ');
 534                 if (sep == NULL)
 535                         continue;
 536
 537                 *sep = '\0';
 538
 539                 scnprintf(name, sizeof(name), "[%s]", line);
 540
 541                 err = process_module(arg, name, start);
 542                 if (err)
 543                         break;
 544         }
 545 out:
 546         free(line);
 547         fclose(file);
 548         return err;
 549 }
 550
 551 struct process_kallsyms_args {
 552         struct map *map;
 553         struct dso *dso;
 554 };
 555
 556 /*
 557  * These are symbols in the kernel image, so make sure that
 558  * sym is from a kernel DSO.
 559  */
 560 bool symbol__is_idle(struct symbol *sym)
 561 {
 562         const char * const idle_symbols[] = {
 563                 "cpu_idle",
 564                 "cpu_startup_entry",
 565                 "intel_idle",
 566                 "default_idle",
 567                 "native_safe_halt",
 568                 "enter_idle",
 569                 "exit_idle",
 570                 "mwait_idle",
 571                 "mwait_idle_with_hints",
 572                 "poll_idle",
 573                 "ppc64_runlatch_off",
 574                 "pseries_dedicated_idle_sleep",
 575                 NULL
 576         };
 577
 578         int i;
 579
 580         if (!sym)
 581                 return false;
 582
 583         for (i = 0; idle_symbols[i]; i++) {
 584                 if (!strcmp(idle_symbols[i], sym->name))
 585                         return true;
 586         }
 587
 588         return false;
 589 }
 590
 591 static int map__process_kallsym_symbol(void *arg, const char *name,
 592                                        char type, u64 start)
 593 {
 594         struct symbol *sym;
 595         struct process_kallsyms_args *a = arg;
 596         struct rb_root *root = &a->dso->symbols[a->map->type];
 597
 598         if (!symbol_type__is_a(type, a->map->type))
 599                 return 0;
 600
 601         /*
 602          * module symbols are not sorted so we add all
 603          * symbols, setting length to 0, and rely on
 604          * symbols__fixup_end() to fix it up.
 605          */
 606         sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
 607         if (sym == NULL)
 608                 return -ENOMEM;
 609         /*
 610          * We will pass the symbols to the filter later, in
 611          * map__split_kallsyms, when we have split the maps per module
 612          */
 613         symbols__insert(root, sym);
 614
 615         return 0;
 616 }
 617
 618 /*
 619  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 620  * so that we can in the next step set the symbol ->end address and then
 621  * call kernel_maps__split_kallsyms.
 622  */
 623 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 624                                   struct map *map)
 625 {
 626         struct process_kallsyms_args args = { .map = map, .dso = dso, };
 627         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 628 }
 629
 630 static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
 631                                          symbol_filter_t filter)
 632 {
 633         struct map_groups *kmaps = map__kmaps(map);
 634         struct map *curr_map;
 635         struct symbol *pos;
 636         int count = 0, moved = 0;
 637         struct rb_root *root = &dso->symbols[map->type];
 638         struct rb_node *next = rb_first(root);
 639
 640         if (!kmaps)
 641                 return -1;
 642
 643         while (next) {
 644                 char *module;
 645
 646                 pos = rb_entry(next, struct symbol, rb_node);
 647                 next = rb_next(&pos->rb_node);
 648
 649                 module = strchr(pos->name, '\t');
 650                 if (module)
 651                         *module = '\0';
 652
 653                 curr_map = map_groups__find(kmaps, map->type, pos->start);
 654
 655                 if (!curr_map || (filter && filter(curr_map, pos))) {
 656                         rb_erase(&pos->rb_node, root);
 657                         symbol__delete(pos);
 658                 } else {
 659                         pos->start -= curr_map->start - curr_map->pgoff;
 660                         if (pos->end)
 661                                 pos->end -= curr_map->start - curr_map->pgoff;
 662                         if (curr_map != map) {
 663                                 rb_erase(&pos->rb_node, root);
 664                                 symbols__insert(
 665                                         &curr_map->dso->symbols[curr_map->type],
 666                                         pos);
 667                                 ++moved;
 668                         } else {
 669                                 ++count;
 670                         }
 671                 }
 672         }
 673
 674         /* Symbols have been adjusted */
 675         dso->adjust_symbols = 1;
 676
 677         return count + moved;
 678 }
 679
 680 /*
 681  * Split the symbols into maps, making sure there are no overlaps, i.e. the
 682  * kernel range is broken in several maps, named [kernel].N, as we don't have
 683  * the original ELF section names vmlinux have.
 684  */
 685 static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
 686                                symbol_filter_t filter)
 687 {
 688         struct map_groups *kmaps = map__kmaps(map);
 689         struct machine *machine;
 690         struct map *curr_map = map;
 691         struct symbol *pos;
 692         int count = 0, moved = 0;
 693         struct rb_root *root = &dso->symbols[map->type];
 694         struct rb_node *next = rb_first(root);
 695         int kernel_range = 0;
 696
 697         if (!kmaps)
 698                 return -1;
 699
 700         machine = kmaps->machine;
 701
 702         while (next) {
 703                 char *module;
 704
 705                 pos = rb_entry(next, struct symbol, rb_node);
 706                 next = rb_next(&pos->rb_node);
 707
 708                 module = strchr(pos->name, '\t');
 709                 if (module) {
 710                         if (!symbol_conf.use_modules)
 711                                 goto discard_symbol;
 712
 713                         *module++ = '\0';
 714
 715                         if (strcmp(curr_map->dso->short_name, module)) {
 716                                 if (curr_map != map &&
 717                                     dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 718                                     machine__is_default_guest(machine)) {
 719                                         /*
 720                                          * We assume all symbols of a module are
 721                                          * continuous in * kallsyms, so curr_map
 722                                          * points to a module and all its
 723                                          * symbols are in its kmap. Mark it as
 724                                          * loaded.
 725                                          */
 726                                         dso__set_loaded(curr_map->dso,
 727                                                         curr_map->type);
 728                                 }
 729
 730                                 curr_map = map_groups__find_by_name(kmaps,
 731                                                         map->type, module);
 732                                 if (curr_map == NULL) {
 733                                         pr_debug("%s/proc/{kallsyms,modules} "
 734                                                  "inconsistency while looking "
 735                                                  "for \"%s\" module!\n",
 736                                                  machine->root_dir, module);
 737                                         curr_map = map;
 738                                         goto discard_symbol;
 739                                 }
 740
 741                                 if (curr_map->dso->loaded &&
 742                                     !machine__is_default_guest(machine))
 743                                         goto discard_symbol;
 744                         }
 745                         /*
 746                          * So that we look just like we get from .ko files,
 747                          * i.e. not prelinked, relative to map->start.
 748                          */
 749                         pos->start = curr_map->map_ip(curr_map, pos->start);
 750                         pos->end   = curr_map->map_ip(curr_map, pos->end);
 751                 } else if (curr_map != map) {
 752                         char dso_name[PATH_MAX];
 753                         struct dso *ndso;
 754
 755                         if (delta) {
 756                                 /* Kernel was relocated at boot time */
 757                                 pos->start -= delta;
 758                                 pos->end -= delta;
 759                         }
 760
 761                         if (count == 0) {
 762                                 curr_map = map;
 763                                 goto filter_symbol;
 764                         }
 765
 766                         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 767                                 snprintf(dso_name, sizeof(dso_name),
 768                                         "[guest.kernel].%d",
 769                                         kernel_range++);
 770                         else
 771                                 snprintf(dso_name, sizeof(dso_name),
 772                                         "[kernel].%d",
 773                                         kernel_range++);
 774
 775                         ndso = dso__new(dso_name);
 776                         if (ndso == NULL)
 777                                 return -1;
 778
 779                         ndso->kernel = dso->kernel;
 780
 781                         curr_map = map__new2(pos->start, ndso, map->type);
 782                         if (curr_map == NULL) {
 783                                 dso__delete(ndso);
 784                                 return -1;
 785                         }
 786
 787                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 788                         map_groups__insert(kmaps, curr_map);
 789                         ++kernel_range;
 790                 } else if (delta) {
 791                         /* Kernel was relocated at boot time */
 792                         pos->start -= delta;
 793                         pos->end -= delta;
 794                 }
 795 filter_symbol:
 796                 if (filter && filter(curr_map, pos)) {
 797 discard_symbol:         rb_erase(&pos->rb_node, root);
 798                         symbol__delete(pos);
 799                 } else {
 800                         if (curr_map != map) {
 801                                 rb_erase(&pos->rb_node, root);
 802                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 803                                 ++moved;
 804                         } else
 805                                 ++count;
 806                 }
 807         }
 808
 809         if (curr_map != map &&
 810             dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 811             machine__is_default_guest(kmaps->machine)) {
 812                 dso__set_loaded(curr_map->dso, curr_map->type);
 813         }
 814
 815         return count + moved;
 816 }
 817
 818 bool symbol__restricted_filename(const char *filename,
 819                                  const char *restricted_filename)
 820 {
 821         bool restricted = false;
 822
 823         if (symbol_conf.kptr_restrict) {
 824                 char *r = realpath(filename, NULL);
 825
 826                 if (r != NULL) {
 827                         restricted = strcmp(r, restricted_filename) == 0;
 828                         free(r);
 829                         return restricted;
 830                 }
 831         }
 832
 833         return restricted;
 834 }
 835
 836 struct module_info {
 837         struct rb_node rb_node;
 838         char *name;
 839         u64 start;
 840 };
 841
 842 static void add_module(struct module_info *mi, struct rb_root *modules)
 843 {
 844         struct rb_node **p = &modules->rb_node;
 845         struct rb_node *parent = NULL;
 846         struct module_info *m;
 847
 848         while (*p != NULL) {
 849                 parent = *p;
 850                 m = rb_entry(parent, struct module_info, rb_node);
 851                 if (strcmp(mi->name, m->name) < 0)
 852                         p = &(*p)->rb_left;
 853                 else
 854                         p = &(*p)->rb_right;
 855         }
 856         rb_link_node(&mi->rb_node, parent, p);
 857         rb_insert_color(&mi->rb_node, modules);
 858 }
 859
 860 static void delete_modules(struct rb_root *modules)
 861 {
 862         struct module_info *mi;
 863         struct rb_node *next = rb_first(modules);
 864
 865         while (next) {
 866                 mi = rb_entry(next, struct module_info, rb_node);
 867                 next = rb_next(&mi->rb_node);
 868                 rb_erase(&mi->rb_node, modules);
 869                 zfree(&mi->name);
 870                 free(mi);
 871         }
 872 }
 873
 874 static struct module_info *find_module(const char *name,
 875                                        struct rb_root *modules)
 876 {
 877         struct rb_node *n = modules->rb_node;
 878
 879         while (n) {
 880                 struct module_info *m;
 881                 int cmp;
 882
 883                 m = rb_entry(n, struct module_info, rb_node);
 884                 cmp = strcmp(name, m->name);
 885                 if (cmp < 0)
 886                         n = n->rb_left;
 887                 else if (cmp > 0)
 888                         n = n->rb_right;
 889                 else
 890                         return m;
 891         }
 892
 893         return NULL;
 894 }
 895
 896 static int __read_proc_modules(void *arg, const char *name, u64 start)
 897 {
 898         struct rb_root *modules = arg;
 899         struct module_info *mi;
 900
 901         mi = zalloc(sizeof(struct module_info));
 902         if (!mi)
 903                 return -ENOMEM;
 904
 905         mi->name = strdup(name);
 906         mi->start = start;
 907
 908         if (!mi->name) {
 909                 free(mi);
 910                 return -ENOMEM;
 911         }
 912
 913         add_module(mi, modules);
 914
 915         return 0;
 916 }
 917
 918 static int read_proc_modules(const char *filename, struct rb_root *modules)
 919 {
 920         if (symbol__restricted_filename(filename, "/proc/modules"))
 921                 return -1;
 922
 923         if (modules__parse(filename, modules, __read_proc_modules)) {
 924                 delete_modules(modules);
 925                 return -1;
 926         }
 927
 928         return 0;
 929 }
 930
 931 int compare_proc_modules(const char *from, const char *to)
 932 {
 933         struct rb_root from_modules = RB_ROOT;
 934         struct rb_root to_modules = RB_ROOT;
 935         struct rb_node *from_node, *to_node;
 936         struct module_info *from_m, *to_m;
 937         int ret = -1;
 938
 939         if (read_proc_modules(from, &from_modules))
 940                 return -1;
 941
 942         if (read_proc_modules(to, &to_modules))
 943                 goto out_delete_from;
 944
 945         from_node = rb_first(&from_modules);
 946         to_node = rb_first(&to_modules);
 947         while (from_node) {
 948                 if (!to_node)
 949                         break;
 950
 951                 from_m = rb_entry(from_node, struct module_info, rb_node);
 952                 to_m = rb_entry(to_node, struct module_info, rb_node);
 953
 954                 if (from_m->start != to_m->start ||
 955                     strcmp(from_m->name, to_m->name))
 956                         break;
 957
 958                 from_node = rb_next(from_node);
 959                 to_node = rb_next(to_node);
 960         }
 961
 962         if (!from_node && !to_node)
 963                 ret = 0;
 964
 965         delete_modules(&to_modules);
 966 out_delete_from:
 967         delete_modules(&from_modules);
 968
 969         return ret;
 970 }
 971
 972 static int do_validate_kcore_modules(const char *filename, struct map *map,
 973                                   struct map_groups *kmaps)
 974 {
 975         struct rb_root modules = RB_ROOT;
 976         struct map *old_map;
 977         int err;
 978
 979         err = read_proc_modules(filename, &modules);
 980         if (err)
 981                 return err;
 982
 983         old_map = map_groups__first(kmaps, map->type);
 984         while (old_map) {
 985                 struct map *next = map_groups__next(old_map);
 986                 struct module_info *mi;
 987
 988                 if (old_map == map || old_map->start == map->start) {
 989                         /* The kernel map */
 990                         old_map = next;
 991                         continue;
 992                 }
 993
 994                 /* Module must be in memory at the same address */
 995                 mi = find_module(old_map->dso->short_name, &modules);
 996                 if (!mi || mi->start != old_map->start) {
 997                         err = -EINVAL;
 998                         goto out;
 999                 }
1000
1001                 old_map = next;
1002         }
1003 out:
1004         delete_modules(&modules);
1005         return err;
1006 }
1007
1008 /*
1009  * If kallsyms is referenced by name then we look for filename in the same
1010  * directory.
1011  */
1012 static bool filename_from_kallsyms_filename(char *filename,
1013                                             const char *base_name,
1014                                             const char *kallsyms_filename)
1015 {
1016         char *name;
1017
1018         strcpy(filename, kallsyms_filename);
1019         name = strrchr(filename, '/');
1020         if (!name)
1021                 return false;
1022
1023         name += 1;
1024
1025         if (!strcmp(name, "kallsyms")) {
1026                 strcpy(name, base_name);
1027                 return true;
1028         }
1029
1030         return false;
1031 }
1032
1033 static int validate_kcore_modules(const char *kallsyms_filename,
1034                                   struct map *map)
1035 {
1036         struct map_groups *kmaps = map__kmaps(map);
1037         char modules_filename[PATH_MAX];
1038
1039         if (!kmaps)
1040                 return -EINVAL;
1041
1042         if (!filename_from_kallsyms_filename(modules_filename, "modules",
1043                                              kallsyms_filename))
1044                 return -EINVAL;
1045
1046         if (do_validate_kcore_modules(modules_filename, map, kmaps))
1047                 return -EINVAL;
1048
1049         return 0;
1050 }
1051
1052 static int validate_kcore_addresses(const char *kallsyms_filename,
1053                                     struct map *map)
1054 {
1055         struct kmap *kmap = map__kmap(map);
1056
1057         if (!kmap)
1058                 return -EINVAL;
1059
1060         if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
1061                 u64 start;
1062
1063                 start = kallsyms__get_function_start(kallsyms_filename,
1064                                                      kmap->ref_reloc_sym->name);
1065                 if (start != kmap->ref_reloc_sym->addr)
1066                         return -EINVAL;
1067         }
1068
1069         return validate_kcore_modules(kallsyms_filename, map);
1070 }
1071
1072 struct kcore_mapfn_data {
1073         struct dso *dso;
1074         enum map_type type;
1075         struct list_head maps;
1076 };
1077
1078 static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
1079 {
1080         struct kcore_mapfn_data *md = data;
1081         struct map *map;
1082
1083         map = map__new2(start, md->dso, md->type);
1084         if (map == NULL)
1085                 return -ENOMEM;
1086
1087         map->end = map->start + len;
1088         map->pgoff = pgoff;
1089
1090         list_add(&map->node, &md->maps);
1091
1092         return 0;
1093 }
1094
1095 static int dso__load_kcore(struct dso *dso, struct map *map,
1096                            const char *kallsyms_filename)
1097 {
1098         struct map_groups *kmaps = map__kmaps(map);
1099         struct machine *machine;
1100         struct kcore_mapfn_data md;
1101         struct map *old_map, *new_map, *replacement_map = NULL;
1102         bool is_64_bit;
1103         int err, fd;
1104         char kcore_filename[PATH_MAX];
1105         struct symbol *sym;
1106
1107         if (!kmaps)
1108                 return -EINVAL;
1109
1110         machine = kmaps->machine;
1111
1112         /* This function requires that the map is the kernel map */
1113         if (map != machine->vmlinux_maps[map->type])
1114                 return -EINVAL;
1115
1116         if (!filename_from_kallsyms_filename(kcore_filename, "kcore",
1117                                              kallsyms_filename))
1118                 return -EINVAL;
1119
1120         /* Modules and kernel must be present at their original addresses */
1121         if (validate_kcore_addresses(kallsyms_filename, map))
1122                 return -EINVAL;
1123
1124         md.dso = dso;
1125         md.type = map->type;
1126         INIT_LIST_HEAD(&md.maps);
1127
1128         fd = open(kcore_filename, O_RDONLY);
1129         if (fd < 0)
1130                 return -EINVAL;
1131
1132         /* Read new maps into temporary lists */
1133         err = file__read_maps(fd, md.type == MAP__FUNCTION, kcore_mapfn, &md,
1134                               &is_64_bit);
1135         if (err)
1136                 goto out_err;
1137         dso->is_64_bit = is_64_bit;
1138
1139         if (list_empty(&md.maps)) {
1140                 err = -EINVAL;
1141                 goto out_err;
1142         }
1143
1144         /* Remove old maps */
1145         old_map = map_groups__first(kmaps, map->type);
1146         while (old_map) {
1147                 struct map *next = map_groups__next(old_map);
1148
1149                 if (old_map != map)
1150                         map_groups__remove(kmaps, old_map);
1151                 old_map = next;
1152         }
1153
1154         /* Find the kernel map using the first symbol */
1155         sym = dso__first_symbol(dso, map->type);
1156         list_for_each_entry(new_map, &md.maps, node) {
1157                 if (sym && sym->start >= new_map->start &&
1158                     sym->start < new_map->end) {
1159                         replacement_map = new_map;
1160                         break;
1161                 }
1162         }
1163
1164         if (!replacement_map)
1165                 replacement_map = list_entry(md.maps.next, struct map, node);
1166
1167         /* Add new maps */
1168         while (!list_empty(&md.maps)) {
1169                 new_map = list_entry(md.maps.next, struct map, node);
1170                 list_del(&new_map->node);
1171                 if (new_map == replacement_map) {
1172                         map->start      = new_map->start;
1173                         map->end        = new_map->end;
1174                         map->pgoff      = new_map->pgoff;
1175                         map->map_ip     = new_map->map_ip;
1176                         map->unmap_ip   = new_map->unmap_ip;
1177                         map__delete(new_map);
1178                         /* Ensure maps are correctly ordered */
1179                         map_groups__remove(kmaps, map);
1180                         map_groups__insert(kmaps, map);
1181                 } else {
1182                         map_groups__insert(kmaps, new_map);
1183                 }
1184         }
1185
1186         /*
1187          * Set the data type and long name so that kcore can be read via
1188          * dso__data_read_addr().
1189          */
1190         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1191                 dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE;
1192         else
1193                 dso->binary_type = DSO_BINARY_TYPE__KCORE;
1194         dso__set_long_name(dso, strdup(kcore_filename), true);
1195
1196         close(fd);
1197
1198         if (map->type == MAP__FUNCTION)
1199                 pr_debug("Using %s for kernel object code\n", kcore_filename);
1200         else
1201                 pr_debug("Using %s for kernel data\n", kcore_filename);
1202
1203         return 0;
1204
1205 out_err:
1206         while (!list_empty(&md.maps)) {
1207                 map = list_entry(md.maps.next, struct map, node);
1208                 list_del(&map->node);
1209                 map__delete(map);
1210         }
1211         close(fd);
1212         return -EINVAL;
1213 }
1214
1215 /*
1216  * If the kernel is relocated at boot time, kallsyms won't match.  Compute the
1217  * delta based on the relocation reference symbol.
1218  */
1219 static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
1220 {
1221         struct kmap *kmap = map__kmap(map);
1222         u64 addr;
1223
1224         if (!kmap)
1225                 return -1;
1226
1227         if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
1228                 return 0;
1229
1230         addr = kallsyms__get_function_start(filename,
1231                                             kmap->ref_reloc_sym->name);
1232         if (!addr)
1233                 return -1;
1234
1235         *delta = addr - kmap->ref_reloc_sym->addr;
1236         return 0;
1237 }
1238
1239 int dso__load_kallsyms(struct dso *dso, const char *filename,
1240                        struct map *map, symbol_filter_t filter)
1241 {
1242         u64 delta = 0;
1243
1244         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
1245                 return -1;
1246
1247         if (dso__load_all_kallsyms(dso, filename, map) < 0)
1248                 return -1;
1249
1250         if (kallsyms__delta(map, filename, &delta))
1251                 return -1;
1252
1253         symbols__fixup_duplicate(&dso->symbols[map->type]);
1254         symbols__fixup_end(&dso->symbols[map->type]);
1255
1256         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1257                 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1258         else
1259                 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
1260
1261         if (!dso__load_kcore(dso, map, filename))
1262                 return dso__split_kallsyms_for_kcore(dso, map, filter);
1263         else
1264                 return dso__split_kallsyms(dso, map, delta, filter);
1265 }
1266
1267 static int dso__load_perf_map(struct dso *dso, struct map *map,
1268                               symbol_filter_t filter)
1269 {
1270         char *line = NULL;
1271         size_t n;
1272         FILE *file;
1273         int nr_syms = 0;
1274
1275         file = fopen(dso->long_name, "r");
1276         if (file == NULL)
1277                 goto out_failure;
1278
1279         while (!feof(file)) {
1280                 u64 start, size;
1281                 struct symbol *sym;
1282                 int line_len, len;
1283
1284                 line_len = getline(&line, &n, file);
1285                 if (line_len < 0)
1286                         break;
1287
1288                 if (!line)
1289                         goto out_failure;
1290
1291                 line[--line_len] = '\0'; /* \n */
1292
1293                 len = hex2u64(line, &start);
1294
1295                 len++;
1296                 if (len + 2 >= line_len)
1297                         continue;
1298
1299                 len += hex2u64(line + len, &size);
1300
1301                 len++;
1302                 if (len + 2 >= line_len)
1303                         continue;
1304
1305                 sym = symbol__new(start, size, STB_GLOBAL, line + len);
1306
1307                 if (sym == NULL)
1308                         goto out_delete_line;
1309
1310                 if (filter && filter(map, sym))
1311                         symbol__delete(sym);
1312                 else {
1313                         symbols__insert(&dso->symbols[map->type], sym);
1314                         nr_syms++;
1315                 }
1316         }
1317
1318         free(line);
1319         fclose(file);
1320
1321         return nr_syms;
1322
1323 out_delete_line:
1324         free(line);
1325 out_failure:
1326         return -1;
1327 }
1328
1329 static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
1330                                            enum dso_binary_type type)
1331 {
1332         switch (type) {
1333         case DSO_BINARY_TYPE__JAVA_JIT:
1334         case DSO_BINARY_TYPE__DEBUGLINK:
1335         case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
1336         case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
1337         case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
1338         case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
1339         case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
1340                 return !kmod && dso->kernel == DSO_TYPE_USER;
1341
1342         case DSO_BINARY_TYPE__KALLSYMS:
1343         case DSO_BINARY_TYPE__VMLINUX:
1344         case DSO_BINARY_TYPE__KCORE:
1345                 return dso->kernel == DSO_TYPE_KERNEL;
1346
1347         case DSO_BINARY_TYPE__GUEST_KALLSYMS:
1348         case DSO_BINARY_TYPE__GUEST_VMLINUX:
1349         case DSO_BINARY_TYPE__GUEST_KCORE:
1350                 return dso->kernel == DSO_TYPE_GUEST_KERNEL;
1351
1352         case DSO_BINARY_TYPE__GUEST_KMODULE:
1353         case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
1354         case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
1355         case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
1356                 /*
1357                  * kernel modules know their symtab type - it's set when
1358                  * creating a module dso in machine__new_module().
1359                  */
1360                 return kmod && dso->symtab_type == type;
1361
1362         case DSO_BINARY_TYPE__BUILD_ID_CACHE:
1363                 return true;
1364
1365         case DSO_BINARY_TYPE__NOT_FOUND:
1366         default:
1367                 return false;
1368         }
1369 }
1370
1371 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1372 {
1373         char *name;
1374         int ret = -1;
1375         u_int i;
1376         struct machine *machine;
1377         char *root_dir = (char *) "";
1378         int ss_pos = 0;
1379         struct symsrc ss_[2];
1380         struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
1381         bool kmod;
1382
1383         dso__set_loaded(dso, map->type);
1384
1385         if (dso->kernel == DSO_TYPE_KERNEL)
1386                 return dso__load_kernel_sym(dso, map, filter);
1387         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1388                 return dso__load_guest_kernel_sym(dso, map, filter);
1389
1390         if (map->groups && map->groups->machine)
1391                 machine = map->groups->machine;
1392         else
1393                 machine = NULL;
1394
1395         dso->adjust_symbols = 0;
1396
1397         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1398                 struct stat st;
1399
1400                 if (lstat(dso->name, &st) < 0)
1401                         return -1;
1402
1403                 if (st.st_uid && (st.st_uid != geteuid())) {
1404                         pr_warning("File %s not owned by current user or root, "
1405                                 "ignoring it.\n", dso->name);
1406                         return -1;
1407                 }
1408
1409                 ret = dso__load_perf_map(dso, map, filter);
1410                 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
1411                                              DSO_BINARY_TYPE__NOT_FOUND;
1412                 return ret;
1413         }
1414
1415         if (machine)
1416                 root_dir = machine->root_dir;
1417
1418         name = malloc(PATH_MAX);
1419         if (!name)
1420                 return -1;
1421
1422         kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
1423                 dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
1424                 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
1425                 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
1426
1427         /*
1428          * Iterate over candidate debug images.
1429          * Keep track of "interesting" ones (those which have a symtab, dynsym,
1430          * and/or opd section) for processing.
1431          */
1432         for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
1433                 struct symsrc *ss = &ss_[ss_pos];
1434                 bool next_slot = false;
1435
1436                 enum dso_binary_type symtab_type = binary_type_symtab[i];
1437
1438                 if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type))
1439                         continue;
1440
1441                 if (dso__read_binary_type_filename(dso, symtab_type,
1442                                                    root_dir, name, PATH_MAX))
1443                         continue;
1444
1445                 /* Name is now the name of the next image to try */
1446                 if (symsrc__init(ss, dso, name, symtab_type) < 0)
1447                         continue;
1448
1449                 if (!syms_ss && symsrc__has_symtab(ss)) {
1450                         syms_ss = ss;
1451                         next_slot = true;
1452                         if (!dso->symsrc_filename)
1453                                 dso->symsrc_filename = strdup(name);
1454                 }
1455
1456                 if (!runtime_ss && symsrc__possibly_runtime(ss)) {
1457                         runtime_ss = ss;
1458                         next_slot = true;
1459                 }
1460
1461                 if (next_slot) {
1462                         ss_pos++;
1463
1464                         if (syms_ss && runtime_ss)
1465                                 break;
1466                 } else {
1467                         symsrc__destroy(ss);
1468                 }
1469
1470         }
1471
1472         if (!runtime_ss && !syms_ss)
1473                 goto out_free;
1474
1475         if (runtime_ss && !syms_ss) {
1476                 syms_ss = runtime_ss;
1477         }
1478
1479         /* We'll have to hope for the best */
1480         if (!runtime_ss && syms_ss)
1481                 runtime_ss = syms_ss;
1482
1483         if (syms_ss)
1484                 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, kmod);
1485         else
1486                 ret = -1;
1487
1488         if (ret > 0) {
1489                 int nr_plt;
1490
1491                 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
1492                 if (nr_plt > 0)
1493                         ret += nr_plt;
1494         }
1495
1496         for (; ss_pos > 0; ss_pos--)
1497                 symsrc__destroy(&ss_[ss_pos - 1]);
1498 out_free:
1499         free(name);
1500         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1501                 return 0;
1502         return ret;
1503 }
1504
1505 struct map *map_groups__find_by_name(struct map_groups *mg,
1506                                      enum map_type type, const char *name)
1507 {
1508         struct rb_node *nd;
1509
1510         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1511                 struct map *map = rb_entry(nd, struct map, rb_node);
1512
1513                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1514                         return map;
1515         }
1516
1517         return NULL;
1518 }
1519
1520 int dso__load_vmlinux(struct dso *dso, struct map *map,
1521                       const char *vmlinux, bool vmlinux_allocated,
1522                       symbol_filter_t filter)
1523 {
1524         int err = -1;
1525         struct symsrc ss;
1526         char symfs_vmlinux[PATH_MAX];
1527         enum dso_binary_type symtab_type;
1528
1529         if (vmlinux[0] == '/')
1530                 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
1531         else
1532                 symbol__join_symfs(symfs_vmlinux, vmlinux);
1533
1534         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1535                 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1536         else
1537                 symtab_type = DSO_BINARY_TYPE__VMLINUX;
1538
1539         if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
1540                 return -1;
1541
1542         err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
1543         symsrc__destroy(&ss);
1544
1545         if (err > 0) {
1546                 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1547                         dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1548                 else
1549                         dso->binary_type = DSO_BINARY_TYPE__VMLINUX;
1550                 dso__set_long_name(dso, vmlinux, vmlinux_allocated);
1551                 dso__set_loaded(dso, map->type);
1552                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1553         }
1554
1555         return err;
1556 }
1557
1558 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
1559                            symbol_filter_t filter)
1560 {
1561         int i, err = 0;
1562         char *filename = NULL;
1563
1564         if (!symbol_conf.ignore_vmlinux_buildid)
1565                 filename = dso__build_id_filename(dso, NULL, 0);
1566         if (filename != NULL) {
1567                 err = dso__load_vmlinux(dso, map, filename, true, filter);
1568                 if (err > 0)
1569                         goto out;
1570                 free(filename);
1571         }
1572
1573         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1574                  vmlinux_path__nr_entries + 1);
1575
1576         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1577                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], false, filter);
1578                 if (err > 0)
1579                         break;
1580         }
1581 out:
1582         return err;
1583 }
1584
1585 static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
1586 {
1587         char kallsyms_filename[PATH_MAX];
1588         struct dirent *dent;
1589         int ret = -1;
1590         DIR *d;
1591
1592         d = opendir(dir);
1593         if (!d)
1594                 return -1;
1595
1596         while (1) {
1597                 dent = readdir(d);
1598                 if (!dent)
1599                         break;
1600                 if (dent->d_type != DT_DIR)
1601                         continue;
1602                 scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
1603                           "%s/%s/kallsyms", dir, dent->d_name);
1604                 if (!validate_kcore_addresses(kallsyms_filename, map)) {
1605                         strlcpy(dir, kallsyms_filename, dir_sz);
1606                         ret = 0;
1607                         break;
1608                 }
1609         }
1610
1611         closedir(d);
1612
1613         return ret;
1614 }
1615
1616 static char *dso__find_kallsyms(struct dso *dso, struct map *map)
1617 {
1618         u8 host_build_id[BUILD_ID_SIZE];
1619         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1620         bool is_host = false;
1621         char path[PATH_MAX];
1622
1623         if (!dso->has_build_id) {
1624                 /*
1625                  * Last resort, if we don't have a build-id and couldn't find
1626                  * any vmlinux file, try the running kernel kallsyms table.
1627                  */
1628                 goto proc_kallsyms;
1629         }
1630
1631         if (sysfs__read_build_id("/sys/kernel/notes", host_build_id,
1632                                  sizeof(host_build_id)) == 0)
1633                 is_host = dso__build_id_equal(dso, host_build_id);
1634
1635         build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
1636
1637         scnprintf(path, sizeof(path), "%s/[kernel.kcore]/%s", buildid_dir,
1638                   sbuild_id);
1639
1640         /* Use /proc/kallsyms if possible */
1641         if (is_host) {
1642                 DIR *d;
1643                 int fd;
1644
1645                 /* If no cached kcore go with /proc/kallsyms */
1646                 d = opendir(path);
1647                 if (!d)
1648                         goto proc_kallsyms;
1649                 closedir(d);
1650
1651                 /*
1652                  * Do not check the build-id cache, until we know we cannot use
1653                  * /proc/kcore.
1654                  */
1655                 fd = open("/proc/kcore", O_RDONLY);
1656                 if (fd != -1) {
1657                         close(fd);
1658                         /* If module maps match go with /proc/kallsyms */
1659                         if (!validate_kcore_addresses("/proc/kallsyms", map))
1660                                 goto proc_kallsyms;
1661                 }
1662
1663                 /* Find kallsyms in build-id cache with kcore */
1664                 if (!find_matching_kcore(map, path, sizeof(path)))
1665                         return strdup(path);
1666
1667                 goto proc_kallsyms;
1668         }
1669
1670         /* Find kallsyms in build-id cache with kcore */
1671         if (!find_matching_kcore(map, path, sizeof(path)))
1672                 return strdup(path);
1673
1674         scnprintf(path, sizeof(path), "%s/[kernel.kallsyms]/%s",
1675                   buildid_dir, sbuild_id);
1676
1677         if (access(path, F_OK)) {
1678                 pr_err("No kallsyms or vmlinux with build-id %s was found\n",
1679                        sbuild_id);
1680                 return NULL;
1681         }
1682
1683         return strdup(path);
1684
1685 proc_kallsyms:
1686         return strdup("/proc/kallsyms");
1687 }
1688
1689 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
1690                                 symbol_filter_t filter)
1691 {
1692         int err;
1693         const char *kallsyms_filename = NULL;
1694         char *kallsyms_allocated_filename = NULL;
1695         /*
1696          * Step 1: if the user specified a kallsyms or vmlinux filename, use
1697          * it and only it, reporting errors to the user if it cannot be used.
1698          *
1699          * For instance, try to analyse an ARM perf.data file _without_ a
1700          * build-id, or if the user specifies the wrong path to the right
1701          * vmlinux file, obviously we can't fallback to another vmlinux (a
1702          * x86_86 one, on the machine where analysis is being performed, say),
1703          * or worse, /proc/kallsyms.
1704          *
1705          * If the specified file _has_ a build-id and there is a build-id
1706          * section in the perf.data file, we will still do the expected
1707          * validation in dso__load_vmlinux and will bail out if they don't
1708          * match.
1709          */
1710         if (symbol_conf.kallsyms_name != NULL) {
1711                 kallsyms_filename = symbol_conf.kallsyms_name;
1712                 goto do_kallsyms;
1713         }
1714
1715         if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
1716                 return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name,
1717                                          false, filter);
1718         }
1719
1720         if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
1721                 err = dso__load_vmlinux_path(dso, map, filter);
1722                 if (err > 0)
1723                         return err;
1724         }
1725
1726         /* do not try local files if a symfs was given */
1727         if (symbol_conf.symfs[0] != 0)
1728                 return -1;
1729
1730         kallsyms_allocated_filename = dso__find_kallsyms(dso, map);
1731         if (!kallsyms_allocated_filename)
1732                 return -1;
1733
1734         kallsyms_filename = kallsyms_allocated_filename;
1735
1736 do_kallsyms:
1737         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1738         if (err > 0)
1739                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1740         free(kallsyms_allocated_filename);
1741
1742         if (err > 0 && !dso__is_kcore(dso)) {
1743                 dso->binary_type = DSO_BINARY_TYPE__KALLSYMS;
1744                 dso__set_long_name(dso, "[kernel.kallsyms]", false);
1745                 map__fixup_start(map);
1746                 map__fixup_end(map);
1747         }
1748
1749         return err;
1750 }
1751
1752 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
1753                                       symbol_filter_t filter)
1754 {
1755         int err;
1756         const char *kallsyms_filename = NULL;
1757         struct machine *machine;
1758         char path[PATH_MAX];
1759
1760         if (!map->groups) {
1761                 pr_debug("Guest kernel map hasn't the point to groups\n");
1762                 return -1;
1763         }
1764         machine = map->groups->machine;
1765
1766         if (machine__is_default_guest(machine)) {
1767                 /*
1768                  * if the user specified a vmlinux filename, use it and only
1769                  * it, reporting errors to the user if it cannot be used.
1770                  * Or use file guest_kallsyms inputted by user on commandline
1771                  */
1772                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1773                         err = dso__load_vmlinux(dso, map,
1774                                                 symbol_conf.default_guest_vmlinux_name,
1775                                                 false, filter);
1776                         return err;
1777                 }
1778
1779                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1780                 if (!kallsyms_filename)
1781                         return -1;
1782         } else {
1783                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1784                 kallsyms_filename = path;
1785         }
1786
1787         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1788         if (err > 0)
1789                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1790         if (err > 0 && !dso__is_kcore(dso)) {
1791                 dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1792                 machine__mmap_name(machine, path, sizeof(path));
1793                 dso__set_long_name(dso, strdup(path), true);
1794                 map__fixup_start(map);
1795                 map__fixup_end(map);
1796         }
1797
1798         return err;
1799 }
1800
1801 static void vmlinux_path__exit(void)
1802 {
1803         while (--vmlinux_path__nr_entries >= 0)
1804                 zfree(&vmlinux_path[vmlinux_path__nr_entries]);
1805
1806         zfree(&vmlinux_path);
1807 }
1808
1809 static int vmlinux_path__init(struct perf_session_env *env)
1810 {
1811         struct utsname uts;
1812         char bf[PATH_MAX];
1813         char *kernel_version;
1814
1815         vmlinux_path = malloc(sizeof(char *) * 6);
1816         if (vmlinux_path == NULL)
1817                 return -1;
1818
1819         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
1820         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1821                 goto out_fail;
1822         ++vmlinux_path__nr_entries;
1823         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
1824         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1825                 goto out_fail;
1826         ++vmlinux_path__nr_entries;
1827
1828         /* only try kernel version if no symfs was given */
1829         if (symbol_conf.symfs[0] != 0)
1830                 return 0;
1831
1832         if (env) {
1833                 kernel_version = env->os_release;
1834         } else {
1835                 if (uname(&uts) < 0)
1836                         goto out_fail;
1837
1838                 kernel_version = uts.release;
1839         }
1840
1841         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", kernel_version);
1842         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1843         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1844                 goto out_fail;
1845         ++vmlinux_path__nr_entries;
1846         snprintf(bf, sizeof(bf), "/usr/lib/debug/boot/vmlinux-%s",
1847                  kernel_version);
1848         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1849         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1850                 goto out_fail;
1851         ++vmlinux_path__nr_entries;
1852         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", kernel_version);
1853         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1854         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1855                 goto out_fail;
1856         ++vmlinux_path__nr_entries;
1857         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
1858                  kernel_version);
1859         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1860         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1861                 goto out_fail;
1862         ++vmlinux_path__nr_entries;
1863
1864         return 0;
1865
1866 out_fail:
1867         vmlinux_path__exit();
1868         return -1;
1869 }
1870
1871 int setup_list(struct strlist **list, const char *list_str,
1872                       const char *list_name)
1873 {
1874         if (list_str == NULL)
1875                 return 0;
1876
1877         *list = strlist__new(true, list_str);
1878         if (!*list) {
1879                 pr_err("problems parsing %s list\n", list_name);
1880                 return -1;
1881         }
1882         return 0;
1883 }
1884
1885 int setup_intlist(struct intlist **list, const char *list_str,
1886                   const char *list_name)
1887 {
1888         if (list_str == NULL)
1889                 return 0;
1890
1891         *list = intlist__new(list_str);
1892         if (!*list) {
1893                 pr_err("problems parsing %s list\n", list_name);
1894                 return -1;
1895         }
1896
1897         symbol_conf.has_filter = true;
1898         return 0;
1899 }
1900
1901 static bool symbol__read_kptr_restrict(void)
1902 {
1903         bool value = false;
1904
1905         if (geteuid() != 0) {
1906                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
1907                 if (fp != NULL) {
1908                         char line[8];
1909
1910                         if (fgets(line, sizeof(line), fp) != NULL)
1911                                 value = atoi(line) != 0;
1912
1913                         fclose(fp);
1914                 }
1915         }
1916
1917         return value;
1918 }
1919
1920 int symbol__init(struct perf_session_env *env)
1921 {
1922         const char *symfs;
1923
1924         if (symbol_conf.initialized)
1925                 return 0;
1926
1927         symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
1928
1929         symbol__elf_init();
1930
1931         if (symbol_conf.sort_by_name)
1932                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
1933                                           sizeof(struct symbol));
1934
1935         if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
1936                 return -1;
1937
1938         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
1939                 pr_err("'.' is the only non valid --field-separator argument\n");
1940                 return -1;
1941         }
1942
1943         if (setup_list(&symbol_conf.dso_list,
1944                        symbol_conf.dso_list_str, "dso") < 0)
1945                 return -1;
1946
1947         if (setup_list(&symbol_conf.comm_list,
1948                        symbol_conf.comm_list_str, "comm") < 0)
1949                 goto out_free_dso_list;
1950
1951         if (setup_intlist(&symbol_conf.pid_list,
1952                        symbol_conf.pid_list_str, "pid") < 0)
1953                 goto out_free_comm_list;
1954
1955         if (setup_intlist(&symbol_conf.tid_list,
1956                        symbol_conf.tid_list_str, "tid") < 0)
1957                 goto out_free_pid_list;
1958
1959         if (setup_list(&symbol_conf.sym_list,
1960                        symbol_conf.sym_list_str, "symbol") < 0)
1961                 goto out_free_tid_list;
1962
1963         /*
1964          * A path to symbols of "/" is identical to ""
1965          * reset here for simplicity.
1966          */
1967         symfs = realpath(symbol_conf.symfs, NULL);
1968         if (symfs == NULL)
1969                 symfs = symbol_conf.symfs;
1970         if (strcmp(symfs, "/") == 0)
1971                 symbol_conf.symfs = "";
1972         if (symfs != symbol_conf.symfs)
1973                 free((void *)symfs);
1974
1975         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
1976
1977         symbol_conf.initialized = true;
1978         return 0;
1979
1980 out_free_tid_list:
1981         intlist__delete(symbol_conf.tid_list);
1982 out_free_pid_list:
1983         intlist__delete(symbol_conf.pid_list);
1984 out_free_comm_list:
1985         strlist__delete(symbol_conf.comm_list);
1986 out_free_dso_list:
1987         strlist__delete(symbol_conf.dso_list);
1988         return -1;
1989 }
1990
1991 void symbol__exit(void)
1992 {
1993         if (!symbol_conf.initialized)
1994                 return;
1995         strlist__delete(symbol_conf.sym_list);
1996         strlist__delete(symbol_conf.dso_list);
1997         strlist__delete(symbol_conf.comm_list);
1998         intlist__delete(symbol_conf.tid_list);
1999         intlist__delete(symbol_conf.pid_list);
2000         vmlinux_path__exit();
2001         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2002         symbol_conf.initialized = false;
2003 }