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