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