xref: /linux/tools/perf/util/symbol-elf.c (revision 3bf3e21c15d4386a5f15118ec39bbc1b67ea5759)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <fcntl.h>
3 #include <stdio.h>
4 #include <errno.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <unistd.h>
8 #include <inttypes.h>
9 
10 #include "dso.h"
11 #include "map.h"
12 #include "maps.h"
13 #include "symbol.h"
14 #include "symsrc.h"
15 #include "demangle-cxx.h"
16 #include "demangle-ocaml.h"
17 #include "demangle-java.h"
18 #include "demangle-rust.h"
19 #include "machine.h"
20 #include "vdso.h"
21 #include "debug.h"
22 #include "util/copyfile.h"
23 #include <linux/ctype.h>
24 #include <linux/kernel.h>
25 #include <linux/zalloc.h>
26 #include <symbol/kallsyms.h>
27 #include <internal/lib.h>
28 
29 #ifdef HAVE_LIBBFD_SUPPORT
30 #define PACKAGE 'perf'
31 #include <bfd.h>
32 #endif
33 
34 #if defined(HAVE_LIBBFD_SUPPORT) || defined(HAVE_CPLUS_DEMANGLE_SUPPORT)
35 #ifndef DMGL_PARAMS
36 #define DMGL_PARAMS     (1 << 0)  /* Include function args */
37 #define DMGL_ANSI       (1 << 1)  /* Include const, volatile, etc */
38 #endif
39 #endif
40 
41 #ifndef EM_AARCH64
42 #define EM_AARCH64	183  /* ARM 64 bit */
43 #endif
44 
45 #ifndef EM_LOONGARCH
46 #define EM_LOONGARCH	258
47 #endif
48 
49 #ifndef ELF32_ST_VISIBILITY
50 #define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
51 #endif
52 
53 /* For ELF64 the definitions are the same.  */
54 #ifndef ELF64_ST_VISIBILITY
55 #define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
56 #endif
57 
58 /* How to extract information held in the st_other field.  */
59 #ifndef GELF_ST_VISIBILITY
60 #define GELF_ST_VISIBILITY(val)	ELF64_ST_VISIBILITY (val)
61 #endif
62 
63 typedef Elf64_Nhdr GElf_Nhdr;
64 
65 
66 #ifndef HAVE_ELF_GETPHDRNUM_SUPPORT
67 static int elf_getphdrnum(Elf *elf, size_t *dst)
68 {
69 	GElf_Ehdr gehdr;
70 	GElf_Ehdr *ehdr;
71 
72 	ehdr = gelf_getehdr(elf, &gehdr);
73 	if (!ehdr)
74 		return -1;
75 
76 	*dst = ehdr->e_phnum;
77 
78 	return 0;
79 }
80 #endif
81 
82 #ifndef HAVE_ELF_GETSHDRSTRNDX_SUPPORT
83 static int elf_getshdrstrndx(Elf *elf __maybe_unused, size_t *dst __maybe_unused)
84 {
85 	pr_err("%s: update your libelf to > 0.140, this one lacks elf_getshdrstrndx().\n", __func__);
86 	return -1;
87 }
88 #endif
89 
90 #ifndef NT_GNU_BUILD_ID
91 #define NT_GNU_BUILD_ID 3
92 #endif
93 
94 /**
95  * elf_symtab__for_each_symbol - iterate thru all the symbols
96  *
97  * @syms: struct elf_symtab instance to iterate
98  * @idx: uint32_t idx
99  * @sym: GElf_Sym iterator
100  */
101 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
102 	for (idx = 0, gelf_getsym(syms, idx, &sym);\
103 	     idx < nr_syms; \
104 	     idx++, gelf_getsym(syms, idx, &sym))
105 
106 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
107 {
108 	return GELF_ST_TYPE(sym->st_info);
109 }
110 
111 static inline uint8_t elf_sym__visibility(const GElf_Sym *sym)
112 {
113 	return GELF_ST_VISIBILITY(sym->st_other);
114 }
115 
116 #ifndef STT_GNU_IFUNC
117 #define STT_GNU_IFUNC 10
118 #endif
119 
120 static inline int elf_sym__is_function(const GElf_Sym *sym)
121 {
122 	return (elf_sym__type(sym) == STT_FUNC ||
123 		elf_sym__type(sym) == STT_GNU_IFUNC) &&
124 	       sym->st_name != 0 &&
125 	       sym->st_shndx != SHN_UNDEF;
126 }
127 
128 static inline bool elf_sym__is_object(const GElf_Sym *sym)
129 {
130 	return elf_sym__type(sym) == STT_OBJECT &&
131 		sym->st_name != 0 &&
132 		sym->st_shndx != SHN_UNDEF;
133 }
134 
135 static inline int elf_sym__is_label(const GElf_Sym *sym)
136 {
137 	return elf_sym__type(sym) == STT_NOTYPE &&
138 		sym->st_name != 0 &&
139 		sym->st_shndx != SHN_UNDEF &&
140 		sym->st_shndx != SHN_ABS &&
141 		elf_sym__visibility(sym) != STV_HIDDEN &&
142 		elf_sym__visibility(sym) != STV_INTERNAL;
143 }
144 
145 static bool elf_sym__filter(GElf_Sym *sym)
146 {
147 	return elf_sym__is_function(sym) || elf_sym__is_object(sym);
148 }
149 
150 static inline const char *elf_sym__name(const GElf_Sym *sym,
151 					const Elf_Data *symstrs)
152 {
153 	return symstrs->d_buf + sym->st_name;
154 }
155 
156 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
157 					const Elf_Data *secstrs)
158 {
159 	return secstrs->d_buf + shdr->sh_name;
160 }
161 
162 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
163 					const Elf_Data *secstrs)
164 {
165 	return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
166 }
167 
168 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
169 				    const Elf_Data *secstrs)
170 {
171 	return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
172 }
173 
174 static bool elf_sec__filter(GElf_Shdr *shdr, Elf_Data *secstrs)
175 {
176 	return elf_sec__is_text(shdr, secstrs) ||
177 	       elf_sec__is_data(shdr, secstrs);
178 }
179 
180 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
181 {
182 	Elf_Scn *sec = NULL;
183 	GElf_Shdr shdr;
184 	size_t cnt = 1;
185 
186 	while ((sec = elf_nextscn(elf, sec)) != NULL) {
187 		gelf_getshdr(sec, &shdr);
188 
189 		if ((addr >= shdr.sh_addr) &&
190 		    (addr < (shdr.sh_addr + shdr.sh_size)))
191 			return cnt;
192 
193 		++cnt;
194 	}
195 
196 	return -1;
197 }
198 
199 Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
200 			     GElf_Shdr *shp, const char *name, size_t *idx)
201 {
202 	Elf_Scn *sec = NULL;
203 	size_t cnt = 1;
204 
205 	/* ELF is corrupted/truncated, avoid calling elf_strptr. */
206 	if (!elf_rawdata(elf_getscn(elf, ep->e_shstrndx), NULL))
207 		return NULL;
208 
209 	while ((sec = elf_nextscn(elf, sec)) != NULL) {
210 		char *str;
211 
212 		gelf_getshdr(sec, shp);
213 		str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
214 		if (str && !strcmp(name, str)) {
215 			if (idx)
216 				*idx = cnt;
217 			return sec;
218 		}
219 		++cnt;
220 	}
221 
222 	return NULL;
223 }
224 
225 bool filename__has_section(const char *filename, const char *sec)
226 {
227 	int fd;
228 	Elf *elf;
229 	GElf_Ehdr ehdr;
230 	GElf_Shdr shdr;
231 	bool found = false;
232 
233 	fd = open(filename, O_RDONLY);
234 	if (fd < 0)
235 		return false;
236 
237 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
238 	if (elf == NULL)
239 		goto out;
240 
241 	if (gelf_getehdr(elf, &ehdr) == NULL)
242 		goto elf_out;
243 
244 	found = !!elf_section_by_name(elf, &ehdr, &shdr, sec, NULL);
245 
246 elf_out:
247 	elf_end(elf);
248 out:
249 	close(fd);
250 	return found;
251 }
252 
253 static int elf_read_program_header(Elf *elf, u64 vaddr, GElf_Phdr *phdr)
254 {
255 	size_t i, phdrnum;
256 	u64 sz;
257 
258 	if (elf_getphdrnum(elf, &phdrnum))
259 		return -1;
260 
261 	for (i = 0; i < phdrnum; i++) {
262 		if (gelf_getphdr(elf, i, phdr) == NULL)
263 			return -1;
264 
265 		if (phdr->p_type != PT_LOAD)
266 			continue;
267 
268 		sz = max(phdr->p_memsz, phdr->p_filesz);
269 		if (!sz)
270 			continue;
271 
272 		if (vaddr >= phdr->p_vaddr && (vaddr < phdr->p_vaddr + sz))
273 			return 0;
274 	}
275 
276 	/* Not found any valid program header */
277 	return -1;
278 }
279 
280 static bool want_demangle(bool is_kernel_sym)
281 {
282 	return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
283 }
284 
285 /*
286  * Demangle C++ function signature, typically replaced by demangle-cxx.cpp
287  * version.
288  */
289 __weak char *cxx_demangle_sym(const char *str __maybe_unused, bool params __maybe_unused,
290 			      bool modifiers __maybe_unused)
291 {
292 #ifdef HAVE_LIBBFD_SUPPORT
293 	int flags = (params ? DMGL_PARAMS : 0) | (modifiers ? DMGL_ANSI : 0);
294 
295 	return bfd_demangle(NULL, str, flags);
296 #elif defined(HAVE_CPLUS_DEMANGLE_SUPPORT)
297 	int flags = (params ? DMGL_PARAMS : 0) | (modifiers ? DMGL_ANSI : 0);
298 
299 	return cplus_demangle(str, flags);
300 #else
301 	return NULL;
302 #endif
303 }
304 
305 static char *demangle_sym(struct dso *dso, int kmodule, const char *elf_name)
306 {
307 	char *demangled = NULL;
308 
309 	/*
310 	 * We need to figure out if the object was created from C++ sources
311 	 * DWARF DW_compile_unit has this, but we don't always have access
312 	 * to it...
313 	 */
314 	if (!want_demangle(dso->kernel || kmodule))
315 	    return demangled;
316 
317 	demangled = cxx_demangle_sym(elf_name, verbose > 0, verbose > 0);
318 	if (demangled == NULL) {
319 		demangled = ocaml_demangle_sym(elf_name);
320 		if (demangled == NULL) {
321 			demangled = java_demangle_sym(elf_name, JAVA_DEMANGLE_NORET);
322 		}
323 	}
324 	else if (rust_is_mangled(demangled))
325 		/*
326 		    * Input to Rust demangling is the BFD-demangled
327 		    * name which it Rust-demangles in place.
328 		    */
329 		rust_demangle_sym(demangled);
330 
331 	return demangled;
332 }
333 
334 struct rel_info {
335 	u32		nr_entries;
336 	u32		*sorted;
337 	bool		is_rela;
338 	Elf_Data	*reldata;
339 	GElf_Rela	rela;
340 	GElf_Rel	rel;
341 };
342 
343 static u32 get_rel_symidx(struct rel_info *ri, u32 idx)
344 {
345 	idx = ri->sorted ? ri->sorted[idx] : idx;
346 	if (ri->is_rela) {
347 		gelf_getrela(ri->reldata, idx, &ri->rela);
348 		return GELF_R_SYM(ri->rela.r_info);
349 	}
350 	gelf_getrel(ri->reldata, idx, &ri->rel);
351 	return GELF_R_SYM(ri->rel.r_info);
352 }
353 
354 static u64 get_rel_offset(struct rel_info *ri, u32 x)
355 {
356 	if (ri->is_rela) {
357 		GElf_Rela rela;
358 
359 		gelf_getrela(ri->reldata, x, &rela);
360 		return rela.r_offset;
361 	} else {
362 		GElf_Rel rel;
363 
364 		gelf_getrel(ri->reldata, x, &rel);
365 		return rel.r_offset;
366 	}
367 }
368 
369 static int rel_cmp(const void *a, const void *b, void *r)
370 {
371 	struct rel_info *ri = r;
372 	u64 a_offset = get_rel_offset(ri, *(const u32 *)a);
373 	u64 b_offset = get_rel_offset(ri, *(const u32 *)b);
374 
375 	return a_offset < b_offset ? -1 : (a_offset > b_offset ? 1 : 0);
376 }
377 
378 static int sort_rel(struct rel_info *ri)
379 {
380 	size_t sz = sizeof(ri->sorted[0]);
381 	u32 i;
382 
383 	ri->sorted = calloc(ri->nr_entries, sz);
384 	if (!ri->sorted)
385 		return -1;
386 	for (i = 0; i < ri->nr_entries; i++)
387 		ri->sorted[i] = i;
388 	qsort_r(ri->sorted, ri->nr_entries, sz, rel_cmp, ri);
389 	return 0;
390 }
391 
392 /*
393  * For x86_64, the GNU linker is putting IFUNC information in the relocation
394  * addend.
395  */
396 static bool addend_may_be_ifunc(GElf_Ehdr *ehdr, struct rel_info *ri)
397 {
398 	return ehdr->e_machine == EM_X86_64 && ri->is_rela &&
399 	       GELF_R_TYPE(ri->rela.r_info) == R_X86_64_IRELATIVE;
400 }
401 
402 static bool get_ifunc_name(Elf *elf, struct dso *dso, GElf_Ehdr *ehdr,
403 			   struct rel_info *ri, char *buf, size_t buf_sz)
404 {
405 	u64 addr = ri->rela.r_addend;
406 	struct symbol *sym;
407 	GElf_Phdr phdr;
408 
409 	if (!addend_may_be_ifunc(ehdr, ri))
410 		return false;
411 
412 	if (elf_read_program_header(elf, addr, &phdr))
413 		return false;
414 
415 	addr -= phdr.p_vaddr - phdr.p_offset;
416 
417 	sym = dso__find_symbol_nocache(dso, addr);
418 
419 	/* Expecting the address to be an IFUNC or IFUNC alias */
420 	if (!sym || sym->start != addr || (sym->type != STT_GNU_IFUNC && !sym->ifunc_alias))
421 		return false;
422 
423 	snprintf(buf, buf_sz, "%s@plt", sym->name);
424 
425 	return true;
426 }
427 
428 static void exit_rel(struct rel_info *ri)
429 {
430 	zfree(&ri->sorted);
431 }
432 
433 static bool get_plt_sizes(struct dso *dso, GElf_Ehdr *ehdr, GElf_Shdr *shdr_plt,
434 			  u64 *plt_header_size, u64 *plt_entry_size)
435 {
436 	switch (ehdr->e_machine) {
437 	case EM_ARM:
438 		*plt_header_size = 20;
439 		*plt_entry_size = 12;
440 		return true;
441 	case EM_AARCH64:
442 		*plt_header_size = 32;
443 		*plt_entry_size = 16;
444 		return true;
445 	case EM_LOONGARCH:
446 		*plt_header_size = 32;
447 		*plt_entry_size = 16;
448 		return true;
449 	case EM_SPARC:
450 		*plt_header_size = 48;
451 		*plt_entry_size = 12;
452 		return true;
453 	case EM_SPARCV9:
454 		*plt_header_size = 128;
455 		*plt_entry_size = 32;
456 		return true;
457 	case EM_386:
458 	case EM_X86_64:
459 		*plt_entry_size = shdr_plt->sh_entsize;
460 		/* Size is 8 or 16, if not, assume alignment indicates size */
461 		if (*plt_entry_size != 8 && *plt_entry_size != 16)
462 			*plt_entry_size = shdr_plt->sh_addralign == 8 ? 8 : 16;
463 		*plt_header_size = *plt_entry_size;
464 		break;
465 	default: /* FIXME: s390/alpha/mips/parisc/poperpc/sh/xtensa need to be checked */
466 		*plt_header_size = shdr_plt->sh_entsize;
467 		*plt_entry_size = shdr_plt->sh_entsize;
468 		break;
469 	}
470 	if (*plt_entry_size)
471 		return true;
472 	pr_debug("Missing PLT entry size for %s\n", dso->long_name);
473 	return false;
474 }
475 
476 static bool machine_is_x86(GElf_Half e_machine)
477 {
478 	return e_machine == EM_386 || e_machine == EM_X86_64;
479 }
480 
481 struct rela_dyn {
482 	GElf_Addr	offset;
483 	u32		sym_idx;
484 };
485 
486 struct rela_dyn_info {
487 	struct dso	*dso;
488 	Elf_Data	*plt_got_data;
489 	u32		nr_entries;
490 	struct rela_dyn	*sorted;
491 	Elf_Data	*dynsym_data;
492 	Elf_Data	*dynstr_data;
493 	Elf_Data	*rela_dyn_data;
494 };
495 
496 static void exit_rela_dyn(struct rela_dyn_info *di)
497 {
498 	zfree(&di->sorted);
499 }
500 
501 static int cmp_offset(const void *a, const void *b)
502 {
503 	const struct rela_dyn *va = a;
504 	const struct rela_dyn *vb = b;
505 
506 	return va->offset < vb->offset ? -1 : (va->offset > vb->offset ? 1 : 0);
507 }
508 
509 static int sort_rela_dyn(struct rela_dyn_info *di)
510 {
511 	u32 i, n;
512 
513 	di->sorted = calloc(di->nr_entries, sizeof(di->sorted[0]));
514 	if (!di->sorted)
515 		return -1;
516 
517 	/* Get data for sorting: the offset and symbol index */
518 	for (i = 0, n = 0; i < di->nr_entries; i++) {
519 		GElf_Rela rela;
520 		u32 sym_idx;
521 
522 		gelf_getrela(di->rela_dyn_data, i, &rela);
523 		sym_idx = GELF_R_SYM(rela.r_info);
524 		if (sym_idx) {
525 			di->sorted[n].sym_idx = sym_idx;
526 			di->sorted[n].offset = rela.r_offset;
527 			n += 1;
528 		}
529 	}
530 
531 	/* Sort by offset */
532 	di->nr_entries = n;
533 	qsort(di->sorted, n, sizeof(di->sorted[0]), cmp_offset);
534 
535 	return 0;
536 }
537 
538 static void get_rela_dyn_info(Elf *elf, GElf_Ehdr *ehdr, struct rela_dyn_info *di, Elf_Scn *scn)
539 {
540 	GElf_Shdr rela_dyn_shdr;
541 	GElf_Shdr shdr;
542 
543 	di->plt_got_data = elf_getdata(scn, NULL);
544 
545 	scn = elf_section_by_name(elf, ehdr, &rela_dyn_shdr, ".rela.dyn", NULL);
546 	if (!scn || !rela_dyn_shdr.sh_link || !rela_dyn_shdr.sh_entsize)
547 		return;
548 
549 	di->nr_entries = rela_dyn_shdr.sh_size / rela_dyn_shdr.sh_entsize;
550 	di->rela_dyn_data = elf_getdata(scn, NULL);
551 
552 	scn = elf_getscn(elf, rela_dyn_shdr.sh_link);
553 	if (!scn || !gelf_getshdr(scn, &shdr) || !shdr.sh_link)
554 		return;
555 
556 	di->dynsym_data = elf_getdata(scn, NULL);
557 	di->dynstr_data = elf_getdata(elf_getscn(elf, shdr.sh_link), NULL);
558 
559 	if (!di->plt_got_data || !di->dynstr_data || !di->dynsym_data || !di->rela_dyn_data)
560 		return;
561 
562 	/* Sort into offset order */
563 	sort_rela_dyn(di);
564 }
565 
566 /* Get instruction displacement from a plt entry for x86_64 */
567 static u32 get_x86_64_plt_disp(const u8 *p)
568 {
569 	u8 endbr64[] = {0xf3, 0x0f, 0x1e, 0xfa};
570 	int n = 0;
571 
572 	/* Skip endbr64 */
573 	if (!memcmp(p, endbr64, sizeof(endbr64)))
574 		n += sizeof(endbr64);
575 	/* Skip bnd prefix */
576 	if (p[n] == 0xf2)
577 		n += 1;
578 	/* jmp with 4-byte displacement */
579 	if (p[n] == 0xff && p[n + 1] == 0x25) {
580 		u32 disp;
581 
582 		n += 2;
583 		/* Also add offset from start of entry to end of instruction */
584 		memcpy(&disp, p + n, sizeof(disp));
585 		return n + 4 + le32toh(disp);
586 	}
587 	return 0;
588 }
589 
590 static bool get_plt_got_name(GElf_Shdr *shdr, size_t i,
591 			     struct rela_dyn_info *di,
592 			     char *buf, size_t buf_sz)
593 {
594 	struct rela_dyn vi, *vr;
595 	const char *sym_name;
596 	char *demangled;
597 	GElf_Sym sym;
598 	bool result;
599 	u32 disp;
600 
601 	if (!di->sorted)
602 		return false;
603 
604 	disp = get_x86_64_plt_disp(di->plt_got_data->d_buf + i);
605 	if (!disp)
606 		return false;
607 
608 	/* Compute target offset of the .plt.got entry */
609 	vi.offset = shdr->sh_offset + di->plt_got_data->d_off + i + disp;
610 
611 	/* Find that offset in .rela.dyn (sorted by offset) */
612 	vr = bsearch(&vi, di->sorted, di->nr_entries, sizeof(di->sorted[0]), cmp_offset);
613 	if (!vr)
614 		return false;
615 
616 	/* Get the associated symbol */
617 	gelf_getsym(di->dynsym_data, vr->sym_idx, &sym);
618 	sym_name = elf_sym__name(&sym, di->dynstr_data);
619 	demangled = demangle_sym(di->dso, 0, sym_name);
620 	if (demangled != NULL)
621 		sym_name = demangled;
622 
623 	snprintf(buf, buf_sz, "%s@plt", sym_name);
624 
625 	result = *sym_name;
626 
627 	free(demangled);
628 
629 	return result;
630 }
631 
632 static int dso__synthesize_plt_got_symbols(struct dso *dso, Elf *elf,
633 					   GElf_Ehdr *ehdr,
634 					   char *buf, size_t buf_sz)
635 {
636 	struct rela_dyn_info di = { .dso = dso };
637 	struct symbol *sym;
638 	GElf_Shdr shdr;
639 	Elf_Scn *scn;
640 	int err = -1;
641 	size_t i;
642 
643 	scn = elf_section_by_name(elf, ehdr, &shdr, ".plt.got", NULL);
644 	if (!scn || !shdr.sh_entsize)
645 		return 0;
646 
647 	if (ehdr->e_machine == EM_X86_64)
648 		get_rela_dyn_info(elf, ehdr, &di, scn);
649 
650 	for (i = 0; i < shdr.sh_size; i += shdr.sh_entsize) {
651 		if (!get_plt_got_name(&shdr, i, &di, buf, buf_sz))
652 			snprintf(buf, buf_sz, "offset_%#" PRIx64 "@plt", (u64)shdr.sh_offset + i);
653 		sym = symbol__new(shdr.sh_offset + i, shdr.sh_entsize, STB_GLOBAL, STT_FUNC, buf);
654 		if (!sym)
655 			goto out;
656 		symbols__insert(&dso->symbols, sym);
657 	}
658 	err = 0;
659 out:
660 	exit_rela_dyn(&di);
661 	return err;
662 }
663 
664 /*
665  * We need to check if we have a .dynsym, so that we can handle the
666  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
667  * .dynsym or .symtab).
668  * And always look at the original dso, not at debuginfo packages, that
669  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
670  */
671 int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss)
672 {
673 	uint32_t idx;
674 	GElf_Sym sym;
675 	u64 plt_offset, plt_header_size, plt_entry_size;
676 	GElf_Shdr shdr_plt, plt_sec_shdr;
677 	struct symbol *f, *plt_sym;
678 	GElf_Shdr shdr_rel_plt, shdr_dynsym;
679 	Elf_Data *syms, *symstrs;
680 	Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
681 	GElf_Ehdr ehdr;
682 	char sympltname[1024];
683 	Elf *elf;
684 	int nr = 0, err = -1;
685 	struct rel_info ri = { .is_rela = false };
686 	bool lazy_plt;
687 
688 	elf = ss->elf;
689 	ehdr = ss->ehdr;
690 
691 	if (!elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL))
692 		return 0;
693 
694 	/*
695 	 * A symbol from a previous section (e.g. .init) can have been expanded
696 	 * by symbols__fixup_end() to overlap .plt. Truncate it before adding
697 	 * a symbol for .plt header.
698 	 */
699 	f = dso__find_symbol_nocache(dso, shdr_plt.sh_offset);
700 	if (f && f->start < shdr_plt.sh_offset && f->end > shdr_plt.sh_offset)
701 		f->end = shdr_plt.sh_offset;
702 
703 	if (!get_plt_sizes(dso, &ehdr, &shdr_plt, &plt_header_size, &plt_entry_size))
704 		return 0;
705 
706 	/* Add a symbol for .plt header */
707 	plt_sym = symbol__new(shdr_plt.sh_offset, plt_header_size, STB_GLOBAL, STT_FUNC, ".plt");
708 	if (!plt_sym)
709 		goto out_elf_end;
710 	symbols__insert(&dso->symbols, plt_sym);
711 
712 	/* Only x86 has .plt.got */
713 	if (machine_is_x86(ehdr.e_machine) &&
714 	    dso__synthesize_plt_got_symbols(dso, elf, &ehdr, sympltname, sizeof(sympltname)))
715 		goto out_elf_end;
716 
717 	/* Only x86 has .plt.sec */
718 	if (machine_is_x86(ehdr.e_machine) &&
719 	    elf_section_by_name(elf, &ehdr, &plt_sec_shdr, ".plt.sec", NULL)) {
720 		if (!get_plt_sizes(dso, &ehdr, &plt_sec_shdr, &plt_header_size, &plt_entry_size))
721 			return 0;
722 		/* Extend .plt symbol to entire .plt */
723 		plt_sym->end = plt_sym->start + shdr_plt.sh_size;
724 		/* Use .plt.sec offset */
725 		plt_offset = plt_sec_shdr.sh_offset;
726 		lazy_plt = false;
727 	} else {
728 		plt_offset = shdr_plt.sh_offset;
729 		lazy_plt = true;
730 	}
731 
732 	scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
733 					  ".rela.plt", NULL);
734 	if (scn_plt_rel == NULL) {
735 		scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
736 						  ".rel.plt", NULL);
737 		if (scn_plt_rel == NULL)
738 			return 0;
739 	}
740 
741 	if (shdr_rel_plt.sh_type != SHT_RELA &&
742 	    shdr_rel_plt.sh_type != SHT_REL)
743 		return 0;
744 
745 	if (!shdr_rel_plt.sh_link)
746 		return 0;
747 
748 	if (shdr_rel_plt.sh_link == ss->dynsym_idx) {
749 		scn_dynsym = ss->dynsym;
750 		shdr_dynsym = ss->dynshdr;
751 	} else if (shdr_rel_plt.sh_link == ss->symtab_idx) {
752 		/*
753 		 * A static executable can have a .plt due to IFUNCs, in which
754 		 * case .symtab is used not .dynsym.
755 		 */
756 		scn_dynsym = ss->symtab;
757 		shdr_dynsym = ss->symshdr;
758 	} else {
759 		goto out_elf_end;
760 	}
761 
762 	if (!scn_dynsym)
763 		return 0;
764 
765 	/*
766 	 * Fetch the relocation section to find the idxes to the GOT
767 	 * and the symbols in the .dynsym they refer to.
768 	 */
769 	ri.reldata = elf_getdata(scn_plt_rel, NULL);
770 	if (!ri.reldata)
771 		goto out_elf_end;
772 
773 	syms = elf_getdata(scn_dynsym, NULL);
774 	if (syms == NULL)
775 		goto out_elf_end;
776 
777 	scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
778 	if (scn_symstrs == NULL)
779 		goto out_elf_end;
780 
781 	symstrs = elf_getdata(scn_symstrs, NULL);
782 	if (symstrs == NULL)
783 		goto out_elf_end;
784 
785 	if (symstrs->d_size == 0)
786 		goto out_elf_end;
787 
788 	ri.nr_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
789 
790 	ri.is_rela = shdr_rel_plt.sh_type == SHT_RELA;
791 
792 	if (lazy_plt) {
793 		/*
794 		 * Assume a .plt with the same number of entries as the number
795 		 * of relocation entries is not lazy and does not have a header.
796 		 */
797 		if (ri.nr_entries * plt_entry_size == shdr_plt.sh_size)
798 			dso__delete_symbol(dso, plt_sym);
799 		else
800 			plt_offset += plt_header_size;
801 	}
802 
803 	/*
804 	 * x86 doesn't insert IFUNC relocations in .plt order, so sort to get
805 	 * back in order.
806 	 */
807 	if (machine_is_x86(ehdr.e_machine) && sort_rel(&ri))
808 		goto out_elf_end;
809 
810 	for (idx = 0; idx < ri.nr_entries; idx++) {
811 		const char *elf_name = NULL;
812 		char *demangled = NULL;
813 
814 		gelf_getsym(syms, get_rel_symidx(&ri, idx), &sym);
815 
816 		elf_name = elf_sym__name(&sym, symstrs);
817 		demangled = demangle_sym(dso, 0, elf_name);
818 		if (demangled)
819 			elf_name = demangled;
820 		if (*elf_name)
821 			snprintf(sympltname, sizeof(sympltname), "%s@plt", elf_name);
822 		else if (!get_ifunc_name(elf, dso, &ehdr, &ri, sympltname, sizeof(sympltname)))
823 			snprintf(sympltname, sizeof(sympltname),
824 				 "offset_%#" PRIx64 "@plt", plt_offset);
825 		free(demangled);
826 
827 		f = symbol__new(plt_offset, plt_entry_size, STB_GLOBAL, STT_FUNC, sympltname);
828 		if (!f)
829 			goto out_elf_end;
830 
831 		plt_offset += plt_entry_size;
832 		symbols__insert(&dso->symbols, f);
833 		++nr;
834 	}
835 
836 	err = 0;
837 out_elf_end:
838 	exit_rel(&ri);
839 	if (err == 0)
840 		return nr;
841 	pr_debug("%s: problems reading %s PLT info.\n",
842 		 __func__, dso->long_name);
843 	return 0;
844 }
845 
846 char *dso__demangle_sym(struct dso *dso, int kmodule, const char *elf_name)
847 {
848 	return demangle_sym(dso, kmodule, elf_name);
849 }
850 
851 /*
852  * Align offset to 4 bytes as needed for note name and descriptor data.
853  */
854 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
855 
856 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
857 {
858 	int err = -1;
859 	GElf_Ehdr ehdr;
860 	GElf_Shdr shdr;
861 	Elf_Data *data;
862 	Elf_Scn *sec;
863 	Elf_Kind ek;
864 	void *ptr;
865 
866 	if (size < BUILD_ID_SIZE)
867 		goto out;
868 
869 	ek = elf_kind(elf);
870 	if (ek != ELF_K_ELF)
871 		goto out;
872 
873 	if (gelf_getehdr(elf, &ehdr) == NULL) {
874 		pr_err("%s: cannot get elf header.\n", __func__);
875 		goto out;
876 	}
877 
878 	/*
879 	 * Check following sections for notes:
880 	 *   '.note.gnu.build-id'
881 	 *   '.notes'
882 	 *   '.note' (VDSO specific)
883 	 */
884 	do {
885 		sec = elf_section_by_name(elf, &ehdr, &shdr,
886 					  ".note.gnu.build-id", NULL);
887 		if (sec)
888 			break;
889 
890 		sec = elf_section_by_name(elf, &ehdr, &shdr,
891 					  ".notes", NULL);
892 		if (sec)
893 			break;
894 
895 		sec = elf_section_by_name(elf, &ehdr, &shdr,
896 					  ".note", NULL);
897 		if (sec)
898 			break;
899 
900 		return err;
901 
902 	} while (0);
903 
904 	data = elf_getdata(sec, NULL);
905 	if (data == NULL)
906 		goto out;
907 
908 	ptr = data->d_buf;
909 	while (ptr < (data->d_buf + data->d_size)) {
910 		GElf_Nhdr *nhdr = ptr;
911 		size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
912 		       descsz = NOTE_ALIGN(nhdr->n_descsz);
913 		const char *name;
914 
915 		ptr += sizeof(*nhdr);
916 		name = ptr;
917 		ptr += namesz;
918 		if (nhdr->n_type == NT_GNU_BUILD_ID &&
919 		    nhdr->n_namesz == sizeof("GNU")) {
920 			if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
921 				size_t sz = min(size, descsz);
922 				memcpy(bf, ptr, sz);
923 				memset(bf + sz, 0, size - sz);
924 				err = sz;
925 				break;
926 			}
927 		}
928 		ptr += descsz;
929 	}
930 
931 out:
932 	return err;
933 }
934 
935 #ifdef HAVE_LIBBFD_BUILDID_SUPPORT
936 
937 static int read_build_id(const char *filename, struct build_id *bid)
938 {
939 	size_t size = sizeof(bid->data);
940 	int err = -1;
941 	bfd *abfd;
942 
943 	abfd = bfd_openr(filename, NULL);
944 	if (!abfd)
945 		return -1;
946 
947 	if (!bfd_check_format(abfd, bfd_object)) {
948 		pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
949 		goto out_close;
950 	}
951 
952 	if (!abfd->build_id || abfd->build_id->size > size)
953 		goto out_close;
954 
955 	memcpy(bid->data, abfd->build_id->data, abfd->build_id->size);
956 	memset(bid->data + abfd->build_id->size, 0, size - abfd->build_id->size);
957 	err = bid->size = abfd->build_id->size;
958 
959 out_close:
960 	bfd_close(abfd);
961 	return err;
962 }
963 
964 #else // HAVE_LIBBFD_BUILDID_SUPPORT
965 
966 static int read_build_id(const char *filename, struct build_id *bid)
967 {
968 	size_t size = sizeof(bid->data);
969 	int fd, err = -1;
970 	Elf *elf;
971 
972 	if (size < BUILD_ID_SIZE)
973 		goto out;
974 
975 	fd = open(filename, O_RDONLY);
976 	if (fd < 0)
977 		goto out;
978 
979 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
980 	if (elf == NULL) {
981 		pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
982 		goto out_close;
983 	}
984 
985 	err = elf_read_build_id(elf, bid->data, size);
986 	if (err > 0)
987 		bid->size = err;
988 
989 	elf_end(elf);
990 out_close:
991 	close(fd);
992 out:
993 	return err;
994 }
995 
996 #endif // HAVE_LIBBFD_BUILDID_SUPPORT
997 
998 int filename__read_build_id(const char *filename, struct build_id *bid)
999 {
1000 	struct kmod_path m = { .name = NULL, };
1001 	char path[PATH_MAX];
1002 	int err;
1003 
1004 	if (!filename)
1005 		return -EFAULT;
1006 
1007 	err = kmod_path__parse(&m, filename);
1008 	if (err)
1009 		return -1;
1010 
1011 	if (m.comp) {
1012 		int error = 0, fd;
1013 
1014 		fd = filename__decompress(filename, path, sizeof(path), m.comp, &error);
1015 		if (fd < 0) {
1016 			pr_debug("Failed to decompress (error %d) %s\n",
1017 				 error, filename);
1018 			return -1;
1019 		}
1020 		close(fd);
1021 		filename = path;
1022 	}
1023 
1024 	err = read_build_id(filename, bid);
1025 
1026 	if (m.comp)
1027 		unlink(filename);
1028 	return err;
1029 }
1030 
1031 int sysfs__read_build_id(const char *filename, struct build_id *bid)
1032 {
1033 	size_t size = sizeof(bid->data);
1034 	int fd, err = -1;
1035 
1036 	fd = open(filename, O_RDONLY);
1037 	if (fd < 0)
1038 		goto out;
1039 
1040 	while (1) {
1041 		char bf[BUFSIZ];
1042 		GElf_Nhdr nhdr;
1043 		size_t namesz, descsz;
1044 
1045 		if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1046 			break;
1047 
1048 		namesz = NOTE_ALIGN(nhdr.n_namesz);
1049 		descsz = NOTE_ALIGN(nhdr.n_descsz);
1050 		if (nhdr.n_type == NT_GNU_BUILD_ID &&
1051 		    nhdr.n_namesz == sizeof("GNU")) {
1052 			if (read(fd, bf, namesz) != (ssize_t)namesz)
1053 				break;
1054 			if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1055 				size_t sz = min(descsz, size);
1056 				if (read(fd, bid->data, sz) == (ssize_t)sz) {
1057 					memset(bid->data + sz, 0, size - sz);
1058 					bid->size = sz;
1059 					err = 0;
1060 					break;
1061 				}
1062 			} else if (read(fd, bf, descsz) != (ssize_t)descsz)
1063 				break;
1064 		} else {
1065 			int n = namesz + descsz;
1066 
1067 			if (n > (int)sizeof(bf)) {
1068 				n = sizeof(bf);
1069 				pr_debug("%s: truncating reading of build id in sysfs file %s: n_namesz=%u, n_descsz=%u.\n",
1070 					 __func__, filename, nhdr.n_namesz, nhdr.n_descsz);
1071 			}
1072 			if (read(fd, bf, n) != n)
1073 				break;
1074 		}
1075 	}
1076 	close(fd);
1077 out:
1078 	return err;
1079 }
1080 
1081 #ifdef HAVE_LIBBFD_SUPPORT
1082 
1083 int filename__read_debuglink(const char *filename, char *debuglink,
1084 			     size_t size)
1085 {
1086 	int err = -1;
1087 	asection *section;
1088 	bfd *abfd;
1089 
1090 	abfd = bfd_openr(filename, NULL);
1091 	if (!abfd)
1092 		return -1;
1093 
1094 	if (!bfd_check_format(abfd, bfd_object)) {
1095 		pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
1096 		goto out_close;
1097 	}
1098 
1099 	section = bfd_get_section_by_name(abfd, ".gnu_debuglink");
1100 	if (!section)
1101 		goto out_close;
1102 
1103 	if (section->size > size)
1104 		goto out_close;
1105 
1106 	if (!bfd_get_section_contents(abfd, section, debuglink, 0,
1107 				      section->size))
1108 		goto out_close;
1109 
1110 	err = 0;
1111 
1112 out_close:
1113 	bfd_close(abfd);
1114 	return err;
1115 }
1116 
1117 #else
1118 
1119 int filename__read_debuglink(const char *filename, char *debuglink,
1120 			     size_t size)
1121 {
1122 	int fd, err = -1;
1123 	Elf *elf;
1124 	GElf_Ehdr ehdr;
1125 	GElf_Shdr shdr;
1126 	Elf_Data *data;
1127 	Elf_Scn *sec;
1128 	Elf_Kind ek;
1129 
1130 	fd = open(filename, O_RDONLY);
1131 	if (fd < 0)
1132 		goto out;
1133 
1134 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1135 	if (elf == NULL) {
1136 		pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1137 		goto out_close;
1138 	}
1139 
1140 	ek = elf_kind(elf);
1141 	if (ek != ELF_K_ELF)
1142 		goto out_elf_end;
1143 
1144 	if (gelf_getehdr(elf, &ehdr) == NULL) {
1145 		pr_err("%s: cannot get elf header.\n", __func__);
1146 		goto out_elf_end;
1147 	}
1148 
1149 	sec = elf_section_by_name(elf, &ehdr, &shdr,
1150 				  ".gnu_debuglink", NULL);
1151 	if (sec == NULL)
1152 		goto out_elf_end;
1153 
1154 	data = elf_getdata(sec, NULL);
1155 	if (data == NULL)
1156 		goto out_elf_end;
1157 
1158 	/* the start of this section is a zero-terminated string */
1159 	strncpy(debuglink, data->d_buf, size);
1160 
1161 	err = 0;
1162 
1163 out_elf_end:
1164 	elf_end(elf);
1165 out_close:
1166 	close(fd);
1167 out:
1168 	return err;
1169 }
1170 
1171 #endif
1172 
1173 static int dso__swap_init(struct dso *dso, unsigned char eidata)
1174 {
1175 	static unsigned int const endian = 1;
1176 
1177 	dso->needs_swap = DSO_SWAP__NO;
1178 
1179 	switch (eidata) {
1180 	case ELFDATA2LSB:
1181 		/* We are big endian, DSO is little endian. */
1182 		if (*(unsigned char const *)&endian != 1)
1183 			dso->needs_swap = DSO_SWAP__YES;
1184 		break;
1185 
1186 	case ELFDATA2MSB:
1187 		/* We are little endian, DSO is big endian. */
1188 		if (*(unsigned char const *)&endian != 0)
1189 			dso->needs_swap = DSO_SWAP__YES;
1190 		break;
1191 
1192 	default:
1193 		pr_err("unrecognized DSO data encoding %d\n", eidata);
1194 		return -EINVAL;
1195 	}
1196 
1197 	return 0;
1198 }
1199 
1200 bool symsrc__possibly_runtime(struct symsrc *ss)
1201 {
1202 	return ss->dynsym || ss->opdsec;
1203 }
1204 
1205 bool symsrc__has_symtab(struct symsrc *ss)
1206 {
1207 	return ss->symtab != NULL;
1208 }
1209 
1210 void symsrc__destroy(struct symsrc *ss)
1211 {
1212 	zfree(&ss->name);
1213 	elf_end(ss->elf);
1214 	close(ss->fd);
1215 }
1216 
1217 bool elf__needs_adjust_symbols(GElf_Ehdr ehdr)
1218 {
1219 	/*
1220 	 * Usually vmlinux is an ELF file with type ET_EXEC for most
1221 	 * architectures; except Arm64 kernel is linked with option
1222 	 * '-share', so need to check type ET_DYN.
1223 	 */
1224 	return ehdr.e_type == ET_EXEC || ehdr.e_type == ET_REL ||
1225 	       ehdr.e_type == ET_DYN;
1226 }
1227 
1228 int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
1229 		 enum dso_binary_type type)
1230 {
1231 	GElf_Ehdr ehdr;
1232 	Elf *elf;
1233 	int fd;
1234 
1235 	if (dso__needs_decompress(dso)) {
1236 		fd = dso__decompress_kmodule_fd(dso, name);
1237 		if (fd < 0)
1238 			return -1;
1239 
1240 		type = dso->symtab_type;
1241 	} else {
1242 		fd = open(name, O_RDONLY);
1243 		if (fd < 0) {
1244 			dso->load_errno = errno;
1245 			return -1;
1246 		}
1247 	}
1248 
1249 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1250 	if (elf == NULL) {
1251 		pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1252 		dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
1253 		goto out_close;
1254 	}
1255 
1256 	if (gelf_getehdr(elf, &ehdr) == NULL) {
1257 		dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
1258 		pr_debug("%s: cannot get elf header.\n", __func__);
1259 		goto out_elf_end;
1260 	}
1261 
1262 	if (dso__swap_init(dso, ehdr.e_ident[EI_DATA])) {
1263 		dso->load_errno = DSO_LOAD_ERRNO__INTERNAL_ERROR;
1264 		goto out_elf_end;
1265 	}
1266 
1267 	/* Always reject images with a mismatched build-id: */
1268 	if (dso->has_build_id && !symbol_conf.ignore_vmlinux_buildid) {
1269 		u8 build_id[BUILD_ID_SIZE];
1270 		struct build_id bid;
1271 		int size;
1272 
1273 		size = elf_read_build_id(elf, build_id, BUILD_ID_SIZE);
1274 		if (size <= 0) {
1275 			dso->load_errno = DSO_LOAD_ERRNO__CANNOT_READ_BUILDID;
1276 			goto out_elf_end;
1277 		}
1278 
1279 		build_id__init(&bid, build_id, size);
1280 		if (!dso__build_id_equal(dso, &bid)) {
1281 			pr_debug("%s: build id mismatch for %s.\n", __func__, name);
1282 			dso->load_errno = DSO_LOAD_ERRNO__MISMATCHING_BUILDID;
1283 			goto out_elf_end;
1284 		}
1285 	}
1286 
1287 	ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
1288 
1289 	ss->symtab_idx = 0;
1290 	ss->symtab = elf_section_by_name(elf, &ehdr, &ss->symshdr, ".symtab",
1291 			&ss->symtab_idx);
1292 	if (ss->symshdr.sh_type != SHT_SYMTAB)
1293 		ss->symtab = NULL;
1294 
1295 	ss->dynsym_idx = 0;
1296 	ss->dynsym = elf_section_by_name(elf, &ehdr, &ss->dynshdr, ".dynsym",
1297 			&ss->dynsym_idx);
1298 	if (ss->dynshdr.sh_type != SHT_DYNSYM)
1299 		ss->dynsym = NULL;
1300 
1301 	ss->opdidx = 0;
1302 	ss->opdsec = elf_section_by_name(elf, &ehdr, &ss->opdshdr, ".opd",
1303 			&ss->opdidx);
1304 	if (ss->opdshdr.sh_type != SHT_PROGBITS)
1305 		ss->opdsec = NULL;
1306 
1307 	if (dso->kernel == DSO_SPACE__USER)
1308 		ss->adjust_symbols = true;
1309 	else
1310 		ss->adjust_symbols = elf__needs_adjust_symbols(ehdr);
1311 
1312 	ss->name   = strdup(name);
1313 	if (!ss->name) {
1314 		dso->load_errno = errno;
1315 		goto out_elf_end;
1316 	}
1317 
1318 	ss->elf    = elf;
1319 	ss->fd     = fd;
1320 	ss->ehdr   = ehdr;
1321 	ss->type   = type;
1322 
1323 	return 0;
1324 
1325 out_elf_end:
1326 	elf_end(elf);
1327 out_close:
1328 	close(fd);
1329 	return -1;
1330 }
1331 
1332 /**
1333  * ref_reloc_sym_not_found - has kernel relocation symbol been found.
1334  * @kmap: kernel maps and relocation reference symbol
1335  *
1336  * This function returns %true if we are dealing with the kernel maps and the
1337  * relocation reference symbol has not yet been found.  Otherwise %false is
1338  * returned.
1339  */
1340 static bool ref_reloc_sym_not_found(struct kmap *kmap)
1341 {
1342 	return kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1343 	       !kmap->ref_reloc_sym->unrelocated_addr;
1344 }
1345 
1346 /**
1347  * ref_reloc - kernel relocation offset.
1348  * @kmap: kernel maps and relocation reference symbol
1349  *
1350  * This function returns the offset of kernel addresses as determined by using
1351  * the relocation reference symbol i.e. if the kernel has not been relocated
1352  * then the return value is zero.
1353  */
1354 static u64 ref_reloc(struct kmap *kmap)
1355 {
1356 	if (kmap && kmap->ref_reloc_sym &&
1357 	    kmap->ref_reloc_sym->unrelocated_addr)
1358 		return kmap->ref_reloc_sym->addr -
1359 		       kmap->ref_reloc_sym->unrelocated_addr;
1360 	return 0;
1361 }
1362 
1363 void __weak arch__sym_update(struct symbol *s __maybe_unused,
1364 		GElf_Sym *sym __maybe_unused) { }
1365 
1366 static int dso__process_kernel_symbol(struct dso *dso, struct map *map,
1367 				      GElf_Sym *sym, GElf_Shdr *shdr,
1368 				      struct maps *kmaps, struct kmap *kmap,
1369 				      struct dso **curr_dsop, struct map **curr_mapp,
1370 				      const char *section_name,
1371 				      bool adjust_kernel_syms, bool kmodule, bool *remap_kernel)
1372 {
1373 	struct dso *curr_dso = *curr_dsop;
1374 	struct map *curr_map;
1375 	char dso_name[PATH_MAX];
1376 
1377 	/* Adjust symbol to map to file offset */
1378 	if (adjust_kernel_syms)
1379 		sym->st_value -= shdr->sh_addr - shdr->sh_offset;
1380 
1381 	if (strcmp(section_name, (curr_dso->short_name + dso->short_name_len)) == 0)
1382 		return 0;
1383 
1384 	if (strcmp(section_name, ".text") == 0) {
1385 		/*
1386 		 * The initial kernel mapping is based on
1387 		 * kallsyms and identity maps.  Overwrite it to
1388 		 * map to the kernel dso.
1389 		 */
1390 		if (*remap_kernel && dso->kernel && !kmodule) {
1391 			*remap_kernel = false;
1392 			map__set_start(map, shdr->sh_addr + ref_reloc(kmap));
1393 			map__set_end(map, map__start(map) + shdr->sh_size);
1394 			map__set_pgoff(map, shdr->sh_offset);
1395 			map__set_map_ip(map, map__dso_map_ip);
1396 			map__set_unmap_ip(map, map__dso_unmap_ip);
1397 			/* Ensure maps are correctly ordered */
1398 			if (kmaps) {
1399 				int err;
1400 				struct map *tmp = map__get(map);
1401 
1402 				maps__remove(kmaps, map);
1403 				err = maps__insert(kmaps, map);
1404 				map__put(tmp);
1405 				if (err)
1406 					return err;
1407 			}
1408 		}
1409 
1410 		/*
1411 		 * The initial module mapping is based on
1412 		 * /proc/modules mapped to offset zero.
1413 		 * Overwrite it to map to the module dso.
1414 		 */
1415 		if (*remap_kernel && kmodule) {
1416 			*remap_kernel = false;
1417 			map__set_pgoff(map, shdr->sh_offset);
1418 		}
1419 
1420 		*curr_mapp = map;
1421 		*curr_dsop = dso;
1422 		return 0;
1423 	}
1424 
1425 	if (!kmap)
1426 		return 0;
1427 
1428 	snprintf(dso_name, sizeof(dso_name), "%s%s", dso->short_name, section_name);
1429 
1430 	curr_map = maps__find_by_name(kmaps, dso_name);
1431 	if (curr_map == NULL) {
1432 		u64 start = sym->st_value;
1433 
1434 		if (kmodule)
1435 			start += map__start(map) + shdr->sh_offset;
1436 
1437 		curr_dso = dso__new(dso_name);
1438 		if (curr_dso == NULL)
1439 			return -1;
1440 		curr_dso->kernel = dso->kernel;
1441 		curr_dso->long_name = dso->long_name;
1442 		curr_dso->long_name_len = dso->long_name_len;
1443 		curr_dso->binary_type = dso->binary_type;
1444 		curr_dso->adjust_symbols = dso->adjust_symbols;
1445 		curr_map = map__new2(start, curr_dso);
1446 		dso__put(curr_dso);
1447 		if (curr_map == NULL)
1448 			return -1;
1449 
1450 		if (curr_dso->kernel)
1451 			map__kmap(curr_map)->kmaps = kmaps;
1452 
1453 		if (adjust_kernel_syms) {
1454 			map__set_start(curr_map, shdr->sh_addr + ref_reloc(kmap));
1455 			map__set_end(curr_map, map__start(curr_map) + shdr->sh_size);
1456 			map__set_pgoff(curr_map, shdr->sh_offset);
1457 		} else {
1458 			map__set_map_ip(curr_map, identity__map_ip);
1459 			map__set_unmap_ip(curr_map, identity__map_ip);
1460 		}
1461 		curr_dso->symtab_type = dso->symtab_type;
1462 		if (maps__insert(kmaps, curr_map))
1463 			return -1;
1464 		/*
1465 		 * Add it before we drop the reference to curr_map, i.e. while
1466 		 * we still are sure to have a reference to this DSO via
1467 		 * *curr_map->dso.
1468 		 */
1469 		dsos__add(&maps__machine(kmaps)->dsos, curr_dso);
1470 		/* kmaps already got it */
1471 		map__put(curr_map);
1472 		dso__set_loaded(curr_dso);
1473 		*curr_mapp = curr_map;
1474 		*curr_dsop = curr_dso;
1475 	} else
1476 		*curr_dsop = map__dso(curr_map);
1477 
1478 	return 0;
1479 }
1480 
1481 static int
1482 dso__load_sym_internal(struct dso *dso, struct map *map, struct symsrc *syms_ss,
1483 		       struct symsrc *runtime_ss, int kmodule, int dynsym)
1484 {
1485 	struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1486 	struct maps *kmaps = kmap ? map__kmaps(map) : NULL;
1487 	struct map *curr_map = map;
1488 	struct dso *curr_dso = dso;
1489 	Elf_Data *symstrs, *secstrs, *secstrs_run, *secstrs_sym;
1490 	uint32_t nr_syms;
1491 	int err = -1;
1492 	uint32_t idx;
1493 	GElf_Ehdr ehdr;
1494 	GElf_Shdr shdr;
1495 	GElf_Shdr tshdr;
1496 	Elf_Data *syms, *opddata = NULL;
1497 	GElf_Sym sym;
1498 	Elf_Scn *sec, *sec_strndx;
1499 	Elf *elf;
1500 	int nr = 0;
1501 	bool remap_kernel = false, adjust_kernel_syms = false;
1502 
1503 	if (kmap && !kmaps)
1504 		return -1;
1505 
1506 	elf = syms_ss->elf;
1507 	ehdr = syms_ss->ehdr;
1508 	if (dynsym) {
1509 		sec  = syms_ss->dynsym;
1510 		shdr = syms_ss->dynshdr;
1511 	} else {
1512 		sec =  syms_ss->symtab;
1513 		shdr = syms_ss->symshdr;
1514 	}
1515 
1516 	if (elf_section_by_name(runtime_ss->elf, &runtime_ss->ehdr, &tshdr,
1517 				".text", NULL)) {
1518 		dso->text_offset = tshdr.sh_addr - tshdr.sh_offset;
1519 		dso->text_end = tshdr.sh_offset + tshdr.sh_size;
1520 	}
1521 
1522 	if (runtime_ss->opdsec)
1523 		opddata = elf_rawdata(runtime_ss->opdsec, NULL);
1524 
1525 	syms = elf_getdata(sec, NULL);
1526 	if (syms == NULL)
1527 		goto out_elf_end;
1528 
1529 	sec = elf_getscn(elf, shdr.sh_link);
1530 	if (sec == NULL)
1531 		goto out_elf_end;
1532 
1533 	symstrs = elf_getdata(sec, NULL);
1534 	if (symstrs == NULL)
1535 		goto out_elf_end;
1536 
1537 	sec_strndx = elf_getscn(runtime_ss->elf, runtime_ss->ehdr.e_shstrndx);
1538 	if (sec_strndx == NULL)
1539 		goto out_elf_end;
1540 
1541 	secstrs_run = elf_getdata(sec_strndx, NULL);
1542 	if (secstrs_run == NULL)
1543 		goto out_elf_end;
1544 
1545 	sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1546 	if (sec_strndx == NULL)
1547 		goto out_elf_end;
1548 
1549 	secstrs_sym = elf_getdata(sec_strndx, NULL);
1550 	if (secstrs_sym == NULL)
1551 		goto out_elf_end;
1552 
1553 	nr_syms = shdr.sh_size / shdr.sh_entsize;
1554 
1555 	memset(&sym, 0, sizeof(sym));
1556 
1557 	/*
1558 	 * The kernel relocation symbol is needed in advance in order to adjust
1559 	 * kernel maps correctly.
1560 	 */
1561 	if (ref_reloc_sym_not_found(kmap)) {
1562 		elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1563 			const char *elf_name = elf_sym__name(&sym, symstrs);
1564 
1565 			if (strcmp(elf_name, kmap->ref_reloc_sym->name))
1566 				continue;
1567 			kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1568 			map__set_reloc(map, kmap->ref_reloc_sym->addr - kmap->ref_reloc_sym->unrelocated_addr);
1569 			break;
1570 		}
1571 	}
1572 
1573 	/*
1574 	 * Handle any relocation of vdso necessary because older kernels
1575 	 * attempted to prelink vdso to its virtual address.
1576 	 */
1577 	if (dso__is_vdso(dso))
1578 		map__set_reloc(map, map__start(map) - dso->text_offset);
1579 
1580 	dso->adjust_symbols = runtime_ss->adjust_symbols || ref_reloc(kmap);
1581 	/*
1582 	 * Initial kernel and module mappings do not map to the dso.
1583 	 * Flag the fixups.
1584 	 */
1585 	if (dso->kernel) {
1586 		remap_kernel = true;
1587 		adjust_kernel_syms = dso->adjust_symbols;
1588 	}
1589 	elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1590 		struct symbol *f;
1591 		const char *elf_name = elf_sym__name(&sym, symstrs);
1592 		char *demangled = NULL;
1593 		int is_label = elf_sym__is_label(&sym);
1594 		const char *section_name;
1595 		bool used_opd = false;
1596 
1597 		if (!is_label && !elf_sym__filter(&sym))
1598 			continue;
1599 
1600 		/* Reject ARM ELF "mapping symbols": these aren't unique and
1601 		 * don't identify functions, so will confuse the profile
1602 		 * output: */
1603 		if (ehdr.e_machine == EM_ARM || ehdr.e_machine == EM_AARCH64) {
1604 			if (elf_name[0] == '$' && strchr("adtx", elf_name[1])
1605 			    && (elf_name[2] == '\0' || elf_name[2] == '.'))
1606 				continue;
1607 		}
1608 
1609 		if (runtime_ss->opdsec && sym.st_shndx == runtime_ss->opdidx) {
1610 			u32 offset = sym.st_value - syms_ss->opdshdr.sh_addr;
1611 			u64 *opd = opddata->d_buf + offset;
1612 			sym.st_value = DSO__SWAP(dso, u64, *opd);
1613 			sym.st_shndx = elf_addr_to_index(runtime_ss->elf,
1614 					sym.st_value);
1615 			used_opd = true;
1616 		}
1617 
1618 		/*
1619 		 * When loading symbols in a data mapping, ABS symbols (which
1620 		 * has a value of SHN_ABS in its st_shndx) failed at
1621 		 * elf_getscn().  And it marks the loading as a failure so
1622 		 * already loaded symbols cannot be fixed up.
1623 		 *
1624 		 * I'm not sure what should be done. Just ignore them for now.
1625 		 * - Namhyung Kim
1626 		 */
1627 		if (sym.st_shndx == SHN_ABS)
1628 			continue;
1629 
1630 		sec = elf_getscn(syms_ss->elf, sym.st_shndx);
1631 		if (!sec)
1632 			goto out_elf_end;
1633 
1634 		gelf_getshdr(sec, &shdr);
1635 
1636 		/*
1637 		 * If the attribute bit SHF_ALLOC is not set, the section
1638 		 * doesn't occupy memory during process execution.
1639 		 * E.g. ".gnu.warning.*" section is used by linker to generate
1640 		 * warnings when calling deprecated functions, the symbols in
1641 		 * the section aren't loaded to memory during process execution,
1642 		 * so skip them.
1643 		 */
1644 		if (!(shdr.sh_flags & SHF_ALLOC))
1645 			continue;
1646 
1647 		secstrs = secstrs_sym;
1648 
1649 		/*
1650 		 * We have to fallback to runtime when syms' section header has
1651 		 * NOBITS set. NOBITS results in file offset (sh_offset) not
1652 		 * being incremented. So sh_offset used below has different
1653 		 * values for syms (invalid) and runtime (valid).
1654 		 */
1655 		if (shdr.sh_type == SHT_NOBITS) {
1656 			sec = elf_getscn(runtime_ss->elf, sym.st_shndx);
1657 			if (!sec)
1658 				goto out_elf_end;
1659 
1660 			gelf_getshdr(sec, &shdr);
1661 			secstrs = secstrs_run;
1662 		}
1663 
1664 		if (is_label && !elf_sec__filter(&shdr, secstrs))
1665 			continue;
1666 
1667 		section_name = elf_sec__name(&shdr, secstrs);
1668 
1669 		/* On ARM, symbols for thumb functions have 1 added to
1670 		 * the symbol address as a flag - remove it */
1671 		if ((ehdr.e_machine == EM_ARM) &&
1672 		    (GELF_ST_TYPE(sym.st_info) == STT_FUNC) &&
1673 		    (sym.st_value & 1))
1674 			--sym.st_value;
1675 
1676 		if (dso->kernel) {
1677 			if (dso__process_kernel_symbol(dso, map, &sym, &shdr, kmaps, kmap, &curr_dso, &curr_map,
1678 						       section_name, adjust_kernel_syms, kmodule, &remap_kernel))
1679 				goto out_elf_end;
1680 		} else if ((used_opd && runtime_ss->adjust_symbols) ||
1681 			   (!used_opd && syms_ss->adjust_symbols)) {
1682 			GElf_Phdr phdr;
1683 
1684 			if (elf_read_program_header(runtime_ss->elf,
1685 						    (u64)sym.st_value, &phdr)) {
1686 				pr_debug4("%s: failed to find program header for "
1687 					   "symbol: %s st_value: %#" PRIx64 "\n",
1688 					   __func__, elf_name, (u64)sym.st_value);
1689 				pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1690 					"sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n",
1691 					__func__, (u64)sym.st_value, (u64)shdr.sh_addr,
1692 					(u64)shdr.sh_offset);
1693 				/*
1694 				 * Fail to find program header, let's rollback
1695 				 * to use shdr.sh_addr and shdr.sh_offset to
1696 				 * calibrate symbol's file address, though this
1697 				 * is not necessary for normal C ELF file, we
1698 				 * still need to handle java JIT symbols in this
1699 				 * case.
1700 				 */
1701 				sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1702 			} else {
1703 				pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1704 					"p_vaddr: %#" PRIx64 " p_offset: %#" PRIx64 "\n",
1705 					__func__, (u64)sym.st_value, (u64)phdr.p_vaddr,
1706 					(u64)phdr.p_offset);
1707 				sym.st_value -= phdr.p_vaddr - phdr.p_offset;
1708 			}
1709 		}
1710 
1711 		demangled = demangle_sym(dso, kmodule, elf_name);
1712 		if (demangled != NULL)
1713 			elf_name = demangled;
1714 
1715 		f = symbol__new(sym.st_value, sym.st_size,
1716 				GELF_ST_BIND(sym.st_info),
1717 				GELF_ST_TYPE(sym.st_info), elf_name);
1718 		free(demangled);
1719 		if (!f)
1720 			goto out_elf_end;
1721 
1722 		arch__sym_update(f, &sym);
1723 
1724 		__symbols__insert(&curr_dso->symbols, f, dso->kernel);
1725 		nr++;
1726 	}
1727 
1728 	/*
1729 	 * For misannotated, zeroed, ASM function sizes.
1730 	 */
1731 	if (nr > 0) {
1732 		symbols__fixup_end(&dso->symbols, false);
1733 		symbols__fixup_duplicate(&dso->symbols);
1734 		if (kmap) {
1735 			/*
1736 			 * We need to fixup this here too because we create new
1737 			 * maps here, for things like vsyscall sections.
1738 			 */
1739 			maps__fixup_end(kmaps);
1740 		}
1741 	}
1742 	err = nr;
1743 out_elf_end:
1744 	return err;
1745 }
1746 
1747 int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
1748 		  struct symsrc *runtime_ss, int kmodule)
1749 {
1750 	int nr = 0;
1751 	int err = -1;
1752 
1753 	dso->symtab_type = syms_ss->type;
1754 	dso->is_64_bit = syms_ss->is_64_bit;
1755 	dso->rel = syms_ss->ehdr.e_type == ET_REL;
1756 
1757 	/*
1758 	 * Modules may already have symbols from kallsyms, but those symbols
1759 	 * have the wrong values for the dso maps, so remove them.
1760 	 */
1761 	if (kmodule && syms_ss->symtab)
1762 		symbols__delete(&dso->symbols);
1763 
1764 	if (!syms_ss->symtab) {
1765 		/*
1766 		 * If the vmlinux is stripped, fail so we will fall back
1767 		 * to using kallsyms. The vmlinux runtime symbols aren't
1768 		 * of much use.
1769 		 */
1770 		if (dso->kernel)
1771 			return err;
1772 	} else  {
1773 		err = dso__load_sym_internal(dso, map, syms_ss, runtime_ss,
1774 					     kmodule, 0);
1775 		if (err < 0)
1776 			return err;
1777 		nr = err;
1778 	}
1779 
1780 	if (syms_ss->dynsym) {
1781 		err = dso__load_sym_internal(dso, map, syms_ss, runtime_ss,
1782 					     kmodule, 1);
1783 		if (err < 0)
1784 			return err;
1785 		err += nr;
1786 	}
1787 
1788 	return err;
1789 }
1790 
1791 static int elf_read_maps(Elf *elf, bool exe, mapfn_t mapfn, void *data)
1792 {
1793 	GElf_Phdr phdr;
1794 	size_t i, phdrnum;
1795 	int err;
1796 	u64 sz;
1797 
1798 	if (elf_getphdrnum(elf, &phdrnum))
1799 		return -1;
1800 
1801 	for (i = 0; i < phdrnum; i++) {
1802 		if (gelf_getphdr(elf, i, &phdr) == NULL)
1803 			return -1;
1804 		if (phdr.p_type != PT_LOAD)
1805 			continue;
1806 		if (exe) {
1807 			if (!(phdr.p_flags & PF_X))
1808 				continue;
1809 		} else {
1810 			if (!(phdr.p_flags & PF_R))
1811 				continue;
1812 		}
1813 		sz = min(phdr.p_memsz, phdr.p_filesz);
1814 		if (!sz)
1815 			continue;
1816 		err = mapfn(phdr.p_vaddr, sz, phdr.p_offset, data);
1817 		if (err)
1818 			return err;
1819 	}
1820 	return 0;
1821 }
1822 
1823 int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
1824 		    bool *is_64_bit)
1825 {
1826 	int err;
1827 	Elf *elf;
1828 
1829 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1830 	if (elf == NULL)
1831 		return -1;
1832 
1833 	if (is_64_bit)
1834 		*is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
1835 
1836 	err = elf_read_maps(elf, exe, mapfn, data);
1837 
1838 	elf_end(elf);
1839 	return err;
1840 }
1841 
1842 enum dso_type dso__type_fd(int fd)
1843 {
1844 	enum dso_type dso_type = DSO__TYPE_UNKNOWN;
1845 	GElf_Ehdr ehdr;
1846 	Elf_Kind ek;
1847 	Elf *elf;
1848 
1849 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1850 	if (elf == NULL)
1851 		goto out;
1852 
1853 	ek = elf_kind(elf);
1854 	if (ek != ELF_K_ELF)
1855 		goto out_end;
1856 
1857 	if (gelf_getclass(elf) == ELFCLASS64) {
1858 		dso_type = DSO__TYPE_64BIT;
1859 		goto out_end;
1860 	}
1861 
1862 	if (gelf_getehdr(elf, &ehdr) == NULL)
1863 		goto out_end;
1864 
1865 	if (ehdr.e_machine == EM_X86_64)
1866 		dso_type = DSO__TYPE_X32BIT;
1867 	else
1868 		dso_type = DSO__TYPE_32BIT;
1869 out_end:
1870 	elf_end(elf);
1871 out:
1872 	return dso_type;
1873 }
1874 
1875 static int copy_bytes(int from, off_t from_offs, int to, off_t to_offs, u64 len)
1876 {
1877 	ssize_t r;
1878 	size_t n;
1879 	int err = -1;
1880 	char *buf = malloc(page_size);
1881 
1882 	if (buf == NULL)
1883 		return -1;
1884 
1885 	if (lseek(to, to_offs, SEEK_SET) != to_offs)
1886 		goto out;
1887 
1888 	if (lseek(from, from_offs, SEEK_SET) != from_offs)
1889 		goto out;
1890 
1891 	while (len) {
1892 		n = page_size;
1893 		if (len < n)
1894 			n = len;
1895 		/* Use read because mmap won't work on proc files */
1896 		r = read(from, buf, n);
1897 		if (r < 0)
1898 			goto out;
1899 		if (!r)
1900 			break;
1901 		n = r;
1902 		r = write(to, buf, n);
1903 		if (r < 0)
1904 			goto out;
1905 		if ((size_t)r != n)
1906 			goto out;
1907 		len -= n;
1908 	}
1909 
1910 	err = 0;
1911 out:
1912 	free(buf);
1913 	return err;
1914 }
1915 
1916 struct kcore {
1917 	int fd;
1918 	int elfclass;
1919 	Elf *elf;
1920 	GElf_Ehdr ehdr;
1921 };
1922 
1923 static int kcore__open(struct kcore *kcore, const char *filename)
1924 {
1925 	GElf_Ehdr *ehdr;
1926 
1927 	kcore->fd = open(filename, O_RDONLY);
1928 	if (kcore->fd == -1)
1929 		return -1;
1930 
1931 	kcore->elf = elf_begin(kcore->fd, ELF_C_READ, NULL);
1932 	if (!kcore->elf)
1933 		goto out_close;
1934 
1935 	kcore->elfclass = gelf_getclass(kcore->elf);
1936 	if (kcore->elfclass == ELFCLASSNONE)
1937 		goto out_end;
1938 
1939 	ehdr = gelf_getehdr(kcore->elf, &kcore->ehdr);
1940 	if (!ehdr)
1941 		goto out_end;
1942 
1943 	return 0;
1944 
1945 out_end:
1946 	elf_end(kcore->elf);
1947 out_close:
1948 	close(kcore->fd);
1949 	return -1;
1950 }
1951 
1952 static int kcore__init(struct kcore *kcore, char *filename, int elfclass,
1953 		       bool temp)
1954 {
1955 	kcore->elfclass = elfclass;
1956 
1957 	if (temp)
1958 		kcore->fd = mkstemp(filename);
1959 	else
1960 		kcore->fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0400);
1961 	if (kcore->fd == -1)
1962 		return -1;
1963 
1964 	kcore->elf = elf_begin(kcore->fd, ELF_C_WRITE, NULL);
1965 	if (!kcore->elf)
1966 		goto out_close;
1967 
1968 	if (!gelf_newehdr(kcore->elf, elfclass))
1969 		goto out_end;
1970 
1971 	memset(&kcore->ehdr, 0, sizeof(GElf_Ehdr));
1972 
1973 	return 0;
1974 
1975 out_end:
1976 	elf_end(kcore->elf);
1977 out_close:
1978 	close(kcore->fd);
1979 	unlink(filename);
1980 	return -1;
1981 }
1982 
1983 static void kcore__close(struct kcore *kcore)
1984 {
1985 	elf_end(kcore->elf);
1986 	close(kcore->fd);
1987 }
1988 
1989 static int kcore__copy_hdr(struct kcore *from, struct kcore *to, size_t count)
1990 {
1991 	GElf_Ehdr *ehdr = &to->ehdr;
1992 	GElf_Ehdr *kehdr = &from->ehdr;
1993 
1994 	memcpy(ehdr->e_ident, kehdr->e_ident, EI_NIDENT);
1995 	ehdr->e_type      = kehdr->e_type;
1996 	ehdr->e_machine   = kehdr->e_machine;
1997 	ehdr->e_version   = kehdr->e_version;
1998 	ehdr->e_entry     = 0;
1999 	ehdr->e_shoff     = 0;
2000 	ehdr->e_flags     = kehdr->e_flags;
2001 	ehdr->e_phnum     = count;
2002 	ehdr->e_shentsize = 0;
2003 	ehdr->e_shnum     = 0;
2004 	ehdr->e_shstrndx  = 0;
2005 
2006 	if (from->elfclass == ELFCLASS32) {
2007 		ehdr->e_phoff     = sizeof(Elf32_Ehdr);
2008 		ehdr->e_ehsize    = sizeof(Elf32_Ehdr);
2009 		ehdr->e_phentsize = sizeof(Elf32_Phdr);
2010 	} else {
2011 		ehdr->e_phoff     = sizeof(Elf64_Ehdr);
2012 		ehdr->e_ehsize    = sizeof(Elf64_Ehdr);
2013 		ehdr->e_phentsize = sizeof(Elf64_Phdr);
2014 	}
2015 
2016 	if (!gelf_update_ehdr(to->elf, ehdr))
2017 		return -1;
2018 
2019 	if (!gelf_newphdr(to->elf, count))
2020 		return -1;
2021 
2022 	return 0;
2023 }
2024 
2025 static int kcore__add_phdr(struct kcore *kcore, int idx, off_t offset,
2026 			   u64 addr, u64 len)
2027 {
2028 	GElf_Phdr phdr = {
2029 		.p_type		= PT_LOAD,
2030 		.p_flags	= PF_R | PF_W | PF_X,
2031 		.p_offset	= offset,
2032 		.p_vaddr	= addr,
2033 		.p_paddr	= 0,
2034 		.p_filesz	= len,
2035 		.p_memsz	= len,
2036 		.p_align	= page_size,
2037 	};
2038 
2039 	if (!gelf_update_phdr(kcore->elf, idx, &phdr))
2040 		return -1;
2041 
2042 	return 0;
2043 }
2044 
2045 static off_t kcore__write(struct kcore *kcore)
2046 {
2047 	return elf_update(kcore->elf, ELF_C_WRITE);
2048 }
2049 
2050 struct phdr_data {
2051 	off_t offset;
2052 	off_t rel;
2053 	u64 addr;
2054 	u64 len;
2055 	struct list_head node;
2056 	struct phdr_data *remaps;
2057 };
2058 
2059 struct sym_data {
2060 	u64 addr;
2061 	struct list_head node;
2062 };
2063 
2064 struct kcore_copy_info {
2065 	u64 stext;
2066 	u64 etext;
2067 	u64 first_symbol;
2068 	u64 last_symbol;
2069 	u64 first_module;
2070 	u64 first_module_symbol;
2071 	u64 last_module_symbol;
2072 	size_t phnum;
2073 	struct list_head phdrs;
2074 	struct list_head syms;
2075 };
2076 
2077 #define kcore_copy__for_each_phdr(k, p) \
2078 	list_for_each_entry((p), &(k)->phdrs, node)
2079 
2080 static struct phdr_data *phdr_data__new(u64 addr, u64 len, off_t offset)
2081 {
2082 	struct phdr_data *p = zalloc(sizeof(*p));
2083 
2084 	if (p) {
2085 		p->addr   = addr;
2086 		p->len    = len;
2087 		p->offset = offset;
2088 	}
2089 
2090 	return p;
2091 }
2092 
2093 static struct phdr_data *kcore_copy_info__addnew(struct kcore_copy_info *kci,
2094 						 u64 addr, u64 len,
2095 						 off_t offset)
2096 {
2097 	struct phdr_data *p = phdr_data__new(addr, len, offset);
2098 
2099 	if (p)
2100 		list_add_tail(&p->node, &kci->phdrs);
2101 
2102 	return p;
2103 }
2104 
2105 static void kcore_copy__free_phdrs(struct kcore_copy_info *kci)
2106 {
2107 	struct phdr_data *p, *tmp;
2108 
2109 	list_for_each_entry_safe(p, tmp, &kci->phdrs, node) {
2110 		list_del_init(&p->node);
2111 		free(p);
2112 	}
2113 }
2114 
2115 static struct sym_data *kcore_copy__new_sym(struct kcore_copy_info *kci,
2116 					    u64 addr)
2117 {
2118 	struct sym_data *s = zalloc(sizeof(*s));
2119 
2120 	if (s) {
2121 		s->addr = addr;
2122 		list_add_tail(&s->node, &kci->syms);
2123 	}
2124 
2125 	return s;
2126 }
2127 
2128 static void kcore_copy__free_syms(struct kcore_copy_info *kci)
2129 {
2130 	struct sym_data *s, *tmp;
2131 
2132 	list_for_each_entry_safe(s, tmp, &kci->syms, node) {
2133 		list_del_init(&s->node);
2134 		free(s);
2135 	}
2136 }
2137 
2138 static int kcore_copy__process_kallsyms(void *arg, const char *name, char type,
2139 					u64 start)
2140 {
2141 	struct kcore_copy_info *kci = arg;
2142 
2143 	if (!kallsyms__is_function(type))
2144 		return 0;
2145 
2146 	if (strchr(name, '[')) {
2147 		if (!kci->first_module_symbol || start < kci->first_module_symbol)
2148 			kci->first_module_symbol = start;
2149 		if (start > kci->last_module_symbol)
2150 			kci->last_module_symbol = start;
2151 		return 0;
2152 	}
2153 
2154 	if (!kci->first_symbol || start < kci->first_symbol)
2155 		kci->first_symbol = start;
2156 
2157 	if (!kci->last_symbol || start > kci->last_symbol)
2158 		kci->last_symbol = start;
2159 
2160 	if (!strcmp(name, "_stext")) {
2161 		kci->stext = start;
2162 		return 0;
2163 	}
2164 
2165 	if (!strcmp(name, "_etext")) {
2166 		kci->etext = start;
2167 		return 0;
2168 	}
2169 
2170 	if (is_entry_trampoline(name) && !kcore_copy__new_sym(kci, start))
2171 		return -1;
2172 
2173 	return 0;
2174 }
2175 
2176 static int kcore_copy__parse_kallsyms(struct kcore_copy_info *kci,
2177 				      const char *dir)
2178 {
2179 	char kallsyms_filename[PATH_MAX];
2180 
2181 	scnprintf(kallsyms_filename, PATH_MAX, "%s/kallsyms", dir);
2182 
2183 	if (symbol__restricted_filename(kallsyms_filename, "/proc/kallsyms"))
2184 		return -1;
2185 
2186 	if (kallsyms__parse(kallsyms_filename, kci,
2187 			    kcore_copy__process_kallsyms) < 0)
2188 		return -1;
2189 
2190 	return 0;
2191 }
2192 
2193 static int kcore_copy__process_modules(void *arg,
2194 				       const char *name __maybe_unused,
2195 				       u64 start, u64 size __maybe_unused)
2196 {
2197 	struct kcore_copy_info *kci = arg;
2198 
2199 	if (!kci->first_module || start < kci->first_module)
2200 		kci->first_module = start;
2201 
2202 	return 0;
2203 }
2204 
2205 static int kcore_copy__parse_modules(struct kcore_copy_info *kci,
2206 				     const char *dir)
2207 {
2208 	char modules_filename[PATH_MAX];
2209 
2210 	scnprintf(modules_filename, PATH_MAX, "%s/modules", dir);
2211 
2212 	if (symbol__restricted_filename(modules_filename, "/proc/modules"))
2213 		return -1;
2214 
2215 	if (modules__parse(modules_filename, kci,
2216 			   kcore_copy__process_modules) < 0)
2217 		return -1;
2218 
2219 	return 0;
2220 }
2221 
2222 static int kcore_copy__map(struct kcore_copy_info *kci, u64 start, u64 end,
2223 			   u64 pgoff, u64 s, u64 e)
2224 {
2225 	u64 len, offset;
2226 
2227 	if (s < start || s >= end)
2228 		return 0;
2229 
2230 	offset = (s - start) + pgoff;
2231 	len = e < end ? e - s : end - s;
2232 
2233 	return kcore_copy_info__addnew(kci, s, len, offset) ? 0 : -1;
2234 }
2235 
2236 static int kcore_copy__read_map(u64 start, u64 len, u64 pgoff, void *data)
2237 {
2238 	struct kcore_copy_info *kci = data;
2239 	u64 end = start + len;
2240 	struct sym_data *sdat;
2241 
2242 	if (kcore_copy__map(kci, start, end, pgoff, kci->stext, kci->etext))
2243 		return -1;
2244 
2245 	if (kcore_copy__map(kci, start, end, pgoff, kci->first_module,
2246 			    kci->last_module_symbol))
2247 		return -1;
2248 
2249 	list_for_each_entry(sdat, &kci->syms, node) {
2250 		u64 s = round_down(sdat->addr, page_size);
2251 
2252 		if (kcore_copy__map(kci, start, end, pgoff, s, s + len))
2253 			return -1;
2254 	}
2255 
2256 	return 0;
2257 }
2258 
2259 static int kcore_copy__read_maps(struct kcore_copy_info *kci, Elf *elf)
2260 {
2261 	if (elf_read_maps(elf, true, kcore_copy__read_map, kci) < 0)
2262 		return -1;
2263 
2264 	return 0;
2265 }
2266 
2267 static void kcore_copy__find_remaps(struct kcore_copy_info *kci)
2268 {
2269 	struct phdr_data *p, *k = NULL;
2270 	u64 kend;
2271 
2272 	if (!kci->stext)
2273 		return;
2274 
2275 	/* Find phdr that corresponds to the kernel map (contains stext) */
2276 	kcore_copy__for_each_phdr(kci, p) {
2277 		u64 pend = p->addr + p->len - 1;
2278 
2279 		if (p->addr <= kci->stext && pend >= kci->stext) {
2280 			k = p;
2281 			break;
2282 		}
2283 	}
2284 
2285 	if (!k)
2286 		return;
2287 
2288 	kend = k->offset + k->len;
2289 
2290 	/* Find phdrs that remap the kernel */
2291 	kcore_copy__for_each_phdr(kci, p) {
2292 		u64 pend = p->offset + p->len;
2293 
2294 		if (p == k)
2295 			continue;
2296 
2297 		if (p->offset >= k->offset && pend <= kend)
2298 			p->remaps = k;
2299 	}
2300 }
2301 
2302 static void kcore_copy__layout(struct kcore_copy_info *kci)
2303 {
2304 	struct phdr_data *p;
2305 	off_t rel = 0;
2306 
2307 	kcore_copy__find_remaps(kci);
2308 
2309 	kcore_copy__for_each_phdr(kci, p) {
2310 		if (!p->remaps) {
2311 			p->rel = rel;
2312 			rel += p->len;
2313 		}
2314 		kci->phnum += 1;
2315 	}
2316 
2317 	kcore_copy__for_each_phdr(kci, p) {
2318 		struct phdr_data *k = p->remaps;
2319 
2320 		if (k)
2321 			p->rel = p->offset - k->offset + k->rel;
2322 	}
2323 }
2324 
2325 static int kcore_copy__calc_maps(struct kcore_copy_info *kci, const char *dir,
2326 				 Elf *elf)
2327 {
2328 	if (kcore_copy__parse_kallsyms(kci, dir))
2329 		return -1;
2330 
2331 	if (kcore_copy__parse_modules(kci, dir))
2332 		return -1;
2333 
2334 	if (kci->stext)
2335 		kci->stext = round_down(kci->stext, page_size);
2336 	else
2337 		kci->stext = round_down(kci->first_symbol, page_size);
2338 
2339 	if (kci->etext) {
2340 		kci->etext = round_up(kci->etext, page_size);
2341 	} else if (kci->last_symbol) {
2342 		kci->etext = round_up(kci->last_symbol, page_size);
2343 		kci->etext += page_size;
2344 	}
2345 
2346 	if (kci->first_module_symbol &&
2347 	    (!kci->first_module || kci->first_module_symbol < kci->first_module))
2348 		kci->first_module = kci->first_module_symbol;
2349 
2350 	kci->first_module = round_down(kci->first_module, page_size);
2351 
2352 	if (kci->last_module_symbol) {
2353 		kci->last_module_symbol = round_up(kci->last_module_symbol,
2354 						   page_size);
2355 		kci->last_module_symbol += page_size;
2356 	}
2357 
2358 	if (!kci->stext || !kci->etext)
2359 		return -1;
2360 
2361 	if (kci->first_module && !kci->last_module_symbol)
2362 		return -1;
2363 
2364 	if (kcore_copy__read_maps(kci, elf))
2365 		return -1;
2366 
2367 	kcore_copy__layout(kci);
2368 
2369 	return 0;
2370 }
2371 
2372 static int kcore_copy__copy_file(const char *from_dir, const char *to_dir,
2373 				 const char *name)
2374 {
2375 	char from_filename[PATH_MAX];
2376 	char to_filename[PATH_MAX];
2377 
2378 	scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
2379 	scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
2380 
2381 	return copyfile_mode(from_filename, to_filename, 0400);
2382 }
2383 
2384 static int kcore_copy__unlink(const char *dir, const char *name)
2385 {
2386 	char filename[PATH_MAX];
2387 
2388 	scnprintf(filename, PATH_MAX, "%s/%s", dir, name);
2389 
2390 	return unlink(filename);
2391 }
2392 
2393 static int kcore_copy__compare_fds(int from, int to)
2394 {
2395 	char *buf_from;
2396 	char *buf_to;
2397 	ssize_t ret;
2398 	size_t len;
2399 	int err = -1;
2400 
2401 	buf_from = malloc(page_size);
2402 	buf_to = malloc(page_size);
2403 	if (!buf_from || !buf_to)
2404 		goto out;
2405 
2406 	while (1) {
2407 		/* Use read because mmap won't work on proc files */
2408 		ret = read(from, buf_from, page_size);
2409 		if (ret < 0)
2410 			goto out;
2411 
2412 		if (!ret)
2413 			break;
2414 
2415 		len = ret;
2416 
2417 		if (readn(to, buf_to, len) != (int)len)
2418 			goto out;
2419 
2420 		if (memcmp(buf_from, buf_to, len))
2421 			goto out;
2422 	}
2423 
2424 	err = 0;
2425 out:
2426 	free(buf_to);
2427 	free(buf_from);
2428 	return err;
2429 }
2430 
2431 static int kcore_copy__compare_files(const char *from_filename,
2432 				     const char *to_filename)
2433 {
2434 	int from, to, err = -1;
2435 
2436 	from = open(from_filename, O_RDONLY);
2437 	if (from < 0)
2438 		return -1;
2439 
2440 	to = open(to_filename, O_RDONLY);
2441 	if (to < 0)
2442 		goto out_close_from;
2443 
2444 	err = kcore_copy__compare_fds(from, to);
2445 
2446 	close(to);
2447 out_close_from:
2448 	close(from);
2449 	return err;
2450 }
2451 
2452 static int kcore_copy__compare_file(const char *from_dir, const char *to_dir,
2453 				    const char *name)
2454 {
2455 	char from_filename[PATH_MAX];
2456 	char to_filename[PATH_MAX];
2457 
2458 	scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
2459 	scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
2460 
2461 	return kcore_copy__compare_files(from_filename, to_filename);
2462 }
2463 
2464 /**
2465  * kcore_copy - copy kallsyms, modules and kcore from one directory to another.
2466  * @from_dir: from directory
2467  * @to_dir: to directory
2468  *
2469  * This function copies kallsyms, modules and kcore files from one directory to
2470  * another.  kallsyms and modules are copied entirely.  Only code segments are
2471  * copied from kcore.  It is assumed that two segments suffice: one for the
2472  * kernel proper and one for all the modules.  The code segments are determined
2473  * from kallsyms and modules files.  The kernel map starts at _stext or the
2474  * lowest function symbol, and ends at _etext or the highest function symbol.
2475  * The module map starts at the lowest module address and ends at the highest
2476  * module symbol.  Start addresses are rounded down to the nearest page.  End
2477  * addresses are rounded up to the nearest page.  An extra page is added to the
2478  * highest kernel symbol and highest module symbol to, hopefully, encompass that
2479  * symbol too.  Because it contains only code sections, the resulting kcore is
2480  * unusual.  One significant peculiarity is that the mapping (start -> pgoff)
2481  * is not the same for the kernel map and the modules map.  That happens because
2482  * the data is copied adjacently whereas the original kcore has gaps.  Finally,
2483  * kallsyms file is compared with its copy to check that modules have not been
2484  * loaded or unloaded while the copies were taking place.
2485  *
2486  * Return: %0 on success, %-1 on failure.
2487  */
2488 int kcore_copy(const char *from_dir, const char *to_dir)
2489 {
2490 	struct kcore kcore;
2491 	struct kcore extract;
2492 	int idx = 0, err = -1;
2493 	off_t offset, sz;
2494 	struct kcore_copy_info kci = { .stext = 0, };
2495 	char kcore_filename[PATH_MAX];
2496 	char extract_filename[PATH_MAX];
2497 	struct phdr_data *p;
2498 
2499 	INIT_LIST_HEAD(&kci.phdrs);
2500 	INIT_LIST_HEAD(&kci.syms);
2501 
2502 	if (kcore_copy__copy_file(from_dir, to_dir, "kallsyms"))
2503 		return -1;
2504 
2505 	if (kcore_copy__copy_file(from_dir, to_dir, "modules"))
2506 		goto out_unlink_kallsyms;
2507 
2508 	scnprintf(kcore_filename, PATH_MAX, "%s/kcore", from_dir);
2509 	scnprintf(extract_filename, PATH_MAX, "%s/kcore", to_dir);
2510 
2511 	if (kcore__open(&kcore, kcore_filename))
2512 		goto out_unlink_modules;
2513 
2514 	if (kcore_copy__calc_maps(&kci, from_dir, kcore.elf))
2515 		goto out_kcore_close;
2516 
2517 	if (kcore__init(&extract, extract_filename, kcore.elfclass, false))
2518 		goto out_kcore_close;
2519 
2520 	if (kcore__copy_hdr(&kcore, &extract, kci.phnum))
2521 		goto out_extract_close;
2522 
2523 	offset = gelf_fsize(extract.elf, ELF_T_EHDR, 1, EV_CURRENT) +
2524 		 gelf_fsize(extract.elf, ELF_T_PHDR, kci.phnum, EV_CURRENT);
2525 	offset = round_up(offset, page_size);
2526 
2527 	kcore_copy__for_each_phdr(&kci, p) {
2528 		off_t offs = p->rel + offset;
2529 
2530 		if (kcore__add_phdr(&extract, idx++, offs, p->addr, p->len))
2531 			goto out_extract_close;
2532 	}
2533 
2534 	sz = kcore__write(&extract);
2535 	if (sz < 0 || sz > offset)
2536 		goto out_extract_close;
2537 
2538 	kcore_copy__for_each_phdr(&kci, p) {
2539 		off_t offs = p->rel + offset;
2540 
2541 		if (p->remaps)
2542 			continue;
2543 		if (copy_bytes(kcore.fd, p->offset, extract.fd, offs, p->len))
2544 			goto out_extract_close;
2545 	}
2546 
2547 	if (kcore_copy__compare_file(from_dir, to_dir, "kallsyms"))
2548 		goto out_extract_close;
2549 
2550 	err = 0;
2551 
2552 out_extract_close:
2553 	kcore__close(&extract);
2554 	if (err)
2555 		unlink(extract_filename);
2556 out_kcore_close:
2557 	kcore__close(&kcore);
2558 out_unlink_modules:
2559 	if (err)
2560 		kcore_copy__unlink(to_dir, "modules");
2561 out_unlink_kallsyms:
2562 	if (err)
2563 		kcore_copy__unlink(to_dir, "kallsyms");
2564 
2565 	kcore_copy__free_phdrs(&kci);
2566 	kcore_copy__free_syms(&kci);
2567 
2568 	return err;
2569 }
2570 
2571 int kcore_extract__create(struct kcore_extract *kce)
2572 {
2573 	struct kcore kcore;
2574 	struct kcore extract;
2575 	size_t count = 1;
2576 	int idx = 0, err = -1;
2577 	off_t offset = page_size, sz;
2578 
2579 	if (kcore__open(&kcore, kce->kcore_filename))
2580 		return -1;
2581 
2582 	strcpy(kce->extract_filename, PERF_KCORE_EXTRACT);
2583 	if (kcore__init(&extract, kce->extract_filename, kcore.elfclass, true))
2584 		goto out_kcore_close;
2585 
2586 	if (kcore__copy_hdr(&kcore, &extract, count))
2587 		goto out_extract_close;
2588 
2589 	if (kcore__add_phdr(&extract, idx, offset, kce->addr, kce->len))
2590 		goto out_extract_close;
2591 
2592 	sz = kcore__write(&extract);
2593 	if (sz < 0 || sz > offset)
2594 		goto out_extract_close;
2595 
2596 	if (copy_bytes(kcore.fd, kce->offs, extract.fd, offset, kce->len))
2597 		goto out_extract_close;
2598 
2599 	err = 0;
2600 
2601 out_extract_close:
2602 	kcore__close(&extract);
2603 	if (err)
2604 		unlink(kce->extract_filename);
2605 out_kcore_close:
2606 	kcore__close(&kcore);
2607 
2608 	return err;
2609 }
2610 
2611 void kcore_extract__delete(struct kcore_extract *kce)
2612 {
2613 	unlink(kce->extract_filename);
2614 }
2615 
2616 #ifdef HAVE_GELF_GETNOTE_SUPPORT
2617 
2618 static void sdt_adjust_loc(struct sdt_note *tmp, GElf_Addr base_off)
2619 {
2620 	if (!base_off)
2621 		return;
2622 
2623 	if (tmp->bit32)
2624 		tmp->addr.a32[SDT_NOTE_IDX_LOC] =
2625 			tmp->addr.a32[SDT_NOTE_IDX_LOC] + base_off -
2626 			tmp->addr.a32[SDT_NOTE_IDX_BASE];
2627 	else
2628 		tmp->addr.a64[SDT_NOTE_IDX_LOC] =
2629 			tmp->addr.a64[SDT_NOTE_IDX_LOC] + base_off -
2630 			tmp->addr.a64[SDT_NOTE_IDX_BASE];
2631 }
2632 
2633 static void sdt_adjust_refctr(struct sdt_note *tmp, GElf_Addr base_addr,
2634 			      GElf_Addr base_off)
2635 {
2636 	if (!base_off)
2637 		return;
2638 
2639 	if (tmp->bit32 && tmp->addr.a32[SDT_NOTE_IDX_REFCTR])
2640 		tmp->addr.a32[SDT_NOTE_IDX_REFCTR] -= (base_addr - base_off);
2641 	else if (tmp->addr.a64[SDT_NOTE_IDX_REFCTR])
2642 		tmp->addr.a64[SDT_NOTE_IDX_REFCTR] -= (base_addr - base_off);
2643 }
2644 
2645 /**
2646  * populate_sdt_note : Parse raw data and identify SDT note
2647  * @elf: elf of the opened file
2648  * @data: raw data of a section with description offset applied
2649  * @len: note description size
2650  * @type: type of the note
2651  * @sdt_notes: List to add the SDT note
2652  *
2653  * Responsible for parsing the @data in section .note.stapsdt in @elf and
2654  * if its an SDT note, it appends to @sdt_notes list.
2655  */
2656 static int populate_sdt_note(Elf **elf, const char *data, size_t len,
2657 			     struct list_head *sdt_notes)
2658 {
2659 	const char *provider, *name, *args;
2660 	struct sdt_note *tmp = NULL;
2661 	GElf_Ehdr ehdr;
2662 	GElf_Shdr shdr;
2663 	int ret = -EINVAL;
2664 
2665 	union {
2666 		Elf64_Addr a64[NR_ADDR];
2667 		Elf32_Addr a32[NR_ADDR];
2668 	} buf;
2669 
2670 	Elf_Data dst = {
2671 		.d_buf = &buf, .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
2672 		.d_size = gelf_fsize((*elf), ELF_T_ADDR, NR_ADDR, EV_CURRENT),
2673 		.d_off = 0, .d_align = 0
2674 	};
2675 	Elf_Data src = {
2676 		.d_buf = (void *) data, .d_type = ELF_T_ADDR,
2677 		.d_version = EV_CURRENT, .d_size = dst.d_size, .d_off = 0,
2678 		.d_align = 0
2679 	};
2680 
2681 	tmp = (struct sdt_note *)calloc(1, sizeof(struct sdt_note));
2682 	if (!tmp) {
2683 		ret = -ENOMEM;
2684 		goto out_err;
2685 	}
2686 
2687 	INIT_LIST_HEAD(&tmp->note_list);
2688 
2689 	if (len < dst.d_size + 3)
2690 		goto out_free_note;
2691 
2692 	/* Translation from file representation to memory representation */
2693 	if (gelf_xlatetom(*elf, &dst, &src,
2694 			  elf_getident(*elf, NULL)[EI_DATA]) == NULL) {
2695 		pr_err("gelf_xlatetom : %s\n", elf_errmsg(-1));
2696 		goto out_free_note;
2697 	}
2698 
2699 	/* Populate the fields of sdt_note */
2700 	provider = data + dst.d_size;
2701 
2702 	name = (const char *)memchr(provider, '\0', data + len - provider);
2703 	if (name++ == NULL)
2704 		goto out_free_note;
2705 
2706 	tmp->provider = strdup(provider);
2707 	if (!tmp->provider) {
2708 		ret = -ENOMEM;
2709 		goto out_free_note;
2710 	}
2711 	tmp->name = strdup(name);
2712 	if (!tmp->name) {
2713 		ret = -ENOMEM;
2714 		goto out_free_prov;
2715 	}
2716 
2717 	args = memchr(name, '\0', data + len - name);
2718 
2719 	/*
2720 	 * There is no argument if:
2721 	 * - We reached the end of the note;
2722 	 * - There is not enough room to hold a potential string;
2723 	 * - The argument string is empty or just contains ':'.
2724 	 */
2725 	if (args == NULL || data + len - args < 2 ||
2726 		args[1] == ':' || args[1] == '\0')
2727 		tmp->args = NULL;
2728 	else {
2729 		tmp->args = strdup(++args);
2730 		if (!tmp->args) {
2731 			ret = -ENOMEM;
2732 			goto out_free_name;
2733 		}
2734 	}
2735 
2736 	if (gelf_getclass(*elf) == ELFCLASS32) {
2737 		memcpy(&tmp->addr, &buf, 3 * sizeof(Elf32_Addr));
2738 		tmp->bit32 = true;
2739 	} else {
2740 		memcpy(&tmp->addr, &buf, 3 * sizeof(Elf64_Addr));
2741 		tmp->bit32 = false;
2742 	}
2743 
2744 	if (!gelf_getehdr(*elf, &ehdr)) {
2745 		pr_debug("%s : cannot get elf header.\n", __func__);
2746 		ret = -EBADF;
2747 		goto out_free_args;
2748 	}
2749 
2750 	/* Adjust the prelink effect :
2751 	 * Find out the .stapsdt.base section.
2752 	 * This scn will help us to handle prelinking (if present).
2753 	 * Compare the retrieved file offset of the base section with the
2754 	 * base address in the description of the SDT note. If its different,
2755 	 * then accordingly, adjust the note location.
2756 	 */
2757 	if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_BASE_SCN, NULL))
2758 		sdt_adjust_loc(tmp, shdr.sh_offset);
2759 
2760 	/* Adjust reference counter offset */
2761 	if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_PROBES_SCN, NULL))
2762 		sdt_adjust_refctr(tmp, shdr.sh_addr, shdr.sh_offset);
2763 
2764 	list_add_tail(&tmp->note_list, sdt_notes);
2765 	return 0;
2766 
2767 out_free_args:
2768 	zfree(&tmp->args);
2769 out_free_name:
2770 	zfree(&tmp->name);
2771 out_free_prov:
2772 	zfree(&tmp->provider);
2773 out_free_note:
2774 	free(tmp);
2775 out_err:
2776 	return ret;
2777 }
2778 
2779 /**
2780  * construct_sdt_notes_list : constructs a list of SDT notes
2781  * @elf : elf to look into
2782  * @sdt_notes : empty list_head
2783  *
2784  * Scans the sections in 'elf' for the section
2785  * .note.stapsdt. It, then calls populate_sdt_note to find
2786  * out the SDT events and populates the 'sdt_notes'.
2787  */
2788 static int construct_sdt_notes_list(Elf *elf, struct list_head *sdt_notes)
2789 {
2790 	GElf_Ehdr ehdr;
2791 	Elf_Scn *scn = NULL;
2792 	Elf_Data *data;
2793 	GElf_Shdr shdr;
2794 	size_t shstrndx, next;
2795 	GElf_Nhdr nhdr;
2796 	size_t name_off, desc_off, offset;
2797 	int ret = 0;
2798 
2799 	if (gelf_getehdr(elf, &ehdr) == NULL) {
2800 		ret = -EBADF;
2801 		goto out_ret;
2802 	}
2803 	if (elf_getshdrstrndx(elf, &shstrndx) != 0) {
2804 		ret = -EBADF;
2805 		goto out_ret;
2806 	}
2807 
2808 	/* Look for the required section */
2809 	scn = elf_section_by_name(elf, &ehdr, &shdr, SDT_NOTE_SCN, NULL);
2810 	if (!scn) {
2811 		ret = -ENOENT;
2812 		goto out_ret;
2813 	}
2814 
2815 	if ((shdr.sh_type != SHT_NOTE) || (shdr.sh_flags & SHF_ALLOC)) {
2816 		ret = -ENOENT;
2817 		goto out_ret;
2818 	}
2819 
2820 	data = elf_getdata(scn, NULL);
2821 
2822 	/* Get the SDT notes */
2823 	for (offset = 0; (next = gelf_getnote(data, offset, &nhdr, &name_off,
2824 					      &desc_off)) > 0; offset = next) {
2825 		if (nhdr.n_namesz == sizeof(SDT_NOTE_NAME) &&
2826 		    !memcmp(data->d_buf + name_off, SDT_NOTE_NAME,
2827 			    sizeof(SDT_NOTE_NAME))) {
2828 			/* Check the type of the note */
2829 			if (nhdr.n_type != SDT_NOTE_TYPE)
2830 				goto out_ret;
2831 
2832 			ret = populate_sdt_note(&elf, ((data->d_buf) + desc_off),
2833 						nhdr.n_descsz, sdt_notes);
2834 			if (ret < 0)
2835 				goto out_ret;
2836 		}
2837 	}
2838 	if (list_empty(sdt_notes))
2839 		ret = -ENOENT;
2840 
2841 out_ret:
2842 	return ret;
2843 }
2844 
2845 /**
2846  * get_sdt_note_list : Wrapper to construct a list of sdt notes
2847  * @head : empty list_head
2848  * @target : file to find SDT notes from
2849  *
2850  * This opens the file, initializes
2851  * the ELF and then calls construct_sdt_notes_list.
2852  */
2853 int get_sdt_note_list(struct list_head *head, const char *target)
2854 {
2855 	Elf *elf;
2856 	int fd, ret;
2857 
2858 	fd = open(target, O_RDONLY);
2859 	if (fd < 0)
2860 		return -EBADF;
2861 
2862 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
2863 	if (!elf) {
2864 		ret = -EBADF;
2865 		goto out_close;
2866 	}
2867 	ret = construct_sdt_notes_list(elf, head);
2868 	elf_end(elf);
2869 out_close:
2870 	close(fd);
2871 	return ret;
2872 }
2873 
2874 /**
2875  * cleanup_sdt_note_list : free the sdt notes' list
2876  * @sdt_notes: sdt notes' list
2877  *
2878  * Free up the SDT notes in @sdt_notes.
2879  * Returns the number of SDT notes free'd.
2880  */
2881 int cleanup_sdt_note_list(struct list_head *sdt_notes)
2882 {
2883 	struct sdt_note *tmp, *pos;
2884 	int nr_free = 0;
2885 
2886 	list_for_each_entry_safe(pos, tmp, sdt_notes, note_list) {
2887 		list_del_init(&pos->note_list);
2888 		zfree(&pos->args);
2889 		zfree(&pos->name);
2890 		zfree(&pos->provider);
2891 		free(pos);
2892 		nr_free++;
2893 	}
2894 	return nr_free;
2895 }
2896 
2897 /**
2898  * sdt_notes__get_count: Counts the number of sdt events
2899  * @start: list_head to sdt_notes list
2900  *
2901  * Returns the number of SDT notes in a list
2902  */
2903 int sdt_notes__get_count(struct list_head *start)
2904 {
2905 	struct sdt_note *sdt_ptr;
2906 	int count = 0;
2907 
2908 	list_for_each_entry(sdt_ptr, start, note_list)
2909 		count++;
2910 	return count;
2911 }
2912 #endif
2913 
2914 void symbol__elf_init(void)
2915 {
2916 	elf_version(EV_CURRENT);
2917 }
2918