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 633int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name, 634 enum dso_binary_type type) 635{ 636 int err = -1; 637 GElf_Ehdr ehdr; 638 Elf *elf; 639 int fd; 640 641 if (dso__needs_decompress(dso)) { 642 fd = decompress_kmodule(dso, name, type); 643 if (fd < 0) 644 return -1; 645 } else { 646 fd = open(name, O_RDONLY); 647 if (fd < 0) { 648 dso->load_errno = errno; 649 return -1; 650 } 651 } 652 653 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 654 if (elf == NULL) { 655 pr_debug("%s: cannot read %s ELF file.\n", __func__, name); 656 dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF; 657 goto out_close; 658 } 659 660 if (gelf_getehdr(elf, &ehdr) == NULL) { 661 dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF; 662 pr_debug("%s: cannot get elf header.\n", __func__); 663 goto out_elf_end; 664 } 665 666 if (dso__swap_init(dso, ehdr.e_ident[EI_DATA])) { 667 dso->load_errno = DSO_LOAD_ERRNO__INTERNAL_ERROR; 668 goto out_elf_end; 669 } 670 671 /* Always reject images with a mismatched build-id: */ 672 if (dso->has_build_id) { 673 u8 build_id[BUILD_ID_SIZE]; 674 675 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0) { 676 dso->load_errno = DSO_LOAD_ERRNO__CANNOT_READ_BUILDID; 677 goto out_elf_end; 678 } 679 680 if (!dso__build_id_equal(dso, build_id)) { 681 dso->load_errno = DSO_LOAD_ERRNO__MISMATCHING_BUILDID; 682 goto out_elf_end; 683 } 684 } 685 686 ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64); 687 688 ss->symtab = elf_section_by_name(elf, &ehdr, &ss->symshdr, ".symtab", 689 NULL); 690 if (ss->symshdr.sh_type != SHT_SYMTAB) 691 ss->symtab = NULL; 692 693 ss->dynsym_idx = 0; 694 ss->dynsym = elf_section_by_name(elf, &ehdr, &ss->dynshdr, ".dynsym", 695 &ss->dynsym_idx); 696 if (ss->dynshdr.sh_type != SHT_DYNSYM) 697 ss->dynsym = NULL; 698 699 ss->opdidx = 0; 700 ss->opdsec = elf_section_by_name(elf, &ehdr, &ss->opdshdr, ".opd", 701 &ss->opdidx); 702 if (ss->opdshdr.sh_type != SHT_PROGBITS) 703 ss->opdsec = NULL; 704 705 if (dso->kernel == DSO_TYPE_USER) { 706 GElf_Shdr shdr; 707 ss->adjust_symbols = (ehdr.e_type == ET_EXEC || 708 ehdr.e_type == ET_REL || 709 dso__is_vdso(dso) || 710 elf_section_by_name(elf, &ehdr, &shdr, 711 ".gnu.prelink_undo", 712 NULL) != NULL); 713 } else { 714 ss->adjust_symbols = ehdr.e_type == ET_EXEC || 715 ehdr.e_type == ET_REL; 716 } 717 718 ss->name = strdup(name); 719 if (!ss->name) { 720 dso->load_errno = errno; 721 goto out_elf_end; 722 } 723 724 ss->elf = elf; 725 ss->fd = fd; 726 ss->ehdr = ehdr; 727 ss->type = type; 728 729 return 0; 730 731out_elf_end: 732 elf_end(elf); 733out_close: 734 close(fd); 735 return err; 736} 737 738/** 739 * ref_reloc_sym_not_found - has kernel relocation symbol been found. 740 * @kmap: kernel maps and relocation reference symbol 741 * 742 * This function returns %true if we are dealing with the kernel maps and the 743 * relocation reference symbol has not yet been found. Otherwise %false is 744 * returned. 745 */ 746static bool ref_reloc_sym_not_found(struct kmap *kmap) 747{ 748 return kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name && 749 !kmap->ref_reloc_sym->unrelocated_addr; 750} 751 752/** 753 * ref_reloc - kernel relocation offset. 754 * @kmap: kernel maps and relocation reference symbol 755 * 756 * This function returns the offset of kernel addresses as determined by using 757 * the relocation reference symbol i.e. if the kernel has not been relocated 758 * then the return value is zero. 759 */ 760static u64 ref_reloc(struct kmap *kmap) 761{ 762 if (kmap && kmap->ref_reloc_sym && 763 kmap->ref_reloc_sym->unrelocated_addr) 764 return kmap->ref_reloc_sym->addr - 765 kmap->ref_reloc_sym->unrelocated_addr; 766 return 0; 767} 768 769static bool want_demangle(bool is_kernel_sym) 770{ 771 return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle; 772} 773 774int dso__load_sym(struct dso *dso, struct map *map, 775 struct symsrc *syms_ss, struct symsrc *runtime_ss, 776 symbol_filter_t filter, int kmodule) 777{ 778 struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL; 779 struct map_groups *kmaps = kmap ? map__kmaps(map) : NULL; 780 struct map *curr_map = map; 781 struct dso *curr_dso = dso; 782 Elf_Data *symstrs, *secstrs; 783 uint32_t nr_syms; 784 int err = -1; 785 uint32_t idx; 786 GElf_Ehdr ehdr; 787 GElf_Shdr shdr; 788 Elf_Data *syms, *opddata = NULL; 789 GElf_Sym sym; 790 Elf_Scn *sec, *sec_strndx; 791 Elf *elf; 792 int nr = 0; 793 bool remap_kernel = false, adjust_kernel_syms = false; 794 795 if (kmap && !kmaps) 796 return -1; 797 798 dso->symtab_type = syms_ss->type; 799 dso->is_64_bit = syms_ss->is_64_bit; 800 dso->rel = syms_ss->ehdr.e_type == ET_REL; 801 802 /* 803 * Modules may already have symbols from kallsyms, but those symbols 804 * have the wrong values for the dso maps, so remove them. 805 */ 806 if (kmodule && syms_ss->symtab) 807 symbols__delete(&dso->symbols[map->type]); 808 809 if (!syms_ss->symtab) { 810 /* 811 * If the vmlinux is stripped, fail so we will fall back 812 * to using kallsyms. The vmlinux runtime symbols aren't 813 * of much use. 814 */ 815 if (dso->kernel) 816 goto out_elf_end; 817 818 syms_ss->symtab = syms_ss->dynsym; 819 syms_ss->symshdr = syms_ss->dynshdr; 820 } 821 822 elf = syms_ss->elf; 823 ehdr = syms_ss->ehdr; 824 sec = syms_ss->symtab; 825 shdr = syms_ss->symshdr; 826 827 if (runtime_ss->opdsec) 828 opddata = elf_rawdata(runtime_ss->opdsec, NULL); 829 830 syms = elf_getdata(sec, NULL); 831 if (syms == NULL) 832 goto out_elf_end; 833 834 sec = elf_getscn(elf, shdr.sh_link); 835 if (sec == NULL) 836 goto out_elf_end; 837 838 symstrs = elf_getdata(sec, NULL); 839 if (symstrs == NULL) 840 goto out_elf_end; 841 842 sec_strndx = elf_getscn(runtime_ss->elf, runtime_ss->ehdr.e_shstrndx); 843 if (sec_strndx == NULL) 844 goto out_elf_end; 845 846 secstrs = elf_getdata(sec_strndx, NULL); 847 if (secstrs == NULL) 848 goto out_elf_end; 849 850 nr_syms = shdr.sh_size / shdr.sh_entsize; 851 852 memset(&sym, 0, sizeof(sym)); 853 854 /* 855 * The kernel relocation symbol is needed in advance in order to adjust 856 * kernel maps correctly. 857 */ 858 if (ref_reloc_sym_not_found(kmap)) { 859 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) { 860 const char *elf_name = elf_sym__name(&sym, symstrs); 861 862 if (strcmp(elf_name, kmap->ref_reloc_sym->name)) 863 continue; 864 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value; 865 map->reloc = kmap->ref_reloc_sym->addr - 866 kmap->ref_reloc_sym->unrelocated_addr; 867 break; 868 } 869 } 870 871 dso->adjust_symbols = runtime_ss->adjust_symbols || ref_reloc(kmap); 872 /* 873 * Initial kernel and module mappings do not map to the dso. For 874 * function mappings, flag the fixups. 875 */ 876 if (map->type == MAP__FUNCTION && (dso->kernel || kmodule)) { 877 remap_kernel = true; 878 adjust_kernel_syms = dso->adjust_symbols; 879 } 880 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) { 881 struct symbol *f; 882 const char *elf_name = elf_sym__name(&sym, symstrs); 883 char *demangled = NULL; 884 int is_label = elf_sym__is_label(&sym); 885 const char *section_name; 886 bool used_opd = false; 887 888 if (!is_label && !elf_sym__is_a(&sym, map->type)) 889 continue; 890 891 /* Reject ARM ELF "mapping symbols": these aren't unique and 892 * don't identify functions, so will confuse the profile 893 * output: */ 894 if (ehdr.e_machine == EM_ARM || ehdr.e_machine == EM_AARCH64) { 895 if (elf_name[0] == '$' && strchr("adtx", elf_name[1]) 896 && (elf_name[2] == '\0' || elf_name[2] == '.')) 897 continue; 898 } 899 900 if (runtime_ss->opdsec && sym.st_shndx == runtime_ss->opdidx) { 901 u32 offset = sym.st_value - syms_ss->opdshdr.sh_addr; 902 u64 *opd = opddata->d_buf + offset; 903 sym.st_value = DSO__SWAP(dso, u64, *opd); 904 sym.st_shndx = elf_addr_to_index(runtime_ss->elf, 905 sym.st_value); 906 used_opd = true; 907 } 908 /* 909 * When loading symbols in a data mapping, ABS symbols (which 910 * has a value of SHN_ABS in its st_shndx) failed at 911 * elf_getscn(). And it marks the loading as a failure so 912 * already loaded symbols cannot be fixed up. 913 * 914 * I'm not sure what should be done. Just ignore them for now. 915 * - Namhyung Kim 916 */ 917 if (sym.st_shndx == SHN_ABS) 918 continue; 919 920 sec = elf_getscn(runtime_ss->elf, sym.st_shndx); 921 if (!sec) 922 goto out_elf_end; 923 924 gelf_getshdr(sec, &shdr); 925 926 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type)) 927 continue; 928 929 section_name = elf_sec__name(&shdr, secstrs); 930 931 /* On ARM, symbols for thumb functions have 1 added to 932 * the symbol address as a flag - remove it */ 933 if ((ehdr.e_machine == EM_ARM) && 934 (map->type == MAP__FUNCTION) && 935 (sym.st_value & 1)) 936 --sym.st_value; 937 938 if (dso->kernel || kmodule) { 939 char dso_name[PATH_MAX]; 940 941 /* Adjust symbol to map to file offset */ 942 if (adjust_kernel_syms) 943 sym.st_value -= shdr.sh_addr - shdr.sh_offset; 944 945 if (strcmp(section_name, 946 (curr_dso->short_name + 947 dso->short_name_len)) == 0) 948 goto new_symbol; 949 950 if (strcmp(section_name, ".text") == 0) { 951 /* 952 * The initial kernel mapping is based on 953 * kallsyms and identity maps. Overwrite it to 954 * map to the kernel dso. 955 */ 956 if (remap_kernel && dso->kernel) { 957 remap_kernel = false; 958 map->start = shdr.sh_addr + 959 ref_reloc(kmap); 960 map->end = map->start + shdr.sh_size; 961 map->pgoff = shdr.sh_offset; 962 map->map_ip = map__map_ip; 963 map->unmap_ip = map__unmap_ip; 964 /* Ensure maps are correctly ordered */ 965 if (kmaps) { 966 map_groups__remove(kmaps, map); 967 map_groups__insert(kmaps, map); 968 } 969 } 970 971 /* 972 * The initial module mapping is based on 973 * /proc/modules mapped to offset zero. 974 * Overwrite it to map to the module dso. 975 */ 976 if (remap_kernel && kmodule) { 977 remap_kernel = false; 978 map->pgoff = shdr.sh_offset; 979 } 980 981 curr_map = map; 982 curr_dso = dso; 983 goto new_symbol; 984 } 985 986 if (!kmap) 987 goto new_symbol; 988 989 snprintf(dso_name, sizeof(dso_name), 990 "%s%s", dso->short_name, section_name); 991 992 curr_map = map_groups__find_by_name(kmaps, map->type, dso_name); 993 if (curr_map == NULL) { 994 u64 start = sym.st_value; 995 996 if (kmodule) 997 start += map->start + shdr.sh_offset; 998 999 curr_dso = dso__new(dso_name); 1000 if (curr_dso == NULL) 1001 goto out_elf_end; 1002 curr_dso->kernel = dso->kernel; 1003 curr_dso->long_name = dso->long_name; 1004 curr_dso->long_name_len = dso->long_name_len; 1005 curr_map = map__new2(start, curr_dso, 1006 map->type); 1007 if (curr_map == NULL) { 1008 dso__delete(curr_dso); 1009 goto out_elf_end; 1010 } 1011 if (adjust_kernel_syms) { 1012 curr_map->start = shdr.sh_addr + 1013 ref_reloc(kmap); 1014 curr_map->end = curr_map->start + 1015 shdr.sh_size; 1016 curr_map->pgoff = shdr.sh_offset; 1017 } else { 1018 curr_map->map_ip = identity__map_ip; 1019 curr_map->unmap_ip = identity__map_ip; 1020 } 1021 curr_dso->symtab_type = dso->symtab_type; 1022 map_groups__insert(kmaps, curr_map); 1023 /* 1024 * The new DSO should go to the kernel DSOS 1025 */ 1026 dsos__add(&map->groups->machine->kernel_dsos, 1027 curr_dso); 1028 dso__set_loaded(curr_dso, map->type); 1029 } else 1030 curr_dso = curr_map->dso; 1031 1032 goto new_symbol; 1033 } 1034 1035 if ((used_opd && runtime_ss->adjust_symbols) 1036 || (!used_opd && syms_ss->adjust_symbols)) { 1037 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " " 1038 "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__, 1039 (u64)sym.st_value, (u64)shdr.sh_addr, 1040 (u64)shdr.sh_offset); 1041 sym.st_value -= shdr.sh_addr - shdr.sh_offset; 1042 } 1043new_symbol: 1044 /* 1045 * We need to figure out if the object was created from C++ sources 1046 * DWARF DW_compile_unit has this, but we don't always have access 1047 * to it... 1048 */ 1049 if (want_demangle(dso->kernel || kmodule)) { 1050 int demangle_flags = DMGL_NO_OPTS; 1051 if (verbose) 1052 demangle_flags = DMGL_PARAMS | DMGL_ANSI; 1053 1054 demangled = bfd_demangle(NULL, elf_name, demangle_flags); 1055 if (demangled != NULL) 1056 elf_name = demangled; 1057 } 1058 f = symbol__new(sym.st_value, sym.st_size, 1059 GELF_ST_BIND(sym.st_info), elf_name); 1060 free(demangled); 1061 if (!f) 1062 goto out_elf_end; 1063 1064 if (filter && filter(curr_map, f)) 1065 symbol__delete(f); 1066 else { 1067 symbols__insert(&curr_dso->symbols[curr_map->type], f); 1068 nr++; 1069 } 1070 } 1071 1072 /* 1073 * For misannotated, zeroed, ASM function sizes. 1074 */ 1075 if (nr > 0) { 1076 if (!symbol_conf.allow_aliases) 1077 symbols__fixup_duplicate(&dso->symbols[map->type]); 1078 symbols__fixup_end(&dso->symbols[map->type]); 1079 if (kmap) { 1080 /* 1081 * We need to fixup this here too because we create new 1082 * maps here, for things like vsyscall sections. 1083 */ 1084 __map_groups__fixup_end(kmaps, map->type); 1085 } 1086 } 1087 err = nr; 1088out_elf_end: 1089 return err; 1090} 1091 1092static int elf_read_maps(Elf *elf, bool exe, mapfn_t mapfn, void *data) 1093{ 1094 GElf_Phdr phdr; 1095 size_t i, phdrnum; 1096 int err; 1097 u64 sz; 1098 1099 if (elf_getphdrnum(elf, &phdrnum)) 1100 return -1; 1101 1102 for (i = 0; i < phdrnum; i++) { 1103 if (gelf_getphdr(elf, i, &phdr) == NULL) 1104 return -1; 1105 if (phdr.p_type != PT_LOAD) 1106 continue; 1107 if (exe) { 1108 if (!(phdr.p_flags & PF_X)) 1109 continue; 1110 } else { 1111 if (!(phdr.p_flags & PF_R)) 1112 continue; 1113 } 1114 sz = min(phdr.p_memsz, phdr.p_filesz); 1115 if (!sz) 1116 continue; 1117 err = mapfn(phdr.p_vaddr, sz, phdr.p_offset, data); 1118 if (err) 1119 return err; 1120 } 1121 return 0; 1122} 1123 1124int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data, 1125 bool *is_64_bit) 1126{ 1127 int err; 1128 Elf *elf; 1129 1130 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 1131 if (elf == NULL) 1132 return -1; 1133 1134 if (is_64_bit) 1135 *is_64_bit = (gelf_getclass(elf) == ELFCLASS64); 1136 1137 err = elf_read_maps(elf, exe, mapfn, data); 1138 1139 elf_end(elf); 1140 return err; 1141} 1142 1143enum dso_type dso__type_fd(int fd) 1144{ 1145 enum dso_type dso_type = DSO__TYPE_UNKNOWN; 1146 GElf_Ehdr ehdr; 1147 Elf_Kind ek; 1148 Elf *elf; 1149 1150 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 1151 if (elf == NULL) 1152 goto out; 1153 1154 ek = elf_kind(elf); 1155 if (ek != ELF_K_ELF) 1156 goto out_end; 1157 1158 if (gelf_getclass(elf) == ELFCLASS64) { 1159 dso_type = DSO__TYPE_64BIT; 1160 goto out_end; 1161 } 1162 1163 if (gelf_getehdr(elf, &ehdr) == NULL) 1164 goto out_end; 1165 1166 if (ehdr.e_machine == EM_X86_64) 1167 dso_type = DSO__TYPE_X32BIT; 1168 else 1169 dso_type = DSO__TYPE_32BIT; 1170out_end: 1171 elf_end(elf); 1172out: 1173 return dso_type; 1174} 1175 1176static int copy_bytes(int from, off_t from_offs, int to, off_t to_offs, u64 len) 1177{ 1178 ssize_t r; 1179 size_t n; 1180 int err = -1; 1181 char *buf = malloc(page_size); 1182 1183 if (buf == NULL) 1184 return -1; 1185 1186 if (lseek(to, to_offs, SEEK_SET) != to_offs) 1187 goto out; 1188 1189 if (lseek(from, from_offs, SEEK_SET) != from_offs) 1190 goto out; 1191 1192 while (len) { 1193 n = page_size; 1194 if (len < n) 1195 n = len; 1196 /* Use read because mmap won't work on proc files */ 1197 r = read(from, buf, n); 1198 if (r < 0) 1199 goto out; 1200 if (!r) 1201 break; 1202 n = r; 1203 r = write(to, buf, n); 1204 if (r < 0) 1205 goto out; 1206 if ((size_t)r != n) 1207 goto out; 1208 len -= n; 1209 } 1210 1211 err = 0; 1212out: 1213 free(buf); 1214 return err; 1215} 1216 1217struct kcore { 1218 int fd; 1219 int elfclass; 1220 Elf *elf; 1221 GElf_Ehdr ehdr; 1222}; 1223 1224static int kcore__open(struct kcore *kcore, const char *filename) 1225{ 1226 GElf_Ehdr *ehdr; 1227 1228 kcore->fd = open(filename, O_RDONLY); 1229 if (kcore->fd == -1) 1230 return -1; 1231 1232 kcore->elf = elf_begin(kcore->fd, ELF_C_READ, NULL); 1233 if (!kcore->elf) 1234 goto out_close; 1235 1236 kcore->elfclass = gelf_getclass(kcore->elf); 1237 if (kcore->elfclass == ELFCLASSNONE) 1238 goto out_end; 1239 1240 ehdr = gelf_getehdr(kcore->elf, &kcore->ehdr); 1241 if (!ehdr) 1242 goto out_end; 1243 1244 return 0; 1245 1246out_end: 1247 elf_end(kcore->elf); 1248out_close: 1249 close(kcore->fd); 1250 return -1; 1251} 1252 1253static int kcore__init(struct kcore *kcore, char *filename, int elfclass, 1254 bool temp) 1255{ 1256 kcore->elfclass = elfclass; 1257 1258 if (temp) 1259 kcore->fd = mkstemp(filename); 1260 else 1261 kcore->fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0400); 1262 if (kcore->fd == -1) 1263 return -1; 1264 1265 kcore->elf = elf_begin(kcore->fd, ELF_C_WRITE, NULL); 1266 if (!kcore->elf) 1267 goto out_close; 1268 1269 if (!gelf_newehdr(kcore->elf, elfclass)) 1270 goto out_end; 1271 1272 memset(&kcore->ehdr, 0, sizeof(GElf_Ehdr)); 1273 1274 return 0; 1275 1276out_end: 1277 elf_end(kcore->elf); 1278out_close: 1279 close(kcore->fd); 1280 unlink(filename); 1281 return -1; 1282} 1283 1284static void kcore__close(struct kcore *kcore) 1285{ 1286 elf_end(kcore->elf); 1287 close(kcore->fd); 1288} 1289 1290static int kcore__copy_hdr(struct kcore *from, struct kcore *to, size_t count) 1291{ 1292 GElf_Ehdr *ehdr = &to->ehdr; 1293 GElf_Ehdr *kehdr = &from->ehdr; 1294 1295 memcpy(ehdr->e_ident, kehdr->e_ident, EI_NIDENT); 1296 ehdr->e_type = kehdr->e_type; 1297 ehdr->e_machine = kehdr->e_machine; 1298 ehdr->e_version = kehdr->e_version; 1299 ehdr->e_entry = 0; 1300 ehdr->e_shoff = 0; 1301 ehdr->e_flags = kehdr->e_flags; 1302 ehdr->e_phnum = count; 1303 ehdr->e_shentsize = 0; 1304 ehdr->e_shnum = 0; 1305 ehdr->e_shstrndx = 0; 1306 1307 if (from->elfclass == ELFCLASS32) { 1308 ehdr->e_phoff = sizeof(Elf32_Ehdr); 1309 ehdr->e_ehsize = sizeof(Elf32_Ehdr); 1310 ehdr->e_phentsize = sizeof(Elf32_Phdr); 1311 } else { 1312 ehdr->e_phoff = sizeof(Elf64_Ehdr); 1313 ehdr->e_ehsize = sizeof(Elf64_Ehdr); 1314 ehdr->e_phentsize = sizeof(Elf64_Phdr); 1315 } 1316 1317 if (!gelf_update_ehdr(to->elf, ehdr)) 1318 return -1; 1319 1320 if (!gelf_newphdr(to->elf, count)) 1321 return -1; 1322 1323 return 0; 1324} 1325 1326static int kcore__add_phdr(struct kcore *kcore, int idx, off_t offset, 1327 u64 addr, u64 len) 1328{ 1329 GElf_Phdr phdr = { 1330 .p_type = PT_LOAD, 1331 .p_flags = PF_R | PF_W | PF_X, 1332 .p_offset = offset, 1333 .p_vaddr = addr, 1334 .p_paddr = 0, 1335 .p_filesz = len, 1336 .p_memsz = len, 1337 .p_align = page_size, 1338 }; 1339 1340 if (!gelf_update_phdr(kcore->elf, idx, &phdr)) 1341 return -1; 1342 1343 return 0; 1344} 1345 1346static off_t kcore__write(struct kcore *kcore) 1347{ 1348 return elf_update(kcore->elf, ELF_C_WRITE); 1349} 1350 1351struct phdr_data { 1352 off_t offset; 1353 u64 addr; 1354 u64 len; 1355}; 1356 1357struct kcore_copy_info { 1358 u64 stext; 1359 u64 etext; 1360 u64 first_symbol; 1361 u64 last_symbol; 1362 u64 first_module; 1363 u64 last_module_symbol; 1364 struct phdr_data kernel_map; 1365 struct phdr_data modules_map; 1366}; 1367 1368static int kcore_copy__process_kallsyms(void *arg, const char *name, char type, 1369 u64 start) 1370{ 1371 struct kcore_copy_info *kci = arg; 1372 1373 if (!symbol_type__is_a(type, MAP__FUNCTION)) 1374 return 0; 1375 1376 if (strchr(name, '[')) { 1377 if (start > kci->last_module_symbol) 1378 kci->last_module_symbol = start; 1379 return 0; 1380 } 1381 1382 if (!kci->first_symbol || start < kci->first_symbol) 1383 kci->first_symbol = start; 1384 1385 if (!kci->last_symbol || start > kci->last_symbol) 1386 kci->last_symbol = start; 1387 1388 if (!strcmp(name, "_stext")) { 1389 kci->stext = start; 1390 return 0; 1391 } 1392 1393 if (!strcmp(name, "_etext")) { 1394 kci->etext = start; 1395 return 0; 1396 } 1397 1398 return 0; 1399} 1400 1401static int kcore_copy__parse_kallsyms(struct kcore_copy_info *kci, 1402 const char *dir) 1403{ 1404 char kallsyms_filename[PATH_MAX]; 1405 1406 scnprintf(kallsyms_filename, PATH_MAX, "%s/kallsyms", dir); 1407 1408 if (symbol__restricted_filename(kallsyms_filename, "/proc/kallsyms")) 1409 return -1; 1410 1411 if (kallsyms__parse(kallsyms_filename, kci, 1412 kcore_copy__process_kallsyms) < 0) 1413 return -1; 1414 1415 return 0; 1416} 1417 1418static int kcore_copy__process_modules(void *arg, 1419 const char *name __maybe_unused, 1420 u64 start) 1421{ 1422 struct kcore_copy_info *kci = arg; 1423 1424 if (!kci->first_module || start < kci->first_module) 1425 kci->first_module = start; 1426 1427 return 0; 1428} 1429 1430static int kcore_copy__parse_modules(struct kcore_copy_info *kci, 1431 const char *dir) 1432{ 1433 char modules_filename[PATH_MAX]; 1434 1435 scnprintf(modules_filename, PATH_MAX, "%s/modules", dir); 1436 1437 if (symbol__restricted_filename(modules_filename, "/proc/modules")) 1438 return -1; 1439 1440 if (modules__parse(modules_filename, kci, 1441 kcore_copy__process_modules) < 0) 1442 return -1; 1443 1444 return 0; 1445} 1446 1447static void kcore_copy__map(struct phdr_data *p, u64 start, u64 end, u64 pgoff, 1448 u64 s, u64 e) 1449{ 1450 if (p->addr || s < start || s >= end) 1451 return; 1452 1453 p->addr = s; 1454 p->offset = (s - start) + pgoff; 1455 p->len = e < end ? e - s : end - s; 1456} 1457 1458static int kcore_copy__read_map(u64 start, u64 len, u64 pgoff, void *data) 1459{ 1460 struct kcore_copy_info *kci = data; 1461 u64 end = start + len; 1462 1463 kcore_copy__map(&kci->kernel_map, start, end, pgoff, kci->stext, 1464 kci->etext); 1465 1466 kcore_copy__map(&kci->modules_map, start, end, pgoff, kci->first_module, 1467 kci->last_module_symbol); 1468 1469 return 0; 1470} 1471 1472static int kcore_copy__read_maps(struct kcore_copy_info *kci, Elf *elf) 1473{ 1474 if (elf_read_maps(elf, true, kcore_copy__read_map, kci) < 0) 1475 return -1; 1476 1477 return 0; 1478} 1479 1480static int kcore_copy__calc_maps(struct kcore_copy_info *kci, const char *dir, 1481 Elf *elf) 1482{ 1483 if (kcore_copy__parse_kallsyms(kci, dir)) 1484 return -1; 1485 1486 if (kcore_copy__parse_modules(kci, dir)) 1487 return -1; 1488 1489 if (kci->stext) 1490 kci->stext = round_down(kci->stext, page_size); 1491 else 1492 kci->stext = round_down(kci->first_symbol, page_size); 1493 1494 if (kci->etext) { 1495 kci->etext = round_up(kci->etext, page_size); 1496 } else if (kci->last_symbol) { 1497 kci->etext = round_up(kci->last_symbol, page_size); 1498 kci->etext += page_size; 1499 } 1500 1501 kci->first_module = round_down(kci->first_module, page_size); 1502 1503 if (kci->last_module_symbol) { 1504 kci->last_module_symbol = round_up(kci->last_module_symbol, 1505 page_size); 1506 kci->last_module_symbol += page_size; 1507 } 1508 1509 if (!kci->stext || !kci->etext) 1510 return -1; 1511 1512 if (kci->first_module && !kci->last_module_symbol) 1513 return -1; 1514 1515 return kcore_copy__read_maps(kci, elf); 1516} 1517 1518static int kcore_copy__copy_file(const char *from_dir, const char *to_dir, 1519 const char *name) 1520{ 1521 char from_filename[PATH_MAX]; 1522 char to_filename[PATH_MAX]; 1523 1524 scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name); 1525 scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name); 1526 1527 return copyfile_mode(from_filename, to_filename, 0400); 1528} 1529 1530static int kcore_copy__unlink(const char *dir, const char *name) 1531{ 1532 char filename[PATH_MAX]; 1533 1534 scnprintf(filename, PATH_MAX, "%s/%s", dir, name); 1535 1536 return unlink(filename); 1537} 1538 1539static int kcore_copy__compare_fds(int from, int to) 1540{ 1541 char *buf_from; 1542 char *buf_to; 1543 ssize_t ret; 1544 size_t len; 1545 int err = -1; 1546 1547 buf_from = malloc(page_size); 1548 buf_to = malloc(page_size); 1549 if (!buf_from || !buf_to) 1550 goto out; 1551 1552 while (1) { 1553 /* Use read because mmap won't work on proc files */ 1554 ret = read(from, buf_from, page_size); 1555 if (ret < 0) 1556 goto out; 1557 1558 if (!ret) 1559 break; 1560 1561 len = ret; 1562 1563 if (readn(to, buf_to, len) != (int)len) 1564 goto out; 1565 1566 if (memcmp(buf_from, buf_to, len)) 1567 goto out; 1568 } 1569 1570 err = 0; 1571out: 1572 free(buf_to); 1573 free(buf_from); 1574 return err; 1575} 1576 1577static int kcore_copy__compare_files(const char *from_filename, 1578 const char *to_filename) 1579{ 1580 int from, to, err = -1; 1581 1582 from = open(from_filename, O_RDONLY); 1583 if (from < 0) 1584 return -1; 1585 1586 to = open(to_filename, O_RDONLY); 1587 if (to < 0) 1588 goto out_close_from; 1589 1590 err = kcore_copy__compare_fds(from, to); 1591 1592 close(to); 1593out_close_from: 1594 close(from); 1595 return err; 1596} 1597 1598static int kcore_copy__compare_file(const char *from_dir, const char *to_dir, 1599 const char *name) 1600{ 1601 char from_filename[PATH_MAX]; 1602 char to_filename[PATH_MAX]; 1603 1604 scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name); 1605 scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name); 1606 1607 return kcore_copy__compare_files(from_filename, to_filename); 1608} 1609 1610/** 1611 * kcore_copy - copy kallsyms, modules and kcore from one directory to another. 1612 * @from_dir: from directory 1613 * @to_dir: to directory 1614 * 1615 * This function copies kallsyms, modules and kcore files from one directory to 1616 * another. kallsyms and modules are copied entirely. Only code segments are 1617 * copied from kcore. It is assumed that two segments suffice: one for the 1618 * kernel proper and one for all the modules. The code segments are determined 1619 * from kallsyms and modules files. The kernel map starts at _stext or the 1620 * lowest function symbol, and ends at _etext or the highest function symbol. 1621 * The module map starts at the lowest module address and ends at the highest 1622 * module symbol. Start addresses are rounded down to the nearest page. End 1623 * addresses are rounded up to the nearest page. An extra page is added to the 1624 * highest kernel symbol and highest module symbol to, hopefully, encompass that 1625 * symbol too. Because it contains only code sections, the resulting kcore is 1626 * unusual. One significant peculiarity is that the mapping (start -> pgoff) 1627 * is not the same for the kernel map and the modules map. That happens because 1628 * the data is copied adjacently whereas the original kcore has gaps. Finally, 1629 * kallsyms and modules files are compared with their copies to check that 1630 * modules have not been loaded or unloaded while the copies were taking place. 1631 * 1632 * Return: %0 on success, %-1 on failure. 1633 */ 1634int kcore_copy(const char *from_dir, const char *to_dir) 1635{ 1636 struct kcore kcore; 1637 struct kcore extract; 1638 size_t count = 2; 1639 int idx = 0, err = -1; 1640 off_t offset = page_size, sz, modules_offset = 0; 1641 struct kcore_copy_info kci = { .stext = 0, }; 1642 char kcore_filename[PATH_MAX]; 1643 char extract_filename[PATH_MAX]; 1644 1645 if (kcore_copy__copy_file(from_dir, to_dir, "kallsyms")) 1646 return -1; 1647 1648 if (kcore_copy__copy_file(from_dir, to_dir, "modules")) 1649 goto out_unlink_kallsyms; 1650 1651 scnprintf(kcore_filename, PATH_MAX, "%s/kcore", from_dir); 1652 scnprintf(extract_filename, PATH_MAX, "%s/kcore", to_dir); 1653 1654 if (kcore__open(&kcore, kcore_filename)) 1655 goto out_unlink_modules; 1656 1657 if (kcore_copy__calc_maps(&kci, from_dir, kcore.elf)) 1658 goto out_kcore_close; 1659 1660 if (kcore__init(&extract, extract_filename, kcore.elfclass, false)) 1661 goto out_kcore_close; 1662 1663 if (!kci.modules_map.addr) 1664 count -= 1; 1665 1666 if (kcore__copy_hdr(&kcore, &extract, count)) 1667 goto out_extract_close; 1668 1669 if (kcore__add_phdr(&extract, idx++, offset, kci.kernel_map.addr, 1670 kci.kernel_map.len)) 1671 goto out_extract_close; 1672 1673 if (kci.modules_map.addr) { 1674 modules_offset = offset + kci.kernel_map.len; 1675 if (kcore__add_phdr(&extract, idx, modules_offset, 1676 kci.modules_map.addr, kci.modules_map.len)) 1677 goto out_extract_close; 1678 } 1679 1680 sz = kcore__write(&extract); 1681 if (sz < 0 || sz > offset) 1682 goto out_extract_close; 1683 1684 if (copy_bytes(kcore.fd, kci.kernel_map.offset, extract.fd, offset, 1685 kci.kernel_map.len)) 1686 goto out_extract_close; 1687 1688 if (modules_offset && copy_bytes(kcore.fd, kci.modules_map.offset, 1689 extract.fd, modules_offset, 1690 kci.modules_map.len)) 1691 goto out_extract_close; 1692 1693 if (kcore_copy__compare_file(from_dir, to_dir, "modules")) 1694 goto out_extract_close; 1695 1696 if (kcore_copy__compare_file(from_dir, to_dir, "kallsyms")) 1697 goto out_extract_close; 1698 1699 err = 0; 1700 1701out_extract_close: 1702 kcore__close(&extract); 1703 if (err) 1704 unlink(extract_filename); 1705out_kcore_close: 1706 kcore__close(&kcore); 1707out_unlink_modules: 1708 if (err) 1709 kcore_copy__unlink(to_dir, "modules"); 1710out_unlink_kallsyms: 1711 if (err) 1712 kcore_copy__unlink(to_dir, "kallsyms"); 1713 1714 return err; 1715} 1716 1717int kcore_extract__create(struct kcore_extract *kce) 1718{ 1719 struct kcore kcore; 1720 struct kcore extract; 1721 size_t count = 1; 1722 int idx = 0, err = -1; 1723 off_t offset = page_size, sz; 1724 1725 if (kcore__open(&kcore, kce->kcore_filename)) 1726 return -1; 1727 1728 strcpy(kce->extract_filename, PERF_KCORE_EXTRACT); 1729 if (kcore__init(&extract, kce->extract_filename, kcore.elfclass, true)) 1730 goto out_kcore_close; 1731 1732 if (kcore__copy_hdr(&kcore, &extract, count)) 1733 goto out_extract_close; 1734 1735 if (kcore__add_phdr(&extract, idx, offset, kce->addr, kce->len)) 1736 goto out_extract_close; 1737 1738 sz = kcore__write(&extract); 1739 if (sz < 0 || sz > offset) 1740 goto out_extract_close; 1741 1742 if (copy_bytes(kcore.fd, kce->offs, extract.fd, offset, kce->len)) 1743 goto out_extract_close; 1744 1745 err = 0; 1746 1747out_extract_close: 1748 kcore__close(&extract); 1749 if (err) 1750 unlink(kce->extract_filename); 1751out_kcore_close: 1752 kcore__close(&kcore); 1753 1754 return err; 1755} 1756 1757void kcore_extract__delete(struct kcore_extract *kce) 1758{ 1759 unlink(kce->extract_filename); 1760} 1761 1762void symbol__elf_init(void) 1763{ 1764 elf_version(EV_CURRENT); 1765} 1766