tools/perf/util/symbol-elf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <fcntl.h>
   3 #include <stdio.h>
   4 #include <errno.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <unistd.h>
   8 #include <inttypes.h>
   9
  10 #include "dso.h"
  11 #include "map.h"
  12 #include "maps.h"
  13 #include "symbol.h"
  14 #include "symsrc.h"
  15 #include "demangle-ocaml.h"
  16 #include "demangle-java.h"
  17 #include "demangle-rust.h"
  18 #include "machine.h"
  19 #include "vdso.h"
  20 #include "debug.h"
  21 #include "util/copyfile.h"
  22 #include <linux/ctype.h>
  23 #include <linux/kernel.h>
  24 #include <linux/zalloc.h>
  25 #include <symbol/kallsyms.h>
  26 #include <internal/lib.h>
  27
  28 #ifndef EM_AARCH64
  29 #define EM_AARCH64      183  /* ARM 64 bit */
  30 #endif
  31
  32 #ifndef ELF32_ST_VISIBILITY
  33 #define ELF32_ST_VISIBILITY(o)  ((o) & 0x03)
  34 #endif
  35
  36 /* For ELF64 the definitions are the same.  */
  37 #ifndef ELF64_ST_VISIBILITY
  38 #define ELF64_ST_VISIBILITY(o)  ELF32_ST_VISIBILITY (o)
  39 #endif
  40
  41 /* How to extract information held in the st_other field.  */
  42 #ifndef GELF_ST_VISIBILITY
  43 #define GELF_ST_VISIBILITY(val) ELF64_ST_VISIBILITY (val)
  44 #endif
  45
  46 typedef Elf64_Nhdr GElf_Nhdr;
  47
  48 #ifndef DMGL_PARAMS
  49 #define DMGL_NO_OPTS     0              /* For readability... */
  50 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
  51 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
  52 #endif
  53
  54 #ifdef HAVE_LIBBFD_SUPPORT
  55 #define PACKAGE 'perf'
  56 #include <bfd.h>
  57 #else
  58 #ifdef HAVE_CPLUS_DEMANGLE_SUPPORT
  59 extern char *cplus_demangle(const char *, int);
  60
  61 static inline char *bfd_demangle(void __maybe_unused *v, const char *c, int i)
  62 {
  63         return cplus_demangle(c, i);
  64 }
  65 #else
  66 #ifdef NO_DEMANGLE
  67 static inline char *bfd_demangle(void __maybe_unused *v,
  68                                  const char __maybe_unused *c,
  69                                  int __maybe_unused i)
  70 {
  71         return NULL;
  72 }
  73 #endif
  74 #endif
  75 #endif
  76
  77 #ifndef HAVE_ELF_GETPHDRNUM_SUPPORT
  78 static int elf_getphdrnum(Elf *elf, size_t *dst)
  79 {
  80         GElf_Ehdr gehdr;
  81         GElf_Ehdr *ehdr;
  82
  83         ehdr = gelf_getehdr(elf, &gehdr);
  84         if (!ehdr)
  85                 return -1;
  86
  87         *dst = ehdr->e_phnum;
  88
  89         return 0;
  90 }
  91 #endif
  92
  93 #ifndef HAVE_ELF_GETSHDRSTRNDX_SUPPORT
  94 static int elf_getshdrstrndx(Elf *elf __maybe_unused, size_t *dst __maybe_unused)
  95 {
  96         pr_err("%s: update your libelf to > 0.140, this one lacks elf_getshdrstrndx().\n", __func__);
  97         return -1;
  98 }
  99 #endif
 100
 101 #ifndef NT_GNU_BUILD_ID
 102 #define NT_GNU_BUILD_ID 3
 103 #endif
 104
 105 /**
 106  * elf_symtab__for_each_symbol - iterate thru all the symbols
 107  *
 108  * @syms: struct elf_symtab instance to iterate
 109  * @idx: uint32_t idx
 110  * @sym: GElf_Sym iterator
 111  */
 112 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 113         for (idx = 0, gelf_getsym(syms, idx, &sym);\
 114              idx < nr_syms; \
 115              idx++, gelf_getsym(syms, idx, &sym))
 116
 117 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 118 {
 119         return GELF_ST_TYPE(sym->st_info);
 120 }
 121
 122 static inline uint8_t elf_sym__visibility(const GElf_Sym *sym)
 123 {
 124         return GELF_ST_VISIBILITY(sym->st_other);
 125 }
 126
 127 #ifndef STT_GNU_IFUNC
 128 #define STT_GNU_IFUNC 10
 129 #endif
 130
 131 static inline int elf_sym__is_function(const GElf_Sym *sym)
 132 {
 133         return (elf_sym__type(sym) == STT_FUNC ||
 134                 elf_sym__type(sym) == STT_GNU_IFUNC) &&
 135                sym->st_name != 0 &&
 136                sym->st_shndx != SHN_UNDEF;
 137 }
 138
 139 static inline bool elf_sym__is_object(const GElf_Sym *sym)
 140 {
 141         return elf_sym__type(sym) == STT_OBJECT &&
 142                 sym->st_name != 0 &&
 143                 sym->st_shndx != SHN_UNDEF;
 144 }
 145
 146 static inline int elf_sym__is_label(const GElf_Sym *sym)
 147 {
 148         return elf_sym__type(sym) == STT_NOTYPE &&
 149                 sym->st_name != 0 &&
 150                 sym->st_shndx != SHN_UNDEF &&
 151                 sym->st_shndx != SHN_ABS &&
 152                 elf_sym__visibility(sym) != STV_HIDDEN &&
 153                 elf_sym__visibility(sym) != STV_INTERNAL;
 154 }
 155
 156 static bool elf_sym__filter(GElf_Sym *sym)
 157 {
 158         return elf_sym__is_function(sym) || elf_sym__is_object(sym);
 159 }
 160
 161 static inline const char *elf_sym__name(const GElf_Sym *sym,
 162                                         const Elf_Data *symstrs)
 163 {
 164         return symstrs->d_buf + sym->st_name;
 165 }
 166
 167 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 168                                         const Elf_Data *secstrs)
 169 {
 170         return secstrs->d_buf + shdr->sh_name;
 171 }
 172
 173 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 174                                         const Elf_Data *secstrs)
 175 {
 176         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 177 }
 178
 179 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 180                                     const Elf_Data *secstrs)
 181 {
 182         return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 183 }
 184
 185 static bool elf_sec__filter(GElf_Shdr *shdr, Elf_Data *secstrs)
 186 {
 187         return elf_sec__is_text(shdr, secstrs) ||
 188                elf_sec__is_data(shdr, secstrs);
 189 }
 190
 191 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
 192 {
 193         Elf_Scn *sec = NULL;
 194         GElf_Shdr shdr;
 195         size_t cnt = 1;
 196
 197         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 198                 gelf_getshdr(sec, &shdr);
 199
 200                 if ((addr >= shdr.sh_addr) &&
 201                     (addr < (shdr.sh_addr + shdr.sh_size)))
 202                         return cnt;
 203
 204                 ++cnt;
 205         }
 206
 207         return -1;
 208 }
 209
 210 Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 211                              GElf_Shdr *shp, const char *name, size_t *idx)
 212 {
 213         Elf_Scn *sec = NULL;
 214         size_t cnt = 1;
 215
 216         /* Elf is corrupted/truncated, avoid calling elf_strptr. */
 217         if (!elf_rawdata(elf_getscn(elf, ep->e_shstrndx), NULL))
 218                 return NULL;
 219
 220         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 221                 char *str;
 222
 223                 gelf_getshdr(sec, shp);
 224                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 225                 if (str && !strcmp(name, str)) {
 226                         if (idx)
 227                                 *idx = cnt;
 228                         return sec;
 229                 }
 230                 ++cnt;
 231         }
 232
 233         return NULL;
 234 }
 235
 236 bool filename__has_section(const char *filename, const char *sec)
 237 {
 238         int fd;
 239         Elf *elf;
 240         GElf_Ehdr ehdr;
 241         GElf_Shdr shdr;
 242         bool found = false;
 243
 244         fd = open(filename, O_RDONLY);
 245         if (fd < 0)
 246                 return false;
 247
 248         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 249         if (elf == NULL)
 250                 goto out;
 251
 252         if (gelf_getehdr(elf, &ehdr) == NULL)
 253                 goto elf_out;
 254
 255         found = !!elf_section_by_name(elf, &ehdr, &shdr, sec, NULL);
 256
 257 elf_out:
 258         elf_end(elf);
 259 out:
 260         close(fd);
 261         return found;
 262 }
 263
 264 static int elf_read_program_header(Elf *elf, u64 vaddr, GElf_Phdr *phdr)
 265 {
 266         size_t i, phdrnum;
 267         u64 sz;
 268
 269         if (elf_getphdrnum(elf, &phdrnum))
 270                 return -1;
 271
 272         for (i = 0; i < phdrnum; i++) {
 273                 if (gelf_getphdr(elf, i, phdr) == NULL)
 274                         return -1;
 275
 276                 if (phdr->p_type != PT_LOAD)
 277                         continue;
 278
 279                 sz = max(phdr->p_memsz, phdr->p_filesz);
 280                 if (!sz)
 281                         continue;
 282
 283                 if (vaddr >= phdr->p_vaddr && (vaddr < phdr->p_vaddr + sz))
 284                         return 0;
 285         }
 286
 287         /* Not found any valid program header */
 288         return -1;
 289 }
 290
 291 static bool want_demangle(bool is_kernel_sym)
 292 {
 293         return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
 294 }
 295
 296 static char *demangle_sym(struct dso *dso, int kmodule, const char *elf_name)
 297 {
 298         int demangle_flags = verbose > 0 ? (DMGL_PARAMS | DMGL_ANSI) : DMGL_NO_OPTS;
 299         char *demangled = NULL;
 300
 301         /*
 302          * We need to figure out if the object was created from C++ sources
 303          * DWARF DW_compile_unit has this, but we don't always have access
 304          * to it...
 305          */
 306         if (!want_demangle(dso->kernel || kmodule))
 307             return demangled;
 308
 309         demangled = bfd_demangle(NULL, elf_name, demangle_flags);
 310         if (demangled == NULL) {
 311                 demangled = ocaml_demangle_sym(elf_name);
 312                 if (demangled == NULL) {
 313                         demangled = java_demangle_sym(elf_name, JAVA_DEMANGLE_NORET);
 314                 }
 315         }
 316         else if (rust_is_mangled(demangled))
 317                 /*
 318                     * Input to Rust demangling is the BFD-demangled
 319                     * name which it Rust-demangles in place.
 320                     */
 321                 rust_demangle_sym(demangled);
 322
 323         return demangled;
 324 }
 325
 326 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 327         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 328              idx < nr_entries; \
 329              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 330
 331 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 332         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 333              idx < nr_entries; \
 334              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 335
 336 /*
 337  * We need to check if we have a .dynsym, so that we can handle the
 338  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 339  * .dynsym or .symtab).
 340  * And always look at the original dso, not at debuginfo packages, that
 341  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 342  */
 343 int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss)
 344 {
 345         uint32_t nr_rel_entries, idx;
 346         GElf_Sym sym;
 347         u64 plt_offset, plt_header_size, plt_entry_size;
 348         GElf_Shdr shdr_plt;
 349         struct symbol *f;
 350         GElf_Shdr shdr_rel_plt, shdr_dynsym;
 351         Elf_Data *reldata, *syms, *symstrs;
 352         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 353         size_t dynsym_idx;
 354         GElf_Ehdr ehdr;
 355         char sympltname[1024];
 356         Elf *elf;
 357         int nr = 0, symidx, err = 0;
 358
 359         if (!ss->dynsym)
 360                 return 0;
 361
 362         elf = ss->elf;
 363         ehdr = ss->ehdr;
 364
 365         scn_dynsym = ss->dynsym;
 366         shdr_dynsym = ss->dynshdr;
 367         dynsym_idx = ss->dynsym_idx;
 368
 369         if (scn_dynsym == NULL)
 370                 goto out_elf_end;
 371
 372         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 373                                           ".rela.plt", NULL);
 374         if (scn_plt_rel == NULL) {
 375                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 376                                                   ".rel.plt", NULL);
 377                 if (scn_plt_rel == NULL)
 378                         goto out_elf_end;
 379         }
 380
 381         err = -1;
 382
 383         if (shdr_rel_plt.sh_link != dynsym_idx)
 384                 goto out_elf_end;
 385
 386         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
 387                 goto out_elf_end;
 388
 389         /*
 390          * Fetch the relocation section to find the idxes to the GOT
 391          * and the symbols in the .dynsym they refer to.
 392          */
 393         reldata = elf_getdata(scn_plt_rel, NULL);
 394         if (reldata == NULL)
 395                 goto out_elf_end;
 396
 397         syms = elf_getdata(scn_dynsym, NULL);
 398         if (syms == NULL)
 399                 goto out_elf_end;
 400
 401         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
 402         if (scn_symstrs == NULL)
 403                 goto out_elf_end;
 404
 405         symstrs = elf_getdata(scn_symstrs, NULL);
 406         if (symstrs == NULL)
 407                 goto out_elf_end;
 408
 409         if (symstrs->d_size == 0)
 410                 goto out_elf_end;
 411
 412         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
 413         plt_offset = shdr_plt.sh_offset;
 414         switch (ehdr.e_machine) {
 415                 case EM_ARM:
 416                         plt_header_size = 20;
 417                         plt_entry_size = 12;
 418                         break;
 419
 420                 case EM_AARCH64:
 421                         plt_header_size = 32;
 422                         plt_entry_size = 16;
 423                         break;
 424
 425                 case EM_SPARC:
 426                         plt_header_size = 48;
 427                         plt_entry_size = 12;
 428                         break;
 429
 430                 case EM_SPARCV9:
 431                         plt_header_size = 128;
 432                         plt_entry_size = 32;
 433                         break;
 434
 435                 default: /* FIXME: s390/alpha/mips/parisc/poperpc/sh/xtensa need to be checked */
 436                         plt_header_size = shdr_plt.sh_entsize;
 437                         plt_entry_size = shdr_plt.sh_entsize;
 438                         break;
 439         }
 440         plt_offset += plt_header_size;
 441
 442         if (shdr_rel_plt.sh_type == SHT_RELA) {
 443                 GElf_Rela pos_mem, *pos;
 444
 445                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
 446                                            nr_rel_entries) {
 447                         const char *elf_name = NULL;
 448                         char *demangled = NULL;
 449                         symidx = GELF_R_SYM(pos->r_info);
 450                         gelf_getsym(syms, symidx, &sym);
 451
 452                         elf_name = elf_sym__name(&sym, symstrs);
 453                         demangled = demangle_sym(dso, 0, elf_name);
 454                         if (demangled != NULL)
 455                                 elf_name = demangled;
 456                         snprintf(sympltname, sizeof(sympltname),
 457                                  "%s@plt", elf_name);
 458                         free(demangled);
 459
 460                         f = symbol__new(plt_offset, plt_entry_size,
 461                                         STB_GLOBAL, STT_FUNC, sympltname);
 462                         if (!f)
 463                                 goto out_elf_end;
 464
 465                         plt_offset += plt_entry_size;
 466                         symbols__insert(&dso->symbols, f);
 467                         ++nr;
 468                 }
 469         } else if (shdr_rel_plt.sh_type == SHT_REL) {
 470                 GElf_Rel pos_mem, *pos;
 471                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
 472                                           nr_rel_entries) {
 473                         const char *elf_name = NULL;
 474                         char *demangled = NULL;
 475                         symidx = GELF_R_SYM(pos->r_info);
 476                         gelf_getsym(syms, symidx, &sym);
 477
 478                         elf_name = elf_sym__name(&sym, symstrs);
 479                         demangled = demangle_sym(dso, 0, elf_name);
 480                         if (demangled != NULL)
 481                                 elf_name = demangled;
 482                         snprintf(sympltname, sizeof(sympltname),
 483                                  "%s@plt", elf_name);
 484                         free(demangled);
 485
 486                         f = symbol__new(plt_offset, plt_entry_size,
 487                                         STB_GLOBAL, STT_FUNC, sympltname);
 488                         if (!f)
 489                                 goto out_elf_end;
 490
 491                         plt_offset += plt_entry_size;
 492                         symbols__insert(&dso->symbols, f);
 493                         ++nr;
 494                 }
 495         }
 496
 497         err = 0;
 498 out_elf_end:
 499         if (err == 0)
 500                 return nr;
 501         pr_debug("%s: problems reading %s PLT info.\n",
 502                  __func__, dso->long_name);
 503         return 0;
 504 }
 505
 506 char *dso__demangle_sym(struct dso *dso, int kmodule, const char *elf_name)
 507 {
 508         return demangle_sym(dso, kmodule, elf_name);
 509 }
 510
 511 /*
 512  * Align offset to 4 bytes as needed for note name and descriptor data.
 513  */
 514 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
 515
 516 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
 517 {
 518         int err = -1;
 519         GElf_Ehdr ehdr;
 520         GElf_Shdr shdr;
 521         Elf_Data *data;
 522         Elf_Scn *sec;
 523         Elf_Kind ek;
 524         void *ptr;
 525
 526         if (size < BUILD_ID_SIZE)
 527                 goto out;
 528
 529         ek = elf_kind(elf);
 530         if (ek != ELF_K_ELF)
 531                 goto out;
 532
 533         if (gelf_getehdr(elf, &ehdr) == NULL) {
 534                 pr_err("%s: cannot get elf header.\n", __func__);
 535                 goto out;
 536         }
 537
 538         /*
 539          * Check following sections for notes:
 540          *   '.note.gnu.build-id'
 541          *   '.notes'
 542          *   '.note' (VDSO specific)
 543          */
 544         do {
 545                 sec = elf_section_by_name(elf, &ehdr, &shdr,
 546                                           ".note.gnu.build-id", NULL);
 547                 if (sec)
 548                         break;
 549
 550                 sec = elf_section_by_name(elf, &ehdr, &shdr,
 551                                           ".notes", NULL);
 552                 if (sec)
 553                         break;
 554
 555                 sec = elf_section_by_name(elf, &ehdr, &shdr,
 556                                           ".note", NULL);
 557                 if (sec)
 558                         break;
 559
 560                 return err;
 561
 562         } while (0);
 563
 564         data = elf_getdata(sec, NULL);
 565         if (data == NULL)
 566                 goto out;
 567
 568         ptr = data->d_buf;
 569         while (ptr < (data->d_buf + data->d_size)) {
 570                 GElf_Nhdr *nhdr = ptr;
 571                 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
 572                        descsz = NOTE_ALIGN(nhdr->n_descsz);
 573                 const char *name;
 574
 575                 ptr += sizeof(*nhdr);
 576                 name = ptr;
 577                 ptr += namesz;
 578                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
 579                     nhdr->n_namesz == sizeof("GNU")) {
 580                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
 581                                 size_t sz = min(size, descsz);
 582                                 memcpy(bf, ptr, sz);
 583                                 memset(bf + sz, 0, size - sz);
 584                                 err = descsz;
 585                                 break;
 586                         }
 587                 }
 588                 ptr += descsz;
 589         }
 590
 591 out:
 592         return err;
 593 }
 594
 595 #ifdef HAVE_LIBBFD_BUILDID_SUPPORT
 596
 597 static int read_build_id(const char *filename, struct build_id *bid)
 598 {
 599         size_t size = sizeof(bid->data);
 600         int err = -1;
 601         bfd *abfd;
 602
 603         abfd = bfd_openr(filename, NULL);
 604         if (!abfd)
 605                 return -1;
 606
 607         if (!bfd_check_format(abfd, bfd_object)) {
 608                 pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
 609                 goto out_close;
 610         }
 611
 612         if (!abfd->build_id || abfd->build_id->size > size)
 613                 goto out_close;
 614
 615         memcpy(bid->data, abfd->build_id->data, abfd->build_id->size);
 616         memset(bid->data + abfd->build_id->size, 0, size - abfd->build_id->size);
 617         err = bid->size = abfd->build_id->size;
 618
 619 out_close:
 620         bfd_close(abfd);
 621         return err;
 622 }
 623
 624 #else // HAVE_LIBBFD_BUILDID_SUPPORT
 625
 626 static int read_build_id(const char *filename, struct build_id *bid)
 627 {
 628         size_t size = sizeof(bid->data);
 629         int fd, err = -1;
 630         Elf *elf;
 631
 632         if (size < BUILD_ID_SIZE)
 633                 goto out;
 634
 635         fd = open(filename, O_RDONLY);
 636         if (fd < 0)
 637                 goto out;
 638
 639         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 640         if (elf == NULL) {
 641                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
 642                 goto out_close;
 643         }
 644
 645         err = elf_read_build_id(elf, bid->data, size);
 646         if (err > 0)
 647                 bid->size = err;
 648
 649         elf_end(elf);
 650 out_close:
 651         close(fd);
 652 out:
 653         return err;
 654 }
 655
 656 #endif // HAVE_LIBBFD_BUILDID_SUPPORT
 657
 658 int filename__read_build_id(const char *filename, struct build_id *bid)
 659 {
 660         struct kmod_path m = { .name = NULL, };
 661         char path[PATH_MAX];
 662         int err;
 663
 664         if (!filename)
 665                 return -EFAULT;
 666
 667         err = kmod_path__parse(&m, filename);
 668         if (err)
 669                 return -1;
 670
 671         if (m.comp) {
 672                 int error = 0, fd;
 673
 674                 fd = filename__decompress(filename, path, sizeof(path), m.comp, &error);
 675                 if (fd < 0) {
 676                         pr_debug("Failed to decompress (error %d) %s\n",
 677                                  error, filename);
 678                         return -1;
 679                 }
 680                 close(fd);
 681                 filename = path;
 682         }
 683
 684         err = read_build_id(filename, bid);
 685
 686         if (m.comp)
 687                 unlink(filename);
 688         return err;
 689 }
 690
 691 int sysfs__read_build_id(const char *filename, struct build_id *bid)
 692 {
 693         size_t size = sizeof(bid->data);
 694         int fd, err = -1;
 695
 696         fd = open(filename, O_RDONLY);
 697         if (fd < 0)
 698                 goto out;
 699
 700         while (1) {
 701                 char bf[BUFSIZ];
 702                 GElf_Nhdr nhdr;
 703                 size_t namesz, descsz;
 704
 705                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
 706                         break;
 707
 708                 namesz = NOTE_ALIGN(nhdr.n_namesz);
 709                 descsz = NOTE_ALIGN(nhdr.n_descsz);
 710                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
 711                     nhdr.n_namesz == sizeof("GNU")) {
 712                         if (read(fd, bf, namesz) != (ssize_t)namesz)
 713                                 break;
 714                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
 715                                 size_t sz = min(descsz, size);
 716                                 if (read(fd, bid->data, sz) == (ssize_t)sz) {
 717                                         memset(bid->data + sz, 0, size - sz);
 718                                         bid->size = sz;
 719                                         err = 0;
 720                                         break;
 721                                 }
 722                         } else if (read(fd, bf, descsz) != (ssize_t)descsz)
 723                                 break;
 724                 } else {
 725                         int n = namesz + descsz;
 726
 727                         if (n > (int)sizeof(bf)) {
 728                                 n = sizeof(bf);
 729                                 pr_debug("%s: truncating reading of build id in sysfs file %s: n_namesz=%u, n_descsz=%u.\n",
 730                                          __func__, filename, nhdr.n_namesz, nhdr.n_descsz);
 731                         }
 732                         if (read(fd, bf, n) != n)
 733                                 break;
 734                 }
 735         }
 736         close(fd);
 737 out:
 738         return err;
 739 }
 740
 741 #ifdef HAVE_LIBBFD_SUPPORT
 742
 743 int filename__read_debuglink(const char *filename, char *debuglink,
 744                              size_t size)
 745 {
 746         int err = -1;
 747         asection *section;
 748         bfd *abfd;
 749
 750         abfd = bfd_openr(filename, NULL);
 751         if (!abfd)
 752                 return -1;
 753
 754         if (!bfd_check_format(abfd, bfd_object)) {
 755                 pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
 756                 goto out_close;
 757         }
 758
 759         section = bfd_get_section_by_name(abfd, ".gnu_debuglink");
 760         if (!section)
 761                 goto out_close;
 762
 763         if (section->size > size)
 764                 goto out_close;
 765
 766         if (!bfd_get_section_contents(abfd, section, debuglink, 0,
 767                                       section->size))
 768                 goto out_close;
 769
 770         err = 0;
 771
 772 out_close:
 773         bfd_close(abfd);
 774         return err;
 775 }
 776
 777 #else
 778
 779 int filename__read_debuglink(const char *filename, char *debuglink,
 780                              size_t size)
 781 {
 782         int fd, err = -1;
 783         Elf *elf;
 784         GElf_Ehdr ehdr;
 785         GElf_Shdr shdr;
 786         Elf_Data *data;
 787         Elf_Scn *sec;
 788         Elf_Kind ek;
 789
 790         fd = open(filename, O_RDONLY);
 791         if (fd < 0)
 792                 goto out;
 793
 794         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 795         if (elf == NULL) {
 796                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
 797                 goto out_close;
 798         }
 799
 800         ek = elf_kind(elf);
 801         if (ek != ELF_K_ELF)
 802                 goto out_elf_end;
 803
 804         if (gelf_getehdr(elf, &ehdr) == NULL) {
 805                 pr_err("%s: cannot get elf header.\n", __func__);
 806                 goto out_elf_end;
 807         }
 808
 809         sec = elf_section_by_name(elf, &ehdr, &shdr,
 810                                   ".gnu_debuglink", NULL);
 811         if (sec == NULL)
 812                 goto out_elf_end;
 813
 814         data = elf_getdata(sec, NULL);
 815         if (data == NULL)
 816                 goto out_elf_end;
 817
 818         /* the start of this section is a zero-terminated string */
 819         strncpy(debuglink, data->d_buf, size);
 820
 821         err = 0;
 822
 823 out_elf_end:
 824         elf_end(elf);
 825 out_close:
 826         close(fd);
 827 out:
 828         return err;
 829 }
 830
 831 #endif
 832
 833 static int dso__swap_init(struct dso *dso, unsigned char eidata)
 834 {
 835         static unsigned int const endian = 1;
 836
 837         dso->needs_swap = DSO_SWAP__NO;
 838
 839         switch (eidata) {
 840         case ELFDATA2LSB:
 841                 /* We are big endian, DSO is little endian. */
 842                 if (*(unsigned char const *)&endian != 1)
 843                         dso->needs_swap = DSO_SWAP__YES;
 844                 break;
 845
 846         case ELFDATA2MSB:
 847                 /* We are little endian, DSO is big endian. */
 848                 if (*(unsigned char const *)&endian != 0)
 849                         dso->needs_swap = DSO_SWAP__YES;
 850                 break;
 851
 852         default:
 853                 pr_err("unrecognized DSO data encoding %d\n", eidata);
 854                 return -EINVAL;
 855         }
 856
 857         return 0;
 858 }
 859
 860 bool symsrc__possibly_runtime(struct symsrc *ss)
 861 {
 862         return ss->dynsym || ss->opdsec;
 863 }
 864
 865 bool symsrc__has_symtab(struct symsrc *ss)
 866 {
 867         return ss->symtab != NULL;
 868 }
 869
 870 void symsrc__destroy(struct symsrc *ss)
 871 {
 872         zfree(&ss->name);
 873         elf_end(ss->elf);
 874         close(ss->fd);
 875 }
 876
 877 bool elf__needs_adjust_symbols(GElf_Ehdr ehdr)
 878 {
 879         /*
 880          * Usually vmlinux is an ELF file with type ET_EXEC for most
 881          * architectures; except Arm64 kernel is linked with option
 882          * '-share', so need to check type ET_DYN.
 883          */
 884         return ehdr.e_type == ET_EXEC || ehdr.e_type == ET_REL ||
 885                ehdr.e_type == ET_DYN;
 886 }
 887
 888 int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
 889                  enum dso_binary_type type)
 890 {
 891         GElf_Ehdr ehdr;
 892         Elf *elf;
 893         int fd;
 894
 895         if (dso__needs_decompress(dso)) {
 896                 fd = dso__decompress_kmodule_fd(dso, name);
 897                 if (fd < 0)
 898                         return -1;
 899
 900                 type = dso->symtab_type;
 901         } else {
 902                 fd = open(name, O_RDONLY);
 903                 if (fd < 0) {
 904                         dso->load_errno = errno;
 905                         return -1;
 906                 }
 907         }
 908
 909         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 910         if (elf == NULL) {
 911                 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
 912                 dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
 913                 goto out_close;
 914         }
 915
 916         if (gelf_getehdr(elf, &ehdr) == NULL) {
 917                 dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
 918                 pr_debug("%s: cannot get elf header.\n", __func__);
 919                 goto out_elf_end;
 920         }
 921
 922         if (dso__swap_init(dso, ehdr.e_ident[EI_DATA])) {
 923                 dso->load_errno = DSO_LOAD_ERRNO__INTERNAL_ERROR;
 924                 goto out_elf_end;
 925         }
 926
 927         /* Always reject images with a mismatched build-id: */
 928         if (dso->has_build_id && !symbol_conf.ignore_vmlinux_buildid) {
 929                 u8 build_id[BUILD_ID_SIZE];
 930                 struct build_id bid;
 931                 int size;
 932
 933                 size = elf_read_build_id(elf, build_id, BUILD_ID_SIZE);
 934                 if (size <= 0) {
 935                         dso->load_errno = DSO_LOAD_ERRNO__CANNOT_READ_BUILDID;
 936                         goto out_elf_end;
 937                 }
 938
 939                 build_id__init(&bid, build_id, size);
 940                 if (!dso__build_id_equal(dso, &bid)) {
 941                         pr_debug("%s: build id mismatch for %s.\n", __func__, name);
 942                         dso->load_errno = DSO_LOAD_ERRNO__MISMATCHING_BUILDID;
 943                         goto out_elf_end;
 944                 }
 945         }
 946
 947         ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
 948
 949         ss->symtab = elf_section_by_name(elf, &ehdr, &ss->symshdr, ".symtab",
 950                         NULL);
 951         if (ss->symshdr.sh_type != SHT_SYMTAB)
 952                 ss->symtab = NULL;
 953
 954         ss->dynsym_idx = 0;
 955         ss->dynsym = elf_section_by_name(elf, &ehdr, &ss->dynshdr, ".dynsym",
 956                         &ss->dynsym_idx);
 957         if (ss->dynshdr.sh_type != SHT_DYNSYM)
 958                 ss->dynsym = NULL;
 959
 960         ss->opdidx = 0;
 961         ss->opdsec = elf_section_by_name(elf, &ehdr, &ss->opdshdr, ".opd",
 962                         &ss->opdidx);
 963         if (ss->opdshdr.sh_type != SHT_PROGBITS)
 964                 ss->opdsec = NULL;
 965
 966         if (dso->kernel == DSO_SPACE__USER)
 967                 ss->adjust_symbols = true;
 968         else
 969                 ss->adjust_symbols = elf__needs_adjust_symbols(ehdr);
 970
 971         ss->name   = strdup(name);
 972         if (!ss->name) {
 973                 dso->load_errno = errno;
 974                 goto out_elf_end;
 975         }
 976
 977         ss->elf    = elf;
 978         ss->fd     = fd;
 979         ss->ehdr   = ehdr;
 980         ss->type   = type;
 981
 982         return 0;
 983
 984 out_elf_end:
 985         elf_end(elf);
 986 out_close:
 987         close(fd);
 988         return -1;
 989 }
 990
 991 /**
 992  * ref_reloc_sym_not_found - has kernel relocation symbol been found.
 993  * @kmap: kernel maps and relocation reference symbol
 994  *
 995  * This function returns %true if we are dealing with the kernel maps and the
 996  * relocation reference symbol has not yet been found.  Otherwise %false is
 997  * returned.
 998  */
 999 static bool ref_reloc_sym_not_found(struct kmap *kmap)
1000 {
1001         return kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1002                !kmap->ref_reloc_sym->unrelocated_addr;
1003 }
1004
1005 /**
1006  * ref_reloc - kernel relocation offset.
1007  * @kmap: kernel maps and relocation reference symbol
1008  *
1009  * This function returns the offset of kernel addresses as determined by using
1010  * the relocation reference symbol i.e. if the kernel has not been relocated
1011  * then the return value is zero.
1012  */
1013 static u64 ref_reloc(struct kmap *kmap)
1014 {
1015         if (kmap && kmap->ref_reloc_sym &&
1016             kmap->ref_reloc_sym->unrelocated_addr)
1017                 return kmap->ref_reloc_sym->addr -
1018                        kmap->ref_reloc_sym->unrelocated_addr;
1019         return 0;
1020 }
1021
1022 void __weak arch__sym_update(struct symbol *s __maybe_unused,
1023                 GElf_Sym *sym __maybe_unused) { }
1024
1025 static int dso__process_kernel_symbol(struct dso *dso, struct map *map,
1026                                       GElf_Sym *sym, GElf_Shdr *shdr,
1027                                       struct maps *kmaps, struct kmap *kmap,
1028                                       struct dso **curr_dsop, struct map **curr_mapp,
1029                                       const char *section_name,
1030                                       bool adjust_kernel_syms, bool kmodule, bool *remap_kernel)
1031 {
1032         struct dso *curr_dso = *curr_dsop;
1033         struct map *curr_map;
1034         char dso_name[PATH_MAX];
1035
1036         /* Adjust symbol to map to file offset */
1037         if (adjust_kernel_syms)
1038                 sym->st_value -= shdr->sh_addr - shdr->sh_offset;
1039
1040         if (strcmp(section_name, (curr_dso->short_name + dso->short_name_len)) == 0)
1041                 return 0;
1042
1043         if (strcmp(section_name, ".text") == 0) {
1044                 /*
1045                  * The initial kernel mapping is based on
1046                  * kallsyms and identity maps.  Overwrite it to
1047                  * map to the kernel dso.
1048                  */
1049                 if (*remap_kernel && dso->kernel && !kmodule) {
1050                         *remap_kernel = false;
1051                         map->start = shdr->sh_addr + ref_reloc(kmap);
1052                         map->end = map->start + shdr->sh_size;
1053                         map->pgoff = shdr->sh_offset;
1054                         map->map_ip = map__map_ip;
1055                         map->unmap_ip = map__unmap_ip;
1056                         /* Ensure maps are correctly ordered */
1057                         if (kmaps) {
1058                                 map__get(map);
1059                                 maps__remove(kmaps, map);
1060                                 maps__insert(kmaps, map);
1061                                 map__put(map);
1062                         }
1063                 }
1064
1065                 /*
1066                  * The initial module mapping is based on
1067                  * /proc/modules mapped to offset zero.
1068                  * Overwrite it to map to the module dso.
1069                  */
1070                 if (*remap_kernel && kmodule) {
1071                         *remap_kernel = false;
1072                         map->pgoff = shdr->sh_offset;
1073                 }
1074
1075                 *curr_mapp = map;
1076                 *curr_dsop = dso;
1077                 return 0;
1078         }
1079
1080         if (!kmap)
1081                 return 0;
1082
1083         snprintf(dso_name, sizeof(dso_name), "%s%s", dso->short_name, section_name);
1084
1085         curr_map = maps__find_by_name(kmaps, dso_name);
1086         if (curr_map == NULL) {
1087                 u64 start = sym->st_value;
1088
1089                 if (kmodule)
1090                         start += map->start + shdr->sh_offset;
1091
1092                 curr_dso = dso__new(dso_name);
1093                 if (curr_dso == NULL)
1094                         return -1;
1095                 curr_dso->kernel = dso->kernel;
1096                 curr_dso->long_name = dso->long_name;
1097                 curr_dso->long_name_len = dso->long_name_len;
1098                 curr_map = map__new2(start, curr_dso);
1099                 dso__put(curr_dso);
1100                 if (curr_map == NULL)
1101                         return -1;
1102
1103                 if (curr_dso->kernel)
1104                         map__kmap(curr_map)->kmaps = kmaps;
1105
1106                 if (adjust_kernel_syms) {
1107                         curr_map->start  = shdr->sh_addr + ref_reloc(kmap);
1108                         curr_map->end    = curr_map->start + shdr->sh_size;
1109                         curr_map->pgoff  = shdr->sh_offset;
1110                 } else {
1111                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
1112                 }
1113                 curr_dso->symtab_type = dso->symtab_type;
1114                 maps__insert(kmaps, curr_map);
1115                 /*
1116                  * Add it before we drop the reference to curr_map, i.e. while
1117                  * we still are sure to have a reference to this DSO via
1118                  * *curr_map->dso.
1119                  */
1120                 dsos__add(&kmaps->machine->dsos, curr_dso);
1121                 /* kmaps already got it */
1122                 map__put(curr_map);
1123                 dso__set_loaded(curr_dso);
1124                 *curr_mapp = curr_map;
1125                 *curr_dsop = curr_dso;
1126         } else
1127                 *curr_dsop = curr_map->dso;
1128
1129         return 0;
1130 }
1131
1132 static int
1133 dso__load_sym_internal(struct dso *dso, struct map *map, struct symsrc *syms_ss,
1134                        struct symsrc *runtime_ss, int kmodule, int dynsym)
1135 {
1136         struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1137         struct maps *kmaps = kmap ? map__kmaps(map) : NULL;
1138         struct map *curr_map = map;
1139         struct dso *curr_dso = dso;
1140         Elf_Data *symstrs, *secstrs, *secstrs_run, *secstrs_sym;
1141         uint32_t nr_syms;
1142         int err = -1;
1143         uint32_t idx;
1144         GElf_Ehdr ehdr;
1145         GElf_Shdr shdr;
1146         GElf_Shdr tshdr;
1147         Elf_Data *syms, *opddata = NULL;
1148         GElf_Sym sym;
1149         Elf_Scn *sec, *sec_strndx;
1150         Elf *elf;
1151         int nr = 0;
1152         bool remap_kernel = false, adjust_kernel_syms = false;
1153
1154         if (kmap && !kmaps)
1155                 return -1;
1156
1157         elf = syms_ss->elf;
1158         ehdr = syms_ss->ehdr;
1159         if (dynsym) {
1160                 sec  = syms_ss->dynsym;
1161                 shdr = syms_ss->dynshdr;
1162         } else {
1163                 sec =  syms_ss->symtab;
1164                 shdr = syms_ss->symshdr;
1165         }
1166
1167         if (elf_section_by_name(runtime_ss->elf, &runtime_ss->ehdr, &tshdr,
1168                                 ".text", NULL))
1169                 dso->text_offset = tshdr.sh_addr - tshdr.sh_offset;
1170
1171         if (runtime_ss->opdsec)
1172                 opddata = elf_rawdata(runtime_ss->opdsec, NULL);
1173
1174         syms = elf_getdata(sec, NULL);
1175         if (syms == NULL)
1176                 goto out_elf_end;
1177
1178         sec = elf_getscn(elf, shdr.sh_link);
1179         if (sec == NULL)
1180                 goto out_elf_end;
1181
1182         symstrs = elf_getdata(sec, NULL);
1183         if (symstrs == NULL)
1184                 goto out_elf_end;
1185
1186         sec_strndx = elf_getscn(runtime_ss->elf, runtime_ss->ehdr.e_shstrndx);
1187         if (sec_strndx == NULL)
1188                 goto out_elf_end;
1189
1190         secstrs_run = elf_getdata(sec_strndx, NULL);
1191         if (secstrs_run == NULL)
1192                 goto out_elf_end;
1193
1194         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1195         if (sec_strndx == NULL)
1196                 goto out_elf_end;
1197
1198         secstrs_sym = elf_getdata(sec_strndx, NULL);
1199         if (secstrs_sym == NULL)
1200                 goto out_elf_end;
1201
1202         nr_syms = shdr.sh_size / shdr.sh_entsize;
1203
1204         memset(&sym, 0, sizeof(sym));
1205
1206         /*
1207          * The kernel relocation symbol is needed in advance in order to adjust
1208          * kernel maps correctly.
1209          */
1210         if (ref_reloc_sym_not_found(kmap)) {
1211                 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1212                         const char *elf_name = elf_sym__name(&sym, symstrs);
1213
1214                         if (strcmp(elf_name, kmap->ref_reloc_sym->name))
1215                                 continue;
1216                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1217                         map->reloc = kmap->ref_reloc_sym->addr -
1218                                      kmap->ref_reloc_sym->unrelocated_addr;
1219                         break;
1220                 }
1221         }
1222
1223         /*
1224          * Handle any relocation of vdso necessary because older kernels
1225          * attempted to prelink vdso to its virtual address.
1226          */
1227         if (dso__is_vdso(dso))
1228                 map->reloc = map->start - dso->text_offset;
1229
1230         dso->adjust_symbols = runtime_ss->adjust_symbols || ref_reloc(kmap);
1231         /*
1232          * Initial kernel and module mappings do not map to the dso.
1233          * Flag the fixups.
1234          */
1235         if (dso->kernel) {
1236                 remap_kernel = true;
1237                 adjust_kernel_syms = dso->adjust_symbols;
1238         }
1239         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1240                 struct symbol *f;
1241                 const char *elf_name = elf_sym__name(&sym, symstrs);
1242                 char *demangled = NULL;
1243                 int is_label = elf_sym__is_label(&sym);
1244                 const char *section_name;
1245                 bool used_opd = false;
1246
1247                 if (!is_label && !elf_sym__filter(&sym))
1248                         continue;
1249
1250                 /* Reject ARM ELF "mapping symbols": these aren't unique and
1251                  * don't identify functions, so will confuse the profile
1252                  * output: */
1253                 if (ehdr.e_machine == EM_ARM || ehdr.e_machine == EM_AARCH64) {
1254                         if (elf_name[0] == '$' && strchr("adtx", elf_name[1])
1255                             && (elf_name[2] == '\0' || elf_name[2] == '.'))
1256                                 continue;
1257                 }
1258
1259                 if (runtime_ss->opdsec && sym.st_shndx == runtime_ss->opdidx) {
1260                         u32 offset = sym.st_value - syms_ss->opdshdr.sh_addr;
1261                         u64 *opd = opddata->d_buf + offset;
1262                         sym.st_value = DSO__SWAP(dso, u64, *opd);
1263                         sym.st_shndx = elf_addr_to_index(runtime_ss->elf,
1264                                         sym.st_value);
1265                         used_opd = true;
1266                 }
1267
1268                 /*
1269                  * When loading symbols in a data mapping, ABS symbols (which
1270                  * has a value of SHN_ABS in its st_shndx) failed at
1271                  * elf_getscn().  And it marks the loading as a failure so
1272                  * already loaded symbols cannot be fixed up.
1273                  *
1274                  * I'm not sure what should be done. Just ignore them for now.
1275                  * - Namhyung Kim
1276                  */
1277                 if (sym.st_shndx == SHN_ABS)
1278                         continue;
1279
1280                 sec = elf_getscn(syms_ss->elf, sym.st_shndx);
1281                 if (!sec)
1282                         goto out_elf_end;
1283
1284                 gelf_getshdr(sec, &shdr);
1285
1286                 /*
1287                  * If the attribute bit SHF_ALLOC is not set, the section
1288                  * doesn't occupy memory during process execution.
1289                  * E.g. ".gnu.warning.*" section is used by linker to generate
1290                  * warnings when calling deprecated functions, the symbols in
1291                  * the section aren't loaded to memory during process execution,
1292                  * so skip them.
1293                  */
1294                 if (!(shdr.sh_flags & SHF_ALLOC))
1295                         continue;
1296
1297                 secstrs = secstrs_sym;
1298
1299                 /*
1300                  * We have to fallback to runtime when syms' section header has
1301                  * NOBITS set. NOBITS results in file offset (sh_offset) not
1302                  * being incremented. So sh_offset used below has different
1303                  * values for syms (invalid) and runtime (valid).
1304                  */
1305                 if (shdr.sh_type == SHT_NOBITS) {
1306                         sec = elf_getscn(runtime_ss->elf, sym.st_shndx);
1307                         if (!sec)
1308                                 goto out_elf_end;
1309
1310                         gelf_getshdr(sec, &shdr);
1311                         secstrs = secstrs_run;
1312                 }
1313
1314                 if (is_label && !elf_sec__filter(&shdr, secstrs))
1315                         continue;
1316
1317                 section_name = elf_sec__name(&shdr, secstrs);
1318
1319                 /* On ARM, symbols for thumb functions have 1 added to
1320                  * the symbol address as a flag - remove it */
1321                 if ((ehdr.e_machine == EM_ARM) &&
1322                     (GELF_ST_TYPE(sym.st_info) == STT_FUNC) &&
1323                     (sym.st_value & 1))
1324                         --sym.st_value;
1325
1326                 if (dso->kernel) {
1327                         if (dso__process_kernel_symbol(dso, map, &sym, &shdr, kmaps, kmap, &curr_dso, &curr_map,
1328                                                        section_name, adjust_kernel_syms, kmodule, &remap_kernel))
1329                                 goto out_elf_end;
1330                 } else if ((used_opd && runtime_ss->adjust_symbols) ||
1331                            (!used_opd && syms_ss->adjust_symbols)) {
1332                         GElf_Phdr phdr;
1333
1334                         if (elf_read_program_header(runtime_ss->elf,
1335                                                     (u64)sym.st_value, &phdr)) {
1336                                 pr_debug4("%s: failed to find program header for "
1337                                            "symbol: %s st_value: %#" PRIx64 "\n",
1338                                            __func__, elf_name, (u64)sym.st_value);
1339                                 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1340                                         "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n",
1341                                         __func__, (u64)sym.st_value, (u64)shdr.sh_addr,
1342                                         (u64)shdr.sh_offset);
1343                                 /*
1344                                  * Fail to find program header, let's rollback
1345                                  * to use shdr.sh_addr and shdr.sh_offset to
1346                                  * calibrate symbol's file address, though this
1347                                  * is not necessary for normal C ELF file, we
1348                                  * still need to handle java JIT symbols in this
1349                                  * case.
1350                                  */
1351                                 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1352                         } else {
1353                                 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1354                                         "p_vaddr: %#" PRIx64 " p_offset: %#" PRIx64 "\n",
1355                                         __func__, (u64)sym.st_value, (u64)phdr.p_vaddr,
1356                                         (u64)phdr.p_offset);
1357                                 sym.st_value -= phdr.p_vaddr - phdr.p_offset;
1358                         }
1359                 }
1360
1361                 demangled = demangle_sym(dso, kmodule, elf_name);
1362                 if (demangled != NULL)
1363                         elf_name = demangled;
1364
1365                 f = symbol__new(sym.st_value, sym.st_size,
1366                                 GELF_ST_BIND(sym.st_info),
1367                                 GELF_ST_TYPE(sym.st_info), elf_name);
1368                 free(demangled);
1369                 if (!f)
1370                         goto out_elf_end;
1371
1372                 arch__sym_update(f, &sym);
1373
1374                 __symbols__insert(&curr_dso->symbols, f, dso->kernel);
1375                 nr++;
1376         }
1377
1378         /*
1379          * For misannotated, zeroed, ASM function sizes.
1380          */
1381         if (nr > 0) {
1382                 symbols__fixup_end(&dso->symbols, false);
1383                 symbols__fixup_duplicate(&dso->symbols);
1384                 if (kmap) {
1385                         /*
1386                          * We need to fixup this here too because we create new
1387                          * maps here, for things like vsyscall sections.
1388                          */
1389                         maps__fixup_end(kmaps);
1390                 }
1391         }
1392         err = nr;
1393 out_elf_end:
1394         return err;
1395 }
1396
1397 int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
1398                   struct symsrc *runtime_ss, int kmodule)
1399 {
1400         int nr = 0;
1401         int err = -1;
1402
1403         dso->symtab_type = syms_ss->type;
1404         dso->is_64_bit = syms_ss->is_64_bit;
1405         dso->rel = syms_ss->ehdr.e_type == ET_REL;
1406
1407         /*
1408          * Modules may already have symbols from kallsyms, but those symbols
1409          * have the wrong values for the dso maps, so remove them.
1410          */
1411         if (kmodule && syms_ss->symtab)
1412                 symbols__delete(&dso->symbols);
1413
1414         if (!syms_ss->symtab) {
1415                 /*
1416                  * If the vmlinux is stripped, fail so we will fall back
1417                  * to using kallsyms. The vmlinux runtime symbols aren't
1418                  * of much use.
1419                  */
1420                 if (dso->kernel)
1421                         return err;
1422         } else  {
1423                 err = dso__load_sym_internal(dso, map, syms_ss, runtime_ss,
1424                                              kmodule, 0);
1425                 if (err < 0)
1426                         return err;
1427                 nr = err;
1428         }
1429
1430         if (syms_ss->dynsym) {
1431                 err = dso__load_sym_internal(dso, map, syms_ss, runtime_ss,
1432                                              kmodule, 1);
1433                 if (err < 0)
1434                         return err;
1435                 err += nr;
1436         }
1437
1438         return err;
1439 }
1440
1441 static int elf_read_maps(Elf *elf, bool exe, mapfn_t mapfn, void *data)
1442 {
1443         GElf_Phdr phdr;
1444         size_t i, phdrnum;
1445         int err;
1446         u64 sz;
1447
1448         if (elf_getphdrnum(elf, &phdrnum))
1449                 return -1;
1450
1451         for (i = 0; i < phdrnum; i++) {
1452                 if (gelf_getphdr(elf, i, &phdr) == NULL)
1453                         return -1;
1454                 if (phdr.p_type != PT_LOAD)
1455                         continue;
1456                 if (exe) {
1457                         if (!(phdr.p_flags & PF_X))
1458                                 continue;
1459                 } else {
1460                         if (!(phdr.p_flags & PF_R))
1461                                 continue;
1462                 }
1463                 sz = min(phdr.p_memsz, phdr.p_filesz);
1464                 if (!sz)
1465                         continue;
1466                 err = mapfn(phdr.p_vaddr, sz, phdr.p_offset, data);
1467                 if (err)
1468                         return err;
1469         }
1470         return 0;
1471 }
1472
1473 int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
1474                     bool *is_64_bit)
1475 {
1476         int err;
1477         Elf *elf;
1478
1479         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1480         if (elf == NULL)
1481                 return -1;
1482
1483         if (is_64_bit)
1484                 *is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
1485
1486         err = elf_read_maps(elf, exe, mapfn, data);
1487
1488         elf_end(elf);
1489         return err;
1490 }
1491
1492 enum dso_type dso__type_fd(int fd)
1493 {
1494         enum dso_type dso_type = DSO__TYPE_UNKNOWN;
1495         GElf_Ehdr ehdr;
1496         Elf_Kind ek;
1497         Elf *elf;
1498
1499         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1500         if (elf == NULL)
1501                 goto out;
1502
1503         ek = elf_kind(elf);
1504         if (ek != ELF_K_ELF)
1505                 goto out_end;
1506
1507         if (gelf_getclass(elf) == ELFCLASS64) {
1508                 dso_type = DSO__TYPE_64BIT;
1509                 goto out_end;
1510         }
1511
1512         if (gelf_getehdr(elf, &ehdr) == NULL)
1513                 goto out_end;
1514
1515         if (ehdr.e_machine == EM_X86_64)
1516                 dso_type = DSO__TYPE_X32BIT;
1517         else
1518                 dso_type = DSO__TYPE_32BIT;
1519 out_end:
1520         elf_end(elf);
1521 out:
1522         return dso_type;
1523 }
1524
1525 static int copy_bytes(int from, off_t from_offs, int to, off_t to_offs, u64 len)
1526 {
1527         ssize_t r;
1528         size_t n;
1529         int err = -1;
1530         char *buf = malloc(page_size);
1531
1532         if (buf == NULL)
1533                 return -1;
1534
1535         if (lseek(to, to_offs, SEEK_SET) != to_offs)
1536                 goto out;
1537
1538         if (lseek(from, from_offs, SEEK_SET) != from_offs)
1539                 goto out;
1540
1541         while (len) {
1542                 n = page_size;
1543                 if (len < n)
1544                         n = len;
1545                 /* Use read because mmap won't work on proc files */
1546                 r = read(from, buf, n);
1547                 if (r < 0)
1548                         goto out;
1549                 if (!r)
1550                         break;
1551                 n = r;
1552                 r = write(to, buf, n);
1553                 if (r < 0)
1554                         goto out;
1555                 if ((size_t)r != n)
1556                         goto out;
1557                 len -= n;
1558         }
1559
1560         err = 0;
1561 out:
1562         free(buf);
1563         return err;
1564 }
1565
1566 struct kcore {
1567         int fd;
1568         int elfclass;
1569         Elf *elf;
1570         GElf_Ehdr ehdr;
1571 };
1572
1573 static int kcore__open(struct kcore *kcore, const char *filename)
1574 {
1575         GElf_Ehdr *ehdr;
1576
1577         kcore->fd = open(filename, O_RDONLY);
1578         if (kcore->fd == -1)
1579                 return -1;
1580
1581         kcore->elf = elf_begin(kcore->fd, ELF_C_READ, NULL);
1582         if (!kcore->elf)
1583                 goto out_close;
1584
1585         kcore->elfclass = gelf_getclass(kcore->elf);
1586         if (kcore->elfclass == ELFCLASSNONE)
1587                 goto out_end;
1588
1589         ehdr = gelf_getehdr(kcore->elf, &kcore->ehdr);
1590         if (!ehdr)
1591                 goto out_end;
1592
1593         return 0;
1594
1595 out_end:
1596         elf_end(kcore->elf);
1597 out_close:
1598         close(kcore->fd);
1599         return -1;
1600 }
1601
1602 static int kcore__init(struct kcore *kcore, char *filename, int elfclass,
1603                        bool temp)
1604 {
1605         kcore->elfclass = elfclass;
1606
1607         if (temp)
1608                 kcore->fd = mkstemp(filename);
1609         else
1610                 kcore->fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0400);
1611         if (kcore->fd == -1)
1612                 return -1;
1613
1614         kcore->elf = elf_begin(kcore->fd, ELF_C_WRITE, NULL);
1615         if (!kcore->elf)
1616                 goto out_close;
1617
1618         if (!gelf_newehdr(kcore->elf, elfclass))
1619                 goto out_end;
1620
1621         memset(&kcore->ehdr, 0, sizeof(GElf_Ehdr));
1622
1623         return 0;
1624
1625 out_end:
1626         elf_end(kcore->elf);
1627 out_close:
1628         close(kcore->fd);
1629         unlink(filename);
1630         return -1;
1631 }
1632
1633 static void kcore__close(struct kcore *kcore)
1634 {
1635         elf_end(kcore->elf);
1636         close(kcore->fd);
1637 }
1638
1639 static int kcore__copy_hdr(struct kcore *from, struct kcore *to, size_t count)
1640 {
1641         GElf_Ehdr *ehdr = &to->ehdr;
1642         GElf_Ehdr *kehdr = &from->ehdr;
1643
1644         memcpy(ehdr->e_ident, kehdr->e_ident, EI_NIDENT);
1645         ehdr->e_type      = kehdr->e_type;
1646         ehdr->e_machine   = kehdr->e_machine;
1647         ehdr->e_version   = kehdr->e_version;
1648         ehdr->e_entry     = 0;
1649         ehdr->e_shoff     = 0;
1650         ehdr->e_flags     = kehdr->e_flags;
1651         ehdr->e_phnum     = count;
1652         ehdr->e_shentsize = 0;
1653         ehdr->e_shnum     = 0;
1654         ehdr->e_shstrndx  = 0;
1655
1656         if (from->elfclass == ELFCLASS32) {
1657                 ehdr->e_phoff     = sizeof(Elf32_Ehdr);
1658                 ehdr->e_ehsize    = sizeof(Elf32_Ehdr);
1659                 ehdr->e_phentsize = sizeof(Elf32_Phdr);
1660         } else {
1661                 ehdr->e_phoff     = sizeof(Elf64_Ehdr);
1662                 ehdr->e_ehsize    = sizeof(Elf64_Ehdr);
1663                 ehdr->e_phentsize = sizeof(Elf64_Phdr);
1664         }
1665
1666         if (!gelf_update_ehdr(to->elf, ehdr))
1667                 return -1;
1668
1669         if (!gelf_newphdr(to->elf, count))
1670                 return -1;
1671
1672         return 0;
1673 }
1674
1675 static int kcore__add_phdr(struct kcore *kcore, int idx, off_t offset,
1676                            u64 addr, u64 len)
1677 {
1678         GElf_Phdr phdr = {
1679                 .p_type         = PT_LOAD,
1680                 .p_flags        = PF_R | PF_W | PF_X,
1681                 .p_offset       = offset,
1682                 .p_vaddr        = addr,
1683                 .p_paddr        = 0,
1684                 .p_filesz       = len,
1685                 .p_memsz        = len,
1686                 .p_align        = page_size,
1687         };
1688
1689         if (!gelf_update_phdr(kcore->elf, idx, &phdr))
1690                 return -1;
1691
1692         return 0;
1693 }
1694
1695 static off_t kcore__write(struct kcore *kcore)
1696 {
1697         return elf_update(kcore->elf, ELF_C_WRITE);
1698 }
1699
1700 struct phdr_data {
1701         off_t offset;
1702         off_t rel;
1703         u64 addr;
1704         u64 len;
1705         struct list_head node;
1706         struct phdr_data *remaps;
1707 };
1708
1709 struct sym_data {
1710         u64 addr;
1711         struct list_head node;
1712 };
1713
1714 struct kcore_copy_info {
1715         u64 stext;
1716         u64 etext;
1717         u64 first_symbol;
1718         u64 last_symbol;
1719         u64 first_module;
1720         u64 first_module_symbol;
1721         u64 last_module_symbol;
1722         size_t phnum;
1723         struct list_head phdrs;
1724         struct list_head syms;
1725 };
1726
1727 #define kcore_copy__for_each_phdr(k, p) \
1728         list_for_each_entry((p), &(k)->phdrs, node)
1729
1730 static struct phdr_data *phdr_data__new(u64 addr, u64 len, off_t offset)
1731 {
1732         struct phdr_data *p = zalloc(sizeof(*p));
1733
1734         if (p) {
1735                 p->addr   = addr;
1736                 p->len    = len;
1737                 p->offset = offset;
1738         }
1739
1740         return p;
1741 }
1742
1743 static struct phdr_data *kcore_copy_info__addnew(struct kcore_copy_info *kci,
1744                                                  u64 addr, u64 len,
1745                                                  off_t offset)
1746 {
1747         struct phdr_data *p = phdr_data__new(addr, len, offset);
1748
1749         if (p)
1750                 list_add_tail(&p->node, &kci->phdrs);
1751
1752         return p;
1753 }
1754
1755 static void kcore_copy__free_phdrs(struct kcore_copy_info *kci)
1756 {
1757         struct phdr_data *p, *tmp;
1758
1759         list_for_each_entry_safe(p, tmp, &kci->phdrs, node) {
1760                 list_del_init(&p->node);
1761                 free(p);
1762         }
1763 }
1764
1765 static struct sym_data *kcore_copy__new_sym(struct kcore_copy_info *kci,
1766                                             u64 addr)
1767 {
1768         struct sym_data *s = zalloc(sizeof(*s));
1769
1770         if (s) {
1771                 s->addr = addr;
1772                 list_add_tail(&s->node, &kci->syms);
1773         }
1774
1775         return s;
1776 }
1777
1778 static void kcore_copy__free_syms(struct kcore_copy_info *kci)
1779 {
1780         struct sym_data *s, *tmp;
1781
1782         list_for_each_entry_safe(s, tmp, &kci->syms, node) {
1783                 list_del_init(&s->node);
1784                 free(s);
1785         }
1786 }
1787
1788 static int kcore_copy__process_kallsyms(void *arg, const char *name, char type,
1789                                         u64 start)
1790 {
1791         struct kcore_copy_info *kci = arg;
1792
1793         if (!kallsyms__is_function(type))
1794                 return 0;
1795
1796         if (strchr(name, '[')) {
1797                 if (!kci->first_module_symbol || start < kci->first_module_symbol)
1798                         kci->first_module_symbol = start;
1799                 if (start > kci->last_module_symbol)
1800                         kci->last_module_symbol = start;
1801                 return 0;
1802         }
1803
1804         if (!kci->first_symbol || start < kci->first_symbol)
1805                 kci->first_symbol = start;
1806
1807         if (!kci->last_symbol || start > kci->last_symbol)
1808                 kci->last_symbol = start;
1809
1810         if (!strcmp(name, "_stext")) {
1811                 kci->stext = start;
1812                 return 0;
1813         }
1814
1815         if (!strcmp(name, "_etext")) {
1816                 kci->etext = start;
1817                 return 0;
1818         }
1819
1820         if (is_entry_trampoline(name) && !kcore_copy__new_sym(kci, start))
1821                 return -1;
1822
1823         return 0;
1824 }
1825
1826 static int kcore_copy__parse_kallsyms(struct kcore_copy_info *kci,
1827                                       const char *dir)
1828 {
1829         char kallsyms_filename[PATH_MAX];
1830
1831         scnprintf(kallsyms_filename, PATH_MAX, "%s/kallsyms", dir);
1832
1833         if (symbol__restricted_filename(kallsyms_filename, "/proc/kallsyms"))
1834                 return -1;
1835
1836         if (kallsyms__parse(kallsyms_filename, kci,
1837                             kcore_copy__process_kallsyms) < 0)
1838                 return -1;
1839
1840         return 0;
1841 }
1842
1843 static int kcore_copy__process_modules(void *arg,
1844                                        const char *name __maybe_unused,
1845                                        u64 start, u64 size __maybe_unused)
1846 {
1847         struct kcore_copy_info *kci = arg;
1848
1849         if (!kci->first_module || start < kci->first_module)
1850                 kci->first_module = start;
1851
1852         return 0;
1853 }
1854
1855 static int kcore_copy__parse_modules(struct kcore_copy_info *kci,
1856                                      const char *dir)
1857 {
1858         char modules_filename[PATH_MAX];
1859
1860         scnprintf(modules_filename, PATH_MAX, "%s/modules", dir);
1861
1862         if (symbol__restricted_filename(modules_filename, "/proc/modules"))
1863                 return -1;
1864
1865         if (modules__parse(modules_filename, kci,
1866                            kcore_copy__process_modules) < 0)
1867                 return -1;
1868
1869         return 0;
1870 }
1871
1872 static int kcore_copy__map(struct kcore_copy_info *kci, u64 start, u64 end,
1873                            u64 pgoff, u64 s, u64 e)
1874 {
1875         u64 len, offset;
1876
1877         if (s < start || s >= end)
1878                 return 0;
1879
1880         offset = (s - start) + pgoff;
1881         len = e < end ? e - s : end - s;
1882
1883         return kcore_copy_info__addnew(kci, s, len, offset) ? 0 : -1;
1884 }
1885
1886 static int kcore_copy__read_map(u64 start, u64 len, u64 pgoff, void *data)
1887 {
1888         struct kcore_copy_info *kci = data;
1889         u64 end = start + len;
1890         struct sym_data *sdat;
1891
1892         if (kcore_copy__map(kci, start, end, pgoff, kci->stext, kci->etext))
1893                 return -1;
1894
1895         if (kcore_copy__map(kci, start, end, pgoff, kci->first_module,
1896                             kci->last_module_symbol))
1897                 return -1;
1898
1899         list_for_each_entry(sdat, &kci->syms, node) {
1900                 u64 s = round_down(sdat->addr, page_size);
1901
1902                 if (kcore_copy__map(kci, start, end, pgoff, s, s + len))
1903                         return -1;
1904         }
1905
1906         return 0;
1907 }
1908
1909 static int kcore_copy__read_maps(struct kcore_copy_info *kci, Elf *elf)
1910 {
1911         if (elf_read_maps(elf, true, kcore_copy__read_map, kci) < 0)
1912                 return -1;
1913
1914         return 0;
1915 }
1916
1917 static void kcore_copy__find_remaps(struct kcore_copy_info *kci)
1918 {
1919         struct phdr_data *p, *k = NULL;
1920         u64 kend;
1921
1922         if (!kci->stext)
1923                 return;
1924
1925         /* Find phdr that corresponds to the kernel map (contains stext) */
1926         kcore_copy__for_each_phdr(kci, p) {
1927                 u64 pend = p->addr + p->len - 1;
1928
1929                 if (p->addr <= kci->stext && pend >= kci->stext) {
1930                         k = p;
1931                         break;
1932                 }
1933         }
1934
1935         if (!k)
1936                 return;
1937
1938         kend = k->offset + k->len;
1939
1940         /* Find phdrs that remap the kernel */
1941         kcore_copy__for_each_phdr(kci, p) {
1942                 u64 pend = p->offset + p->len;
1943
1944                 if (p == k)
1945                         continue;
1946
1947                 if (p->offset >= k->offset && pend <= kend)
1948                         p->remaps = k;
1949         }
1950 }
1951
1952 static void kcore_copy__layout(struct kcore_copy_info *kci)
1953 {
1954         struct phdr_data *p;
1955         off_t rel = 0;
1956
1957         kcore_copy__find_remaps(kci);
1958
1959         kcore_copy__for_each_phdr(kci, p) {
1960                 if (!p->remaps) {
1961                         p->rel = rel;
1962                         rel += p->len;
1963                 }
1964                 kci->phnum += 1;
1965         }
1966
1967         kcore_copy__for_each_phdr(kci, p) {
1968                 struct phdr_data *k = p->remaps;
1969
1970                 if (k)
1971                         p->rel = p->offset - k->offset + k->rel;
1972         }
1973 }
1974
1975 static int kcore_copy__calc_maps(struct kcore_copy_info *kci, const char *dir,
1976                                  Elf *elf)
1977 {
1978         if (kcore_copy__parse_kallsyms(kci, dir))
1979                 return -1;
1980
1981         if (kcore_copy__parse_modules(kci, dir))
1982                 return -1;
1983
1984         if (kci->stext)
1985                 kci->stext = round_down(kci->stext, page_size);
1986         else
1987                 kci->stext = round_down(kci->first_symbol, page_size);
1988
1989         if (kci->etext) {
1990                 kci->etext = round_up(kci->etext, page_size);
1991         } else if (kci->last_symbol) {
1992                 kci->etext = round_up(kci->last_symbol, page_size);
1993                 kci->etext += page_size;
1994         }
1995
1996         if (kci->first_module_symbol &&
1997             (!kci->first_module || kci->first_module_symbol < kci->first_module))
1998                 kci->first_module = kci->first_module_symbol;
1999
2000         kci->first_module = round_down(kci->first_module, page_size);
2001
2002         if (kci->last_module_symbol) {
2003                 kci->last_module_symbol = round_up(kci->last_module_symbol,
2004                                                    page_size);
2005                 kci->last_module_symbol += page_size;
2006         }
2007
2008         if (!kci->stext || !kci->etext)
2009                 return -1;
2010
2011         if (kci->first_module && !kci->last_module_symbol)
2012                 return -1;
2013
2014         if (kcore_copy__read_maps(kci, elf))
2015                 return -1;
2016
2017         kcore_copy__layout(kci);
2018
2019         return 0;
2020 }
2021
2022 static int kcore_copy__copy_file(const char *from_dir, const char *to_dir,
2023                                  const char *name)
2024 {
2025         char from_filename[PATH_MAX];
2026         char to_filename[PATH_MAX];
2027
2028         scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
2029         scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
2030
2031         return copyfile_mode(from_filename, to_filename, 0400);
2032 }
2033
2034 static int kcore_copy__unlink(const char *dir, const char *name)
2035 {
2036         char filename[PATH_MAX];
2037
2038         scnprintf(filename, PATH_MAX, "%s/%s", dir, name);
2039
2040         return unlink(filename);
2041 }
2042
2043 static int kcore_copy__compare_fds(int from, int to)
2044 {
2045         char *buf_from;
2046         char *buf_to;
2047         ssize_t ret;
2048         size_t len;
2049         int err = -1;
2050
2051         buf_from = malloc(page_size);
2052         buf_to = malloc(page_size);
2053         if (!buf_from || !buf_to)
2054                 goto out;
2055
2056         while (1) {
2057                 /* Use read because mmap won't work on proc files */
2058                 ret = read(from, buf_from, page_size);
2059                 if (ret < 0)
2060                         goto out;
2061
2062                 if (!ret)
2063                         break;
2064
2065                 len = ret;
2066
2067                 if (readn(to, buf_to, len) != (int)len)
2068                         goto out;
2069
2070                 if (memcmp(buf_from, buf_to, len))
2071                         goto out;
2072         }
2073
2074         err = 0;
2075 out:
2076         free(buf_to);
2077         free(buf_from);
2078         return err;
2079 }
2080
2081 static int kcore_copy__compare_files(const char *from_filename,
2082                                      const char *to_filename)
2083 {
2084         int from, to, err = -1;
2085
2086         from = open(from_filename, O_RDONLY);
2087         if (from < 0)
2088                 return -1;
2089
2090         to = open(to_filename, O_RDONLY);
2091         if (to < 0)
2092                 goto out_close_from;
2093
2094         err = kcore_copy__compare_fds(from, to);
2095
2096         close(to);
2097 out_close_from:
2098         close(from);
2099         return err;
2100 }
2101
2102 static int kcore_copy__compare_file(const char *from_dir, const char *to_dir,
2103                                     const char *name)
2104 {
2105         char from_filename[PATH_MAX];
2106         char to_filename[PATH_MAX];
2107
2108         scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
2109         scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
2110
2111         return kcore_copy__compare_files(from_filename, to_filename);
2112 }
2113
2114 /**
2115  * kcore_copy - copy kallsyms, modules and kcore from one directory to another.
2116  * @from_dir: from directory
2117  * @to_dir: to directory
2118  *
2119  * This function copies kallsyms, modules and kcore files from one directory to
2120  * another.  kallsyms and modules are copied entirely.  Only code segments are
2121  * copied from kcore.  It is assumed that two segments suffice: one for the
2122  * kernel proper and one for all the modules.  The code segments are determined
2123  * from kallsyms and modules files.  The kernel map starts at _stext or the
2124  * lowest function symbol, and ends at _etext or the highest function symbol.
2125  * The module map starts at the lowest module address and ends at the highest
2126  * module symbol.  Start addresses are rounded down to the nearest page.  End
2127  * addresses are rounded up to the nearest page.  An extra page is added to the
2128  * highest kernel symbol and highest module symbol to, hopefully, encompass that
2129  * symbol too.  Because it contains only code sections, the resulting kcore is
2130  * unusual.  One significant peculiarity is that the mapping (start -> pgoff)
2131  * is not the same for the kernel map and the modules map.  That happens because
2132  * the data is copied adjacently whereas the original kcore has gaps.  Finally,
2133  * kallsyms file is compared with its copy to check that modules have not been
2134  * loaded or unloaded while the copies were taking place.
2135  *
2136  * Return: %0 on success, %-1 on failure.
2137  */
2138 int kcore_copy(const char *from_dir, const char *to_dir)
2139 {
2140         struct kcore kcore;
2141         struct kcore extract;
2142         int idx = 0, err = -1;
2143         off_t offset, sz;
2144         struct kcore_copy_info kci = { .stext = 0, };
2145         char kcore_filename[PATH_MAX];
2146         char extract_filename[PATH_MAX];
2147         struct phdr_data *p;
2148
2149         INIT_LIST_HEAD(&kci.phdrs);
2150         INIT_LIST_HEAD(&kci.syms);
2151
2152         if (kcore_copy__copy_file(from_dir, to_dir, "kallsyms"))
2153                 return -1;
2154
2155         if (kcore_copy__copy_file(from_dir, to_dir, "modules"))
2156                 goto out_unlink_kallsyms;
2157
2158         scnprintf(kcore_filename, PATH_MAX, "%s/kcore", from_dir);
2159         scnprintf(extract_filename, PATH_MAX, "%s/kcore", to_dir);
2160
2161         if (kcore__open(&kcore, kcore_filename))
2162                 goto out_unlink_modules;
2163
2164         if (kcore_copy__calc_maps(&kci, from_dir, kcore.elf))
2165                 goto out_kcore_close;
2166
2167         if (kcore__init(&extract, extract_filename, kcore.elfclass, false))
2168                 goto out_kcore_close;
2169
2170         if (kcore__copy_hdr(&kcore, &extract, kci.phnum))
2171                 goto out_extract_close;
2172
2173         offset = gelf_fsize(extract.elf, ELF_T_EHDR, 1, EV_CURRENT) +
2174                  gelf_fsize(extract.elf, ELF_T_PHDR, kci.phnum, EV_CURRENT);
2175         offset = round_up(offset, page_size);
2176
2177         kcore_copy__for_each_phdr(&kci, p) {
2178                 off_t offs = p->rel + offset;
2179
2180                 if (kcore__add_phdr(&extract, idx++, offs, p->addr, p->len))
2181                         goto out_extract_close;
2182         }
2183
2184         sz = kcore__write(&extract);
2185         if (sz < 0 || sz > offset)
2186                 goto out_extract_close;
2187
2188         kcore_copy__for_each_phdr(&kci, p) {
2189                 off_t offs = p->rel + offset;
2190
2191                 if (p->remaps)
2192                         continue;
2193                 if (copy_bytes(kcore.fd, p->offset, extract.fd, offs, p->len))
2194                         goto out_extract_close;
2195         }
2196
2197         if (kcore_copy__compare_file(from_dir, to_dir, "kallsyms"))
2198                 goto out_extract_close;
2199
2200         err = 0;
2201
2202 out_extract_close:
2203         kcore__close(&extract);
2204         if (err)
2205                 unlink(extract_filename);
2206 out_kcore_close:
2207         kcore__close(&kcore);
2208 out_unlink_modules:
2209         if (err)
2210                 kcore_copy__unlink(to_dir, "modules");
2211 out_unlink_kallsyms:
2212         if (err)
2213                 kcore_copy__unlink(to_dir, "kallsyms");
2214
2215         kcore_copy__free_phdrs(&kci);
2216         kcore_copy__free_syms(&kci);
2217
2218         return err;
2219 }
2220
2221 int kcore_extract__create(struct kcore_extract *kce)
2222 {
2223         struct kcore kcore;
2224         struct kcore extract;
2225         size_t count = 1;
2226         int idx = 0, err = -1;
2227         off_t offset = page_size, sz;
2228
2229         if (kcore__open(&kcore, kce->kcore_filename))
2230                 return -1;
2231
2232         strcpy(kce->extract_filename, PERF_KCORE_EXTRACT);
2233         if (kcore__init(&extract, kce->extract_filename, kcore.elfclass, true))
2234                 goto out_kcore_close;
2235
2236         if (kcore__copy_hdr(&kcore, &extract, count))
2237                 goto out_extract_close;
2238
2239         if (kcore__add_phdr(&extract, idx, offset, kce->addr, kce->len))
2240                 goto out_extract_close;
2241
2242         sz = kcore__write(&extract);
2243         if (sz < 0 || sz > offset)
2244                 goto out_extract_close;
2245
2246         if (copy_bytes(kcore.fd, kce->offs, extract.fd, offset, kce->len))
2247                 goto out_extract_close;
2248
2249         err = 0;
2250
2251 out_extract_close:
2252         kcore__close(&extract);
2253         if (err)
2254                 unlink(kce->extract_filename);
2255 out_kcore_close:
2256         kcore__close(&kcore);
2257
2258         return err;
2259 }
2260
2261 void kcore_extract__delete(struct kcore_extract *kce)
2262 {
2263         unlink(kce->extract_filename);
2264 }
2265
2266 #ifdef HAVE_GELF_GETNOTE_SUPPORT
2267
2268 static void sdt_adjust_loc(struct sdt_note *tmp, GElf_Addr base_off)
2269 {
2270         if (!base_off)
2271                 return;
2272
2273         if (tmp->bit32)
2274                 tmp->addr.a32[SDT_NOTE_IDX_LOC] =
2275                         tmp->addr.a32[SDT_NOTE_IDX_LOC] + base_off -
2276                         tmp->addr.a32[SDT_NOTE_IDX_BASE];
2277         else
2278                 tmp->addr.a64[SDT_NOTE_IDX_LOC] =
2279                         tmp->addr.a64[SDT_NOTE_IDX_LOC] + base_off -
2280                         tmp->addr.a64[SDT_NOTE_IDX_BASE];
2281 }
2282
2283 static void sdt_adjust_refctr(struct sdt_note *tmp, GElf_Addr base_addr,
2284                               GElf_Addr base_off)
2285 {
2286         if (!base_off)
2287                 return;
2288
2289         if (tmp->bit32 && tmp->addr.a32[SDT_NOTE_IDX_REFCTR])
2290                 tmp->addr.a32[SDT_NOTE_IDX_REFCTR] -= (base_addr - base_off);
2291         else if (tmp->addr.a64[SDT_NOTE_IDX_REFCTR])
2292                 tmp->addr.a64[SDT_NOTE_IDX_REFCTR] -= (base_addr - base_off);
2293 }
2294
2295 /**
2296  * populate_sdt_note : Parse raw data and identify SDT note
2297  * @elf: elf of the opened file
2298  * @data: raw data of a section with description offset applied
2299  * @len: note description size
2300  * @type: type of the note
2301  * @sdt_notes: List to add the SDT note
2302  *
2303  * Responsible for parsing the @data in section .note.stapsdt in @elf and
2304  * if its an SDT note, it appends to @sdt_notes list.
2305  */
2306 static int populate_sdt_note(Elf **elf, const char *data, size_t len,
2307                              struct list_head *sdt_notes)
2308 {
2309         const char *provider, *name, *args;
2310         struct sdt_note *tmp = NULL;
2311         GElf_Ehdr ehdr;
2312         GElf_Shdr shdr;
2313         int ret = -EINVAL;
2314
2315         union {
2316                 Elf64_Addr a64[NR_ADDR];
2317                 Elf32_Addr a32[NR_ADDR];
2318         } buf;
2319
2320         Elf_Data dst = {
2321                 .d_buf = &buf, .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
2322                 .d_size = gelf_fsize((*elf), ELF_T_ADDR, NR_ADDR, EV_CURRENT),
2323                 .d_off = 0, .d_align = 0
2324         };
2325         Elf_Data src = {
2326                 .d_buf = (void *) data, .d_type = ELF_T_ADDR,
2327                 .d_version = EV_CURRENT, .d_size = dst.d_size, .d_off = 0,
2328                 .d_align = 0
2329         };
2330
2331         tmp = (struct sdt_note *)calloc(1, sizeof(struct sdt_note));
2332         if (!tmp) {
2333                 ret = -ENOMEM;
2334                 goto out_err;
2335         }
2336
2337         INIT_LIST_HEAD(&tmp->note_list);
2338
2339         if (len < dst.d_size + 3)
2340                 goto out_free_note;
2341
2342         /* Translation from file representation to memory representation */
2343         if (gelf_xlatetom(*elf, &dst, &src,
2344                           elf_getident(*elf, NULL)[EI_DATA]) == NULL) {
2345                 pr_err("gelf_xlatetom : %s\n", elf_errmsg(-1));
2346                 goto out_free_note;
2347         }
2348
2349         /* Populate the fields of sdt_note */
2350         provider = data + dst.d_size;
2351
2352         name = (const char *)memchr(provider, '\0', data + len - provider);
2353         if (name++ == NULL)
2354                 goto out_free_note;
2355
2356         tmp->provider = strdup(provider);
2357         if (!tmp->provider) {
2358                 ret = -ENOMEM;
2359                 goto out_free_note;
2360         }
2361         tmp->name = strdup(name);
2362         if (!tmp->name) {
2363                 ret = -ENOMEM;
2364                 goto out_free_prov;
2365         }
2366
2367         args = memchr(name, '\0', data + len - name);
2368
2369         /*
2370          * There is no argument if:
2371          * - We reached the end of the note;
2372          * - There is not enough room to hold a potential string;
2373          * - The argument string is empty or just contains ':'.
2374          */
2375         if (args == NULL || data + len - args < 2 ||
2376                 args[1] == ':' || args[1] == '\0')
2377                 tmp->args = NULL;
2378         else {
2379                 tmp->args = strdup(++args);
2380                 if (!tmp->args) {
2381                         ret = -ENOMEM;
2382                         goto out_free_name;
2383                 }
2384         }
2385
2386         if (gelf_getclass(*elf) == ELFCLASS32) {
2387                 memcpy(&tmp->addr, &buf, 3 * sizeof(Elf32_Addr));
2388                 tmp->bit32 = true;
2389         } else {
2390                 memcpy(&tmp->addr, &buf, 3 * sizeof(Elf64_Addr));
2391                 tmp->bit32 = false;
2392         }
2393
2394         if (!gelf_getehdr(*elf, &ehdr)) {
2395                 pr_debug("%s : cannot get elf header.\n", __func__);
2396                 ret = -EBADF;
2397                 goto out_free_args;
2398         }
2399
2400         /* Adjust the prelink effect :
2401          * Find out the .stapsdt.base section.
2402          * This scn will help us to handle prelinking (if present).
2403          * Compare the retrieved file offset of the base section with the
2404          * base address in the description of the SDT note. If its different,
2405          * then accordingly, adjust the note location.
2406          */
2407         if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_BASE_SCN, NULL))
2408                 sdt_adjust_loc(tmp, shdr.sh_offset);
2409
2410         /* Adjust reference counter offset */
2411         if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_PROBES_SCN, NULL))
2412                 sdt_adjust_refctr(tmp, shdr.sh_addr, shdr.sh_offset);
2413
2414         list_add_tail(&tmp->note_list, sdt_notes);
2415         return 0;
2416
2417 out_free_args:
2418         zfree(&tmp->args);
2419 out_free_name:
2420         zfree(&tmp->name);
2421 out_free_prov:
2422         zfree(&tmp->provider);
2423 out_free_note:
2424         free(tmp);
2425 out_err:
2426         return ret;
2427 }
2428
2429 /**
2430  * construct_sdt_notes_list : constructs a list of SDT notes
2431  * @elf : elf to look into
2432  * @sdt_notes : empty list_head
2433  *
2434  * Scans the sections in 'elf' for the section
2435  * .note.stapsdt. It, then calls populate_sdt_note to find
2436  * out the SDT events and populates the 'sdt_notes'.
2437  */
2438 static int construct_sdt_notes_list(Elf *elf, struct list_head *sdt_notes)
2439 {
2440         GElf_Ehdr ehdr;
2441         Elf_Scn *scn = NULL;
2442         Elf_Data *data;
2443         GElf_Shdr shdr;
2444         size_t shstrndx, next;
2445         GElf_Nhdr nhdr;
2446         size_t name_off, desc_off, offset;
2447         int ret = 0;
2448
2449         if (gelf_getehdr(elf, &ehdr) == NULL) {
2450                 ret = -EBADF;
2451                 goto out_ret;
2452         }
2453         if (elf_getshdrstrndx(elf, &shstrndx) != 0) {
2454                 ret = -EBADF;
2455                 goto out_ret;
2456         }
2457
2458         /* Look for the required section */
2459         scn = elf_section_by_name(elf, &ehdr, &shdr, SDT_NOTE_SCN, NULL);
2460         if (!scn) {
2461                 ret = -ENOENT;
2462                 goto out_ret;
2463         }
2464
2465         if ((shdr.sh_type != SHT_NOTE) || (shdr.sh_flags & SHF_ALLOC)) {
2466                 ret = -ENOENT;
2467                 goto out_ret;
2468         }
2469
2470         data = elf_getdata(scn, NULL);
2471
2472         /* Get the SDT notes */
2473         for (offset = 0; (next = gelf_getnote(data, offset, &nhdr, &name_off,
2474                                               &desc_off)) > 0; offset = next) {
2475                 if (nhdr.n_namesz == sizeof(SDT_NOTE_NAME) &&
2476                     !memcmp(data->d_buf + name_off, SDT_NOTE_NAME,
2477                             sizeof(SDT_NOTE_NAME))) {
2478                         /* Check the type of the note */
2479                         if (nhdr.n_type != SDT_NOTE_TYPE)
2480                                 goto out_ret;
2481
2482                         ret = populate_sdt_note(&elf, ((data->d_buf) + desc_off),
2483                                                 nhdr.n_descsz, sdt_notes);
2484                         if (ret < 0)
2485                                 goto out_ret;
2486                 }
2487         }
2488         if (list_empty(sdt_notes))
2489                 ret = -ENOENT;
2490
2491 out_ret:
2492         return ret;
2493 }
2494
2495 /**
2496  * get_sdt_note_list : Wrapper to construct a list of sdt notes
2497  * @head : empty list_head
2498  * @target : file to find SDT notes from
2499  *
2500  * This opens the file, initializes
2501  * the ELF and then calls construct_sdt_notes_list.
2502  */
2503 int get_sdt_note_list(struct list_head *head, const char *target)
2504 {
2505         Elf *elf;
2506         int fd, ret;
2507
2508         fd = open(target, O_RDONLY);
2509         if (fd < 0)
2510                 return -EBADF;
2511
2512         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
2513         if (!elf) {
2514                 ret = -EBADF;
2515                 goto out_close;
2516         }
2517         ret = construct_sdt_notes_list(elf, head);
2518         elf_end(elf);
2519 out_close:
2520         close(fd);
2521         return ret;
2522 }
2523
2524 /**
2525  * cleanup_sdt_note_list : free the sdt notes' list
2526  * @sdt_notes: sdt notes' list
2527  *
2528  * Free up the SDT notes in @sdt_notes.
2529  * Returns the number of SDT notes free'd.
2530  */
2531 int cleanup_sdt_note_list(struct list_head *sdt_notes)
2532 {
2533         struct sdt_note *tmp, *pos;
2534         int nr_free = 0;
2535
2536         list_for_each_entry_safe(pos, tmp, sdt_notes, note_list) {
2537                 list_del_init(&pos->note_list);
2538                 zfree(&pos->args);
2539                 zfree(&pos->name);
2540                 zfree(&pos->provider);
2541                 free(pos);
2542                 nr_free++;
2543         }
2544         return nr_free;
2545 }
2546
2547 /**
2548  * sdt_notes__get_count: Counts the number of sdt events
2549  * @start: list_head to sdt_notes list
2550  *
2551  * Returns the number of SDT notes in a list
2552  */
2553 int sdt_notes__get_count(struct list_head *start)
2554 {
2555         struct sdt_note *sdt_ptr;
2556         int count = 0;
2557
2558         list_for_each_entry(sdt_ptr, start, note_list)
2559                 count++;
2560         return count;
2561 }
2562 #endif
2563
2564 void symbol__elf_init(void)
2565 {
2566         elf_version(EV_CURRENT);
2567 }