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