11 #include <sys/param.h>
23 #include <sys/utsname.h>
25 #ifndef NT_GNU_BUILD_ID
26 #define NT_GNU_BUILD_ID 3
29 static bool dso__build_id_equal(const struct dso
*self
, u8
*build_id
);
30 static int elf_read_build_id(Elf
*elf
, void *bf
, size_t size
);
31 static void dsos__add(struct list_head
*head
, struct dso
*dso
);
32 static struct map
*map__new2(u64 start
, struct dso
*dso
, enum map_type type
);
33 static int dso__load_kernel_sym(struct dso
*self
, struct map
*map
,
34 symbol_filter_t filter
);
35 static int dso__load_guest_kernel_sym(struct dso
*self
, struct map
*map
,
36 symbol_filter_t filter
);
37 static int vmlinux_path__nr_entries
;
38 static char **vmlinux_path
;
40 struct symbol_conf symbol_conf
= {
41 .exclude_other
= true,
43 .try_vmlinux_path
= true,
46 int dso__name_len(const struct dso
*self
)
49 return self
->long_name_len
;
51 return self
->short_name_len
;
54 bool dso__loaded(const struct dso
*self
, enum map_type type
)
56 return self
->loaded
& (1 << type
);
59 bool dso__sorted_by_name(const struct dso
*self
, enum map_type type
)
61 return self
->sorted_by_name
& (1 << type
);
64 static void dso__set_sorted_by_name(struct dso
*self
, enum map_type type
)
66 self
->sorted_by_name
|= (1 << type
);
69 bool symbol_type__is_a(char symbol_type
, enum map_type map_type
)
73 return symbol_type
== 'T' || symbol_type
== 'W';
75 return symbol_type
== 'D' || symbol_type
== 'd';
81 static void symbols__fixup_end(struct rb_root
*self
)
83 struct rb_node
*nd
, *prevnd
= rb_first(self
);
84 struct symbol
*curr
, *prev
;
89 curr
= rb_entry(prevnd
, struct symbol
, rb_node
);
91 for (nd
= rb_next(prevnd
); nd
; nd
= rb_next(nd
)) {
93 curr
= rb_entry(nd
, struct symbol
, rb_node
);
95 if (prev
->end
== prev
->start
)
96 prev
->end
= curr
->start
- 1;
100 if (curr
->end
== curr
->start
)
101 curr
->end
= roundup(curr
->start
, 4096);
104 static void __map_groups__fixup_end(struct map_groups
*self
, enum map_type type
)
106 struct map
*prev
, *curr
;
107 struct rb_node
*nd
, *prevnd
= rb_first(&self
->maps
[type
]);
112 curr
= rb_entry(prevnd
, struct map
, rb_node
);
114 for (nd
= rb_next(prevnd
); nd
; nd
= rb_next(nd
)) {
116 curr
= rb_entry(nd
, struct map
, rb_node
);
117 prev
->end
= curr
->start
- 1;
121 * We still haven't the actual symbols, so guess the
122 * last map final address.
127 static void map_groups__fixup_end(struct map_groups
*self
)
130 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
131 __map_groups__fixup_end(self
, i
);
134 static struct symbol
*symbol__new(u64 start
, u64 len
, u8 binding
,
137 size_t namelen
= strlen(name
) + 1;
138 struct symbol
*self
= calloc(1, (symbol_conf
.priv_size
+
139 sizeof(*self
) + namelen
));
143 if (symbol_conf
.priv_size
)
144 self
= ((void *)self
) + symbol_conf
.priv_size
;
147 self
->end
= len
? start
+ len
- 1 : start
;
148 self
->binding
= binding
;
149 self
->namelen
= namelen
- 1;
151 pr_debug4("%s: %s %#Lx-%#Lx\n", __func__
, name
, start
, self
->end
);
153 memcpy(self
->name
, name
, namelen
);
158 void symbol__delete(struct symbol
*self
)
160 free(((void *)self
) - symbol_conf
.priv_size
);
163 static size_t symbol__fprintf(struct symbol
*self
, FILE *fp
)
165 return fprintf(fp
, " %llx-%llx %c %s\n",
166 self
->start
, self
->end
,
167 self
->binding
== STB_GLOBAL
? 'g' :
168 self
->binding
== STB_LOCAL
? 'l' : 'w',
172 void dso__set_long_name(struct dso
*self
, char *name
)
176 self
->long_name
= name
;
177 self
->long_name_len
= strlen(name
);
180 static void dso__set_short_name(struct dso
*self
, const char *name
)
184 self
->short_name
= name
;
185 self
->short_name_len
= strlen(name
);
188 static void dso__set_basename(struct dso
*self
)
190 dso__set_short_name(self
, basename(self
->long_name
));
193 struct dso
*dso__new(const char *name
)
195 struct dso
*self
= calloc(1, sizeof(*self
) + strlen(name
) + 1);
199 strcpy(self
->name
, name
);
200 dso__set_long_name(self
, self
->name
);
201 dso__set_short_name(self
, self
->name
);
202 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
203 self
->symbols
[i
] = self
->symbol_names
[i
] = RB_ROOT
;
204 self
->slen_calculated
= 0;
205 self
->origin
= DSO__ORIG_NOT_FOUND
;
207 self
->sorted_by_name
= 0;
208 self
->has_build_id
= 0;
209 self
->kernel
= DSO_TYPE_USER
;
210 INIT_LIST_HEAD(&self
->node
);
216 static void symbols__delete(struct rb_root
*self
)
219 struct rb_node
*next
= rb_first(self
);
222 pos
= rb_entry(next
, struct symbol
, rb_node
);
223 next
= rb_next(&pos
->rb_node
);
224 rb_erase(&pos
->rb_node
, self
);
229 void dso__delete(struct dso
*self
)
232 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
233 symbols__delete(&self
->symbols
[i
]);
234 if (self
->sname_alloc
)
235 free((char *)self
->short_name
);
236 if (self
->lname_alloc
)
237 free(self
->long_name
);
241 void dso__set_build_id(struct dso
*self
, void *build_id
)
243 memcpy(self
->build_id
, build_id
, sizeof(self
->build_id
));
244 self
->has_build_id
= 1;
247 static void symbols__insert(struct rb_root
*self
, struct symbol
*sym
)
249 struct rb_node
**p
= &self
->rb_node
;
250 struct rb_node
*parent
= NULL
;
251 const u64 ip
= sym
->start
;
256 s
= rb_entry(parent
, struct symbol
, rb_node
);
262 rb_link_node(&sym
->rb_node
, parent
, p
);
263 rb_insert_color(&sym
->rb_node
, self
);
266 static struct symbol
*symbols__find(struct rb_root
*self
, u64 ip
)
276 struct symbol
*s
= rb_entry(n
, struct symbol
, rb_node
);
280 else if (ip
> s
->end
)
289 struct symbol_name_rb_node
{
290 struct rb_node rb_node
;
294 static void symbols__insert_by_name(struct rb_root
*self
, struct symbol
*sym
)
296 struct rb_node
**p
= &self
->rb_node
;
297 struct rb_node
*parent
= NULL
;
298 struct symbol_name_rb_node
*symn
= ((void *)sym
) - sizeof(*parent
), *s
;
302 s
= rb_entry(parent
, struct symbol_name_rb_node
, rb_node
);
303 if (strcmp(sym
->name
, s
->sym
.name
) < 0)
308 rb_link_node(&symn
->rb_node
, parent
, p
);
309 rb_insert_color(&symn
->rb_node
, self
);
312 static void symbols__sort_by_name(struct rb_root
*self
, struct rb_root
*source
)
316 for (nd
= rb_first(source
); nd
; nd
= rb_next(nd
)) {
317 struct symbol
*pos
= rb_entry(nd
, struct symbol
, rb_node
);
318 symbols__insert_by_name(self
, pos
);
322 static struct symbol
*symbols__find_by_name(struct rb_root
*self
, const char *name
)
332 struct symbol_name_rb_node
*s
;
335 s
= rb_entry(n
, struct symbol_name_rb_node
, rb_node
);
336 cmp
= strcmp(name
, s
->sym
.name
);
349 struct symbol
*dso__find_symbol(struct dso
*self
,
350 enum map_type type
, u64 addr
)
352 return symbols__find(&self
->symbols
[type
], addr
);
355 struct symbol
*dso__find_symbol_by_name(struct dso
*self
, enum map_type type
,
358 return symbols__find_by_name(&self
->symbol_names
[type
], name
);
361 void dso__sort_by_name(struct dso
*self
, enum map_type type
)
363 dso__set_sorted_by_name(self
, type
);
364 return symbols__sort_by_name(&self
->symbol_names
[type
],
365 &self
->symbols
[type
]);
368 int build_id__sprintf(const u8
*self
, int len
, char *bf
)
371 const u8
*raw
= self
;
374 for (i
= 0; i
< len
; ++i
) {
375 sprintf(bid
, "%02x", *raw
);
383 size_t dso__fprintf_buildid(struct dso
*self
, FILE *fp
)
385 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
387 build_id__sprintf(self
->build_id
, sizeof(self
->build_id
), sbuild_id
);
388 return fprintf(fp
, "%s", sbuild_id
);
391 size_t dso__fprintf(struct dso
*self
, enum map_type type
, FILE *fp
)
394 size_t ret
= fprintf(fp
, "dso: %s (", self
->short_name
);
396 if (self
->short_name
!= self
->long_name
)
397 ret
+= fprintf(fp
, "%s, ", self
->long_name
);
398 ret
+= fprintf(fp
, "%s, %sloaded, ", map_type__name
[type
],
399 self
->loaded
? "" : "NOT ");
400 ret
+= dso__fprintf_buildid(self
, fp
);
401 ret
+= fprintf(fp
, ")\n");
402 for (nd
= rb_first(&self
->symbols
[type
]); nd
; nd
= rb_next(nd
)) {
403 struct symbol
*pos
= rb_entry(nd
, struct symbol
, rb_node
);
404 ret
+= symbol__fprintf(pos
, fp
);
410 int kallsyms__parse(const char *filename
, void *arg
,
411 int (*process_symbol
)(void *arg
, const char *name
,
412 char type
, u64 start
))
417 FILE *file
= fopen(filename
, "r");
422 while (!feof(file
)) {
428 line_len
= getline(&line
, &n
, file
);
429 if (line_len
< 0 || !line
)
432 line
[--line_len
] = '\0'; /* \n */
434 len
= hex2u64(line
, &start
);
437 if (len
+ 2 >= line_len
)
440 symbol_type
= toupper(line
[len
]);
441 symbol_name
= line
+ len
+ 2;
443 err
= process_symbol(arg
, symbol_name
, symbol_type
, start
);
456 struct process_kallsyms_args
{
461 static u8
kallsyms2elf_type(char type
)
466 return isupper(type
) ? STB_GLOBAL
: STB_LOCAL
;
469 static int map__process_kallsym_symbol(void *arg
, const char *name
,
470 char type
, u64 start
)
473 struct process_kallsyms_args
*a
= arg
;
474 struct rb_root
*root
= &a
->dso
->symbols
[a
->map
->type
];
476 if (!symbol_type__is_a(type
, a
->map
->type
))
480 * Will fix up the end later, when we have all symbols sorted.
482 sym
= symbol__new(start
, 0, kallsyms2elf_type(type
), name
);
487 * We will pass the symbols to the filter later, in
488 * map__split_kallsyms, when we have split the maps per module
490 symbols__insert(root
, sym
);
496 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
497 * so that we can in the next step set the symbol ->end address and then
498 * call kernel_maps__split_kallsyms.
500 static int dso__load_all_kallsyms(struct dso
*self
, const char *filename
,
503 struct process_kallsyms_args args
= { .map
= map
, .dso
= self
, };
504 return kallsyms__parse(filename
, &args
, map__process_kallsym_symbol
);
508 * Split the symbols into maps, making sure there are no overlaps, i.e. the
509 * kernel range is broken in several maps, named [kernel].N, as we don't have
510 * the original ELF section names vmlinux have.
512 static int dso__split_kallsyms(struct dso
*self
, struct map
*map
,
513 symbol_filter_t filter
)
515 struct map_groups
*kmaps
= map__kmap(map
)->kmaps
;
516 struct machine
*machine
= kmaps
->machine
;
517 struct map
*curr_map
= map
;
520 struct rb_root
*root
= &self
->symbols
[map
->type
];
521 struct rb_node
*next
= rb_first(root
);
522 int kernel_range
= 0;
527 pos
= rb_entry(next
, struct symbol
, rb_node
);
528 next
= rb_next(&pos
->rb_node
);
530 module
= strchr(pos
->name
, '\t');
532 if (!symbol_conf
.use_modules
)
537 if (strcmp(curr_map
->dso
->short_name
, module
)) {
538 if (curr_map
!= map
&&
539 self
->kernel
== DSO_TYPE_GUEST_KERNEL
&&
540 machine__is_default_guest(machine
)) {
542 * We assume all symbols of a module are
543 * continuous in * kallsyms, so curr_map
544 * points to a module and all its
545 * symbols are in its kmap. Mark it as
548 dso__set_loaded(curr_map
->dso
,
552 curr_map
= map_groups__find_by_name(kmaps
,
554 if (curr_map
== NULL
) {
555 pr_debug("%s/proc/{kallsyms,modules} "
556 "inconsistency while looking "
557 "for \"%s\" module!\n",
558 machine
->root_dir
, module
);
563 if (curr_map
->dso
->loaded
&&
564 !machine__is_default_guest(machine
))
568 * So that we look just like we get from .ko files,
569 * i.e. not prelinked, relative to map->start.
571 pos
->start
= curr_map
->map_ip(curr_map
, pos
->start
);
572 pos
->end
= curr_map
->map_ip(curr_map
, pos
->end
);
573 } else if (curr_map
!= map
) {
574 char dso_name
[PATH_MAX
];
577 if (self
->kernel
== DSO_TYPE_GUEST_KERNEL
)
578 snprintf(dso_name
, sizeof(dso_name
),
582 snprintf(dso_name
, sizeof(dso_name
),
586 dso
= dso__new(dso_name
);
590 dso
->kernel
= self
->kernel
;
592 curr_map
= map__new2(pos
->start
, dso
, map
->type
);
593 if (curr_map
== NULL
) {
598 curr_map
->map_ip
= curr_map
->unmap_ip
= identity__map_ip
;
599 map_groups__insert(kmaps
, curr_map
);
603 if (filter
&& filter(curr_map
, pos
)) {
604 discard_symbol
: rb_erase(&pos
->rb_node
, root
);
607 if (curr_map
!= map
) {
608 rb_erase(&pos
->rb_node
, root
);
609 symbols__insert(&curr_map
->dso
->symbols
[curr_map
->type
], pos
);
615 if (curr_map
!= map
&&
616 self
->kernel
== DSO_TYPE_GUEST_KERNEL
&&
617 machine__is_default_guest(kmaps
->machine
)) {
618 dso__set_loaded(curr_map
->dso
, curr_map
->type
);
624 int dso__load_kallsyms(struct dso
*self
, const char *filename
,
625 struct map
*map
, symbol_filter_t filter
)
627 if (dso__load_all_kallsyms(self
, filename
, map
) < 0)
630 symbols__fixup_end(&self
->symbols
[map
->type
]);
631 if (self
->kernel
== DSO_TYPE_GUEST_KERNEL
)
632 self
->origin
= DSO__ORIG_GUEST_KERNEL
;
634 self
->origin
= DSO__ORIG_KERNEL
;
636 return dso__split_kallsyms(self
, map
, filter
);
639 static int dso__load_perf_map(struct dso
*self
, struct map
*map
,
640 symbol_filter_t filter
)
647 file
= fopen(self
->long_name
, "r");
651 while (!feof(file
)) {
656 line_len
= getline(&line
, &n
, file
);
663 line
[--line_len
] = '\0'; /* \n */
665 len
= hex2u64(line
, &start
);
668 if (len
+ 2 >= line_len
)
671 len
+= hex2u64(line
+ len
, &size
);
674 if (len
+ 2 >= line_len
)
677 sym
= symbol__new(start
, size
, STB_GLOBAL
, line
+ len
);
680 goto out_delete_line
;
682 if (filter
&& filter(map
, sym
))
685 symbols__insert(&self
->symbols
[map
->type
], sym
);
702 * elf_symtab__for_each_symbol - iterate thru all the symbols
704 * @self: struct elf_symtab instance to iterate
706 * @sym: GElf_Sym iterator
708 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
709 for (idx = 0, gelf_getsym(syms, idx, &sym);\
711 idx++, gelf_getsym(syms, idx, &sym))
713 static inline uint8_t elf_sym__type(const GElf_Sym
*sym
)
715 return GELF_ST_TYPE(sym
->st_info
);
718 static inline int elf_sym__is_function(const GElf_Sym
*sym
)
720 return elf_sym__type(sym
) == STT_FUNC
&&
722 sym
->st_shndx
!= SHN_UNDEF
;
725 static inline bool elf_sym__is_object(const GElf_Sym
*sym
)
727 return elf_sym__type(sym
) == STT_OBJECT
&&
729 sym
->st_shndx
!= SHN_UNDEF
;
732 static inline int elf_sym__is_label(const GElf_Sym
*sym
)
734 return elf_sym__type(sym
) == STT_NOTYPE
&&
736 sym
->st_shndx
!= SHN_UNDEF
&&
737 sym
->st_shndx
!= SHN_ABS
;
740 static inline const char *elf_sec__name(const GElf_Shdr
*shdr
,
741 const Elf_Data
*secstrs
)
743 return secstrs
->d_buf
+ shdr
->sh_name
;
746 static inline int elf_sec__is_text(const GElf_Shdr
*shdr
,
747 const Elf_Data
*secstrs
)
749 return strstr(elf_sec__name(shdr
, secstrs
), "text") != NULL
;
752 static inline bool elf_sec__is_data(const GElf_Shdr
*shdr
,
753 const Elf_Data
*secstrs
)
755 return strstr(elf_sec__name(shdr
, secstrs
), "data") != NULL
;
758 static inline const char *elf_sym__name(const GElf_Sym
*sym
,
759 const Elf_Data
*symstrs
)
761 return symstrs
->d_buf
+ sym
->st_name
;
764 static Elf_Scn
*elf_section_by_name(Elf
*elf
, GElf_Ehdr
*ep
,
765 GElf_Shdr
*shp
, const char *name
,
771 while ((sec
= elf_nextscn(elf
, sec
)) != NULL
) {
774 gelf_getshdr(sec
, shp
);
775 str
= elf_strptr(elf
, ep
->e_shstrndx
, shp
->sh_name
);
776 if (!strcmp(name
, str
)) {
787 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
788 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
790 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
792 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
793 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
795 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
798 * We need to check if we have a .dynsym, so that we can handle the
799 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
800 * .dynsym or .symtab).
801 * And always look at the original dso, not at debuginfo packages, that
802 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
804 static int dso__synthesize_plt_symbols(struct dso
*self
, struct map
*map
,
805 symbol_filter_t filter
)
807 uint32_t nr_rel_entries
, idx
;
812 GElf_Shdr shdr_rel_plt
, shdr_dynsym
;
813 Elf_Data
*reldata
, *syms
, *symstrs
;
814 Elf_Scn
*scn_plt_rel
, *scn_symstrs
, *scn_dynsym
;
817 char sympltname
[1024];
819 int nr
= 0, symidx
, fd
, err
= 0;
821 fd
= open(self
->long_name
, O_RDONLY
);
825 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
829 if (gelf_getehdr(elf
, &ehdr
) == NULL
)
832 scn_dynsym
= elf_section_by_name(elf
, &ehdr
, &shdr_dynsym
,
833 ".dynsym", &dynsym_idx
);
834 if (scn_dynsym
== NULL
)
837 scn_plt_rel
= elf_section_by_name(elf
, &ehdr
, &shdr_rel_plt
,
839 if (scn_plt_rel
== NULL
) {
840 scn_plt_rel
= elf_section_by_name(elf
, &ehdr
, &shdr_rel_plt
,
842 if (scn_plt_rel
== NULL
)
848 if (shdr_rel_plt
.sh_link
!= dynsym_idx
)
851 if (elf_section_by_name(elf
, &ehdr
, &shdr_plt
, ".plt", NULL
) == NULL
)
855 * Fetch the relocation section to find the idxes to the GOT
856 * and the symbols in the .dynsym they refer to.
858 reldata
= elf_getdata(scn_plt_rel
, NULL
);
862 syms
= elf_getdata(scn_dynsym
, NULL
);
866 scn_symstrs
= elf_getscn(elf
, shdr_dynsym
.sh_link
);
867 if (scn_symstrs
== NULL
)
870 symstrs
= elf_getdata(scn_symstrs
, NULL
);
874 nr_rel_entries
= shdr_rel_plt
.sh_size
/ shdr_rel_plt
.sh_entsize
;
875 plt_offset
= shdr_plt
.sh_offset
;
877 if (shdr_rel_plt
.sh_type
== SHT_RELA
) {
878 GElf_Rela pos_mem
, *pos
;
880 elf_section__for_each_rela(reldata
, pos
, pos_mem
, idx
,
882 symidx
= GELF_R_SYM(pos
->r_info
);
883 plt_offset
+= shdr_plt
.sh_entsize
;
884 gelf_getsym(syms
, symidx
, &sym
);
885 snprintf(sympltname
, sizeof(sympltname
),
886 "%s@plt", elf_sym__name(&sym
, symstrs
));
888 f
= symbol__new(plt_offset
, shdr_plt
.sh_entsize
,
889 STB_GLOBAL
, sympltname
);
893 if (filter
&& filter(map
, f
))
896 symbols__insert(&self
->symbols
[map
->type
], f
);
900 } else if (shdr_rel_plt
.sh_type
== SHT_REL
) {
901 GElf_Rel pos_mem
, *pos
;
902 elf_section__for_each_rel(reldata
, pos
, pos_mem
, idx
,
904 symidx
= GELF_R_SYM(pos
->r_info
);
905 plt_offset
+= shdr_plt
.sh_entsize
;
906 gelf_getsym(syms
, symidx
, &sym
);
907 snprintf(sympltname
, sizeof(sympltname
),
908 "%s@plt", elf_sym__name(&sym
, symstrs
));
910 f
= symbol__new(plt_offset
, shdr_plt
.sh_entsize
,
911 STB_GLOBAL
, sympltname
);
915 if (filter
&& filter(map
, f
))
918 symbols__insert(&self
->symbols
[map
->type
], f
);
933 pr_debug("%s: problems reading %s PLT info.\n",
934 __func__
, self
->long_name
);
938 static bool elf_sym__is_a(GElf_Sym
*self
, enum map_type type
)
942 return elf_sym__is_function(self
);
944 return elf_sym__is_object(self
);
950 static bool elf_sec__is_a(GElf_Shdr
*self
, Elf_Data
*secstrs
, enum map_type type
)
954 return elf_sec__is_text(self
, secstrs
);
956 return elf_sec__is_data(self
, secstrs
);
962 static size_t elf_addr_to_index(Elf
*elf
, GElf_Addr addr
)
968 while ((sec
= elf_nextscn(elf
, sec
)) != NULL
) {
969 gelf_getshdr(sec
, &shdr
);
971 if ((addr
>= shdr
.sh_addr
) &&
972 (addr
< (shdr
.sh_addr
+ shdr
.sh_size
)))
981 static int dso__load_sym(struct dso
*self
, struct map
*map
, const char *name
,
982 int fd
, symbol_filter_t filter
, int kmodule
,
985 struct kmap
*kmap
= self
->kernel
? map__kmap(map
) : NULL
;
986 struct map
*curr_map
= map
;
987 struct dso
*curr_dso
= self
;
988 Elf_Data
*symstrs
, *secstrs
;
993 GElf_Shdr shdr
, opdshdr
;
994 Elf_Data
*syms
, *opddata
= NULL
;
996 Elf_Scn
*sec
, *sec_strndx
, *opdsec
;
1001 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
1003 pr_debug("%s: cannot read %s ELF file.\n", __func__
, name
);
1007 if (gelf_getehdr(elf
, &ehdr
) == NULL
) {
1008 pr_debug("%s: cannot get elf header.\n", __func__
);
1012 /* Always reject images with a mismatched build-id: */
1013 if (self
->has_build_id
) {
1014 u8 build_id
[BUILD_ID_SIZE
];
1016 if (elf_read_build_id(elf
, build_id
,
1017 BUILD_ID_SIZE
) != BUILD_ID_SIZE
)
1020 if (!dso__build_id_equal(self
, build_id
))
1024 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
, ".symtab", NULL
);
1029 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
, ".dynsym", NULL
);
1034 opdsec
= elf_section_by_name(elf
, &ehdr
, &opdshdr
, ".opd", &opdidx
);
1036 opddata
= elf_rawdata(opdsec
, NULL
);
1038 syms
= elf_getdata(sec
, NULL
);
1042 sec
= elf_getscn(elf
, shdr
.sh_link
);
1046 symstrs
= elf_getdata(sec
, NULL
);
1047 if (symstrs
== NULL
)
1050 sec_strndx
= elf_getscn(elf
, ehdr
.e_shstrndx
);
1051 if (sec_strndx
== NULL
)
1054 secstrs
= elf_getdata(sec_strndx
, NULL
);
1055 if (secstrs
== NULL
)
1058 nr_syms
= shdr
.sh_size
/ shdr
.sh_entsize
;
1060 memset(&sym
, 0, sizeof(sym
));
1061 if (self
->kernel
== DSO_TYPE_USER
) {
1062 self
->adjust_symbols
= (ehdr
.e_type
== ET_EXEC
||
1063 elf_section_by_name(elf
, &ehdr
, &shdr
,
1064 ".gnu.prelink_undo",
1066 } else self
->adjust_symbols
= 0;
1068 elf_symtab__for_each_symbol(syms
, nr_syms
, idx
, sym
) {
1070 const char *elf_name
= elf_sym__name(&sym
, symstrs
);
1071 char *demangled
= NULL
;
1072 int is_label
= elf_sym__is_label(&sym
);
1073 const char *section_name
;
1075 if (kmap
&& kmap
->ref_reloc_sym
&& kmap
->ref_reloc_sym
->name
&&
1076 strcmp(elf_name
, kmap
->ref_reloc_sym
->name
) == 0)
1077 kmap
->ref_reloc_sym
->unrelocated_addr
= sym
.st_value
;
1079 if (!is_label
&& !elf_sym__is_a(&sym
, map
->type
))
1082 /* Reject ARM ELF "mapping symbols": these aren't unique and
1083 * don't identify functions, so will confuse the profile
1085 if (ehdr
.e_machine
== EM_ARM
) {
1086 if (!strcmp(elf_name
, "$a") ||
1087 !strcmp(elf_name
, "$d") ||
1088 !strcmp(elf_name
, "$t"))
1092 if (opdsec
&& sym
.st_shndx
== opdidx
) {
1093 u32 offset
= sym
.st_value
- opdshdr
.sh_addr
;
1094 u64
*opd
= opddata
->d_buf
+ offset
;
1095 sym
.st_value
= *opd
;
1096 sym
.st_shndx
= elf_addr_to_index(elf
, sym
.st_value
);
1099 sec
= elf_getscn(elf
, sym
.st_shndx
);
1103 gelf_getshdr(sec
, &shdr
);
1105 if (is_label
&& !elf_sec__is_a(&shdr
, secstrs
, map
->type
))
1108 section_name
= elf_sec__name(&shdr
, secstrs
);
1110 if (self
->kernel
!= DSO_TYPE_USER
|| kmodule
) {
1111 char dso_name
[PATH_MAX
];
1113 if (strcmp(section_name
,
1114 (curr_dso
->short_name
+
1115 self
->short_name_len
)) == 0)
1118 if (strcmp(section_name
, ".text") == 0) {
1124 snprintf(dso_name
, sizeof(dso_name
),
1125 "%s%s", self
->short_name
, section_name
);
1127 curr_map
= map_groups__find_by_name(kmap
->kmaps
, map
->type
, dso_name
);
1128 if (curr_map
== NULL
) {
1129 u64 start
= sym
.st_value
;
1132 start
+= map
->start
+ shdr
.sh_offset
;
1134 curr_dso
= dso__new(dso_name
);
1135 if (curr_dso
== NULL
)
1137 curr_dso
->kernel
= self
->kernel
;
1138 curr_map
= map__new2(start
, curr_dso
,
1140 if (curr_map
== NULL
) {
1141 dso__delete(curr_dso
);
1144 curr_map
->map_ip
= identity__map_ip
;
1145 curr_map
->unmap_ip
= identity__map_ip
;
1146 curr_dso
->origin
= self
->origin
;
1147 map_groups__insert(kmap
->kmaps
, curr_map
);
1148 dsos__add(&self
->node
, curr_dso
);
1149 dso__set_loaded(curr_dso
, map
->type
);
1151 curr_dso
= curr_map
->dso
;
1156 if (curr_dso
->adjust_symbols
) {
1157 pr_debug4("%s: adjusting symbol: st_value: %#Lx "
1158 "sh_addr: %#Lx sh_offset: %#Lx\n", __func__
,
1159 (u64
)sym
.st_value
, (u64
)shdr
.sh_addr
,
1160 (u64
)shdr
.sh_offset
);
1161 sym
.st_value
-= shdr
.sh_addr
- shdr
.sh_offset
;
1164 * We need to figure out if the object was created from C++ sources
1165 * DWARF DW_compile_unit has this, but we don't always have access
1168 demangled
= bfd_demangle(NULL
, elf_name
, DMGL_PARAMS
| DMGL_ANSI
);
1169 if (demangled
!= NULL
)
1170 elf_name
= demangled
;
1172 f
= symbol__new(sym
.st_value
, sym
.st_size
,
1173 GELF_ST_BIND(sym
.st_info
), elf_name
);
1178 if (filter
&& filter(curr_map
, f
))
1181 symbols__insert(&curr_dso
->symbols
[curr_map
->type
], f
);
1187 * For misannotated, zeroed, ASM function sizes.
1190 symbols__fixup_end(&self
->symbols
[map
->type
]);
1193 * We need to fixup this here too because we create new
1194 * maps here, for things like vsyscall sections.
1196 __map_groups__fixup_end(kmap
->kmaps
, map
->type
);
1206 static bool dso__build_id_equal(const struct dso
*self
, u8
*build_id
)
1208 return memcmp(self
->build_id
, build_id
, sizeof(self
->build_id
)) == 0;
1211 bool __dsos__read_build_ids(struct list_head
*head
, bool with_hits
)
1213 bool have_build_id
= false;
1216 list_for_each_entry(pos
, head
, node
) {
1217 if (with_hits
&& !pos
->hit
)
1219 if (pos
->has_build_id
) {
1220 have_build_id
= true;
1223 if (filename__read_build_id(pos
->long_name
, pos
->build_id
,
1224 sizeof(pos
->build_id
)) > 0) {
1225 have_build_id
= true;
1226 pos
->has_build_id
= true;
1230 return have_build_id
;
1234 * Align offset to 4 bytes as needed for note name and descriptor data.
1236 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1238 static int elf_read_build_id(Elf
*elf
, void *bf
, size_t size
)
1248 if (size
< BUILD_ID_SIZE
)
1252 if (ek
!= ELF_K_ELF
)
1255 if (gelf_getehdr(elf
, &ehdr
) == NULL
) {
1256 pr_err("%s: cannot get elf header.\n", __func__
);
1260 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
,
1261 ".note.gnu.build-id", NULL
);
1263 sec
= elf_section_by_name(elf
, &ehdr
, &shdr
,
1269 data
= elf_getdata(sec
, NULL
);
1274 while (ptr
< (data
->d_buf
+ data
->d_size
)) {
1275 GElf_Nhdr
*nhdr
= ptr
;
1276 int namesz
= NOTE_ALIGN(nhdr
->n_namesz
),
1277 descsz
= NOTE_ALIGN(nhdr
->n_descsz
);
1280 ptr
+= sizeof(*nhdr
);
1283 if (nhdr
->n_type
== NT_GNU_BUILD_ID
&&
1284 nhdr
->n_namesz
== sizeof("GNU")) {
1285 if (memcmp(name
, "GNU", sizeof("GNU")) == 0) {
1286 memcpy(bf
, ptr
, BUILD_ID_SIZE
);
1287 err
= BUILD_ID_SIZE
;
1298 int filename__read_build_id(const char *filename
, void *bf
, size_t size
)
1303 if (size
< BUILD_ID_SIZE
)
1306 fd
= open(filename
, O_RDONLY
);
1310 elf
= elf_begin(fd
, PERF_ELF_C_READ_MMAP
, NULL
);
1312 pr_debug2("%s: cannot read %s ELF file.\n", __func__
, filename
);
1316 err
= elf_read_build_id(elf
, bf
, size
);
1325 int sysfs__read_build_id(const char *filename
, void *build_id
, size_t size
)
1329 if (size
< BUILD_ID_SIZE
)
1332 fd
= open(filename
, O_RDONLY
);
1341 if (read(fd
, &nhdr
, sizeof(nhdr
)) != sizeof(nhdr
))
1344 namesz
= NOTE_ALIGN(nhdr
.n_namesz
);
1345 descsz
= NOTE_ALIGN(nhdr
.n_descsz
);
1346 if (nhdr
.n_type
== NT_GNU_BUILD_ID
&&
1347 nhdr
.n_namesz
== sizeof("GNU")) {
1348 if (read(fd
, bf
, namesz
) != namesz
)
1350 if (memcmp(bf
, "GNU", sizeof("GNU")) == 0) {
1351 if (read(fd
, build_id
,
1352 BUILD_ID_SIZE
) == BUILD_ID_SIZE
) {
1356 } else if (read(fd
, bf
, descsz
) != descsz
)
1359 int n
= namesz
+ descsz
;
1360 if (read(fd
, bf
, n
) != n
)
1369 char dso__symtab_origin(const struct dso
*self
)
1371 static const char origin
[] = {
1372 [DSO__ORIG_KERNEL
] = 'k',
1373 [DSO__ORIG_JAVA_JIT
] = 'j',
1374 [DSO__ORIG_BUILD_ID_CACHE
] = 'B',
1375 [DSO__ORIG_FEDORA
] = 'f',
1376 [DSO__ORIG_UBUNTU
] = 'u',
1377 [DSO__ORIG_BUILDID
] = 'b',
1378 [DSO__ORIG_DSO
] = 'd',
1379 [DSO__ORIG_KMODULE
] = 'K',
1380 [DSO__ORIG_GUEST_KERNEL
] = 'g',
1381 [DSO__ORIG_GUEST_KMODULE
] = 'G',
1384 if (self
== NULL
|| self
->origin
== DSO__ORIG_NOT_FOUND
)
1386 return origin
[self
->origin
];
1389 int dso__load(struct dso
*self
, struct map
*map
, symbol_filter_t filter
)
1391 int size
= PATH_MAX
;
1395 struct machine
*machine
;
1396 const char *root_dir
;
1399 dso__set_loaded(self
, map
->type
);
1401 if (self
->kernel
== DSO_TYPE_KERNEL
)
1402 return dso__load_kernel_sym(self
, map
, filter
);
1403 else if (self
->kernel
== DSO_TYPE_GUEST_KERNEL
)
1404 return dso__load_guest_kernel_sym(self
, map
, filter
);
1406 if (map
->groups
&& map
->groups
->machine
)
1407 machine
= map
->groups
->machine
;
1411 name
= malloc(size
);
1415 self
->adjust_symbols
= 0;
1417 if (strncmp(self
->name
, "/tmp/perf-", 10) == 0) {
1418 ret
= dso__load_perf_map(self
, map
, filter
);
1419 self
->origin
= ret
> 0 ? DSO__ORIG_JAVA_JIT
:
1420 DSO__ORIG_NOT_FOUND
;
1424 /* Iterate over candidate debug images.
1425 * On the first pass, only load images if they have a full symtab.
1426 * Failing that, do a second pass where we accept .dynsym also
1428 for (self
->origin
= DSO__ORIG_BUILD_ID_CACHE
, want_symtab
= 1;
1429 self
->origin
!= DSO__ORIG_NOT_FOUND
;
1431 switch (self
->origin
) {
1432 case DSO__ORIG_BUILD_ID_CACHE
:
1433 if (dso__build_id_filename(self
, name
, size
) == NULL
)
1436 case DSO__ORIG_FEDORA
:
1437 snprintf(name
, size
, "/usr/lib/debug%s.debug",
1440 case DSO__ORIG_UBUNTU
:
1441 snprintf(name
, size
, "/usr/lib/debug%s",
1444 case DSO__ORIG_BUILDID
: {
1445 char build_id_hex
[BUILD_ID_SIZE
* 2 + 1];
1447 if (!self
->has_build_id
)
1450 build_id__sprintf(self
->build_id
,
1451 sizeof(self
->build_id
),
1453 snprintf(name
, size
,
1454 "/usr/lib/debug/.build-id/%.2s/%s.debug",
1455 build_id_hex
, build_id_hex
+ 2);
1459 snprintf(name
, size
, "%s", self
->long_name
);
1461 case DSO__ORIG_GUEST_KMODULE
:
1462 if (map
->groups
&& map
->groups
->machine
)
1463 root_dir
= map
->groups
->machine
->root_dir
;
1466 snprintf(name
, size
, "%s%s", root_dir
, self
->long_name
);
1471 * If we wanted a full symtab but no image had one,
1472 * relax our requirements and repeat the search.
1476 self
->origin
= DSO__ORIG_BUILD_ID_CACHE
;
1481 /* Name is now the name of the next image to try */
1482 fd
= open(name
, O_RDONLY
);
1486 ret
= dso__load_sym(self
, map
, name
, fd
, filter
, 0,
1491 * Some people seem to have debuginfo files _WITHOUT_ debug
1498 int nr_plt
= dso__synthesize_plt_symbols(self
, map
, filter
);
1506 if (ret
< 0 && strstr(self
->name
, " (deleted)") != NULL
)
1511 struct map
*map_groups__find_by_name(struct map_groups
*self
,
1512 enum map_type type
, const char *name
)
1516 for (nd
= rb_first(&self
->maps
[type
]); nd
; nd
= rb_next(nd
)) {
1517 struct map
*map
= rb_entry(nd
, struct map
, rb_node
);
1519 if (map
->dso
&& strcmp(map
->dso
->short_name
, name
) == 0)
1526 static int dso__kernel_module_get_build_id(struct dso
*self
,
1527 const char *root_dir
)
1529 char filename
[PATH_MAX
];
1531 * kernel module short names are of the form "[module]" and
1532 * we need just "module" here.
1534 const char *name
= self
->short_name
+ 1;
1536 snprintf(filename
, sizeof(filename
),
1537 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1538 root_dir
, (int)strlen(name
) - 1, name
);
1540 if (sysfs__read_build_id(filename
, self
->build_id
,
1541 sizeof(self
->build_id
)) == 0)
1542 self
->has_build_id
= true;
1547 static int map_groups__set_modules_path_dir(struct map_groups
*self
,
1548 const char *dir_name
)
1550 struct dirent
*dent
;
1551 DIR *dir
= opendir(dir_name
);
1555 pr_debug("%s: cannot open %s dir\n", __func__
, dir_name
);
1559 while ((dent
= readdir(dir
)) != NULL
) {
1560 char path
[PATH_MAX
];
1563 /*sshfs might return bad dent->d_type, so we have to stat*/
1564 sprintf(path
, "%s/%s", dir_name
, dent
->d_name
);
1565 if (stat(path
, &st
))
1568 if (S_ISDIR(st
.st_mode
)) {
1569 if (!strcmp(dent
->d_name
, ".") ||
1570 !strcmp(dent
->d_name
, ".."))
1573 snprintf(path
, sizeof(path
), "%s/%s",
1574 dir_name
, dent
->d_name
);
1575 ret
= map_groups__set_modules_path_dir(self
, path
);
1579 char *dot
= strrchr(dent
->d_name
, '.'),
1584 if (dot
== NULL
|| strcmp(dot
, ".ko"))
1586 snprintf(dso_name
, sizeof(dso_name
), "[%.*s]",
1587 (int)(dot
- dent
->d_name
), dent
->d_name
);
1589 strxfrchar(dso_name
, '-', '_');
1590 map
= map_groups__find_by_name(self
, MAP__FUNCTION
, dso_name
);
1594 snprintf(path
, sizeof(path
), "%s/%s",
1595 dir_name
, dent
->d_name
);
1597 long_name
= strdup(path
);
1598 if (long_name
== NULL
) {
1602 dso__set_long_name(map
->dso
, long_name
);
1603 map
->dso
->lname_alloc
= 1;
1604 dso__kernel_module_get_build_id(map
->dso
, "");
1613 static char *get_kernel_version(const char *root_dir
)
1615 char version
[PATH_MAX
];
1618 const char *prefix
= "Linux version ";
1620 sprintf(version
, "%s/proc/version", root_dir
);
1621 file
= fopen(version
, "r");
1626 tmp
= fgets(version
, sizeof(version
), file
);
1629 name
= strstr(version
, prefix
);
1632 name
+= strlen(prefix
);
1633 tmp
= strchr(name
, ' ');
1637 return strdup(name
);
1640 static int machine__set_modules_path(struct machine
*self
)
1643 char modules_path
[PATH_MAX
];
1645 version
= get_kernel_version(self
->root_dir
);
1649 snprintf(modules_path
, sizeof(modules_path
), "%s/lib/modules/%s/kernel",
1650 self
->root_dir
, version
);
1653 return map_groups__set_modules_path_dir(&self
->kmaps
, modules_path
);
1657 * Constructor variant for modules (where we know from /proc/modules where
1658 * they are loaded) and for vmlinux, where only after we load all the
1659 * symbols we'll know where it starts and ends.
1661 static struct map
*map__new2(u64 start
, struct dso
*dso
, enum map_type type
)
1663 struct map
*self
= calloc(1, (sizeof(*self
) +
1664 (dso
->kernel
? sizeof(struct kmap
) : 0)));
1667 * ->end will be filled after we load all the symbols
1669 map__init(self
, type
, start
, 0, 0, dso
);
1675 struct map
*machine__new_module(struct machine
*self
, u64 start
,
1676 const char *filename
)
1679 struct dso
*dso
= __dsos__findnew(&self
->kernel_dsos
, filename
);
1684 map
= map__new2(start
, dso
, MAP__FUNCTION
);
1688 if (machine__is_host(self
))
1689 dso
->origin
= DSO__ORIG_KMODULE
;
1691 dso
->origin
= DSO__ORIG_GUEST_KMODULE
;
1692 map_groups__insert(&self
->kmaps
, map
);
1696 static int machine__create_modules(struct machine
*self
)
1702 const char *modules
;
1703 char path
[PATH_MAX
];
1705 if (machine__is_default_guest(self
))
1706 modules
= symbol_conf
.default_guest_modules
;
1708 sprintf(path
, "%s/proc/modules", self
->root_dir
);
1712 file
= fopen(modules
, "r");
1716 while (!feof(file
)) {
1717 char name
[PATH_MAX
];
1722 line_len
= getline(&line
, &n
, file
);
1729 line
[--line_len
] = '\0'; /* \n */
1731 sep
= strrchr(line
, 'x');
1735 hex2u64(sep
+ 1, &start
);
1737 sep
= strchr(line
, ' ');
1743 snprintf(name
, sizeof(name
), "[%s]", line
);
1744 map
= machine__new_module(self
, start
, name
);
1746 goto out_delete_line
;
1747 dso__kernel_module_get_build_id(map
->dso
, self
->root_dir
);
1753 return machine__set_modules_path(self
);
1761 static int dso__load_vmlinux(struct dso
*self
, struct map
*map
,
1762 const char *vmlinux
, symbol_filter_t filter
)
1766 fd
= open(vmlinux
, O_RDONLY
);
1770 dso__set_loaded(self
, map
->type
);
1771 err
= dso__load_sym(self
, map
, vmlinux
, fd
, filter
, 0, 0);
1775 pr_debug("Using %s for symbols\n", vmlinux
);
1780 int dso__load_vmlinux_path(struct dso
*self
, struct map
*map
,
1781 symbol_filter_t filter
)
1786 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1787 vmlinux_path__nr_entries
+ 1);
1789 filename
= dso__build_id_filename(self
, NULL
, 0);
1790 if (filename
!= NULL
) {
1791 err
= dso__load_vmlinux(self
, map
, filename
, filter
);
1793 dso__set_long_name(self
, filename
);
1799 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
) {
1800 err
= dso__load_vmlinux(self
, map
, vmlinux_path
[i
], filter
);
1802 dso__set_long_name(self
, strdup(vmlinux_path
[i
]));
1810 static int dso__load_kernel_sym(struct dso
*self
, struct map
*map
,
1811 symbol_filter_t filter
)
1814 const char *kallsyms_filename
= NULL
;
1815 char *kallsyms_allocated_filename
= NULL
;
1817 * Step 1: if the user specified a vmlinux filename, use it and only
1818 * it, reporting errors to the user if it cannot be used.
1820 * For instance, try to analyse an ARM perf.data file _without_ a
1821 * build-id, or if the user specifies the wrong path to the right
1822 * vmlinux file, obviously we can't fallback to another vmlinux (a
1823 * x86_86 one, on the machine where analysis is being performed, say),
1824 * or worse, /proc/kallsyms.
1826 * If the specified file _has_ a build-id and there is a build-id
1827 * section in the perf.data file, we will still do the expected
1828 * validation in dso__load_vmlinux and will bail out if they don't
1831 if (symbol_conf
.vmlinux_name
!= NULL
) {
1832 err
= dso__load_vmlinux(self
, map
,
1833 symbol_conf
.vmlinux_name
, filter
);
1835 dso__set_long_name(self
,
1836 strdup(symbol_conf
.vmlinux_name
));
1842 if (vmlinux_path
!= NULL
) {
1843 err
= dso__load_vmlinux_path(self
, map
, filter
);
1849 * Say the kernel DSO was created when processing the build-id header table,
1850 * we have a build-id, so check if it is the same as the running kernel,
1851 * using it if it is.
1853 if (self
->has_build_id
) {
1854 u8 kallsyms_build_id
[BUILD_ID_SIZE
];
1855 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
1857 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id
,
1858 sizeof(kallsyms_build_id
)) == 0) {
1859 if (dso__build_id_equal(self
, kallsyms_build_id
)) {
1860 kallsyms_filename
= "/proc/kallsyms";
1865 * Now look if we have it on the build-id cache in
1866 * $HOME/.debug/[kernel.kallsyms].
1868 build_id__sprintf(self
->build_id
, sizeof(self
->build_id
),
1871 if (asprintf(&kallsyms_allocated_filename
,
1872 "%s/.debug/[kernel.kallsyms]/%s",
1873 getenv("HOME"), sbuild_id
) == -1) {
1874 pr_err("Not enough memory for kallsyms file lookup\n");
1878 kallsyms_filename
= kallsyms_allocated_filename
;
1880 if (access(kallsyms_filename
, F_OK
)) {
1881 pr_err("No kallsyms or vmlinux with build-id %s "
1882 "was found\n", sbuild_id
);
1883 free(kallsyms_allocated_filename
);
1888 * Last resort, if we don't have a build-id and couldn't find
1889 * any vmlinux file, try the running kernel kallsyms table.
1891 kallsyms_filename
= "/proc/kallsyms";
1895 err
= dso__load_kallsyms(self
, kallsyms_filename
, map
, filter
);
1897 pr_debug("Using %s for symbols\n", kallsyms_filename
);
1898 free(kallsyms_allocated_filename
);
1902 if (kallsyms_filename
!= NULL
)
1903 dso__set_long_name(self
, strdup("[kernel.kallsyms]"));
1904 map__fixup_start(map
);
1905 map__fixup_end(map
);
1911 static int dso__load_guest_kernel_sym(struct dso
*self
, struct map
*map
,
1912 symbol_filter_t filter
)
1915 const char *kallsyms_filename
= NULL
;
1916 struct machine
*machine
;
1917 char path
[PATH_MAX
];
1920 pr_debug("Guest kernel map hasn't the point to groups\n");
1923 machine
= map
->groups
->machine
;
1925 if (machine__is_default_guest(machine
)) {
1927 * if the user specified a vmlinux filename, use it and only
1928 * it, reporting errors to the user if it cannot be used.
1929 * Or use file guest_kallsyms inputted by user on commandline
1931 if (symbol_conf
.default_guest_vmlinux_name
!= NULL
) {
1932 err
= dso__load_vmlinux(self
, map
,
1933 symbol_conf
.default_guest_vmlinux_name
, filter
);
1937 kallsyms_filename
= symbol_conf
.default_guest_kallsyms
;
1938 if (!kallsyms_filename
)
1941 sprintf(path
, "%s/proc/kallsyms", machine
->root_dir
);
1942 kallsyms_filename
= path
;
1945 err
= dso__load_kallsyms(self
, kallsyms_filename
, map
, filter
);
1947 pr_debug("Using %s for symbols\n", kallsyms_filename
);
1951 if (kallsyms_filename
!= NULL
) {
1952 machine__mmap_name(machine
, path
, sizeof(path
));
1953 dso__set_long_name(self
, strdup(path
));
1955 map__fixup_start(map
);
1956 map__fixup_end(map
);
1962 static void dsos__add(struct list_head
*head
, struct dso
*dso
)
1964 list_add_tail(&dso
->node
, head
);
1967 static struct dso
*dsos__find(struct list_head
*head
, const char *name
)
1971 list_for_each_entry(pos
, head
, node
)
1972 if (strcmp(pos
->long_name
, name
) == 0)
1977 struct dso
*__dsos__findnew(struct list_head
*head
, const char *name
)
1979 struct dso
*dso
= dsos__find(head
, name
);
1982 dso
= dso__new(name
);
1984 dsos__add(head
, dso
);
1985 dso__set_basename(dso
);
1992 size_t __dsos__fprintf(struct list_head
*head
, FILE *fp
)
1997 list_for_each_entry(pos
, head
, node
) {
1999 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
2000 ret
+= dso__fprintf(pos
, i
, fp
);
2006 size_t machines__fprintf_dsos(struct rb_root
*self
, FILE *fp
)
2011 for (nd
= rb_first(self
); nd
; nd
= rb_next(nd
)) {
2012 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
2013 ret
+= __dsos__fprintf(&pos
->kernel_dsos
, fp
);
2014 ret
+= __dsos__fprintf(&pos
->user_dsos
, fp
);
2020 static size_t __dsos__fprintf_buildid(struct list_head
*head
, FILE *fp
,
2026 list_for_each_entry(pos
, head
, node
) {
2027 if (with_hits
&& !pos
->hit
)
2029 ret
+= dso__fprintf_buildid(pos
, fp
);
2030 ret
+= fprintf(fp
, " %s\n", pos
->long_name
);
2035 size_t machine__fprintf_dsos_buildid(struct machine
*self
, FILE *fp
, bool with_hits
)
2037 return __dsos__fprintf_buildid(&self
->kernel_dsos
, fp
, with_hits
) +
2038 __dsos__fprintf_buildid(&self
->user_dsos
, fp
, with_hits
);
2041 size_t machines__fprintf_dsos_buildid(struct rb_root
*self
, FILE *fp
, bool with_hits
)
2046 for (nd
= rb_first(self
); nd
; nd
= rb_next(nd
)) {
2047 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
2048 ret
+= machine__fprintf_dsos_buildid(pos
, fp
, with_hits
);
2053 struct dso
*dso__new_kernel(const char *name
)
2055 struct dso
*self
= dso__new(name
?: "[kernel.kallsyms]");
2058 dso__set_short_name(self
, "[kernel]");
2059 self
->kernel
= DSO_TYPE_KERNEL
;
2065 static struct dso
*dso__new_guest_kernel(struct machine
*machine
,
2069 struct dso
*self
= dso__new(name
?: machine__mmap_name(machine
, bf
, sizeof(bf
)));
2072 dso__set_short_name(self
, "[guest.kernel]");
2073 self
->kernel
= DSO_TYPE_GUEST_KERNEL
;
2079 void dso__read_running_kernel_build_id(struct dso
*self
, struct machine
*machine
)
2081 char path
[PATH_MAX
];
2083 if (machine__is_default_guest(machine
))
2085 sprintf(path
, "%s/sys/kernel/notes", machine
->root_dir
);
2086 if (sysfs__read_build_id(path
, self
->build_id
,
2087 sizeof(self
->build_id
)) == 0)
2088 self
->has_build_id
= true;
2091 static struct dso
*machine__create_kernel(struct machine
*self
)
2093 const char *vmlinux_name
= NULL
;
2096 if (machine__is_host(self
)) {
2097 vmlinux_name
= symbol_conf
.vmlinux_name
;
2098 kernel
= dso__new_kernel(vmlinux_name
);
2100 if (machine__is_default_guest(self
))
2101 vmlinux_name
= symbol_conf
.default_guest_vmlinux_name
;
2102 kernel
= dso__new_guest_kernel(self
, vmlinux_name
);
2105 if (kernel
!= NULL
) {
2106 dso__read_running_kernel_build_id(kernel
, self
);
2107 dsos__add(&self
->kernel_dsos
, kernel
);
2112 int __machine__create_kernel_maps(struct machine
*self
, struct dso
*kernel
)
2116 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
2119 self
->vmlinux_maps
[type
] = map__new2(0, kernel
, type
);
2120 if (self
->vmlinux_maps
[type
] == NULL
)
2123 self
->vmlinux_maps
[type
]->map_ip
=
2124 self
->vmlinux_maps
[type
]->unmap_ip
= identity__map_ip
;
2126 kmap
= map__kmap(self
->vmlinux_maps
[type
]);
2127 kmap
->kmaps
= &self
->kmaps
;
2128 map_groups__insert(&self
->kmaps
, self
->vmlinux_maps
[type
]);
2134 void machine__destroy_kernel_maps(struct machine
*self
)
2138 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
2141 if (self
->vmlinux_maps
[type
] == NULL
)
2144 kmap
= map__kmap(self
->vmlinux_maps
[type
]);
2145 map_groups__remove(&self
->kmaps
, self
->vmlinux_maps
[type
]);
2146 if (kmap
->ref_reloc_sym
) {
2148 * ref_reloc_sym is shared among all maps, so free just
2151 if (type
== MAP__FUNCTION
) {
2152 free((char *)kmap
->ref_reloc_sym
->name
);
2153 kmap
->ref_reloc_sym
->name
= NULL
;
2154 free(kmap
->ref_reloc_sym
);
2156 kmap
->ref_reloc_sym
= NULL
;
2159 map__delete(self
->vmlinux_maps
[type
]);
2160 self
->vmlinux_maps
[type
] = NULL
;
2164 int machine__create_kernel_maps(struct machine
*self
)
2166 struct dso
*kernel
= machine__create_kernel(self
);
2168 if (kernel
== NULL
||
2169 __machine__create_kernel_maps(self
, kernel
) < 0)
2172 if (symbol_conf
.use_modules
&& machine__create_modules(self
) < 0)
2173 pr_debug("Problems creating module maps, continuing anyway...\n");
2175 * Now that we have all the maps created, just set the ->end of them:
2177 map_groups__fixup_end(&self
->kmaps
);
2181 static void vmlinux_path__exit(void)
2183 while (--vmlinux_path__nr_entries
>= 0) {
2184 free(vmlinux_path
[vmlinux_path__nr_entries
]);
2185 vmlinux_path
[vmlinux_path__nr_entries
] = NULL
;
2189 vmlinux_path
= NULL
;
2192 static int vmlinux_path__init(void)
2197 if (uname(&uts
) < 0)
2200 vmlinux_path
= malloc(sizeof(char *) * 5);
2201 if (vmlinux_path
== NULL
)
2204 vmlinux_path
[vmlinux_path__nr_entries
] = strdup("vmlinux");
2205 if (vmlinux_path
[vmlinux_path__nr_entries
] == NULL
)
2207 ++vmlinux_path__nr_entries
;
2208 vmlinux_path
[vmlinux_path__nr_entries
] = strdup("/boot/vmlinux");
2209 if (vmlinux_path
[vmlinux_path__nr_entries
] == NULL
)
2211 ++vmlinux_path__nr_entries
;
2212 snprintf(bf
, sizeof(bf
), "/boot/vmlinux-%s", uts
.release
);
2213 vmlinux_path
[vmlinux_path__nr_entries
] = strdup(bf
);
2214 if (vmlinux_path
[vmlinux_path__nr_entries
] == NULL
)
2216 ++vmlinux_path__nr_entries
;
2217 snprintf(bf
, sizeof(bf
), "/lib/modules/%s/build/vmlinux", uts
.release
);
2218 vmlinux_path
[vmlinux_path__nr_entries
] = strdup(bf
);
2219 if (vmlinux_path
[vmlinux_path__nr_entries
] == NULL
)
2221 ++vmlinux_path__nr_entries
;
2222 snprintf(bf
, sizeof(bf
), "/usr/lib/debug/lib/modules/%s/vmlinux",
2224 vmlinux_path
[vmlinux_path__nr_entries
] = strdup(bf
);
2225 if (vmlinux_path
[vmlinux_path__nr_entries
] == NULL
)
2227 ++vmlinux_path__nr_entries
;
2232 vmlinux_path__exit();
2236 size_t machine__fprintf_vmlinux_path(struct machine
*self
, FILE *fp
)
2240 struct dso
*kdso
= self
->vmlinux_maps
[MAP__FUNCTION
]->dso
;
2242 if (kdso
->has_build_id
) {
2243 char filename
[PATH_MAX
];
2244 if (dso__build_id_filename(kdso
, filename
, sizeof(filename
)))
2245 printed
+= fprintf(fp
, "[0] %s\n", filename
);
2248 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
)
2249 printed
+= fprintf(fp
, "[%d] %s\n",
2250 i
+ kdso
->has_build_id
, vmlinux_path
[i
]);
2255 static int setup_list(struct strlist
**list
, const char *list_str
,
2256 const char *list_name
)
2258 if (list_str
== NULL
)
2261 *list
= strlist__new(true, list_str
);
2263 pr_err("problems parsing %s list\n", list_name
);
2269 int symbol__init(void)
2271 if (symbol_conf
.initialized
)
2274 elf_version(EV_CURRENT
);
2275 if (symbol_conf
.sort_by_name
)
2276 symbol_conf
.priv_size
+= (sizeof(struct symbol_name_rb_node
) -
2277 sizeof(struct symbol
));
2279 if (symbol_conf
.try_vmlinux_path
&& vmlinux_path__init() < 0)
2282 if (symbol_conf
.field_sep
&& *symbol_conf
.field_sep
== '.') {
2283 pr_err("'.' is the only non valid --field-separator argument\n");
2287 if (setup_list(&symbol_conf
.dso_list
,
2288 symbol_conf
.dso_list_str
, "dso") < 0)
2291 if (setup_list(&symbol_conf
.comm_list
,
2292 symbol_conf
.comm_list_str
, "comm") < 0)
2293 goto out_free_dso_list
;
2295 if (setup_list(&symbol_conf
.sym_list
,
2296 symbol_conf
.sym_list_str
, "symbol") < 0)
2297 goto out_free_comm_list
;
2299 symbol_conf
.initialized
= true;
2303 strlist__delete(symbol_conf
.dso_list
);
2305 strlist__delete(symbol_conf
.comm_list
);
2309 void symbol__exit(void)
2311 if (!symbol_conf
.initialized
)
2313 strlist__delete(symbol_conf
.sym_list
);
2314 strlist__delete(symbol_conf
.dso_list
);
2315 strlist__delete(symbol_conf
.comm_list
);
2316 vmlinux_path__exit();
2317 symbol_conf
.sym_list
= symbol_conf
.dso_list
= symbol_conf
.comm_list
= NULL
;
2318 symbol_conf
.initialized
= false;
2321 int machines__create_kernel_maps(struct rb_root
*self
, pid_t pid
)
2323 struct machine
*machine
= machines__findnew(self
, pid
);
2325 if (machine
== NULL
)
2328 return machine__create_kernel_maps(machine
);
2331 static int hex(char ch
)
2333 if ((ch
>= '0') && (ch
<= '9'))
2335 if ((ch
>= 'a') && (ch
<= 'f'))
2336 return ch
- 'a' + 10;
2337 if ((ch
>= 'A') && (ch
<= 'F'))
2338 return ch
- 'A' + 10;
2343 * While we find nice hex chars, build a long_val.
2344 * Return number of chars processed.
2346 int hex2u64(const char *ptr
, u64
*long_val
)
2348 const char *p
= ptr
;
2352 const int hex_val
= hex(*p
);
2357 *long_val
= (*long_val
<< 4) | hex_val
;
2364 char *strxfrchar(char *s
, char from
, char to
)
2368 while ((p
= strchr(p
, from
)) != NULL
)
2374 int machines__create_guest_kernel_maps(struct rb_root
*self
)
2377 struct dirent
**namelist
= NULL
;
2379 char path
[PATH_MAX
];
2382 if (symbol_conf
.default_guest_vmlinux_name
||
2383 symbol_conf
.default_guest_modules
||
2384 symbol_conf
.default_guest_kallsyms
) {
2385 machines__create_kernel_maps(self
, DEFAULT_GUEST_KERNEL_ID
);
2388 if (symbol_conf
.guestmount
) {
2389 items
= scandir(symbol_conf
.guestmount
, &namelist
, NULL
, NULL
);
2392 for (i
= 0; i
< items
; i
++) {
2393 if (!isdigit(namelist
[i
]->d_name
[0])) {
2394 /* Filter out . and .. */
2397 pid
= atoi(namelist
[i
]->d_name
);
2398 sprintf(path
, "%s/%s/proc/kallsyms",
2399 symbol_conf
.guestmount
,
2400 namelist
[i
]->d_name
);
2401 ret
= access(path
, R_OK
);
2403 pr_debug("Can't access file %s\n", path
);
2406 machines__create_kernel_maps(self
, pid
);
2415 void machines__destroy_guest_kernel_maps(struct rb_root
*self
)
2417 struct rb_node
*next
= rb_first(self
);
2420 struct machine
*pos
= rb_entry(next
, struct machine
, rb_node
);
2422 next
= rb_next(&pos
->rb_node
);
2423 rb_erase(&pos
->rb_node
, self
);
2424 machine__delete(pos
);
2428 int machine__load_kallsyms(struct machine
*self
, const char *filename
,
2429 enum map_type type
, symbol_filter_t filter
)
2431 struct map
*map
= self
->vmlinux_maps
[type
];
2432 int ret
= dso__load_kallsyms(map
->dso
, filename
, map
, filter
);
2435 dso__set_loaded(map
->dso
, type
);
2437 * Since /proc/kallsyms will have multiple sessions for the
2438 * kernel, with modules between them, fixup the end of all
2441 __map_groups__fixup_end(&self
->kmaps
, type
);
2447 int machine__load_vmlinux_path(struct machine
*self
, enum map_type type
,
2448 symbol_filter_t filter
)
2450 struct map
*map
= self
->vmlinux_maps
[type
];
2451 int ret
= dso__load_vmlinux_path(map
->dso
, map
, filter
);
2454 dso__set_loaded(map
->dso
, type
);
2455 map__reloc_vmlinux(map
);