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