1 // SPDX-License-Identifier: GPL-2.0
11 #include "map_groups.h"
13 #include "demangle-java.h"
14 #include "demangle-rust.h"
19 #include <linux/ctype.h>
20 #include <linux/zalloc.h>
21 #include <symbol/kallsyms.h>
24 #define EM_AARCH64 183 /* ARM 64 bit */
27 #ifndef ELF32_ST_VISIBILITY
28 #define ELF32_ST_VISIBILITY(o) ((o) & 0x03)
31 /* For ELF64 the definitions are the same. */
32 #ifndef ELF64_ST_VISIBILITY
33 #define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o)
36 /* How to extract information held in the st_other field. */
37 #ifndef GELF_ST_VISIBILITY
38 #define GELF_ST_VISIBILITY(val) ELF64_ST_VISIBILITY (val)
41 typedef Elf64_Nhdr GElf_Nhdr
;
44 #define DMGL_NO_OPTS 0 /* For readability... */
45 #define DMGL_PARAMS (1 << 0) /* Include function args */
46 #define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */
49 #ifdef HAVE_CPLUS_DEMANGLE_SUPPORT
50 extern char *cplus_demangle(const char *, int);
52 static inline char *bfd_demangle(void __maybe_unused
*v
, const char *c
, int i
)
54 return cplus_demangle(c
, i
);
58 static inline char *bfd_demangle(void __maybe_unused
*v
,
59 const char __maybe_unused
*c
,
65 #define PACKAGE 'perf'
70 #ifndef HAVE_ELF_GETPHDRNUM_SUPPORT
71 static int elf_getphdrnum(Elf
*elf
, size_t *dst
)
76 ehdr
= gelf_getehdr(elf
, &gehdr
);
86 #ifndef HAVE_ELF_GETSHDRSTRNDX_SUPPORT
87 static int elf_getshdrstrndx(Elf
*elf __maybe_unused
, size_t *dst __maybe_unused
)
89 pr_err("%s: update your libelf to > 0.140, this one lacks elf_getshdrstrndx().\n", __func__
);
94 #ifndef NT_GNU_BUILD_ID
95 #define NT_GNU_BUILD_ID 3
99 * elf_symtab__for_each_symbol - iterate thru all the symbols
101 * @syms: struct elf_symtab instance to iterate
103 * @sym: GElf_Sym iterator
105 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
106 for (idx = 0, gelf_getsym(syms, idx, &sym);\
108 idx++, gelf_getsym(syms, idx, &sym))
110 static inline uint8_t elf_sym__type(const GElf_Sym
*sym
)
112 return GELF_ST_TYPE(sym
->st_info
);
115 static inline uint8_t elf_sym__visibility(const GElf_Sym
*sym
)
117 return GELF_ST_VISIBILITY(sym
->st_other
);
120 #ifndef STT_GNU_IFUNC
121 #define STT_GNU_IFUNC 10
124 static inline int elf_sym__is_function(const GElf_Sym
*sym
)
126 return (elf_sym__type(sym
) == STT_FUNC
||
127 elf_sym__type(sym
) == STT_GNU_IFUNC
) &&
129 sym
->st_shndx
!= SHN_UNDEF
;
132 static inline bool elf_sym__is_object(const GElf_Sym
*sym
)
134 return elf_sym__type(sym
) == STT_OBJECT
&&
136 sym
->st_shndx
!= SHN_UNDEF
;
139 static inline int elf_sym__is_label(const GElf_Sym
*sym
)
141 return elf_sym__type(sym
) == STT_NOTYPE
&&
143 sym
->st_shndx
!= SHN_UNDEF
&&
144 sym
->st_shndx
!= SHN_ABS
&&
145 elf_sym__visibility(sym
) != STV_HIDDEN
&&
146 elf_sym__visibility(sym
) != STV_INTERNAL
;
149 static bool elf_sym__filter(GElf_Sym
*sym
)
151 return elf_sym__is_function(sym
) || elf_sym__is_object(sym
);
154 static inline const char *elf_sym__name(const GElf_Sym
*sym
,
155 const Elf_Data
*symstrs
)
157 return symstrs
->d_buf
+ sym
->st_name
;
160 static inline const char *elf_sec__name(const GElf_Shdr
*shdr
,
161 const Elf_Data
*secstrs
)
163 return secstrs
->d_buf
+ shdr
->sh_name
;
166 static inline int elf_sec__is_text(const GElf_Shdr
*shdr
,
167 const Elf_Data
*secstrs
)
169 return strstr(elf_sec__name(shdr
, secstrs
), "text") != NULL
;
172 static inline bool elf_sec__is_data(const GElf_Shdr
*shdr
,
173 const Elf_Data
*secstrs
)
175 return strstr(elf_sec__name(shdr
, secstrs
), "data") != NULL
;
178 static bool elf_sec__filter(GElf_Shdr
*shdr
, Elf_Data
*secstrs
)
180 return elf_sec__is_text(shdr
, secstrs
) ||
181 elf_sec__is_data(shdr
, secstrs
);
184 static size_t elf_addr_to_index(Elf
*elf
, GElf_Addr addr
)
190 while ((sec
= elf_nextscn(elf
, sec
)) != NULL
) {
191 gelf_getshdr(sec
, &shdr
);
193 if ((addr
>= shdr
.sh_addr
) &&
194 (addr
< (shdr
.sh_addr
+ shdr
.sh_size
)))
203 Elf_Scn
*elf_section_by_name(Elf
*elf
, GElf_Ehdr
*ep
,
204 GElf_Shdr
*shp
, const char *name
, size_t *idx
)
209 /* Elf is corrupted/truncated, avoid calling elf_strptr. */
210 if (!elf_rawdata(elf_getscn(elf
, ep
->e_shstrndx
), NULL
))
213 while ((sec
= elf_nextscn(elf
, sec
)) != NULL
) {
216 gelf_getshdr(sec
, shp
);
217 str
= elf_strptr(elf
, ep
->e_shstrndx
, shp
->sh_name
);
218 if (str
&& !strcmp(name
, str
)) {
229 static bool want_demangle(bool is_kernel_sym
)
231 return is_kernel_sym
? symbol_conf
.demangle_kernel
: symbol_conf
.demangle
;
234 static char *demangle_sym(struct dso
*dso
, int kmodule
, const char *elf_name
)
236 int demangle_flags
= verbose
> 0 ? (DMGL_PARAMS
| DMGL_ANSI
) : DMGL_NO_OPTS
;
237 char *demangled
= NULL
;
240 * We need to figure out if the object was created from C++ sources
241 * DWARF DW_compile_unit has this, but we don't always have access
244 if (!want_demangle(dso
->kernel
|| kmodule
))
247 demangled
= bfd_demangle(NULL
, elf_name
, demangle_flags
);
248 if (demangled
== NULL
)
249 demangled
= java_demangle_sym(elf_name
, JAVA_DEMANGLE_NORET
);
250 else if (rust_is_mangled(demangled
))
252 * Input to Rust demangling is the BFD-demangled
253 * name which it Rust-demangles in place.
255 rust_demangle_sym(demangled
);
260 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
261 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
263 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
265 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
266 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
268 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
271 * We need to check if we have a .dynsym, so that we can handle the
272 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
273 * .dynsym or .symtab).
274 * And always look at the original dso, not at debuginfo packages, that
275 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
277 int dso__synthesize_plt_symbols(struct dso
*dso
, struct symsrc
*ss
)
279 uint32_t nr_rel_entries
, idx
;
281 u64 plt_offset
, plt_header_size
, plt_entry_size
;
284 GElf_Shdr shdr_rel_plt
, shdr_dynsym
;
285 Elf_Data
*reldata
, *syms
, *symstrs
;
286 Elf_Scn
*scn_plt_rel
, *scn_symstrs
, *scn_dynsym
;
289 char sympltname
[1024];
291 int nr
= 0, symidx
, err
= 0;
299 scn_dynsym
= ss
->dynsym
;
300 shdr_dynsym
= ss
->dynshdr
;
301 dynsym_idx
= ss
->dynsym_idx
;
303 if (scn_dynsym
== NULL
)
306 scn_plt_rel
= elf_section_by_name(elf
, &ehdr
, &shdr_rel_plt
,
308 if (scn_plt_rel
== NULL
) {
309 scn_plt_rel
= elf_section_by_name(elf
, &ehdr
, &shdr_rel_plt
,
311 if (scn_plt_rel
== NULL
)
317 if (shdr_rel_plt
.sh_link
!= dynsym_idx
)
320 if (elf_section_by_name(elf
, &ehdr
, &shdr_plt
, ".plt", NULL
) == NULL
)
324 * Fetch the relocation section to find the idxes to the GOT
325 * and the symbols in the .dynsym they refer to.
327 reldata
= elf_getdata(scn_plt_rel
, NULL
);
331 syms
= elf_getdata(scn_dynsym
, NULL
);
335 scn_symstrs
= elf_getscn(elf
, shdr_dynsym
.sh_link
);
336 if (scn_symstrs
== NULL
)
339 symstrs
= elf_getdata(scn_symstrs
, NULL
);
343 if (symstrs
->d_size
== 0)
346 nr_rel_entries
= shdr_rel_plt
.sh_size
/ shdr_rel_plt
.sh_entsize
;
347 plt_offset
= shdr_plt
.sh_offset
;
348 switch (ehdr
.e_machine
) {
350 plt_header_size
= 20;
355 plt_header_size
= 32;
360 plt_header_size
= 48;
365 plt_header_size
= 128;
369 default: /* FIXME: s390/alpha/mips/parisc/poperpc/sh/xtensa need to be checked */
370 plt_header_size
= shdr_plt
.sh_entsize
;
371 plt_entry_size
= shdr_plt
.sh_entsize
;
374 plt_offset
+= plt_header_size
;
376 if (shdr_rel_plt
.sh_type
== SHT_RELA
) {
377 GElf_Rela pos_mem
, *pos
;
379 elf_section__for_each_rela(reldata
, pos
, pos_mem
, idx
,
381 const char *elf_name
= NULL
;
382 char *demangled
= NULL
;
383 symidx
= GELF_R_SYM(pos
->r_info
);
384 gelf_getsym(syms
, symidx
, &sym
);
386 elf_name
= elf_sym__name(&sym
, symstrs
);
387 demangled
= demangle_sym(dso
, 0, elf_name
);
388 if (demangled
!= NULL
)
389 elf_name
= demangled
;
390 snprintf(sympltname
, sizeof(sympltname
),
394 f
= symbol__new(plt_offset
, plt_entry_size
,
395 STB_GLOBAL
, STT_FUNC
, sympltname
);
399 plt_offset
+= plt_entry_size
;
400 symbols__insert(&dso
->symbols
, f
);
403 } else if (shdr_rel_plt
.sh_type
== SHT_REL
) {
404 GElf_Rel pos_mem
, *pos
;
405 elf_section__for_each_rel(reldata
, pos
, pos_mem
, idx
,
407 const char *elf_name
= NULL
;
408 char *demangled
= NULL
;
409 symidx
= GELF_R_SYM(pos
->r_info
);
410 gelf_getsym(syms
, symidx
, &sym
);
412 elf_name
= elf_sym__name(&sym
, symstrs
);
413 demangled
= demangle_sym(dso
, 0, elf_name
);
414 if (demangled
!= NULL
)
415 elf_name
= demangled
;
416 snprintf(sympltname
, sizeof(sympltname
),
420 f
= symbol__new(plt_offset
, plt_entry_size
,
421 STB_GLOBAL
, STT_FUNC
, sympltname
);
425 plt_offset
+= plt_entry_size
;
426 symbols__insert(&dso
->symbols
, f
);
435 pr_debug("%s: problems reading %s PLT info.\n",
436 __func__
, dso
->long_name
);
440 char *dso__demangle_sym(struct dso
*dso
, int kmodule
, const char *elf_name
)
442 return demangle_sym(dso
, kmodule
, elf_name
);
446 * Align offset to 4 bytes as needed for note name and descriptor data.
448 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
450 static int elf_read_build_id(Elf
*elf
, void *bf
, size_t size
)
460 if (size
< BUILD_ID_SIZE
)
467 if (gelf_getehdr(elf
, &ehdr
) == NULL
) {
468 pr_err("%s: cannot get elf header.\n", __func__
);
473 * Check following sections for notes:
474 * '.note.gnu.build-id'
476 * '.note' (VDSO specific)
479 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
,
480 ".note.gnu.build-id", NULL
);
484 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
,
489 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
,
498 data
= elf_getdata(sec
, NULL
);
503 while (ptr
< (data
->d_buf
+ data
->d_size
)) {
504 GElf_Nhdr
*nhdr
= ptr
;
505 size_t namesz
= NOTE_ALIGN(nhdr
->n_namesz
),
506 descsz
= NOTE_ALIGN(nhdr
->n_descsz
);
509 ptr
+= sizeof(*nhdr
);
512 if (nhdr
->n_type
== NT_GNU_BUILD_ID
&&
513 nhdr
->n_namesz
== sizeof("GNU")) {
514 if (memcmp(name
, "GNU", sizeof("GNU")) == 0) {
515 size_t sz
= min(size
, descsz
);
517 memset(bf
+ sz
, 0, size
- sz
);
529 int filename__read_build_id(const char *filename
, void *bf
, size_t size
)
534 if (size
< BUILD_ID_SIZE
)
537 fd
= open(filename
, O_RDONLY
);
541 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
543 pr_debug2("%s: cannot read %s ELF file.\n", __func__
, filename
);
547 err
= elf_read_build_id(elf
, bf
, size
);
556 int sysfs__read_build_id(const char *filename
, void *build_id
, size_t size
)
560 if (size
< BUILD_ID_SIZE
)
563 fd
= open(filename
, O_RDONLY
);
570 size_t namesz
, descsz
;
572 if (read(fd
, &nhdr
, sizeof(nhdr
)) != sizeof(nhdr
))
575 namesz
= NOTE_ALIGN(nhdr
.n_namesz
);
576 descsz
= NOTE_ALIGN(nhdr
.n_descsz
);
577 if (nhdr
.n_type
== NT_GNU_BUILD_ID
&&
578 nhdr
.n_namesz
== sizeof("GNU")) {
579 if (read(fd
, bf
, namesz
) != (ssize_t
)namesz
)
581 if (memcmp(bf
, "GNU", sizeof("GNU")) == 0) {
582 size_t sz
= min(descsz
, size
);
583 if (read(fd
, build_id
, sz
) == (ssize_t
)sz
) {
584 memset(build_id
+ sz
, 0, size
- sz
);
588 } else if (read(fd
, bf
, descsz
) != (ssize_t
)descsz
)
591 int n
= namesz
+ descsz
;
593 if (n
> (int)sizeof(bf
)) {
595 pr_debug("%s: truncating reading of build id in sysfs file %s: n_namesz=%u, n_descsz=%u.\n",
596 __func__
, filename
, nhdr
.n_namesz
, nhdr
.n_descsz
);
598 if (read(fd
, bf
, n
) != n
)
607 int filename__read_debuglink(const char *filename
, char *debuglink
,
618 fd
= open(filename
, O_RDONLY
);
622 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
624 pr_debug2("%s: cannot read %s ELF file.\n", __func__
, filename
);
632 if (gelf_getehdr(elf
, &ehdr
) == NULL
) {
633 pr_err("%s: cannot get elf header.\n", __func__
);
637 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
,
638 ".gnu_debuglink", NULL
);
642 data
= elf_getdata(sec
, NULL
);
646 /* the start of this section is a zero-terminated string */
647 strncpy(debuglink
, data
->d_buf
, size
);
659 static int dso__swap_init(struct dso
*dso
, unsigned char eidata
)
661 static unsigned int const endian
= 1;
663 dso
->needs_swap
= DSO_SWAP__NO
;
667 /* We are big endian, DSO is little endian. */
668 if (*(unsigned char const *)&endian
!= 1)
669 dso
->needs_swap
= DSO_SWAP__YES
;
673 /* We are little endian, DSO is big endian. */
674 if (*(unsigned char const *)&endian
!= 0)
675 dso
->needs_swap
= DSO_SWAP__YES
;
679 pr_err("unrecognized DSO data encoding %d\n", eidata
);
686 bool symsrc__possibly_runtime(struct symsrc
*ss
)
688 return ss
->dynsym
|| ss
->opdsec
;
691 bool symsrc__has_symtab(struct symsrc
*ss
)
693 return ss
->symtab
!= NULL
;
696 void symsrc__destroy(struct symsrc
*ss
)
703 bool __weak
elf__needs_adjust_symbols(GElf_Ehdr ehdr
)
705 return ehdr
.e_type
== ET_EXEC
|| ehdr
.e_type
== ET_REL
;
708 int symsrc__init(struct symsrc
*ss
, struct dso
*dso
, const char *name
,
709 enum dso_binary_type type
)
715 if (dso__needs_decompress(dso
)) {
716 fd
= dso__decompress_kmodule_fd(dso
, name
);
720 type
= dso
->symtab_type
;
722 fd
= open(name
, O_RDONLY
);
724 dso
->load_errno
= errno
;
729 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
731 pr_debug("%s: cannot read %s ELF file.\n", __func__
, name
);
732 dso
->load_errno
= DSO_LOAD_ERRNO__INVALID_ELF
;
736 if (gelf_getehdr(elf
, &ehdr
) == NULL
) {
737 dso
->load_errno
= DSO_LOAD_ERRNO__INVALID_ELF
;
738 pr_debug("%s: cannot get elf header.\n", __func__
);
742 if (dso__swap_init(dso
, ehdr
.e_ident
[EI_DATA
])) {
743 dso
->load_errno
= DSO_LOAD_ERRNO__INTERNAL_ERROR
;
747 /* Always reject images with a mismatched build-id: */
748 if (dso
->has_build_id
&& !symbol_conf
.ignore_vmlinux_buildid
) {
749 u8 build_id
[BUILD_ID_SIZE
];
751 if (elf_read_build_id(elf
, build_id
, BUILD_ID_SIZE
) < 0) {
752 dso
->load_errno
= DSO_LOAD_ERRNO__CANNOT_READ_BUILDID
;
756 if (!dso__build_id_equal(dso
, build_id
)) {
757 pr_debug("%s: build id mismatch for %s.\n", __func__
, name
);
758 dso
->load_errno
= DSO_LOAD_ERRNO__MISMATCHING_BUILDID
;
763 ss
->is_64_bit
= (gelf_getclass(elf
) == ELFCLASS64
);
765 ss
->symtab
= elf_section_by_name(elf
, &ehdr
, &ss
->symshdr
, ".symtab",
767 if (ss
->symshdr
.sh_type
!= SHT_SYMTAB
)
771 ss
->dynsym
= elf_section_by_name(elf
, &ehdr
, &ss
->dynshdr
, ".dynsym",
773 if (ss
->dynshdr
.sh_type
!= SHT_DYNSYM
)
777 ss
->opdsec
= elf_section_by_name(elf
, &ehdr
, &ss
->opdshdr
, ".opd",
779 if (ss
->opdshdr
.sh_type
!= SHT_PROGBITS
)
782 if (dso
->kernel
== DSO_TYPE_USER
)
783 ss
->adjust_symbols
= true;
785 ss
->adjust_symbols
= elf__needs_adjust_symbols(ehdr
);
787 ss
->name
= strdup(name
);
789 dso
->load_errno
= errno
;
808 * ref_reloc_sym_not_found - has kernel relocation symbol been found.
809 * @kmap: kernel maps and relocation reference symbol
811 * This function returns %true if we are dealing with the kernel maps and the
812 * relocation reference symbol has not yet been found. Otherwise %false is
815 static bool ref_reloc_sym_not_found(struct kmap
*kmap
)
817 return kmap
&& kmap
->ref_reloc_sym
&& kmap
->ref_reloc_sym
->name
&&
818 !kmap
->ref_reloc_sym
->unrelocated_addr
;
822 * ref_reloc - kernel relocation offset.
823 * @kmap: kernel maps and relocation reference symbol
825 * This function returns the offset of kernel addresses as determined by using
826 * the relocation reference symbol i.e. if the kernel has not been relocated
827 * then the return value is zero.
829 static u64
ref_reloc(struct kmap
*kmap
)
831 if (kmap
&& kmap
->ref_reloc_sym
&&
832 kmap
->ref_reloc_sym
->unrelocated_addr
)
833 return kmap
->ref_reloc_sym
->addr
-
834 kmap
->ref_reloc_sym
->unrelocated_addr
;
838 void __weak
arch__sym_update(struct symbol
*s __maybe_unused
,
839 GElf_Sym
*sym __maybe_unused
) { }
841 static int dso__process_kernel_symbol(struct dso
*dso
, struct map
*map
,
842 GElf_Sym
*sym
, GElf_Shdr
*shdr
,
843 struct map_groups
*kmaps
, struct kmap
*kmap
,
844 struct dso
**curr_dsop
, struct map
**curr_mapp
,
845 const char *section_name
,
846 bool adjust_kernel_syms
, bool kmodule
, bool *remap_kernel
)
848 struct dso
*curr_dso
= *curr_dsop
;
849 struct map
*curr_map
;
850 char dso_name
[PATH_MAX
];
852 /* Adjust symbol to map to file offset */
853 if (adjust_kernel_syms
)
854 sym
->st_value
-= shdr
->sh_addr
- shdr
->sh_offset
;
856 if (strcmp(section_name
, (curr_dso
->short_name
+ dso
->short_name_len
)) == 0)
859 if (strcmp(section_name
, ".text") == 0) {
861 * The initial kernel mapping is based on
862 * kallsyms and identity maps. Overwrite it to
863 * map to the kernel dso.
865 if (*remap_kernel
&& dso
->kernel
) {
866 *remap_kernel
= false;
867 map
->start
= shdr
->sh_addr
+ ref_reloc(kmap
);
868 map
->end
= map
->start
+ shdr
->sh_size
;
869 map
->pgoff
= shdr
->sh_offset
;
870 map
->map_ip
= map__map_ip
;
871 map
->unmap_ip
= map__unmap_ip
;
872 /* Ensure maps are correctly ordered */
875 map_groups__remove(kmaps
, map
);
876 map_groups__insert(kmaps
, map
);
882 * The initial module mapping is based on
883 * /proc/modules mapped to offset zero.
884 * Overwrite it to map to the module dso.
886 if (*remap_kernel
&& kmodule
) {
887 *remap_kernel
= false;
888 map
->pgoff
= shdr
->sh_offset
;
899 snprintf(dso_name
, sizeof(dso_name
), "%s%s", dso
->short_name
, section_name
);
901 curr_map
= map_groups__find_by_name(kmaps
, dso_name
);
902 if (curr_map
== NULL
) {
903 u64 start
= sym
->st_value
;
906 start
+= map
->start
+ shdr
->sh_offset
;
908 curr_dso
= dso__new(dso_name
);
909 if (curr_dso
== NULL
)
911 curr_dso
->kernel
= dso
->kernel
;
912 curr_dso
->long_name
= dso
->long_name
;
913 curr_dso
->long_name_len
= dso
->long_name_len
;
914 curr_map
= map__new2(start
, curr_dso
);
916 if (curr_map
== NULL
)
919 if (adjust_kernel_syms
) {
920 curr_map
->start
= shdr
->sh_addr
+ ref_reloc(kmap
);
921 curr_map
->end
= curr_map
->start
+ shdr
->sh_size
;
922 curr_map
->pgoff
= shdr
->sh_offset
;
924 curr_map
->map_ip
= curr_map
->unmap_ip
= identity__map_ip
;
926 curr_dso
->symtab_type
= dso
->symtab_type
;
927 map_groups__insert(kmaps
, curr_map
);
929 * Add it before we drop the referece to curr_map, i.e. while
930 * we still are sure to have a reference to this DSO via
933 dsos__add(&map
->groups
->machine
->dsos
, curr_dso
);
934 /* kmaps already got it */
936 dso__set_loaded(curr_dso
);
937 *curr_mapp
= curr_map
;
938 *curr_dsop
= curr_dso
;
940 *curr_dsop
= curr_map
->dso
;
945 int dso__load_sym(struct dso
*dso
, struct map
*map
, struct symsrc
*syms_ss
,
946 struct symsrc
*runtime_ss
, int kmodule
)
948 struct kmap
*kmap
= dso
->kernel
? map__kmap(map
) : NULL
;
949 struct map_groups
*kmaps
= kmap
? map__kmaps(map
) : NULL
;
950 struct map
*curr_map
= map
;
951 struct dso
*curr_dso
= dso
;
952 Elf_Data
*symstrs
, *secstrs
;
959 Elf_Data
*syms
, *opddata
= NULL
;
961 Elf_Scn
*sec
, *sec_strndx
;
964 bool remap_kernel
= false, adjust_kernel_syms
= false;
969 dso
->symtab_type
= syms_ss
->type
;
970 dso
->is_64_bit
= syms_ss
->is_64_bit
;
971 dso
->rel
= syms_ss
->ehdr
.e_type
== ET_REL
;
974 * Modules may already have symbols from kallsyms, but those symbols
975 * have the wrong values for the dso maps, so remove them.
977 if (kmodule
&& syms_ss
->symtab
)
978 symbols__delete(&dso
->symbols
);
980 if (!syms_ss
->symtab
) {
982 * If the vmlinux is stripped, fail so we will fall back
983 * to using kallsyms. The vmlinux runtime symbols aren't
989 syms_ss
->symtab
= syms_ss
->dynsym
;
990 syms_ss
->symshdr
= syms_ss
->dynshdr
;
994 ehdr
= syms_ss
->ehdr
;
995 sec
= syms_ss
->symtab
;
996 shdr
= syms_ss
->symshdr
;
998 if (elf_section_by_name(runtime_ss
->elf
, &runtime_ss
->ehdr
, &tshdr
,
1000 dso
->text_offset
= tshdr
.sh_addr
- tshdr
.sh_offset
;
1002 if (runtime_ss
->opdsec
)
1003 opddata
= elf_rawdata(runtime_ss
->opdsec
, NULL
);
1005 syms
= elf_getdata(sec
, NULL
);
1009 sec
= elf_getscn(elf
, shdr
.sh_link
);
1013 symstrs
= elf_getdata(sec
, NULL
);
1014 if (symstrs
== NULL
)
1017 sec_strndx
= elf_getscn(runtime_ss
->elf
, runtime_ss
->ehdr
.e_shstrndx
);
1018 if (sec_strndx
== NULL
)
1021 secstrs
= elf_getdata(sec_strndx
, NULL
);
1022 if (secstrs
== NULL
)
1025 nr_syms
= shdr
.sh_size
/ shdr
.sh_entsize
;
1027 memset(&sym
, 0, sizeof(sym
));
1030 * The kernel relocation symbol is needed in advance in order to adjust
1031 * kernel maps correctly.
1033 if (ref_reloc_sym_not_found(kmap
)) {
1034 elf_symtab__for_each_symbol(syms
, nr_syms
, idx
, sym
) {
1035 const char *elf_name
= elf_sym__name(&sym
, symstrs
);
1037 if (strcmp(elf_name
, kmap
->ref_reloc_sym
->name
))
1039 kmap
->ref_reloc_sym
->unrelocated_addr
= sym
.st_value
;
1040 map
->reloc
= kmap
->ref_reloc_sym
->addr
-
1041 kmap
->ref_reloc_sym
->unrelocated_addr
;
1047 * Handle any relocation of vdso necessary because older kernels
1048 * attempted to prelink vdso to its virtual address.
1050 if (dso__is_vdso(dso
))
1051 map
->reloc
= map
->start
- dso
->text_offset
;
1053 dso
->adjust_symbols
= runtime_ss
->adjust_symbols
|| ref_reloc(kmap
);
1055 * Initial kernel and module mappings do not map to the dso.
1058 if (dso
->kernel
|| kmodule
) {
1059 remap_kernel
= true;
1060 adjust_kernel_syms
= dso
->adjust_symbols
;
1062 elf_symtab__for_each_symbol(syms
, nr_syms
, idx
, sym
) {
1064 const char *elf_name
= elf_sym__name(&sym
, symstrs
);
1065 char *demangled
= NULL
;
1066 int is_label
= elf_sym__is_label(&sym
);
1067 const char *section_name
;
1068 bool used_opd
= false;
1070 if (!is_label
&& !elf_sym__filter(&sym
))
1073 /* Reject ARM ELF "mapping symbols": these aren't unique and
1074 * don't identify functions, so will confuse the profile
1076 if (ehdr
.e_machine
== EM_ARM
|| ehdr
.e_machine
== EM_AARCH64
) {
1077 if (elf_name
[0] == '$' && strchr("adtx", elf_name
[1])
1078 && (elf_name
[2] == '\0' || elf_name
[2] == '.'))
1082 if (runtime_ss
->opdsec
&& sym
.st_shndx
== runtime_ss
->opdidx
) {
1083 u32 offset
= sym
.st_value
- syms_ss
->opdshdr
.sh_addr
;
1084 u64
*opd
= opddata
->d_buf
+ offset
;
1085 sym
.st_value
= DSO__SWAP(dso
, u64
, *opd
);
1086 sym
.st_shndx
= elf_addr_to_index(runtime_ss
->elf
,
1091 * When loading symbols in a data mapping, ABS symbols (which
1092 * has a value of SHN_ABS in its st_shndx) failed at
1093 * elf_getscn(). And it marks the loading as a failure so
1094 * already loaded symbols cannot be fixed up.
1096 * I'm not sure what should be done. Just ignore them for now.
1099 if (sym
.st_shndx
== SHN_ABS
)
1102 sec
= elf_getscn(runtime_ss
->elf
, sym
.st_shndx
);
1106 gelf_getshdr(sec
, &shdr
);
1108 if (is_label
&& !elf_sec__filter(&shdr
, secstrs
))
1111 section_name
= elf_sec__name(&shdr
, secstrs
);
1113 /* On ARM, symbols for thumb functions have 1 added to
1114 * the symbol address as a flag - remove it */
1115 if ((ehdr
.e_machine
== EM_ARM
) &&
1116 (GELF_ST_TYPE(sym
.st_info
) == STT_FUNC
) &&
1120 if (dso
->kernel
|| kmodule
) {
1121 if (dso__process_kernel_symbol(dso
, map
, &sym
, &shdr
, kmaps
, kmap
, &curr_dso
, &curr_map
,
1122 section_name
, adjust_kernel_syms
, kmodule
, &remap_kernel
))
1124 } else if ((used_opd
&& runtime_ss
->adjust_symbols
) ||
1125 (!used_opd
&& syms_ss
->adjust_symbols
)) {
1126 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64
" "
1127 "sh_addr: %#" PRIx64
" sh_offset: %#" PRIx64
"\n", __func__
,
1128 (u64
)sym
.st_value
, (u64
)shdr
.sh_addr
,
1129 (u64
)shdr
.sh_offset
);
1130 sym
.st_value
-= shdr
.sh_addr
- shdr
.sh_offset
;
1133 demangled
= demangle_sym(dso
, kmodule
, elf_name
);
1134 if (demangled
!= NULL
)
1135 elf_name
= demangled
;
1137 f
= symbol__new(sym
.st_value
, sym
.st_size
,
1138 GELF_ST_BIND(sym
.st_info
),
1139 GELF_ST_TYPE(sym
.st_info
), elf_name
);
1144 arch__sym_update(f
, &sym
);
1146 __symbols__insert(&curr_dso
->symbols
, f
, dso
->kernel
);
1151 * For misannotated, zeroed, ASM function sizes.
1154 symbols__fixup_end(&dso
->symbols
);
1155 symbols__fixup_duplicate(&dso
->symbols
);
1158 * We need to fixup this here too because we create new
1159 * maps here, for things like vsyscall sections.
1161 map_groups__fixup_end(kmaps
);
1169 static int elf_read_maps(Elf
*elf
, bool exe
, mapfn_t mapfn
, void *data
)
1176 if (elf_getphdrnum(elf
, &phdrnum
))
1179 for (i
= 0; i
< phdrnum
; i
++) {
1180 if (gelf_getphdr(elf
, i
, &phdr
) == NULL
)
1182 if (phdr
.p_type
!= PT_LOAD
)
1185 if (!(phdr
.p_flags
& PF_X
))
1188 if (!(phdr
.p_flags
& PF_R
))
1191 sz
= min(phdr
.p_memsz
, phdr
.p_filesz
);
1194 err
= mapfn(phdr
.p_vaddr
, sz
, phdr
.p_offset
, data
);
1201 int file__read_maps(int fd
, bool exe
, mapfn_t mapfn
, void *data
,
1207 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
1212 *is_64_bit
= (gelf_getclass(elf
) == ELFCLASS64
);
1214 err
= elf_read_maps(elf
, exe
, mapfn
, data
);
1220 enum dso_type
dso__type_fd(int fd
)
1222 enum dso_type dso_type
= DSO__TYPE_UNKNOWN
;
1227 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
1232 if (ek
!= ELF_K_ELF
)
1235 if (gelf_getclass(elf
) == ELFCLASS64
) {
1236 dso_type
= DSO__TYPE_64BIT
;
1240 if (gelf_getehdr(elf
, &ehdr
) == NULL
)
1243 if (ehdr
.e_machine
== EM_X86_64
)
1244 dso_type
= DSO__TYPE_X32BIT
;
1246 dso_type
= DSO__TYPE_32BIT
;
1253 static int copy_bytes(int from
, off_t from_offs
, int to
, off_t to_offs
, u64 len
)
1258 char *buf
= malloc(page_size
);
1263 if (lseek(to
, to_offs
, SEEK_SET
) != to_offs
)
1266 if (lseek(from
, from_offs
, SEEK_SET
) != from_offs
)
1273 /* Use read because mmap won't work on proc files */
1274 r
= read(from
, buf
, n
);
1280 r
= write(to
, buf
, n
);
1301 static int kcore__open(struct kcore
*kcore
, const char *filename
)
1305 kcore
->fd
= open(filename
, O_RDONLY
);
1306 if (kcore
->fd
== -1)
1309 kcore
->elf
= elf_begin(kcore
->fd
, ELF_C_READ
, NULL
);
1313 kcore
->elfclass
= gelf_getclass(kcore
->elf
);
1314 if (kcore
->elfclass
== ELFCLASSNONE
)
1317 ehdr
= gelf_getehdr(kcore
->elf
, &kcore
->ehdr
);
1324 elf_end(kcore
->elf
);
1330 static int kcore__init(struct kcore
*kcore
, char *filename
, int elfclass
,
1333 kcore
->elfclass
= elfclass
;
1336 kcore
->fd
= mkstemp(filename
);
1338 kcore
->fd
= open(filename
, O_WRONLY
| O_CREAT
| O_EXCL
, 0400);
1339 if (kcore
->fd
== -1)
1342 kcore
->elf
= elf_begin(kcore
->fd
, ELF_C_WRITE
, NULL
);
1346 if (!gelf_newehdr(kcore
->elf
, elfclass
))
1349 memset(&kcore
->ehdr
, 0, sizeof(GElf_Ehdr
));
1354 elf_end(kcore
->elf
);
1361 static void kcore__close(struct kcore
*kcore
)
1363 elf_end(kcore
->elf
);
1367 static int kcore__copy_hdr(struct kcore
*from
, struct kcore
*to
, size_t count
)
1369 GElf_Ehdr
*ehdr
= &to
->ehdr
;
1370 GElf_Ehdr
*kehdr
= &from
->ehdr
;
1372 memcpy(ehdr
->e_ident
, kehdr
->e_ident
, EI_NIDENT
);
1373 ehdr
->e_type
= kehdr
->e_type
;
1374 ehdr
->e_machine
= kehdr
->e_machine
;
1375 ehdr
->e_version
= kehdr
->e_version
;
1378 ehdr
->e_flags
= kehdr
->e_flags
;
1379 ehdr
->e_phnum
= count
;
1380 ehdr
->e_shentsize
= 0;
1382 ehdr
->e_shstrndx
= 0;
1384 if (from
->elfclass
== ELFCLASS32
) {
1385 ehdr
->e_phoff
= sizeof(Elf32_Ehdr
);
1386 ehdr
->e_ehsize
= sizeof(Elf32_Ehdr
);
1387 ehdr
->e_phentsize
= sizeof(Elf32_Phdr
);
1389 ehdr
->e_phoff
= sizeof(Elf64_Ehdr
);
1390 ehdr
->e_ehsize
= sizeof(Elf64_Ehdr
);
1391 ehdr
->e_phentsize
= sizeof(Elf64_Phdr
);
1394 if (!gelf_update_ehdr(to
->elf
, ehdr
))
1397 if (!gelf_newphdr(to
->elf
, count
))
1403 static int kcore__add_phdr(struct kcore
*kcore
, int idx
, off_t offset
,
1408 .p_flags
= PF_R
| PF_W
| PF_X
,
1414 .p_align
= page_size
,
1417 if (!gelf_update_phdr(kcore
->elf
, idx
, &phdr
))
1423 static off_t
kcore__write(struct kcore
*kcore
)
1425 return elf_update(kcore
->elf
, ELF_C_WRITE
);
1433 struct list_head node
;
1434 struct phdr_data
*remaps
;
1439 struct list_head node
;
1442 struct kcore_copy_info
{
1448 u64 last_module_symbol
;
1450 struct list_head phdrs
;
1451 struct list_head syms
;
1454 #define kcore_copy__for_each_phdr(k, p) \
1455 list_for_each_entry((p), &(k)->phdrs, node)
1457 static struct phdr_data
*phdr_data__new(u64 addr
, u64 len
, off_t offset
)
1459 struct phdr_data
*p
= zalloc(sizeof(*p
));
1470 static struct phdr_data
*kcore_copy_info__addnew(struct kcore_copy_info
*kci
,
1474 struct phdr_data
*p
= phdr_data__new(addr
, len
, offset
);
1477 list_add_tail(&p
->node
, &kci
->phdrs
);
1482 static void kcore_copy__free_phdrs(struct kcore_copy_info
*kci
)
1484 struct phdr_data
*p
, *tmp
;
1486 list_for_each_entry_safe(p
, tmp
, &kci
->phdrs
, node
) {
1487 list_del_init(&p
->node
);
1492 static struct sym_data
*kcore_copy__new_sym(struct kcore_copy_info
*kci
,
1495 struct sym_data
*s
= zalloc(sizeof(*s
));
1499 list_add_tail(&s
->node
, &kci
->syms
);
1505 static void kcore_copy__free_syms(struct kcore_copy_info
*kci
)
1507 struct sym_data
*s
, *tmp
;
1509 list_for_each_entry_safe(s
, tmp
, &kci
->syms
, node
) {
1510 list_del_init(&s
->node
);
1515 static int kcore_copy__process_kallsyms(void *arg
, const char *name
, char type
,
1518 struct kcore_copy_info
*kci
= arg
;
1520 if (!kallsyms__is_function(type
))
1523 if (strchr(name
, '[')) {
1524 if (start
> kci
->last_module_symbol
)
1525 kci
->last_module_symbol
= start
;
1529 if (!kci
->first_symbol
|| start
< kci
->first_symbol
)
1530 kci
->first_symbol
= start
;
1532 if (!kci
->last_symbol
|| start
> kci
->last_symbol
)
1533 kci
->last_symbol
= start
;
1535 if (!strcmp(name
, "_stext")) {
1540 if (!strcmp(name
, "_etext")) {
1545 if (is_entry_trampoline(name
) && !kcore_copy__new_sym(kci
, start
))
1551 static int kcore_copy__parse_kallsyms(struct kcore_copy_info
*kci
,
1554 char kallsyms_filename
[PATH_MAX
];
1556 scnprintf(kallsyms_filename
, PATH_MAX
, "%s/kallsyms", dir
);
1558 if (symbol__restricted_filename(kallsyms_filename
, "/proc/kallsyms"))
1561 if (kallsyms__parse(kallsyms_filename
, kci
,
1562 kcore_copy__process_kallsyms
) < 0)
1568 static int kcore_copy__process_modules(void *arg
,
1569 const char *name __maybe_unused
,
1570 u64 start
, u64 size __maybe_unused
)
1572 struct kcore_copy_info
*kci
= arg
;
1574 if (!kci
->first_module
|| start
< kci
->first_module
)
1575 kci
->first_module
= start
;
1580 static int kcore_copy__parse_modules(struct kcore_copy_info
*kci
,
1583 char modules_filename
[PATH_MAX
];
1585 scnprintf(modules_filename
, PATH_MAX
, "%s/modules", dir
);
1587 if (symbol__restricted_filename(modules_filename
, "/proc/modules"))
1590 if (modules__parse(modules_filename
, kci
,
1591 kcore_copy__process_modules
) < 0)
1597 static int kcore_copy__map(struct kcore_copy_info
*kci
, u64 start
, u64 end
,
1598 u64 pgoff
, u64 s
, u64 e
)
1602 if (s
< start
|| s
>= end
)
1605 offset
= (s
- start
) + pgoff
;
1606 len
= e
< end
? e
- s
: end
- s
;
1608 return kcore_copy_info__addnew(kci
, s
, len
, offset
) ? 0 : -1;
1611 static int kcore_copy__read_map(u64 start
, u64 len
, u64 pgoff
, void *data
)
1613 struct kcore_copy_info
*kci
= data
;
1614 u64 end
= start
+ len
;
1615 struct sym_data
*sdat
;
1617 if (kcore_copy__map(kci
, start
, end
, pgoff
, kci
->stext
, kci
->etext
))
1620 if (kcore_copy__map(kci
, start
, end
, pgoff
, kci
->first_module
,
1621 kci
->last_module_symbol
))
1624 list_for_each_entry(sdat
, &kci
->syms
, node
) {
1625 u64 s
= round_down(sdat
->addr
, page_size
);
1627 if (kcore_copy__map(kci
, start
, end
, pgoff
, s
, s
+ len
))
1634 static int kcore_copy__read_maps(struct kcore_copy_info
*kci
, Elf
*elf
)
1636 if (elf_read_maps(elf
, true, kcore_copy__read_map
, kci
) < 0)
1642 static void kcore_copy__find_remaps(struct kcore_copy_info
*kci
)
1644 struct phdr_data
*p
, *k
= NULL
;
1650 /* Find phdr that corresponds to the kernel map (contains stext) */
1651 kcore_copy__for_each_phdr(kci
, p
) {
1652 u64 pend
= p
->addr
+ p
->len
- 1;
1654 if (p
->addr
<= kci
->stext
&& pend
>= kci
->stext
) {
1663 kend
= k
->offset
+ k
->len
;
1665 /* Find phdrs that remap the kernel */
1666 kcore_copy__for_each_phdr(kci
, p
) {
1667 u64 pend
= p
->offset
+ p
->len
;
1672 if (p
->offset
>= k
->offset
&& pend
<= kend
)
1677 static void kcore_copy__layout(struct kcore_copy_info
*kci
)
1679 struct phdr_data
*p
;
1682 kcore_copy__find_remaps(kci
);
1684 kcore_copy__for_each_phdr(kci
, p
) {
1692 kcore_copy__for_each_phdr(kci
, p
) {
1693 struct phdr_data
*k
= p
->remaps
;
1696 p
->rel
= p
->offset
- k
->offset
+ k
->rel
;
1700 static int kcore_copy__calc_maps(struct kcore_copy_info
*kci
, const char *dir
,
1703 if (kcore_copy__parse_kallsyms(kci
, dir
))
1706 if (kcore_copy__parse_modules(kci
, dir
))
1710 kci
->stext
= round_down(kci
->stext
, page_size
);
1712 kci
->stext
= round_down(kci
->first_symbol
, page_size
);
1715 kci
->etext
= round_up(kci
->etext
, page_size
);
1716 } else if (kci
->last_symbol
) {
1717 kci
->etext
= round_up(kci
->last_symbol
, page_size
);
1718 kci
->etext
+= page_size
;
1721 kci
->first_module
= round_down(kci
->first_module
, page_size
);
1723 if (kci
->last_module_symbol
) {
1724 kci
->last_module_symbol
= round_up(kci
->last_module_symbol
,
1726 kci
->last_module_symbol
+= page_size
;
1729 if (!kci
->stext
|| !kci
->etext
)
1732 if (kci
->first_module
&& !kci
->last_module_symbol
)
1735 if (kcore_copy__read_maps(kci
, elf
))
1738 kcore_copy__layout(kci
);
1743 static int kcore_copy__copy_file(const char *from_dir
, const char *to_dir
,
1746 char from_filename
[PATH_MAX
];
1747 char to_filename
[PATH_MAX
];
1749 scnprintf(from_filename
, PATH_MAX
, "%s/%s", from_dir
, name
);
1750 scnprintf(to_filename
, PATH_MAX
, "%s/%s", to_dir
, name
);
1752 return copyfile_mode(from_filename
, to_filename
, 0400);
1755 static int kcore_copy__unlink(const char *dir
, const char *name
)
1757 char filename
[PATH_MAX
];
1759 scnprintf(filename
, PATH_MAX
, "%s/%s", dir
, name
);
1761 return unlink(filename
);
1764 static int kcore_copy__compare_fds(int from
, int to
)
1772 buf_from
= malloc(page_size
);
1773 buf_to
= malloc(page_size
);
1774 if (!buf_from
|| !buf_to
)
1778 /* Use read because mmap won't work on proc files */
1779 ret
= read(from
, buf_from
, page_size
);
1788 if (readn(to
, buf_to
, len
) != (int)len
)
1791 if (memcmp(buf_from
, buf_to
, len
))
1802 static int kcore_copy__compare_files(const char *from_filename
,
1803 const char *to_filename
)
1805 int from
, to
, err
= -1;
1807 from
= open(from_filename
, O_RDONLY
);
1811 to
= open(to_filename
, O_RDONLY
);
1813 goto out_close_from
;
1815 err
= kcore_copy__compare_fds(from
, to
);
1823 static int kcore_copy__compare_file(const char *from_dir
, const char *to_dir
,
1826 char from_filename
[PATH_MAX
];
1827 char to_filename
[PATH_MAX
];
1829 scnprintf(from_filename
, PATH_MAX
, "%s/%s", from_dir
, name
);
1830 scnprintf(to_filename
, PATH_MAX
, "%s/%s", to_dir
, name
);
1832 return kcore_copy__compare_files(from_filename
, to_filename
);
1836 * kcore_copy - copy kallsyms, modules and kcore from one directory to another.
1837 * @from_dir: from directory
1838 * @to_dir: to directory
1840 * This function copies kallsyms, modules and kcore files from one directory to
1841 * another. kallsyms and modules are copied entirely. Only code segments are
1842 * copied from kcore. It is assumed that two segments suffice: one for the
1843 * kernel proper and one for all the modules. The code segments are determined
1844 * from kallsyms and modules files. The kernel map starts at _stext or the
1845 * lowest function symbol, and ends at _etext or the highest function symbol.
1846 * The module map starts at the lowest module address and ends at the highest
1847 * module symbol. Start addresses are rounded down to the nearest page. End
1848 * addresses are rounded up to the nearest page. An extra page is added to the
1849 * highest kernel symbol and highest module symbol to, hopefully, encompass that
1850 * symbol too. Because it contains only code sections, the resulting kcore is
1851 * unusual. One significant peculiarity is that the mapping (start -> pgoff)
1852 * is not the same for the kernel map and the modules map. That happens because
1853 * the data is copied adjacently whereas the original kcore has gaps. Finally,
1854 * kallsyms and modules files are compared with their copies to check that
1855 * modules have not been loaded or unloaded while the copies were taking place.
1857 * Return: %0 on success, %-1 on failure.
1859 int kcore_copy(const char *from_dir
, const char *to_dir
)
1862 struct kcore extract
;
1863 int idx
= 0, err
= -1;
1865 struct kcore_copy_info kci
= { .stext
= 0, };
1866 char kcore_filename
[PATH_MAX
];
1867 char extract_filename
[PATH_MAX
];
1868 struct phdr_data
*p
;
1870 INIT_LIST_HEAD(&kci
.phdrs
);
1871 INIT_LIST_HEAD(&kci
.syms
);
1873 if (kcore_copy__copy_file(from_dir
, to_dir
, "kallsyms"))
1876 if (kcore_copy__copy_file(from_dir
, to_dir
, "modules"))
1877 goto out_unlink_kallsyms
;
1879 scnprintf(kcore_filename
, PATH_MAX
, "%s/kcore", from_dir
);
1880 scnprintf(extract_filename
, PATH_MAX
, "%s/kcore", to_dir
);
1882 if (kcore__open(&kcore
, kcore_filename
))
1883 goto out_unlink_modules
;
1885 if (kcore_copy__calc_maps(&kci
, from_dir
, kcore
.elf
))
1886 goto out_kcore_close
;
1888 if (kcore__init(&extract
, extract_filename
, kcore
.elfclass
, false))
1889 goto out_kcore_close
;
1891 if (kcore__copy_hdr(&kcore
, &extract
, kci
.phnum
))
1892 goto out_extract_close
;
1894 offset
= gelf_fsize(extract
.elf
, ELF_T_EHDR
, 1, EV_CURRENT
) +
1895 gelf_fsize(extract
.elf
, ELF_T_PHDR
, kci
.phnum
, EV_CURRENT
);
1896 offset
= round_up(offset
, page_size
);
1898 kcore_copy__for_each_phdr(&kci
, p
) {
1899 off_t offs
= p
->rel
+ offset
;
1901 if (kcore__add_phdr(&extract
, idx
++, offs
, p
->addr
, p
->len
))
1902 goto out_extract_close
;
1905 sz
= kcore__write(&extract
);
1906 if (sz
< 0 || sz
> offset
)
1907 goto out_extract_close
;
1909 kcore_copy__for_each_phdr(&kci
, p
) {
1910 off_t offs
= p
->rel
+ offset
;
1914 if (copy_bytes(kcore
.fd
, p
->offset
, extract
.fd
, offs
, p
->len
))
1915 goto out_extract_close
;
1918 if (kcore_copy__compare_file(from_dir
, to_dir
, "modules"))
1919 goto out_extract_close
;
1921 if (kcore_copy__compare_file(from_dir
, to_dir
, "kallsyms"))
1922 goto out_extract_close
;
1927 kcore__close(&extract
);
1929 unlink(extract_filename
);
1931 kcore__close(&kcore
);
1934 kcore_copy__unlink(to_dir
, "modules");
1935 out_unlink_kallsyms
:
1937 kcore_copy__unlink(to_dir
, "kallsyms");
1939 kcore_copy__free_phdrs(&kci
);
1940 kcore_copy__free_syms(&kci
);
1945 int kcore_extract__create(struct kcore_extract
*kce
)
1948 struct kcore extract
;
1950 int idx
= 0, err
= -1;
1951 off_t offset
= page_size
, sz
;
1953 if (kcore__open(&kcore
, kce
->kcore_filename
))
1956 strcpy(kce
->extract_filename
, PERF_KCORE_EXTRACT
);
1957 if (kcore__init(&extract
, kce
->extract_filename
, kcore
.elfclass
, true))
1958 goto out_kcore_close
;
1960 if (kcore__copy_hdr(&kcore
, &extract
, count
))
1961 goto out_extract_close
;
1963 if (kcore__add_phdr(&extract
, idx
, offset
, kce
->addr
, kce
->len
))
1964 goto out_extract_close
;
1966 sz
= kcore__write(&extract
);
1967 if (sz
< 0 || sz
> offset
)
1968 goto out_extract_close
;
1970 if (copy_bytes(kcore
.fd
, kce
->offs
, extract
.fd
, offset
, kce
->len
))
1971 goto out_extract_close
;
1976 kcore__close(&extract
);
1978 unlink(kce
->extract_filename
);
1980 kcore__close(&kcore
);
1985 void kcore_extract__delete(struct kcore_extract
*kce
)
1987 unlink(kce
->extract_filename
);
1990 #ifdef HAVE_GELF_GETNOTE_SUPPORT
1992 static void sdt_adjust_loc(struct sdt_note
*tmp
, GElf_Addr base_off
)
1998 tmp
->addr
.a32
[SDT_NOTE_IDX_LOC
] =
1999 tmp
->addr
.a32
[SDT_NOTE_IDX_LOC
] + base_off
-
2000 tmp
->addr
.a32
[SDT_NOTE_IDX_BASE
];
2002 tmp
->addr
.a64
[SDT_NOTE_IDX_LOC
] =
2003 tmp
->addr
.a64
[SDT_NOTE_IDX_LOC
] + base_off
-
2004 tmp
->addr
.a64
[SDT_NOTE_IDX_BASE
];
2007 static void sdt_adjust_refctr(struct sdt_note
*tmp
, GElf_Addr base_addr
,
2013 if (tmp
->bit32
&& tmp
->addr
.a32
[SDT_NOTE_IDX_REFCTR
])
2014 tmp
->addr
.a32
[SDT_NOTE_IDX_REFCTR
] -= (base_addr
- base_off
);
2015 else if (tmp
->addr
.a64
[SDT_NOTE_IDX_REFCTR
])
2016 tmp
->addr
.a64
[SDT_NOTE_IDX_REFCTR
] -= (base_addr
- base_off
);
2020 * populate_sdt_note : Parse raw data and identify SDT note
2021 * @elf: elf of the opened file
2022 * @data: raw data of a section with description offset applied
2023 * @len: note description size
2024 * @type: type of the note
2025 * @sdt_notes: List to add the SDT note
2027 * Responsible for parsing the @data in section .note.stapsdt in @elf and
2028 * if its an SDT note, it appends to @sdt_notes list.
2030 static int populate_sdt_note(Elf
**elf
, const char *data
, size_t len
,
2031 struct list_head
*sdt_notes
)
2033 const char *provider
, *name
, *args
;
2034 struct sdt_note
*tmp
= NULL
;
2040 Elf64_Addr a64
[NR_ADDR
];
2041 Elf32_Addr a32
[NR_ADDR
];
2045 .d_buf
= &buf
, .d_type
= ELF_T_ADDR
, .d_version
= EV_CURRENT
,
2046 .d_size
= gelf_fsize((*elf
), ELF_T_ADDR
, NR_ADDR
, EV_CURRENT
),
2047 .d_off
= 0, .d_align
= 0
2050 .d_buf
= (void *) data
, .d_type
= ELF_T_ADDR
,
2051 .d_version
= EV_CURRENT
, .d_size
= dst
.d_size
, .d_off
= 0,
2055 tmp
= (struct sdt_note
*)calloc(1, sizeof(struct sdt_note
));
2061 INIT_LIST_HEAD(&tmp
->note_list
);
2063 if (len
< dst
.d_size
+ 3)
2066 /* Translation from file representation to memory representation */
2067 if (gelf_xlatetom(*elf
, &dst
, &src
,
2068 elf_getident(*elf
, NULL
)[EI_DATA
]) == NULL
) {
2069 pr_err("gelf_xlatetom : %s\n", elf_errmsg(-1));
2073 /* Populate the fields of sdt_note */
2074 provider
= data
+ dst
.d_size
;
2076 name
= (const char *)memchr(provider
, '\0', data
+ len
- provider
);
2080 tmp
->provider
= strdup(provider
);
2081 if (!tmp
->provider
) {
2085 tmp
->name
= strdup(name
);
2091 args
= memchr(name
, '\0', data
+ len
- name
);
2094 * There is no argument if:
2095 * - We reached the end of the note;
2096 * - There is not enough room to hold a potential string;
2097 * - The argument string is empty or just contains ':'.
2099 if (args
== NULL
|| data
+ len
- args
< 2 ||
2100 args
[1] == ':' || args
[1] == '\0')
2103 tmp
->args
= strdup(++args
);
2110 if (gelf_getclass(*elf
) == ELFCLASS32
) {
2111 memcpy(&tmp
->addr
, &buf
, 3 * sizeof(Elf32_Addr
));
2114 memcpy(&tmp
->addr
, &buf
, 3 * sizeof(Elf64_Addr
));
2118 if (!gelf_getehdr(*elf
, &ehdr
)) {
2119 pr_debug("%s : cannot get elf header.\n", __func__
);
2124 /* Adjust the prelink effect :
2125 * Find out the .stapsdt.base section.
2126 * This scn will help us to handle prelinking (if present).
2127 * Compare the retrieved file offset of the base section with the
2128 * base address in the description of the SDT note. If its different,
2129 * then accordingly, adjust the note location.
2131 if (elf_section_by_name(*elf
, &ehdr
, &shdr
, SDT_BASE_SCN
, NULL
))
2132 sdt_adjust_loc(tmp
, shdr
.sh_offset
);
2134 /* Adjust reference counter offset */
2135 if (elf_section_by_name(*elf
, &ehdr
, &shdr
, SDT_PROBES_SCN
, NULL
))
2136 sdt_adjust_refctr(tmp
, shdr
.sh_addr
, shdr
.sh_offset
);
2138 list_add_tail(&tmp
->note_list
, sdt_notes
);
2146 zfree(&tmp
->provider
);
2154 * construct_sdt_notes_list : constructs a list of SDT notes
2155 * @elf : elf to look into
2156 * @sdt_notes : empty list_head
2158 * Scans the sections in 'elf' for the section
2159 * .note.stapsdt. It, then calls populate_sdt_note to find
2160 * out the SDT events and populates the 'sdt_notes'.
2162 static int construct_sdt_notes_list(Elf
*elf
, struct list_head
*sdt_notes
)
2165 Elf_Scn
*scn
= NULL
;
2168 size_t shstrndx
, next
;
2170 size_t name_off
, desc_off
, offset
;
2173 if (gelf_getehdr(elf
, &ehdr
) == NULL
) {
2177 if (elf_getshdrstrndx(elf
, &shstrndx
) != 0) {
2182 /* Look for the required section */
2183 scn
= elf_section_by_name(elf
, &ehdr
, &shdr
, SDT_NOTE_SCN
, NULL
);
2189 if ((shdr
.sh_type
!= SHT_NOTE
) || (shdr
.sh_flags
& SHF_ALLOC
)) {
2194 data
= elf_getdata(scn
, NULL
);
2196 /* Get the SDT notes */
2197 for (offset
= 0; (next
= gelf_getnote(data
, offset
, &nhdr
, &name_off
,
2198 &desc_off
)) > 0; offset
= next
) {
2199 if (nhdr
.n_namesz
== sizeof(SDT_NOTE_NAME
) &&
2200 !memcmp(data
->d_buf
+ name_off
, SDT_NOTE_NAME
,
2201 sizeof(SDT_NOTE_NAME
))) {
2202 /* Check the type of the note */
2203 if (nhdr
.n_type
!= SDT_NOTE_TYPE
)
2206 ret
= populate_sdt_note(&elf
, ((data
->d_buf
) + desc_off
),
2207 nhdr
.n_descsz
, sdt_notes
);
2212 if (list_empty(sdt_notes
))
2220 * get_sdt_note_list : Wrapper to construct a list of sdt notes
2221 * @head : empty list_head
2222 * @target : file to find SDT notes from
2224 * This opens the file, initializes
2225 * the ELF and then calls construct_sdt_notes_list.
2227 int get_sdt_note_list(struct list_head
*head
, const char *target
)
2232 fd
= open(target
, O_RDONLY
);
2236 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
2241 ret
= construct_sdt_notes_list(elf
, head
);
2249 * cleanup_sdt_note_list : free the sdt notes' list
2250 * @sdt_notes: sdt notes' list
2252 * Free up the SDT notes in @sdt_notes.
2253 * Returns the number of SDT notes free'd.
2255 int cleanup_sdt_note_list(struct list_head
*sdt_notes
)
2257 struct sdt_note
*tmp
, *pos
;
2260 list_for_each_entry_safe(pos
, tmp
, sdt_notes
, note_list
) {
2261 list_del_init(&pos
->note_list
);
2263 zfree(&pos
->provider
);
2271 * sdt_notes__get_count: Counts the number of sdt events
2272 * @start: list_head to sdt_notes list
2274 * Returns the number of SDT notes in a list
2276 int sdt_notes__get_count(struct list_head
*start
)
2278 struct sdt_note
*sdt_ptr
;
2281 list_for_each_entry(sdt_ptr
, start
, note_list
)
2287 void symbol__elf_init(void)
2289 elf_version(EV_CURRENT
);