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