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