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