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