projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf target: Simplify handling of strerror_r return
[linux-2.6-block.git] / tools / perf / util / symbol-elf.c
CommitLineData
e5a1845f
NK		 1#include <fcntl.h>
2#include <stdio.h>
3#include <errno.h>
4#include <string.h>
5#include <unistd.h>
6#include <inttypes.h>
7
8#include "symbol.h"
8fa7d87f 9#include "machine.h"
922d0e4d 10#include "vdso.h"
c506c96b 11#include <symbol/kallsyms.h>
e5a1845f
NK		 12#include "debug.h"
13
e370a3d5
DA		 14#ifndef EM_AARCH64
15#define EM_AARCH64 183 /* ARM 64 bit */
16#endif
17
18
aaba4e12
ACM		 19#ifdef HAVE_CPLUS_DEMANGLE_SUPPORT
20extern char *cplus_demangle(const char *, int);
21
22static inline char *bfd_demangle(void __maybe_unused *v, const char *c, int i)
23{
24 return cplus_demangle(c, i);
25}
26#else
27#ifdef NO_DEMANGLE
28static inline char *bfd_demangle(void __maybe_unused *v,
29 const char __maybe_unused *c,
30 int __maybe_unused i)
31{
32 return NULL;
33}
34#else
35#define PACKAGE 'perf'
36#include <bfd.h>
37#endif
38#endif
39
89fe808a 40#ifndef HAVE_ELF_GETPHDRNUM_SUPPORT
e955d5c4
AH		 41static int elf_getphdrnum(Elf *elf, size_t *dst)
42{
43 GElf_Ehdr gehdr;
44 GElf_Ehdr *ehdr;
45
46 ehdr = gelf_getehdr(elf, &gehdr);
47 if (!ehdr)
48 return -1;
49
50 *dst = ehdr->e_phnum;
51
52 return 0;
53}
54#endif
55
e5a1845f
NK		 56#ifndef NT_GNU_BUILD_ID
57#define NT_GNU_BUILD_ID 3
58#endif
59
60/**
61 * elf_symtab__for_each_symbol - iterate thru all the symbols
62 *
63 * @syms: struct elf_symtab instance to iterate
64 * @idx: uint32_t idx
65 * @sym: GElf_Sym iterator
66 */
67#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
68 for (idx = 0, gelf_getsym(syms, idx, &sym);\
69 idx < nr_syms; \
70 idx++, gelf_getsym(syms, idx, &sym))
71
72static inline uint8_t elf_sym__type(const GElf_Sym *sym)
73{
74 return GELF_ST_TYPE(sym->st_info);
75}
76
4e31050f
VL		 77#ifndef STT_GNU_IFUNC
78#define STT_GNU_IFUNC 10
79#endif
80
e5a1845f
NK		 81static inline int elf_sym__is_function(const GElf_Sym *sym)
82{
a2f3b6bf
AH		 83 return (elf_sym__type(sym) == STT_FUNC ||
84 elf_sym__type(sym) == STT_GNU_IFUNC) &&
e5a1845f
NK		 85 sym->st_name != 0 &&
86 sym->st_shndx != SHN_UNDEF;
87}
88
89static inline bool elf_sym__is_object(const GElf_Sym *sym)
90{
91 return elf_sym__type(sym) == STT_OBJECT &&
92 sym->st_name != 0 &&
93 sym->st_shndx != SHN_UNDEF;
94}
95
96static inline int elf_sym__is_label(const GElf_Sym *sym)
97{
98 return elf_sym__type(sym) == STT_NOTYPE &&
99 sym->st_name != 0 &&
100 sym->st_shndx != SHN_UNDEF &&
101 sym->st_shndx != SHN_ABS;
102}
103
104static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
105{
106 switch (type) {
107 case MAP__FUNCTION:
108 return elf_sym__is_function(sym);
109 case MAP__VARIABLE:
110 return elf_sym__is_object(sym);
111 default:
112 return false;
113 }
114}
115
116static inline const char *elf_sym__name(const GElf_Sym *sym,
117 const Elf_Data *symstrs)
118{
119 return symstrs->d_buf + sym->st_name;
120}
121
122static inline const char *elf_sec__name(const GElf_Shdr *shdr,
123 const Elf_Data *secstrs)
124{
125 return secstrs->d_buf + shdr->sh_name;
126}
127
128static inline int elf_sec__is_text(const GElf_Shdr *shdr,
129 const Elf_Data *secstrs)
130{
131 return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
132}
133
134static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
135 const Elf_Data *secstrs)
136{
137 return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
138}
139
140static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
141 enum map_type type)
142{
143 switch (type) {
144 case MAP__FUNCTION:
145 return elf_sec__is_text(shdr, secstrs);
146 case MAP__VARIABLE:
147 return elf_sec__is_data(shdr, secstrs);
148 default:
149 return false;
150 }
151}
152
153static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
154{
155 Elf_Scn *sec = NULL;
156 GElf_Shdr shdr;
157 size_t cnt = 1;
158
159 while ((sec = elf_nextscn(elf, sec)) != NULL) {
160 gelf_getshdr(sec, &shdr);
161
162 if ((addr >= shdr.sh_addr) &&
163 (addr < (shdr.sh_addr + shdr.sh_size)))
164 return cnt;
165
166 ++cnt;
167 }
168
169 return -1;
170}
171
99ca4233
MH		 172Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
173 GElf_Shdr *shp, const char *name, size_t *idx)
e5a1845f
NK		 174{
175 Elf_Scn *sec = NULL;
176 size_t cnt = 1;
177
49274654
CS		 178 /* Elf is corrupted/truncated, avoid calling elf_strptr. */
179 if (!elf_rawdata(elf_getscn(elf, ep->e_shstrndx), NULL))
180 return NULL;
181
e5a1845f
NK		 182 while ((sec = elf_nextscn(elf, sec)) != NULL) {
183 char *str;
184
185 gelf_getshdr(sec, shp);
186 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
155b3a13 187 if (str && !strcmp(name, str)) {
e5a1845f
NK		 188 if (idx)
189 *idx = cnt;
155b3a13 190 return sec;
e5a1845f
NK		 191 }
192 ++cnt;
193 }
194
155b3a13 195 return NULL;
e5a1845f
NK		 196}
197
198#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
199 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
200 idx < nr_entries; \
201 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
202
203#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
204 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
205 idx < nr_entries; \
206 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
207
208/*
209 * We need to check if we have a .dynsym, so that we can handle the
210 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
211 * .dynsym or .symtab).
212 * And always look at the original dso, not at debuginfo packages, that
213 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
214 */
a44f605b 215int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss, struct map *map,
e5a1845f
NK		 216 symbol_filter_t filter)
217{
218 uint32_t nr_rel_entries, idx;
219 GElf_Sym sym;
220 u64 plt_offset;
221 GElf_Shdr shdr_plt;
222 struct symbol *f;
223 GElf_Shdr shdr_rel_plt, shdr_dynsym;
224 Elf_Data *reldata, *syms, *symstrs;
225 Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
226 size_t dynsym_idx;
227 GElf_Ehdr ehdr;
228 char sympltname[1024];
229 Elf *elf;
a44f605b 230 int nr = 0, symidx, err = 0;
e5a1845f 231
f47b58b7
DA		 232 if (!ss->dynsym)
233 return 0;
234
a44f605b
CS		 235 elf = ss->elf;
236 ehdr = ss->ehdr;
e5a1845f 237
a44f605b
CS		 238 scn_dynsym = ss->dynsym;
239 shdr_dynsym = ss->dynshdr;
240 dynsym_idx = ss->dynsym_idx;
e5a1845f 241
e5a1845f
NK		 242 if (scn_dynsym == NULL)
243 goto out_elf_end;
244
245 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
246 ".rela.plt", NULL);
247 if (scn_plt_rel == NULL) {
248 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
249 ".rel.plt", NULL);
250 if (scn_plt_rel == NULL)
251 goto out_elf_end;
252 }
253
254 err = -1;
255
256 if (shdr_rel_plt.sh_link != dynsym_idx)
257 goto out_elf_end;
258
259 if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
260 goto out_elf_end;
261
262 /*
263 * Fetch the relocation section to find the idxes to the GOT
264 * and the symbols in the .dynsym they refer to.
265 */
266 reldata = elf_getdata(scn_plt_rel, NULL);
267 if (reldata == NULL)
268 goto out_elf_end;
269
270 syms = elf_getdata(scn_dynsym, NULL);
271 if (syms == NULL)
272 goto out_elf_end;
273
274 scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
275 if (scn_symstrs == NULL)
276 goto out_elf_end;
277
278 symstrs = elf_getdata(scn_symstrs, NULL);
279 if (symstrs == NULL)
280 goto out_elf_end;
281
52f9ddba
CS		 282 if (symstrs->d_size == 0)
283 goto out_elf_end;
284
e5a1845f
NK		 285 nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
286 plt_offset = shdr_plt.sh_offset;
287
288 if (shdr_rel_plt.sh_type == SHT_RELA) {
289 GElf_Rela pos_mem, *pos;
290
291 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
292 nr_rel_entries) {
293 symidx = GELF_R_SYM(pos->r_info);
294 plt_offset += shdr_plt.sh_entsize;
295 gelf_getsym(syms, symidx, &sym);
296 snprintf(sympltname, sizeof(sympltname),
297 "%s@plt", elf_sym__name(&sym, symstrs));
298
299 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
300 STB_GLOBAL, sympltname);
301 if (!f)
302 goto out_elf_end;
303
304 if (filter && filter(map, f))
305 symbol__delete(f);
306 else {
307 symbols__insert(&dso->symbols[map->type], f);
308 ++nr;
309 }
310 }
311 } else if (shdr_rel_plt.sh_type == SHT_REL) {
312 GElf_Rel pos_mem, *pos;
313 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
314 nr_rel_entries) {
315 symidx = GELF_R_SYM(pos->r_info);
316 plt_offset += shdr_plt.sh_entsize;
317 gelf_getsym(syms, symidx, &sym);
318 snprintf(sympltname, sizeof(sympltname),
319 "%s@plt", elf_sym__name(&sym, symstrs));
320
321 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
322 STB_GLOBAL, sympltname);
323 if (!f)
324 goto out_elf_end;
325
326 if (filter && filter(map, f))
327 symbol__delete(f);
328 else {
329 symbols__insert(&dso->symbols[map->type], f);
330 ++nr;
331 }
332 }
333 }
334
335 err = 0;
336out_elf_end:
e5a1845f
NK		 337 if (err == 0)
338 return nr;
e5a1845f
NK		 339 pr_debug("%s: problems reading %s PLT info.\n",
340 __func__, dso->long_name);
341 return 0;
342}
343
344/*
345 * Align offset to 4 bytes as needed for note name and descriptor data.
346 */
347#define NOTE_ALIGN(n) (((n) + 3) & -4U)
348
349static int elf_read_build_id(Elf *elf, void *bf, size_t size)
350{
351 int err = -1;
352 GElf_Ehdr ehdr;
353 GElf_Shdr shdr;
354 Elf_Data *data;
355 Elf_Scn *sec;
356 Elf_Kind ek;
357 void *ptr;
358
359 if (size < BUILD_ID_SIZE)
360 goto out;
361
362 ek = elf_kind(elf);
363 if (ek != ELF_K_ELF)
364 goto out;
365
366 if (gelf_getehdr(elf, &ehdr) == NULL) {
367 pr_err("%s: cannot get elf header.\n", __func__);
368 goto out;
369 }
370
371 /*
372 * Check following sections for notes:
373 * '.note.gnu.build-id'
374 * '.notes'
375 * '.note' (VDSO specific)
376 */
377 do {
378 sec = elf_section_by_name(elf, &ehdr, &shdr,
379 ".note.gnu.build-id", NULL);
380 if (sec)
381 break;
382
383 sec = elf_section_by_name(elf, &ehdr, &shdr,
384 ".notes", NULL);
385 if (sec)
386 break;
387
388 sec = elf_section_by_name(elf, &ehdr, &shdr,
389 ".note", NULL);
390 if (sec)
391 break;
392
393 return err;
394
395 } while (0);
396
397 data = elf_getdata(sec, NULL);
398 if (data == NULL)
399 goto out;
400
401 ptr = data->d_buf;
402 while (ptr < (data->d_buf + data->d_size)) {
403 GElf_Nhdr *nhdr = ptr;
404 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
405 descsz = NOTE_ALIGN(nhdr->n_descsz);
406 const char *name;
407
408 ptr += sizeof(*nhdr);
409 name = ptr;
410 ptr += namesz;
411 if (nhdr->n_type == NT_GNU_BUILD_ID &&
412 nhdr->n_namesz == sizeof("GNU")) {
413 if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
414 size_t sz = min(size, descsz);
415 memcpy(bf, ptr, sz);
416 memset(bf + sz, 0, size - sz);
417 err = descsz;
418 break;
419 }
420 }
421 ptr += descsz;
422 }
423
424out:
425 return err;
426}
427
428int filename__read_build_id(const char *filename, void *bf, size_t size)
429{
430 int fd, err = -1;
431 Elf *elf;
432
433 if (size < BUILD_ID_SIZE)
434 goto out;
435
436 fd = open(filename, O_RDONLY);
437 if (fd < 0)
438 goto out;
439
440 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
441 if (elf == NULL) {
442 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
443 goto out_close;
444 }
445
446 err = elf_read_build_id(elf, bf, size);
447
448 elf_end(elf);
449out_close:
450 close(fd);
451out:
452 return err;
453}
454
455int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
456{
457 int fd, err = -1;
458
459 if (size < BUILD_ID_SIZE)
460 goto out;
461
462 fd = open(filename, O_RDONLY);
463 if (fd < 0)
464 goto out;
465
466 while (1) {
467 char bf[BUFSIZ];
468 GElf_Nhdr nhdr;
469 size_t namesz, descsz;
470
471 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
472 break;
473
474 namesz = NOTE_ALIGN(nhdr.n_namesz);
475 descsz = NOTE_ALIGN(nhdr.n_descsz);
476 if (nhdr.n_type == NT_GNU_BUILD_ID &&
477 nhdr.n_namesz == sizeof("GNU")) {
478 if (read(fd, bf, namesz) != (ssize_t)namesz)
479 break;
480 if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
481 size_t sz = min(descsz, size);
482 if (read(fd, build_id, sz) == (ssize_t)sz) {
483 memset(build_id + sz, 0, size - sz);
484 err = 0;
485 break;
486 }
487 } else if (read(fd, bf, descsz) != (ssize_t)descsz)
488 break;
489 } else {
490 int n = namesz + descsz;
491 if (read(fd, bf, n) != n)
492 break;
493 }
494 }
495 close(fd);
496out:
497 return err;
498}
499
500int filename__read_debuglink(const char *filename, char *debuglink,
501 size_t size)
502{
503 int fd, err = -1;
504 Elf *elf;
505 GElf_Ehdr ehdr;
506 GElf_Shdr shdr;
507 Elf_Data *data;
508 Elf_Scn *sec;
509 Elf_Kind ek;
510
511 fd = open(filename, O_RDONLY);
512 if (fd < 0)
513 goto out;
514
515 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
516 if (elf == NULL) {
517 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
518 goto out_close;
519 }
520
521 ek = elf_kind(elf);
522 if (ek != ELF_K_ELF)
784f3390 523 goto out_elf_end;
e5a1845f
NK		 524
525 if (gelf_getehdr(elf, &ehdr) == NULL) {
526 pr_err("%s: cannot get elf header.\n", __func__);
784f3390 527 goto out_elf_end;
e5a1845f
NK		 528 }
529
530 sec = elf_section_by_name(elf, &ehdr, &shdr,
531 ".gnu_debuglink", NULL);
532 if (sec == NULL)
784f3390 533 goto out_elf_end;
e5a1845f
NK		 534
535 data = elf_getdata(sec, NULL);
536 if (data == NULL)
784f3390 537 goto out_elf_end;
e5a1845f
NK		 538
539 /* the start of this section is a zero-terminated string */
540 strncpy(debuglink, data->d_buf, size);
541
0d3dc5e8
SE		 542 err = 0;
543
784f3390 544out_elf_end:
e5a1845f 545 elf_end(elf);
e5a1845f
NK		 546out_close:
547 close(fd);
548out:
549 return err;
550}
551
552static int dso__swap_init(struct dso *dso, unsigned char eidata)
553{
554 static unsigned int const endian = 1;
555
556 dso->needs_swap = DSO_SWAP__NO;
557
558 switch (eidata) {
559 case ELFDATA2LSB:
560 /* We are big endian, DSO is little endian. */
561 if (*(unsigned char const *)&endian != 1)
562 dso->needs_swap = DSO_SWAP__YES;
563 break;
564
565 case ELFDATA2MSB:
566 /* We are little endian, DSO is big endian. */
567 if (*(unsigned char const *)&endian != 0)
568 dso->needs_swap = DSO_SWAP__YES;
569 break;
570
571 default:
572 pr_err("unrecognized DSO data encoding %d\n", eidata);
573 return -EINVAL;
574 }
575
576 return 0;
577}
578
c00c48fc
NK		 579static int decompress_kmodule(struct dso *dso, const char *name,
580 enum dso_binary_type type)
581{
914f85c4 582 int fd = -1;
c00c48fc 583 char tmpbuf[] = "/tmp/perf-kmod-XXXXXX";
914f85c4 584 struct kmod_path m;
c00c48fc 585
0b064f43
NK		 586 if (type != DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP &&
587 type != DSO_BINARY_TYPE__GUEST_KMODULE_COMP &&
588 type != DSO_BINARY_TYPE__BUILD_ID_CACHE)
c00c48fc
NK		 589 return -1;
590
914f85c4
JO		 591 if (type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
592 name = dso->long_name;
593
594 if (kmod_path__parse_ext(&m, name) || !m.comp)
595 return -1;
c00c48fc
NK		 596
597 fd = mkstemp(tmpbuf);
598 if (fd < 0)
914f85c4 599 goto out;
c00c48fc 600
914f85c4 601 if (!decompress_to_file(m.ext, name, fd)) {
c00c48fc
NK		 602 close(fd);
603 fd = -1;
604 }
605
606 unlink(tmpbuf);
607
914f85c4
JO		 608out:
609 free(m.ext);
c00c48fc
NK		 610 return fd;
611}
612
3aafe5ae
CS		 613bool symsrc__possibly_runtime(struct symsrc *ss)
614{
615 return ss->dynsym || ss->opdsec;
616}
617
d26cd12b
CS		 618bool symsrc__has_symtab(struct symsrc *ss)
619{
620 return ss->symtab != NULL;
621}
b68e2f91
CS		 622
623void symsrc__destroy(struct symsrc *ss)
624{
74cf249d 625 zfree(&ss->name);
b68e2f91
CS		 626 elf_end(ss->elf);
627 close(ss->fd);
628}
629
630int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
631 enum dso_binary_type type)
e5a1845f 632{
e5a1845f 633 int err = -1;
e5a1845f 634 GElf_Ehdr ehdr;
e5a1845f 635 Elf *elf;
b68e2f91
CS		 636 int fd;
637
c00c48fc
NK		 638 if (dso__needs_decompress(dso))
639 fd = decompress_kmodule(dso, name, type);
640 else
641 fd = open(name, O_RDONLY);
642
b68e2f91
CS		 643 if (fd < 0)
644 return -1;
e5a1845f
NK		 645
646 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
647 if (elf == NULL) {
648 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
649 goto out_close;
650 }
651
652 if (gelf_getehdr(elf, &ehdr) == NULL) {
653 pr_debug("%s: cannot get elf header.\n", __func__);
654 goto out_elf_end;
655 }
656
657 if (dso__swap_init(dso, ehdr.e_ident[EI_DATA]))
658 goto out_elf_end;
659
660 /* Always reject images with a mismatched build-id: */
661 if (dso->has_build_id) {
662 u8 build_id[BUILD_ID_SIZE];
663
664 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
665 goto out_elf_end;
666
667 if (!dso__build_id_equal(dso, build_id))
668 goto out_elf_end;
669 }
670
c6d8f2a4
AH		 671 ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
672
b68e2f91
CS		 673 ss->symtab = elf_section_by_name(elf, &ehdr, &ss->symshdr, ".symtab",
674 NULL);
675 if (ss->symshdr.sh_type != SHT_SYMTAB)
676 ss->symtab = NULL;
677
678 ss->dynsym_idx = 0;
679 ss->dynsym = elf_section_by_name(elf, &ehdr, &ss->dynshdr, ".dynsym",
680 &ss->dynsym_idx);
681 if (ss->dynshdr.sh_type != SHT_DYNSYM)
682 ss->dynsym = NULL;
683
684 ss->opdidx = 0;
685 ss->opdsec = elf_section_by_name(elf, &ehdr, &ss->opdshdr, ".opd",
686 &ss->opdidx);
687 if (ss->opdshdr.sh_type != SHT_PROGBITS)
688 ss->opdsec = NULL;
689
690 if (dso->kernel == DSO_TYPE_USER) {
691 GElf_Shdr shdr;
692 ss->adjust_symbols = (ehdr.e_type == ET_EXEC ||
0131c4ec 693 ehdr.e_type == ET_REL ||
51682dc7 694 dso__is_vdso(dso) ||
b68e2f91
CS		 695 elf_section_by_name(elf, &ehdr, &shdr,
696 ".gnu.prelink_undo",
697 NULL) != NULL);
698 } else {
0131c4ec
AH		 699 ss->adjust_symbols = ehdr.e_type == ET_EXEC ||
700 ehdr.e_type == ET_REL;
b68e2f91
CS		 701 }
702
703 ss->name = strdup(name);
704 if (!ss->name)
705 goto out_elf_end;
706
707 ss->elf = elf;
708 ss->fd = fd;
709 ss->ehdr = ehdr;
710 ss->type = type;
711
712 return 0;
713
714out_elf_end:
715 elf_end(elf);
716out_close:
717 close(fd);
718 return err;
719}
720
39b12f78
AH		 721/**
722 * ref_reloc_sym_not_found - has kernel relocation symbol been found.
723 * @kmap: kernel maps and relocation reference symbol
724 *
725 * This function returns %true if we are dealing with the kernel maps and the
726 * relocation reference symbol has not yet been found. Otherwise %false is
727 * returned.
728 */
729static bool ref_reloc_sym_not_found(struct kmap *kmap)
730{
731 return kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
732 !kmap->ref_reloc_sym->unrelocated_addr;
733}
734
735/**
736 * ref_reloc - kernel relocation offset.
737 * @kmap: kernel maps and relocation reference symbol
738 *
739 * This function returns the offset of kernel addresses as determined by using
740 * the relocation reference symbol i.e. if the kernel has not been relocated
741 * then the return value is zero.
742 */
743static u64 ref_reloc(struct kmap *kmap)
744{
745 if (kmap && kmap->ref_reloc_sym &&
746 kmap->ref_reloc_sym->unrelocated_addr)
747 return kmap->ref_reloc_sym->addr -
748 kmap->ref_reloc_sym->unrelocated_addr;
749 return 0;
750}
751
763122ad
AK		 752static bool want_demangle(bool is_kernel_sym)
753{
754 return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
755}
756
261360b6
CS		 757int dso__load_sym(struct dso *dso, struct map *map,
758 struct symsrc *syms_ss, struct symsrc *runtime_ss,
d26cd12b 759 symbol_filter_t filter, int kmodule)
b68e2f91
CS		 760{
761 struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
762 struct map *curr_map = map;
763 struct dso *curr_dso = dso;
764 Elf_Data *symstrs, *secstrs;
765 uint32_t nr_syms;
766 int err = -1;
767 uint32_t idx;
768 GElf_Ehdr ehdr;
261360b6 769 GElf_Shdr shdr;
b68e2f91
CS		 770 Elf_Data *syms, *opddata = NULL;
771 GElf_Sym sym;
261360b6 772 Elf_Scn *sec, *sec_strndx;
b68e2f91
CS		 773 Elf *elf;
774 int nr = 0;
39b12f78 775 bool remap_kernel = false, adjust_kernel_syms = false;
b68e2f91 776
261360b6 777 dso->symtab_type = syms_ss->type;
c6d8f2a4 778 dso->is_64_bit = syms_ss->is_64_bit;
0131c4ec
AH		 779 dso->rel = syms_ss->ehdr.e_type == ET_REL;
780
781 /*
782 * Modules may already have symbols from kallsyms, but those symbols
783 * have the wrong values for the dso maps, so remove them.
784 */
785 if (kmodule && syms_ss->symtab)
786 symbols__delete(&dso->symbols[map->type]);
005f9294 787
261360b6 788 if (!syms_ss->symtab) {
d0b0d040
AB		 789 /*
790 * If the vmlinux is stripped, fail so we will fall back
791 * to using kallsyms. The vmlinux runtime symbols aren't
792 * of much use.
793 */
794 if (dso->kernel)
795 goto out_elf_end;
796
261360b6
CS		 797 syms_ss->symtab = syms_ss->dynsym;
798 syms_ss->symshdr = syms_ss->dynshdr;
d26cd12b
CS		 799 }
800
261360b6
CS		 801 elf = syms_ss->elf;
802 ehdr = syms_ss->ehdr;
803 sec = syms_ss->symtab;
804 shdr = syms_ss->symshdr;
b68e2f91 805
261360b6
CS		 806 if (runtime_ss->opdsec)
807 opddata = elf_rawdata(runtime_ss->opdsec, NULL);
e5a1845f
NK		 808
809 syms = elf_getdata(sec, NULL);
810 if (syms == NULL)
811 goto out_elf_end;
812
813 sec = elf_getscn(elf, shdr.sh_link);
814 if (sec == NULL)
815 goto out_elf_end;
816
817 symstrs = elf_getdata(sec, NULL);
818 if (symstrs == NULL)
819 goto out_elf_end;
820
f247fb81 821 sec_strndx = elf_getscn(runtime_ss->elf, runtime_ss->ehdr.e_shstrndx);
e5a1845f
NK		 822 if (sec_strndx == NULL)
823 goto out_elf_end;
824
825 secstrs = elf_getdata(sec_strndx, NULL);
826 if (secstrs == NULL)
827 goto out_elf_end;
828
829 nr_syms = shdr.sh_size / shdr.sh_entsize;
830
831 memset(&sym, 0, sizeof(sym));
39b12f78
AH		 832
833 /*
834 * The kernel relocation symbol is needed in advance in order to adjust
835 * kernel maps correctly.
836 */
837 if (ref_reloc_sym_not_found(kmap)) {
838 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
839 const char *elf_name = elf_sym__name(&sym, symstrs);
840
841 if (strcmp(elf_name, kmap->ref_reloc_sym->name))
842 continue;
843 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
9176753d
AH		 844 map->reloc = kmap->ref_reloc_sym->addr -
845 kmap->ref_reloc_sym->unrelocated_addr;
39b12f78
AH		 846 break;
847 }
848 }
849
850 dso->adjust_symbols = runtime_ss->adjust_symbols || ref_reloc(kmap);
851 /*
852 * Initial kernel and module mappings do not map to the dso. For
853 * function mappings, flag the fixups.
854 */
855 if (map->type == MAP__FUNCTION && (dso->kernel || kmodule)) {
856 remap_kernel = true;
857 adjust_kernel_syms = dso->adjust_symbols;
858 }
e5a1845f
NK		 859 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
860 struct symbol *f;
861 const char *elf_name = elf_sym__name(&sym, symstrs);
862 char *demangled = NULL;
863 int is_label = elf_sym__is_label(&sym);
864 const char *section_name;
261360b6 865 bool used_opd = false;
e5a1845f 866
e5a1845f
NK		 867 if (!is_label && !elf_sym__is_a(&sym, map->type))
868 continue;
869
870 /* Reject ARM ELF "mapping symbols": these aren't unique and
871 * don't identify functions, so will confuse the profile
872 * output: */
4886f2ca
VK		 873 if (ehdr.e_machine == EM_ARM || ehdr.e_machine == EM_AARCH64) {
874 if (elf_name[0] == '$' && strchr("adtx", elf_name[1])
875 && (elf_name[2] == '\0' || elf_name[2] == '.'))
e5a1845f
NK		 876 continue;
877 }
878
261360b6
CS		 879 if (runtime_ss->opdsec && sym.st_shndx == runtime_ss->opdidx) {
880 u32 offset = sym.st_value - syms_ss->opdshdr.sh_addr;
e5a1845f
NK		 881 u64 *opd = opddata->d_buf + offset;
882 sym.st_value = DSO__SWAP(dso, u64, *opd);
261360b6
CS		 883 sym.st_shndx = elf_addr_to_index(runtime_ss->elf,
884 sym.st_value);
885 used_opd = true;
e5a1845f 886 }
3843b05d
NK		 887 /*
888 * When loading symbols in a data mapping, ABS symbols (which
889 * has a value of SHN_ABS in its st_shndx) failed at
890 * elf_getscn(). And it marks the loading as a failure so
891 * already loaded symbols cannot be fixed up.
892 *
893 * I'm not sure what should be done. Just ignore them for now.
894 * - Namhyung Kim
895 */
896 if (sym.st_shndx == SHN_ABS)
897 continue;
e5a1845f 898
261360b6 899 sec = elf_getscn(runtime_ss->elf, sym.st_shndx);
e5a1845f
NK		 900 if (!sec)
901 goto out_elf_end;
902
903 gelf_getshdr(sec, &shdr);
904
905 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
906 continue;
907
908 section_name = elf_sec__name(&shdr, secstrs);
909
910 /* On ARM, symbols for thumb functions have 1 added to
911 * the symbol address as a flag - remove it */
912 if ((ehdr.e_machine == EM_ARM) &&
913 (map->type == MAP__FUNCTION) &&
914 (sym.st_value & 1))
915 --sym.st_value;
916
39b12f78 917 if (dso->kernel || kmodule) {
e5a1845f
NK		 918 char dso_name[PATH_MAX];
919
39b12f78
AH		 920 /* Adjust symbol to map to file offset */
921 if (adjust_kernel_syms)
922 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
923
e5a1845f
NK		 924 if (strcmp(section_name,
925 (curr_dso->short_name +
926 dso->short_name_len)) == 0)
927 goto new_symbol;
928
929 if (strcmp(section_name, ".text") == 0) {
39b12f78
AH		 930 /*
931 * The initial kernel mapping is based on
932 * kallsyms and identity maps. Overwrite it to
933 * map to the kernel dso.
934 */
935 if (remap_kernel && dso->kernel) {
936 remap_kernel = false;
937 map->start = shdr.sh_addr +
938 ref_reloc(kmap);
939 map->end = map->start + shdr.sh_size;
940 map->pgoff = shdr.sh_offset;
941 map->map_ip = map__map_ip;
942 map->unmap_ip = map__unmap_ip;
943 /* Ensure maps are correctly ordered */
944 map_groups__remove(kmap->kmaps, map);
945 map_groups__insert(kmap->kmaps, map);
946 }
947
0131c4ec
AH		 948 /*
949 * The initial module mapping is based on
950 * /proc/modules mapped to offset zero.
951 * Overwrite it to map to the module dso.
952 */
953 if (remap_kernel && kmodule) {
954 remap_kernel = false;
955 map->pgoff = shdr.sh_offset;
956 }
957
e5a1845f
NK		 958 curr_map = map;
959 curr_dso = dso;
960 goto new_symbol;
961 }
962
0131c4ec
AH		 963 if (!kmap)
964 goto new_symbol;
965
e5a1845f
NK		 966 snprintf(dso_name, sizeof(dso_name),
967 "%s%s", dso->short_name, section_name);
968
969 curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
970 if (curr_map == NULL) {
971 u64 start = sym.st_value;
972
973 if (kmodule)
974 start += map->start + shdr.sh_offset;
975
976 curr_dso = dso__new(dso_name);
977 if (curr_dso == NULL)
978 goto out_elf_end;
979 curr_dso->kernel = dso->kernel;
980 curr_dso->long_name = dso->long_name;
981 curr_dso->long_name_len = dso->long_name_len;
982 curr_map = map__new2(start, curr_dso,
983 map->type);
984 if (curr_map == NULL) {
985 dso__delete(curr_dso);
986 goto out_elf_end;
987 }
39b12f78
AH		 988 if (adjust_kernel_syms) {
989 curr_map->start = shdr.sh_addr +
990 ref_reloc(kmap);
991 curr_map->end = curr_map->start +
992 shdr.sh_size;
993 curr_map->pgoff = shdr.sh_offset;
994 } else {
995 curr_map->map_ip = identity__map_ip;
996 curr_map->unmap_ip = identity__map_ip;
997 }
e5a1845f
NK		 998 curr_dso->symtab_type = dso->symtab_type;
999 map_groups__insert(kmap->kmaps, curr_map);
8fa7d87f
WL		 1000 /*
1001 * The new DSO should go to the kernel DSOS
1002 */
1003 dsos__add(&map->groups->machine->kernel_dsos,
1004 curr_dso);
e5a1845f
NK		 1005 dso__set_loaded(curr_dso, map->type);
1006 } else
1007 curr_dso = curr_map->dso;
1008
1009 goto new_symbol;
1010 }
1011
261360b6
CS		 1012 if ((used_opd && runtime_ss->adjust_symbols)
1013 || (!used_opd && syms_ss->adjust_symbols)) {
e5a1845f
NK		 1014 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1015 "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1016 (u64)sym.st_value, (u64)shdr.sh_addr,
1017 (u64)shdr.sh_offset);
1018 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1019 }
950b8354 1020new_symbol:
e5a1845f
NK		 1021 /*
1022 * We need to figure out if the object was created from C++ sources
1023 * DWARF DW_compile_unit has this, but we don't always have access
1024 * to it...
1025 */
763122ad 1026 if (want_demangle(dso->kernel || kmodule)) {
e71e7945
NK		 1027 int demangle_flags = DMGL_NO_OPTS;
1028 if (verbose)
1029 demangle_flags = DMGL_PARAMS | DMGL_ANSI;
1030
1031 demangled = bfd_demangle(NULL, elf_name, demangle_flags);
328ccdac
NK		 1032 if (demangled != NULL)
1033 elf_name = demangled;
1034 }
e5a1845f
NK		 1035 f = symbol__new(sym.st_value, sym.st_size,
1036 GELF_ST_BIND(sym.st_info), elf_name);
1037 free(demangled);
1038 if (!f)
1039 goto out_elf_end;
1040
1041 if (filter && filter(curr_map, f))
1042 symbol__delete(f);
1043 else {
1044 symbols__insert(&curr_dso->symbols[curr_map->type], f);
1045 nr++;
1046 }
1047 }
1048
1049 /*
1050 * For misannotated, zeroed, ASM function sizes.
1051 */
1052 if (nr > 0) {
680d926a
NK		 1053 if (!symbol_conf.allow_aliases)
1054 symbols__fixup_duplicate(&dso->symbols[map->type]);
e5a1845f
NK		 1055 symbols__fixup_end(&dso->symbols[map->type]);
1056 if (kmap) {
1057 /*
1058 * We need to fixup this here too because we create new
1059 * maps here, for things like vsyscall sections.
1060 */
1061 __map_groups__fixup_end(kmap->kmaps, map->type);
1062 }
1063 }
1064 err = nr;
1065out_elf_end:
e5a1845f
NK		 1066 return err;
1067}
1068
8e0cf965
AH		 1069static int elf_read_maps(Elf *elf, bool exe, mapfn_t mapfn, void *data)
1070{
1071 GElf_Phdr phdr;
1072 size_t i, phdrnum;
1073 int err;
1074 u64 sz;
1075
1076 if (elf_getphdrnum(elf, &phdrnum))
1077 return -1;
1078
1079 for (i = 0; i < phdrnum; i++) {
1080 if (gelf_getphdr(elf, i, &phdr) == NULL)
1081 return -1;
1082 if (phdr.p_type != PT_LOAD)
1083 continue;
1084 if (exe) {
1085 if (!(phdr.p_flags & PF_X))
1086 continue;
1087 } else {
1088 if (!(phdr.p_flags & PF_R))
1089 continue;
1090 }
1091 sz = min(phdr.p_memsz, phdr.p_filesz);
1092 if (!sz)
1093 continue;
1094 err = mapfn(phdr.p_vaddr, sz, phdr.p_offset, data);
1095 if (err)
1096 return err;
1097 }
1098 return 0;
1099}
1100
1101int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
1102 bool *is_64_bit)
1103{
1104 int err;
1105 Elf *elf;
1106
1107 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1108 if (elf == NULL)
1109 return -1;
1110
1111 if (is_64_bit)
1112 *is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
1113
1114 err = elf_read_maps(elf, exe, mapfn, data);
1115
1116 elf_end(elf);
1117 return err;
1118}
1119
2b5b8bb2
AH		 1120enum dso_type dso__type_fd(int fd)
1121{
1122 enum dso_type dso_type = DSO__TYPE_UNKNOWN;
1123 GElf_Ehdr ehdr;
1124 Elf_Kind ek;
1125 Elf *elf;
1126
1127 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1128 if (elf == NULL)
1129 goto out;
1130
1131 ek = elf_kind(elf);
1132 if (ek != ELF_K_ELF)
1133 goto out_end;
1134
1135 if (gelf_getclass(elf) == ELFCLASS64) {
1136 dso_type = DSO__TYPE_64BIT;
1137 goto out_end;
1138 }
1139
1140 if (gelf_getehdr(elf, &ehdr) == NULL)
1141 goto out_end;
1142
1143 if (ehdr.e_machine == EM_X86_64)
1144 dso_type = DSO__TYPE_X32BIT;
1145 else
1146 dso_type = DSO__TYPE_32BIT;
1147out_end:
1148 elf_end(elf);
1149out:
1150 return dso_type;
1151}
1152
afba19d9
AH		 1153static int copy_bytes(int from, off_t from_offs, int to, off_t to_offs, u64 len)
1154{
1155 ssize_t r;
1156 size_t n;
1157 int err = -1;
1158 char *buf = malloc(page_size);
1159
1160 if (buf == NULL)
1161 return -1;
1162
1163 if (lseek(to, to_offs, SEEK_SET) != to_offs)
1164 goto out;
1165
1166 if (lseek(from, from_offs, SEEK_SET) != from_offs)
1167 goto out;
1168
1169 while (len) {
1170 n = page_size;
1171 if (len < n)
1172 n = len;
1173 /* Use read because mmap won't work on proc files */
1174 r = read(from, buf, n);
1175 if (r < 0)
1176 goto out;
1177 if (!r)
1178 break;
1179 n = r;
1180 r = write(to, buf, n);
1181 if (r < 0)
1182 goto out;
1183 if ((size_t)r != n)
1184 goto out;
1185 len -= n;
1186 }
1187
1188 err = 0;
1189out:
1190 free(buf);
1191 return err;
1192}
1193
1194struct kcore {
1195 int fd;
1196 int elfclass;
1197 Elf *elf;
1198 GElf_Ehdr ehdr;
1199};
1200
1201static int kcore__open(struct kcore *kcore, const char *filename)
1202{
1203 GElf_Ehdr *ehdr;
1204
1205 kcore->fd = open(filename, O_RDONLY);
1206 if (kcore->fd == -1)
1207 return -1;
1208
1209 kcore->elf = elf_begin(kcore->fd, ELF_C_READ, NULL);
1210 if (!kcore->elf)
1211 goto out_close;
1212
1213 kcore->elfclass = gelf_getclass(kcore->elf);
1214 if (kcore->elfclass == ELFCLASSNONE)
1215 goto out_end;
1216
1217 ehdr = gelf_getehdr(kcore->elf, &kcore->ehdr);
1218 if (!ehdr)
1219 goto out_end;
1220
1221 return 0;
1222
1223out_end:
1224 elf_end(kcore->elf);
1225out_close:
1226 close(kcore->fd);
1227 return -1;
1228}
1229
1230static int kcore__init(struct kcore *kcore, char *filename, int elfclass,
1231 bool temp)
1232{
1233 GElf_Ehdr *ehdr;
1234
1235 kcore->elfclass = elfclass;
1236
1237 if (temp)
1238 kcore->fd = mkstemp(filename);
1239 else
1240 kcore->fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0400);
1241 if (kcore->fd == -1)
1242 return -1;
1243
1244 kcore->elf = elf_begin(kcore->fd, ELF_C_WRITE, NULL);
1245 if (!kcore->elf)
1246 goto out_close;
1247
1248 if (!gelf_newehdr(kcore->elf, elfclass))
1249 goto out_end;
1250
1251 ehdr = gelf_getehdr(kcore->elf, &kcore->ehdr);
1252 if (!ehdr)
1253 goto out_end;
1254
1255 return 0;
1256
1257out_end:
1258 elf_end(kcore->elf);
1259out_close:
1260 close(kcore->fd);
1261 unlink(filename);
1262 return -1;
1263}
1264
1265static void kcore__close(struct kcore *kcore)
1266{
1267 elf_end(kcore->elf);
1268 close(kcore->fd);
1269}
1270
1271static int kcore__copy_hdr(struct kcore *from, struct kcore *to, size_t count)
1272{
1273 GElf_Ehdr *ehdr = &to->ehdr;
1274 GElf_Ehdr *kehdr = &from->ehdr;
1275
1276 memcpy(ehdr->e_ident, kehdr->e_ident, EI_NIDENT);
1277 ehdr->e_type = kehdr->e_type;
1278 ehdr->e_machine = kehdr->e_machine;
1279 ehdr->e_version = kehdr->e_version;
1280 ehdr->e_entry = 0;
1281 ehdr->e_shoff = 0;
1282 ehdr->e_flags = kehdr->e_flags;
1283 ehdr->e_phnum = count;
1284 ehdr->e_shentsize = 0;
1285 ehdr->e_shnum = 0;
1286 ehdr->e_shstrndx = 0;
1287
1288 if (from->elfclass == ELFCLASS32) {
1289 ehdr->e_phoff = sizeof(Elf32_Ehdr);
1290 ehdr->e_ehsize = sizeof(Elf32_Ehdr);
1291 ehdr->e_phentsize = sizeof(Elf32_Phdr);
1292 } else {
1293 ehdr->e_phoff = sizeof(Elf64_Ehdr);
1294 ehdr->e_ehsize = sizeof(Elf64_Ehdr);
1295 ehdr->e_phentsize = sizeof(Elf64_Phdr);
1296 }
1297
1298 if (!gelf_update_ehdr(to->elf, ehdr))
1299 return -1;
1300
1301 if (!gelf_newphdr(to->elf, count))
1302 return -1;
1303
1304 return 0;
1305}
1306
1307static int kcore__add_phdr(struct kcore *kcore, int idx, off_t offset,
1308 u64 addr, u64 len)
1309{
1310 GElf_Phdr gphdr;
1311 GElf_Phdr *phdr;
1312
1313 phdr = gelf_getphdr(kcore->elf, idx, &gphdr);
1314 if (!phdr)
1315 return -1;
1316
1317 phdr->p_type = PT_LOAD;
1318 phdr->p_flags = PF_R | PF_W | PF_X;
1319 phdr->p_offset = offset;
1320 phdr->p_vaddr = addr;
1321 phdr->p_paddr = 0;
1322 phdr->p_filesz = len;
1323 phdr->p_memsz = len;
1324 phdr->p_align = page_size;
1325
1326 if (!gelf_update_phdr(kcore->elf, idx, phdr))
1327 return -1;
1328
1329 return 0;
1330}
1331
1332static off_t kcore__write(struct kcore *kcore)
1333{
1334 return elf_update(kcore->elf, ELF_C_WRITE);
1335}
1336
fc1b691d
AH		 1337struct phdr_data {
1338 off_t offset;
1339 u64 addr;
1340 u64 len;
1341};
1342
1343struct kcore_copy_info {
1344 u64 stext;
1345 u64 etext;
1346 u64 first_symbol;
1347 u64 last_symbol;
1348 u64 first_module;
1349 u64 last_module_symbol;
1350 struct phdr_data kernel_map;
1351 struct phdr_data modules_map;
1352};
1353
1354static int kcore_copy__process_kallsyms(void *arg, const char *name, char type,
1355 u64 start)
1356{
1357 struct kcore_copy_info *kci = arg;
1358
1359 if (!symbol_type__is_a(type, MAP__FUNCTION))
1360 return 0;
1361
1362 if (strchr(name, '[')) {
1363 if (start > kci->last_module_symbol)
1364 kci->last_module_symbol = start;
1365 return 0;
1366 }
1367
1368 if (!kci->first_symbol || start < kci->first_symbol)
1369 kci->first_symbol = start;
1370
1371 if (!kci->last_symbol || start > kci->last_symbol)
1372 kci->last_symbol = start;
1373
1374 if (!strcmp(name, "_stext")) {
1375 kci->stext = start;
1376 return 0;
1377 }
1378
1379 if (!strcmp(name, "_etext")) {
1380 kci->etext = start;
1381 return 0;
1382 }
1383
1384 return 0;
1385}
1386
1387static int kcore_copy__parse_kallsyms(struct kcore_copy_info *kci,
1388 const char *dir)
1389{
1390 char kallsyms_filename[PATH_MAX];
1391
1392 scnprintf(kallsyms_filename, PATH_MAX, "%s/kallsyms", dir);
1393
1394 if (symbol__restricted_filename(kallsyms_filename, "/proc/kallsyms"))
1395 return -1;
1396
1397 if (kallsyms__parse(kallsyms_filename, kci,
1398 kcore_copy__process_kallsyms) < 0)
1399 return -1;
1400
1401 return 0;
1402}
1403
1404static int kcore_copy__process_modules(void *arg,
1405 const char *name __maybe_unused,
1406 u64 start)
1407{
1408 struct kcore_copy_info *kci = arg;
1409
1410 if (!kci->first_module || start < kci->first_module)
1411 kci->first_module = start;
1412
1413 return 0;
1414}
1415
1416static int kcore_copy__parse_modules(struct kcore_copy_info *kci,
1417 const char *dir)
1418{
1419 char modules_filename[PATH_MAX];
1420
1421 scnprintf(modules_filename, PATH_MAX, "%s/modules", dir);
1422
1423 if (symbol__restricted_filename(modules_filename, "/proc/modules"))
1424 return -1;
1425
1426 if (modules__parse(modules_filename, kci,
1427 kcore_copy__process_modules) < 0)
1428 return -1;
1429
1430 return 0;
1431}
1432
1433static void kcore_copy__map(struct phdr_data *p, u64 start, u64 end, u64 pgoff,
1434 u64 s, u64 e)
1435{
1436 if (p->addr || s < start || s >= end)
1437 return;
1438
1439 p->addr = s;
1440 p->offset = (s - start) + pgoff;
1441 p->len = e < end ? e - s : end - s;
1442}
1443
1444static int kcore_copy__read_map(u64 start, u64 len, u64 pgoff, void *data)
1445{
1446 struct kcore_copy_info *kci = data;
1447 u64 end = start + len;
1448
1449 kcore_copy__map(&kci->kernel_map, start, end, pgoff, kci->stext,
1450 kci->etext);
1451
1452 kcore_copy__map(&kci->modules_map, start, end, pgoff, kci->first_module,
1453 kci->last_module_symbol);
1454
1455 return 0;
1456}
1457
1458static int kcore_copy__read_maps(struct kcore_copy_info *kci, Elf *elf)
1459{
1460 if (elf_read_maps(elf, true, kcore_copy__read_map, kci) < 0)
1461 return -1;
1462
1463 return 0;
1464}
1465
1466static int kcore_copy__calc_maps(struct kcore_copy_info *kci, const char *dir,
1467 Elf *elf)
1468{
1469 if (kcore_copy__parse_kallsyms(kci, dir))
1470 return -1;
1471
1472 if (kcore_copy__parse_modules(kci, dir))
1473 return -1;
1474
1475 if (kci->stext)
1476 kci->stext = round_down(kci->stext, page_size);
1477 else
1478 kci->stext = round_down(kci->first_symbol, page_size);
1479
1480 if (kci->etext) {
1481 kci->etext = round_up(kci->etext, page_size);
1482 } else if (kci->last_symbol) {
1483 kci->etext = round_up(kci->last_symbol, page_size);
1484 kci->etext += page_size;
1485 }
1486
1487 kci->first_module = round_down(kci->first_module, page_size);
1488
1489 if (kci->last_module_symbol) {
1490 kci->last_module_symbol = round_up(kci->last_module_symbol,
1491 page_size);
1492 kci->last_module_symbol += page_size;
1493 }
1494
1495 if (!kci->stext || !kci->etext)
1496 return -1;
1497
1498 if (kci->first_module && !kci->last_module_symbol)
1499 return -1;
1500
1501 return kcore_copy__read_maps(kci, elf);
1502}
1503
1504static int kcore_copy__copy_file(const char *from_dir, const char *to_dir,
1505 const char *name)
1506{
1507 char from_filename[PATH_MAX];
1508 char to_filename[PATH_MAX];
1509
1510 scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
1511 scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
1512
1513 return copyfile_mode(from_filename, to_filename, 0400);
1514}
1515
1516static int kcore_copy__unlink(const char *dir, const char *name)
1517{
1518 char filename[PATH_MAX];
1519
1520 scnprintf(filename, PATH_MAX, "%s/%s", dir, name);
1521
1522 return unlink(filename);
1523}
1524
1525static int kcore_copy__compare_fds(int from, int to)
1526{
1527 char *buf_from;
1528 char *buf_to;
1529 ssize_t ret;
1530 size_t len;
1531 int err = -1;
1532
1533 buf_from = malloc(page_size);
1534 buf_to = malloc(page_size);
1535 if (!buf_from || !buf_to)
1536 goto out;
1537
1538 while (1) {
1539 /* Use read because mmap won't work on proc files */
1540 ret = read(from, buf_from, page_size);
1541 if (ret < 0)
1542 goto out;
1543
1544 if (!ret)
1545 break;
1546
1547 len = ret;
1548
1549 if (readn(to, buf_to, len) != (int)len)
1550 goto out;
1551
1552 if (memcmp(buf_from, buf_to, len))
1553 goto out;
1554 }
1555
1556 err = 0;
1557out:
1558 free(buf_to);
1559 free(buf_from);
1560 return err;
1561}
1562
1563static int kcore_copy__compare_files(const char *from_filename,
1564 const char *to_filename)
1565{
1566 int from, to, err = -1;
1567
1568 from = open(from_filename, O_RDONLY);
1569 if (from < 0)
1570 return -1;
1571
1572 to = open(to_filename, O_RDONLY);
1573 if (to < 0)
1574 goto out_close_from;
1575
1576 err = kcore_copy__compare_fds(from, to);
1577
1578 close(to);
1579out_close_from:
1580 close(from);
1581 return err;
1582}
1583
1584static int kcore_copy__compare_file(const char *from_dir, const char *to_dir,
1585 const char *name)
1586{
1587 char from_filename[PATH_MAX];
1588 char to_filename[PATH_MAX];
1589
1590 scnprintf(from_filename, PATH_MAX, "%s/%s", from_dir, name);
1591 scnprintf(to_filename, PATH_MAX, "%s/%s", to_dir, name);
1592
1593 return kcore_copy__compare_files(from_filename, to_filename);
1594}
1595
1596/**
1597 * kcore_copy - copy kallsyms, modules and kcore from one directory to another.
1598 * @from_dir: from directory
1599 * @to_dir: to directory
1600 *
1601 * This function copies kallsyms, modules and kcore files from one directory to
1602 * another. kallsyms and modules are copied entirely. Only code segments are
1603 * copied from kcore. It is assumed that two segments suffice: one for the
1604 * kernel proper and one for all the modules. The code segments are determined
1605 * from kallsyms and modules files. The kernel map starts at _stext or the
1606 * lowest function symbol, and ends at _etext or the highest function symbol.
1607 * The module map starts at the lowest module address and ends at the highest
1608 * module symbol. Start addresses are rounded down to the nearest page. End
1609 * addresses are rounded up to the nearest page. An extra page is added to the
1610 * highest kernel symbol and highest module symbol to, hopefully, encompass that
1611 * symbol too. Because it contains only code sections, the resulting kcore is
1612 * unusual. One significant peculiarity is that the mapping (start -> pgoff)
1613 * is not the same for the kernel map and the modules map. That happens because
1614 * the data is copied adjacently whereas the original kcore has gaps. Finally,
1615 * kallsyms and modules files are compared with their copies to check that
1616 * modules have not been loaded or unloaded while the copies were taking place.
1617 *
1618 * Return: %0 on success, %-1 on failure.
1619 */
1620int kcore_copy(const char *from_dir, const char *to_dir)
1621{
1622 struct kcore kcore;
1623 struct kcore extract;
1624 size_t count = 2;
1625 int idx = 0, err = -1;
1626 off_t offset = page_size, sz, modules_offset = 0;
1627 struct kcore_copy_info kci = { .stext = 0, };
1628 char kcore_filename[PATH_MAX];
1629 char extract_filename[PATH_MAX];
1630
1631 if (kcore_copy__copy_file(from_dir, to_dir, "kallsyms"))
1632 return -1;
1633
1634 if (kcore_copy__copy_file(from_dir, to_dir, "modules"))
1635 goto out_unlink_kallsyms;
1636
1637 scnprintf(kcore_filename, PATH_MAX, "%s/kcore", from_dir);
1638 scnprintf(extract_filename, PATH_MAX, "%s/kcore", to_dir);
1639
1640 if (kcore__open(&kcore, kcore_filename))
1641 goto out_unlink_modules;
1642
1643 if (kcore_copy__calc_maps(&kci, from_dir, kcore.elf))
1644 goto out_kcore_close;
1645
1646 if (kcore__init(&extract, extract_filename, kcore.elfclass, false))
1647 goto out_kcore_close;
1648
1649 if (!kci.modules_map.addr)
1650 count -= 1;
1651
1652 if (kcore__copy_hdr(&kcore, &extract, count))
1653 goto out_extract_close;
1654
1655 if (kcore__add_phdr(&extract, idx++, offset, kci.kernel_map.addr,
1656 kci.kernel_map.len))
1657 goto out_extract_close;
1658
1659 if (kci.modules_map.addr) {
1660 modules_offset = offset + kci.kernel_map.len;
1661 if (kcore__add_phdr(&extract, idx, modules_offset,
1662 kci.modules_map.addr, kci.modules_map.len))
1663 goto out_extract_close;
1664 }
1665
1666 sz = kcore__write(&extract);
1667 if (sz < 0 || sz > offset)
1668 goto out_extract_close;
1669
1670 if (copy_bytes(kcore.fd, kci.kernel_map.offset, extract.fd, offset,
1671 kci.kernel_map.len))
1672 goto out_extract_close;
1673
1674 if (modules_offset && copy_bytes(kcore.fd, kci.modules_map.offset,
1675 extract.fd, modules_offset,
1676 kci.modules_map.len))
1677 goto out_extract_close;
1678
1679 if (kcore_copy__compare_file(from_dir, to_dir, "modules"))
1680 goto out_extract_close;
1681
1682 if (kcore_copy__compare_file(from_dir, to_dir, "kallsyms"))
1683 goto out_extract_close;
1684
1685 err = 0;
1686
1687out_extract_close:
1688 kcore__close(&extract);
1689 if (err)
1690 unlink(extract_filename);
1691out_kcore_close:
1692 kcore__close(&kcore);
1693out_unlink_modules:
1694 if (err)
1695 kcore_copy__unlink(to_dir, "modules");
1696out_unlink_kallsyms:
1697 if (err)
1698 kcore_copy__unlink(to_dir, "kallsyms");
1699
1700 return err;
1701}
1702
afba19d9
AH		 1703int kcore_extract__create(struct kcore_extract *kce)
1704{
1705 struct kcore kcore;
1706 struct kcore extract;
1707 size_t count = 1;
1708 int idx = 0, err = -1;
1709 off_t offset = page_size, sz;
1710
1711 if (kcore__open(&kcore, kce->kcore_filename))
1712 return -1;
1713
1714 strcpy(kce->extract_filename, PERF_KCORE_EXTRACT);
1715 if (kcore__init(&extract, kce->extract_filename, kcore.elfclass, true))
1716 goto out_kcore_close;
1717
1718 if (kcore__copy_hdr(&kcore, &extract, count))
1719 goto out_extract_close;
1720
1721 if (kcore__add_phdr(&extract, idx, offset, kce->addr, kce->len))
1722 goto out_extract_close;
1723
1724 sz = kcore__write(&extract);
1725 if (sz < 0 || sz > offset)
1726 goto out_extract_close;
1727
1728 if (copy_bytes(kcore.fd, kce->offs, extract.fd, offset, kce->len))
1729 goto out_extract_close;
1730
1731 err = 0;
1732
1733out_extract_close:
1734 kcore__close(&extract);
1735 if (err)
1736 unlink(kce->extract_filename);
1737out_kcore_close:
1738 kcore__close(&kcore);
1739
1740 return err;
1741}
1742
1743void kcore_extract__delete(struct kcore_extract *kce)
1744{
1745 unlink(kce->extract_filename);
1746}
1747
e5a1845f
NK		 1748void symbol__elf_init(void)
1749{
1750 elf_version(EV_CURRENT);
1751}
Linux 6.x block layer and io_uring tree(s)