perf: 'perf kvm' tool for monitoring guest performance from host
[linux-2.6.git] / tools / perf / util / symbol.c
1 #define _GNU_SOURCE
2 #include <ctype.h>
3 #include <dirent.h>
4 #include <errno.h>
5 #include <libgen.h>
6 #include <stdlib.h>
7 #include <stdio.h>
8 #include <string.h>
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <sys/param.h>
12 #include <fcntl.h>
13 #include <unistd.h>
14 #include "symbol.h"
15 #include "strlist.h"
16
17 #include <libelf.h>
18 #include <gelf.h>
19 #include <elf.h>
20 #include <limits.h>
21 #include <sys/utsname.h>
22
23 #ifndef NT_GNU_BUILD_ID
24 #define NT_GNU_BUILD_ID 3
25 #endif
26
27 static void dsos__add(struct list_head *head, struct dso *dso);
28 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
29 static int dso__load_kernel_sym(struct dso *self, struct map *map,
30                                 symbol_filter_t filter);
31 static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
32                         symbol_filter_t filter);
33 static int vmlinux_path__nr_entries;
34 static char **vmlinux_path;
35
36 struct symbol_conf symbol_conf = {
37         .exclude_other    = true,
38         .use_modules      = true,
39         .try_vmlinux_path = true,
40 };
41
42 bool dso__loaded(const struct dso *self, enum map_type type)
43 {
44         return self->loaded & (1 << type);
45 }
46
47 bool dso__sorted_by_name(const struct dso *self, enum map_type type)
48 {
49         return self->sorted_by_name & (1 << type);
50 }
51
52 static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
53 {
54         self->sorted_by_name |= (1 << type);
55 }
56
57 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
58 {
59         switch (map_type) {
60         case MAP__FUNCTION:
61                 return symbol_type == 'T' || symbol_type == 'W';
62         case MAP__VARIABLE:
63                 return symbol_type == 'D' || symbol_type == 'd';
64         default:
65                 return false;
66         }
67 }
68
69 static void symbols__fixup_end(struct rb_root *self)
70 {
71         struct rb_node *nd, *prevnd = rb_first(self);
72         struct symbol *curr, *prev;
73
74         if (prevnd == NULL)
75                 return;
76
77         curr = rb_entry(prevnd, struct symbol, rb_node);
78
79         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
80                 prev = curr;
81                 curr = rb_entry(nd, struct symbol, rb_node);
82
83                 if (prev->end == prev->start)
84                         prev->end = curr->start - 1;
85         }
86
87         /* Last entry */
88         if (curr->end == curr->start)
89                 curr->end = roundup(curr->start, 4096);
90 }
91
92 static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
93 {
94         struct map *prev, *curr;
95         struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
96
97         if (prevnd == NULL)
98                 return;
99
100         curr = rb_entry(prevnd, struct map, rb_node);
101
102         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
103                 prev = curr;
104                 curr = rb_entry(nd, struct map, rb_node);
105                 prev->end = curr->start - 1;
106         }
107
108         /*
109          * We still haven't the actual symbols, so guess the
110          * last map final address.
111          */
112         curr->end = ~0UL;
113 }
114
115 static void map_groups__fixup_end(struct map_groups *self)
116 {
117         int i;
118         for (i = 0; i < MAP__NR_TYPES; ++i)
119                 __map_groups__fixup_end(self, i);
120 }
121
122 static struct symbol *symbol__new(u64 start, u64 len, const char *name)
123 {
124         size_t namelen = strlen(name) + 1;
125         struct symbol *self = calloc(1, (symbol_conf.priv_size +
126                                          sizeof(*self) + namelen));
127         if (self == NULL)
128                 return NULL;
129
130         if (symbol_conf.priv_size)
131                 self = ((void *)self) + symbol_conf.priv_size;
132
133         self->start = start;
134         self->end   = len ? start + len - 1 : start;
135
136         pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
137
138         memcpy(self->name, name, namelen);
139
140         return self;
141 }
142
143 void symbol__delete(struct symbol *self)
144 {
145         free(((void *)self) - symbol_conf.priv_size);
146 }
147
148 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
149 {
150         return fprintf(fp, " %llx-%llx %s\n",
151                        self->start, self->end, self->name);
152 }
153
154 void dso__set_long_name(struct dso *self, char *name)
155 {
156         if (name == NULL)
157                 return;
158         self->long_name = name;
159         self->long_name_len = strlen(name);
160 }
161
162 static void dso__set_short_name(struct dso *self, const char *name)
163 {
164         if (name == NULL)
165                 return;
166         self->short_name = name;
167         self->short_name_len = strlen(name);
168 }
169
170 static void dso__set_basename(struct dso *self)
171 {
172         dso__set_short_name(self, basename(self->long_name));
173 }
174
175 struct dso *dso__new(const char *name)
176 {
177         struct dso *self = calloc(1, sizeof(*self) + strlen(name) + 1);
178
179         if (self != NULL) {
180                 int i;
181                 strcpy(self->name, name);
182                 dso__set_long_name(self, self->name);
183                 dso__set_short_name(self, self->name);
184                 for (i = 0; i < MAP__NR_TYPES; ++i)
185                         self->symbols[i] = self->symbol_names[i] = RB_ROOT;
186                 self->slen_calculated = 0;
187                 self->origin = DSO__ORIG_NOT_FOUND;
188                 self->loaded = 0;
189                 self->sorted_by_name = 0;
190                 self->has_build_id = 0;
191                 self->kernel = DSO_TYPE_USER;
192         }
193
194         return self;
195 }
196
197 static void symbols__delete(struct rb_root *self)
198 {
199         struct symbol *pos;
200         struct rb_node *next = rb_first(self);
201
202         while (next) {
203                 pos = rb_entry(next, struct symbol, rb_node);
204                 next = rb_next(&pos->rb_node);
205                 rb_erase(&pos->rb_node, self);
206                 symbol__delete(pos);
207         }
208 }
209
210 void dso__delete(struct dso *self)
211 {
212         int i;
213         for (i = 0; i < MAP__NR_TYPES; ++i)
214                 symbols__delete(&self->symbols[i]);
215         if (self->long_name != self->name)
216                 free(self->long_name);
217         free(self);
218 }
219
220 void dso__set_build_id(struct dso *self, void *build_id)
221 {
222         memcpy(self->build_id, build_id, sizeof(self->build_id));
223         self->has_build_id = 1;
224 }
225
226 static void symbols__insert(struct rb_root *self, struct symbol *sym)
227 {
228         struct rb_node **p = &self->rb_node;
229         struct rb_node *parent = NULL;
230         const u64 ip = sym->start;
231         struct symbol *s;
232
233         while (*p != NULL) {
234                 parent = *p;
235                 s = rb_entry(parent, struct symbol, rb_node);
236                 if (ip < s->start)
237                         p = &(*p)->rb_left;
238                 else
239                         p = &(*p)->rb_right;
240         }
241         rb_link_node(&sym->rb_node, parent, p);
242         rb_insert_color(&sym->rb_node, self);
243 }
244
245 static struct symbol *symbols__find(struct rb_root *self, u64 ip)
246 {
247         struct rb_node *n;
248
249         if (self == NULL)
250                 return NULL;
251
252         n = self->rb_node;
253
254         while (n) {
255                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
256
257                 if (ip < s->start)
258                         n = n->rb_left;
259                 else if (ip > s->end)
260                         n = n->rb_right;
261                 else
262                         return s;
263         }
264
265         return NULL;
266 }
267
268 struct symbol_name_rb_node {
269         struct rb_node  rb_node;
270         struct symbol   sym;
271 };
272
273 static void symbols__insert_by_name(struct rb_root *self, struct symbol *sym)
274 {
275         struct rb_node **p = &self->rb_node;
276         struct rb_node *parent = NULL;
277         struct symbol_name_rb_node *symn = ((void *)sym) - sizeof(*parent), *s;
278
279         while (*p != NULL) {
280                 parent = *p;
281                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
282                 if (strcmp(sym->name, s->sym.name) < 0)
283                         p = &(*p)->rb_left;
284                 else
285                         p = &(*p)->rb_right;
286         }
287         rb_link_node(&symn->rb_node, parent, p);
288         rb_insert_color(&symn->rb_node, self);
289 }
290
291 static void symbols__sort_by_name(struct rb_root *self, struct rb_root *source)
292 {
293         struct rb_node *nd;
294
295         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
296                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
297                 symbols__insert_by_name(self, pos);
298         }
299 }
300
301 static struct symbol *symbols__find_by_name(struct rb_root *self, const char *name)
302 {
303         struct rb_node *n;
304
305         if (self == NULL)
306                 return NULL;
307
308         n = self->rb_node;
309
310         while (n) {
311                 struct symbol_name_rb_node *s;
312                 int cmp;
313
314                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
315                 cmp = strcmp(name, s->sym.name);
316
317                 if (cmp < 0)
318                         n = n->rb_left;
319                 else if (cmp > 0)
320                         n = n->rb_right;
321                 else
322                         return &s->sym;
323         }
324
325         return NULL;
326 }
327
328 struct symbol *dso__find_symbol(struct dso *self,
329                                 enum map_type type, u64 addr)
330 {
331         return symbols__find(&self->symbols[type], addr);
332 }
333
334 struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
335                                         const char *name)
336 {
337         return symbols__find_by_name(&self->symbol_names[type], name);
338 }
339
340 void dso__sort_by_name(struct dso *self, enum map_type type)
341 {
342         dso__set_sorted_by_name(self, type);
343         return symbols__sort_by_name(&self->symbol_names[type],
344                                      &self->symbols[type]);
345 }
346
347 int build_id__sprintf(const u8 *self, int len, char *bf)
348 {
349         char *bid = bf;
350         const u8 *raw = self;
351         int i;
352
353         for (i = 0; i < len; ++i) {
354                 sprintf(bid, "%02x", *raw);
355                 ++raw;
356                 bid += 2;
357         }
358
359         return raw - self;
360 }
361
362 size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
363 {
364         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
365
366         build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
367         return fprintf(fp, "%s", sbuild_id);
368 }
369
370 size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
371 {
372         struct rb_node *nd;
373         size_t ret = fprintf(fp, "dso: %s (", self->short_name);
374
375         if (self->short_name != self->long_name)
376                 ret += fprintf(fp, "%s, ", self->long_name);
377         ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
378                        self->loaded ? "" : "NOT ");
379         ret += dso__fprintf_buildid(self, fp);
380         ret += fprintf(fp, ")\n");
381         for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
382                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
383                 ret += symbol__fprintf(pos, fp);
384         }
385
386         return ret;
387 }
388
389 int kallsyms__parse(const char *filename, void *arg,
390                     int (*process_symbol)(void *arg, const char *name,
391                                                      char type, u64 start))
392 {
393         char *line = NULL;
394         size_t n;
395         int err = 0;
396         FILE *file = fopen(filename, "r");
397
398         if (file == NULL)
399                 goto out_failure;
400
401         while (!feof(file)) {
402                 u64 start;
403                 int line_len, len;
404                 char symbol_type;
405                 char *symbol_name;
406
407                 line_len = getline(&line, &n, file);
408                 if (line_len < 0 || !line)
409                         break;
410
411                 line[--line_len] = '\0'; /* \n */
412
413                 len = hex2u64(line, &start);
414
415                 len++;
416                 if (len + 2 >= line_len)
417                         continue;
418
419                 symbol_type = toupper(line[len]);
420                 symbol_name = line + len + 2;
421
422                 err = process_symbol(arg, symbol_name, symbol_type, start);
423                 if (err)
424                         break;
425         }
426
427         free(line);
428         fclose(file);
429         return err;
430
431 out_failure:
432         return -1;
433 }
434
435 struct process_kallsyms_args {
436         struct map *map;
437         struct dso *dso;
438 };
439
440 static int map__process_kallsym_symbol(void *arg, const char *name,
441                                        char type, u64 start)
442 {
443         struct symbol *sym;
444         struct process_kallsyms_args *a = arg;
445         struct rb_root *root = &a->dso->symbols[a->map->type];
446
447         if (!symbol_type__is_a(type, a->map->type))
448                 return 0;
449
450         /*
451          * Will fix up the end later, when we have all symbols sorted.
452          */
453         sym = symbol__new(start, 0, name);
454
455         if (sym == NULL)
456                 return -ENOMEM;
457         /*
458          * We will pass the symbols to the filter later, in
459          * map__split_kallsyms, when we have split the maps per module
460          */
461         symbols__insert(root, sym);
462
463         return 0;
464 }
465
466 /*
467  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
468  * so that we can in the next step set the symbol ->end address and then
469  * call kernel_maps__split_kallsyms.
470  */
471 static int dso__load_all_kallsyms(struct dso *self, const char *filename,
472                                   struct map *map)
473 {
474         struct process_kallsyms_args args = { .map = map, .dso = self, };
475         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
476 }
477
478 /*
479  * Split the symbols into maps, making sure there are no overlaps, i.e. the
480  * kernel range is broken in several maps, named [kernel].N, as we don't have
481  * the original ELF section names vmlinux have.
482  */
483 static int dso__split_kallsyms(struct dso *self, struct map *map,
484                                symbol_filter_t filter)
485 {
486         struct map_groups *kmaps = map__kmap(map)->kmaps;
487         struct kernel_info *kerninfo = kmaps->this_kerninfo;
488         struct map *curr_map = map;
489         struct symbol *pos;
490         int count = 0;
491         struct rb_root *root = &self->symbols[map->type];
492         struct rb_node *next = rb_first(root);
493         int kernel_range = 0;
494
495         while (next) {
496                 char *module;
497
498                 pos = rb_entry(next, struct symbol, rb_node);
499                 next = rb_next(&pos->rb_node);
500
501                 module = strchr(pos->name, '\t');
502                 if (module) {
503                         if (!symbol_conf.use_modules)
504                                 goto discard_symbol;
505
506                         *module++ = '\0';
507
508                         if (strcmp(curr_map->dso->short_name, module)) {
509                                 if (curr_map != map &&
510                                         self->kernel == DSO_TYPE_GUEST_KERNEL &&
511                                         is_default_guest(kerninfo)) {
512                                         /*
513                                          * We assume all symbols of a module are
514                                          * continuous in * kallsyms, so curr_map
515                                          * points to a module and all its
516                                          * symbols are in its kmap. Mark it as
517                                          * loaded.
518                                          */
519                                         dso__set_loaded(curr_map->dso,
520                                                         curr_map->type);
521                                 }
522
523                                 curr_map = map_groups__find_by_name(kmaps,
524                                                         map->type, module);
525                                 if (curr_map == NULL) {
526                                         pr_err("%s/proc/{kallsyms,modules} "
527                                                  "inconsistency while looking "
528                                                  "for \"%s\" module!\n",
529                                                  kerninfo->root_dir, module);
530                                         curr_map = map;
531                                         goto discard_symbol;
532                                 }
533
534                                 if (curr_map->dso->loaded &&
535                                         !is_default_guest(kmaps->this_kerninfo))
536                                         goto discard_symbol;
537                         }
538                         /*
539                          * So that we look just like we get from .ko files,
540                          * i.e. not prelinked, relative to map->start.
541                          */
542                         pos->start = curr_map->map_ip(curr_map, pos->start);
543                         pos->end   = curr_map->map_ip(curr_map, pos->end);
544                 } else if (curr_map != map) {
545                         char dso_name[PATH_MAX];
546                         struct dso *dso;
547
548                         if (self->kernel == DSO_TYPE_GUEST_KERNEL)
549                                 snprintf(dso_name, sizeof(dso_name),
550                                         "[guest.kernel].%d",
551                                         kernel_range++);
552                         else
553                                 snprintf(dso_name, sizeof(dso_name),
554                                         "[kernel].%d",
555                                         kernel_range++);
556
557                         dso = dso__new(dso_name);
558                         if (dso == NULL)
559                                 return -1;
560
561                         dso->kernel = self->kernel;
562
563                         curr_map = map__new2(pos->start, dso, map->type);
564                         if (curr_map == NULL) {
565                                 dso__delete(dso);
566                                 return -1;
567                         }
568
569                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
570                         map_groups__insert(kmaps, curr_map);
571                         ++kernel_range;
572                 }
573
574                 if (filter && filter(curr_map, pos)) {
575 discard_symbol:         rb_erase(&pos->rb_node, root);
576                         symbol__delete(pos);
577                 } else {
578                         if (curr_map != map) {
579                                 rb_erase(&pos->rb_node, root);
580                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
581                         }
582                         count++;
583                 }
584         }
585
586         if (curr_map != map &&
587             self->kernel == DSO_TYPE_GUEST_KERNEL &&
588             is_default_guest(kmaps->this_kerninfo)) {
589                 dso__set_loaded(curr_map->dso, curr_map->type);
590         }
591
592         return count;
593 }
594
595 int dso__load_kallsyms(struct dso *self, const char *filename,
596                        struct map *map, symbol_filter_t filter)
597 {
598         if (dso__load_all_kallsyms(self, filename, map) < 0)
599                 return -1;
600
601         symbols__fixup_end(&self->symbols[map->type]);
602         if (self->kernel == DSO_TYPE_GUEST_KERNEL)
603                 self->origin = DSO__ORIG_GUEST_KERNEL;
604         else
605                 self->origin = DSO__ORIG_KERNEL;
606
607         return dso__split_kallsyms(self, map, filter);
608 }
609
610 static int dso__load_perf_map(struct dso *self, struct map *map,
611                               symbol_filter_t filter)
612 {
613         char *line = NULL;
614         size_t n;
615         FILE *file;
616         int nr_syms = 0;
617
618         file = fopen(self->long_name, "r");
619         if (file == NULL)
620                 goto out_failure;
621
622         while (!feof(file)) {
623                 u64 start, size;
624                 struct symbol *sym;
625                 int line_len, len;
626
627                 line_len = getline(&line, &n, file);
628                 if (line_len < 0)
629                         break;
630
631                 if (!line)
632                         goto out_failure;
633
634                 line[--line_len] = '\0'; /* \n */
635
636                 len = hex2u64(line, &start);
637
638                 len++;
639                 if (len + 2 >= line_len)
640                         continue;
641
642                 len += hex2u64(line + len, &size);
643
644                 len++;
645                 if (len + 2 >= line_len)
646                         continue;
647
648                 sym = symbol__new(start, size, line + len);
649
650                 if (sym == NULL)
651                         goto out_delete_line;
652
653                 if (filter && filter(map, sym))
654                         symbol__delete(sym);
655                 else {
656                         symbols__insert(&self->symbols[map->type], sym);
657                         nr_syms++;
658                 }
659         }
660
661         free(line);
662         fclose(file);
663
664         return nr_syms;
665
666 out_delete_line:
667         free(line);
668 out_failure:
669         return -1;
670 }
671
672 /**
673  * elf_symtab__for_each_symbol - iterate thru all the symbols
674  *
675  * @self: struct elf_symtab instance to iterate
676  * @idx: uint32_t idx
677  * @sym: GElf_Sym iterator
678  */
679 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
680         for (idx = 0, gelf_getsym(syms, idx, &sym);\
681              idx < nr_syms; \
682              idx++, gelf_getsym(syms, idx, &sym))
683
684 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
685 {
686         return GELF_ST_TYPE(sym->st_info);
687 }
688
689 static inline int elf_sym__is_function(const GElf_Sym *sym)
690 {
691         return elf_sym__type(sym) == STT_FUNC &&
692                sym->st_name != 0 &&
693                sym->st_shndx != SHN_UNDEF;
694 }
695
696 static inline bool elf_sym__is_object(const GElf_Sym *sym)
697 {
698         return elf_sym__type(sym) == STT_OBJECT &&
699                 sym->st_name != 0 &&
700                 sym->st_shndx != SHN_UNDEF;
701 }
702
703 static inline int elf_sym__is_label(const GElf_Sym *sym)
704 {
705         return elf_sym__type(sym) == STT_NOTYPE &&
706                 sym->st_name != 0 &&
707                 sym->st_shndx != SHN_UNDEF &&
708                 sym->st_shndx != SHN_ABS;
709 }
710
711 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
712                                         const Elf_Data *secstrs)
713 {
714         return secstrs->d_buf + shdr->sh_name;
715 }
716
717 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
718                                         const Elf_Data *secstrs)
719 {
720         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
721 }
722
723 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
724                                     const Elf_Data *secstrs)
725 {
726         return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
727 }
728
729 static inline const char *elf_sym__name(const GElf_Sym *sym,
730                                         const Elf_Data *symstrs)
731 {
732         return symstrs->d_buf + sym->st_name;
733 }
734
735 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
736                                     GElf_Shdr *shp, const char *name,
737                                     size_t *idx)
738 {
739         Elf_Scn *sec = NULL;
740         size_t cnt = 1;
741
742         while ((sec = elf_nextscn(elf, sec)) != NULL) {
743                 char *str;
744
745                 gelf_getshdr(sec, shp);
746                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
747                 if (!strcmp(name, str)) {
748                         if (idx)
749                                 *idx = cnt;
750                         break;
751                 }
752                 ++cnt;
753         }
754
755         return sec;
756 }
757
758 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
759         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
760              idx < nr_entries; \
761              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
762
763 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
764         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
765              idx < nr_entries; \
766              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
767
768 /*
769  * We need to check if we have a .dynsym, so that we can handle the
770  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
771  * .dynsym or .symtab).
772  * And always look at the original dso, not at debuginfo packages, that
773  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
774  */
775 static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
776                                        symbol_filter_t filter)
777 {
778         uint32_t nr_rel_entries, idx;
779         GElf_Sym sym;
780         u64 plt_offset;
781         GElf_Shdr shdr_plt;
782         struct symbol *f;
783         GElf_Shdr shdr_rel_plt, shdr_dynsym;
784         Elf_Data *reldata, *syms, *symstrs;
785         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
786         size_t dynsym_idx;
787         GElf_Ehdr ehdr;
788         char sympltname[1024];
789         Elf *elf;
790         int nr = 0, symidx, fd, err = 0;
791
792         fd = open(self->long_name, O_RDONLY);
793         if (fd < 0)
794                 goto out;
795
796         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
797         if (elf == NULL)
798                 goto out_close;
799
800         if (gelf_getehdr(elf, &ehdr) == NULL)
801                 goto out_elf_end;
802
803         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
804                                          ".dynsym", &dynsym_idx);
805         if (scn_dynsym == NULL)
806                 goto out_elf_end;
807
808         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
809                                           ".rela.plt", NULL);
810         if (scn_plt_rel == NULL) {
811                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
812                                                   ".rel.plt", NULL);
813                 if (scn_plt_rel == NULL)
814                         goto out_elf_end;
815         }
816
817         err = -1;
818
819         if (shdr_rel_plt.sh_link != dynsym_idx)
820                 goto out_elf_end;
821
822         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
823                 goto out_elf_end;
824
825         /*
826          * Fetch the relocation section to find the idxes to the GOT
827          * and the symbols in the .dynsym they refer to.
828          */
829         reldata = elf_getdata(scn_plt_rel, NULL);
830         if (reldata == NULL)
831                 goto out_elf_end;
832
833         syms = elf_getdata(scn_dynsym, NULL);
834         if (syms == NULL)
835                 goto out_elf_end;
836
837         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
838         if (scn_symstrs == NULL)
839                 goto out_elf_end;
840
841         symstrs = elf_getdata(scn_symstrs, NULL);
842         if (symstrs == NULL)
843                 goto out_elf_end;
844
845         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
846         plt_offset = shdr_plt.sh_offset;
847
848         if (shdr_rel_plt.sh_type == SHT_RELA) {
849                 GElf_Rela pos_mem, *pos;
850
851                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
852                                            nr_rel_entries) {
853                         symidx = GELF_R_SYM(pos->r_info);
854                         plt_offset += shdr_plt.sh_entsize;
855                         gelf_getsym(syms, symidx, &sym);
856                         snprintf(sympltname, sizeof(sympltname),
857                                  "%s@plt", elf_sym__name(&sym, symstrs));
858
859                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
860                                         sympltname);
861                         if (!f)
862                                 goto out_elf_end;
863
864                         if (filter && filter(map, f))
865                                 symbol__delete(f);
866                         else {
867                                 symbols__insert(&self->symbols[map->type], f);
868                                 ++nr;
869                         }
870                 }
871         } else if (shdr_rel_plt.sh_type == SHT_REL) {
872                 GElf_Rel pos_mem, *pos;
873                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
874                                           nr_rel_entries) {
875                         symidx = GELF_R_SYM(pos->r_info);
876                         plt_offset += shdr_plt.sh_entsize;
877                         gelf_getsym(syms, symidx, &sym);
878                         snprintf(sympltname, sizeof(sympltname),
879                                  "%s@plt", elf_sym__name(&sym, symstrs));
880
881                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
882                                         sympltname);
883                         if (!f)
884                                 goto out_elf_end;
885
886                         if (filter && filter(map, f))
887                                 symbol__delete(f);
888                         else {
889                                 symbols__insert(&self->symbols[map->type], f);
890                                 ++nr;
891                         }
892                 }
893         }
894
895         err = 0;
896 out_elf_end:
897         elf_end(elf);
898 out_close:
899         close(fd);
900
901         if (err == 0)
902                 return nr;
903 out:
904         pr_debug("%s: problems reading %s PLT info.\n",
905                  __func__, self->long_name);
906         return 0;
907 }
908
909 static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
910 {
911         switch (type) {
912         case MAP__FUNCTION:
913                 return elf_sym__is_function(self);
914         case MAP__VARIABLE:
915                 return elf_sym__is_object(self);
916         default:
917                 return false;
918         }
919 }
920
921 static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
922 {
923         switch (type) {
924         case MAP__FUNCTION:
925                 return elf_sec__is_text(self, secstrs);
926         case MAP__VARIABLE:
927                 return elf_sec__is_data(self, secstrs);
928         default:
929                 return false;
930         }
931 }
932
933 static int dso__load_sym(struct dso *self, struct map *map, const char *name,
934                          int fd, symbol_filter_t filter, int kmodule)
935 {
936         struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
937         struct map *curr_map = map;
938         struct dso *curr_dso = self;
939         Elf_Data *symstrs, *secstrs;
940         uint32_t nr_syms;
941         int err = -1;
942         uint32_t idx;
943         GElf_Ehdr ehdr;
944         GElf_Shdr shdr;
945         Elf_Data *syms;
946         GElf_Sym sym;
947         Elf_Scn *sec, *sec_strndx;
948         Elf *elf;
949         int nr = 0;
950
951         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
952         if (elf == NULL) {
953                 pr_err("%s: cannot read %s ELF file.\n", __func__, name);
954                 goto out_close;
955         }
956
957         if (gelf_getehdr(elf, &ehdr) == NULL) {
958                 pr_err("%s: cannot get elf header.\n", __func__);
959                 goto out_elf_end;
960         }
961
962         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
963         if (sec == NULL) {
964                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
965                 if (sec == NULL)
966                         goto out_elf_end;
967         }
968
969         syms = elf_getdata(sec, NULL);
970         if (syms == NULL)
971                 goto out_elf_end;
972
973         sec = elf_getscn(elf, shdr.sh_link);
974         if (sec == NULL)
975                 goto out_elf_end;
976
977         symstrs = elf_getdata(sec, NULL);
978         if (symstrs == NULL)
979                 goto out_elf_end;
980
981         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
982         if (sec_strndx == NULL)
983                 goto out_elf_end;
984
985         secstrs = elf_getdata(sec_strndx, NULL);
986         if (secstrs == NULL)
987                 goto out_elf_end;
988
989         nr_syms = shdr.sh_size / shdr.sh_entsize;
990
991         memset(&sym, 0, sizeof(sym));
992         if (self->kernel == DSO_TYPE_USER) {
993                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
994                                 elf_section_by_name(elf, &ehdr, &shdr,
995                                                      ".gnu.prelink_undo",
996                                                      NULL) != NULL);
997         } else self->adjust_symbols = 0;
998
999         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1000                 struct symbol *f;
1001                 const char *elf_name = elf_sym__name(&sym, symstrs);
1002                 char *demangled = NULL;
1003                 int is_label = elf_sym__is_label(&sym);
1004                 const char *section_name;
1005
1006                 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1007                     strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1008                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1009
1010                 if (!is_label && !elf_sym__is_a(&sym, map->type))
1011                         continue;
1012
1013                 sec = elf_getscn(elf, sym.st_shndx);
1014                 if (!sec)
1015                         goto out_elf_end;
1016
1017                 gelf_getshdr(sec, &shdr);
1018
1019                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1020                         continue;
1021
1022                 section_name = elf_sec__name(&shdr, secstrs);
1023
1024                 if (self->kernel != DSO_TYPE_USER || kmodule) {
1025                         char dso_name[PATH_MAX];
1026
1027                         if (strcmp(section_name,
1028                                    (curr_dso->short_name +
1029                                     self->short_name_len)) == 0)
1030                                 goto new_symbol;
1031
1032                         if (strcmp(section_name, ".text") == 0) {
1033                                 curr_map = map;
1034                                 curr_dso = self;
1035                                 goto new_symbol;
1036                         }
1037
1038                         snprintf(dso_name, sizeof(dso_name),
1039                                  "%s%s", self->short_name, section_name);
1040
1041                         curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1042                         if (curr_map == NULL) {
1043                                 u64 start = sym.st_value;
1044
1045                                 if (kmodule)
1046                                         start += map->start + shdr.sh_offset;
1047
1048                                 curr_dso = dso__new(dso_name);
1049                                 if (curr_dso == NULL)
1050                                         goto out_elf_end;
1051                                 curr_dso->kernel = self->kernel;
1052                                 curr_map = map__new2(start, curr_dso,
1053                                                      map->type);
1054                                 if (curr_map == NULL) {
1055                                         dso__delete(curr_dso);
1056                                         goto out_elf_end;
1057                                 }
1058                                 curr_map->map_ip = identity__map_ip;
1059                                 curr_map->unmap_ip = identity__map_ip;
1060                                 curr_dso->origin = self->origin;
1061                                 map_groups__insert(kmap->kmaps, curr_map);
1062                                 dsos__add(&self->node, curr_dso);
1063                                 dso__set_loaded(curr_dso, map->type);
1064                         } else
1065                                 curr_dso = curr_map->dso;
1066
1067                         goto new_symbol;
1068                 }
1069
1070                 if (curr_dso->adjust_symbols) {
1071                         pr_debug4("%s: adjusting symbol: st_value: %#Lx "
1072                                   "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
1073                                   (u64)sym.st_value, (u64)shdr.sh_addr,
1074                                   (u64)shdr.sh_offset);
1075                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1076                 }
1077                 /*
1078                  * We need to figure out if the object was created from C++ sources
1079                  * DWARF DW_compile_unit has this, but we don't always have access
1080                  * to it...
1081                  */
1082                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1083                 if (demangled != NULL)
1084                         elf_name = demangled;
1085 new_symbol:
1086                 f = symbol__new(sym.st_value, sym.st_size, elf_name);
1087                 free(demangled);
1088                 if (!f)
1089                         goto out_elf_end;
1090
1091                 if (filter && filter(curr_map, f))
1092                         symbol__delete(f);
1093                 else {
1094                         symbols__insert(&curr_dso->symbols[curr_map->type], f);
1095                         nr++;
1096                 }
1097         }
1098
1099         /*
1100          * For misannotated, zeroed, ASM function sizes.
1101          */
1102         if (nr > 0) {
1103                 symbols__fixup_end(&self->symbols[map->type]);
1104                 if (kmap) {
1105                         /*
1106                          * We need to fixup this here too because we create new
1107                          * maps here, for things like vsyscall sections.
1108                          */
1109                         __map_groups__fixup_end(kmap->kmaps, map->type);
1110                 }
1111         }
1112         err = nr;
1113 out_elf_end:
1114         elf_end(elf);
1115 out_close:
1116         return err;
1117 }
1118
1119 static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
1120 {
1121         return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
1122 }
1123
1124 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1125 {
1126         bool have_build_id = false;
1127         struct dso *pos;
1128
1129         list_for_each_entry(pos, head, node) {
1130                 if (with_hits && !pos->hit)
1131                         continue;
1132                 if (filename__read_build_id(pos->long_name, pos->build_id,
1133                                             sizeof(pos->build_id)) > 0) {
1134                         have_build_id     = true;
1135                         pos->has_build_id = true;
1136                 }
1137         }
1138
1139         return have_build_id;
1140 }
1141
1142 /*
1143  * Align offset to 4 bytes as needed for note name and descriptor data.
1144  */
1145 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1146
1147 int filename__read_build_id(const char *filename, void *bf, size_t size)
1148 {
1149         int fd, err = -1;
1150         GElf_Ehdr ehdr;
1151         GElf_Shdr shdr;
1152         Elf_Data *data;
1153         Elf_Scn *sec;
1154         Elf_Kind ek;
1155         void *ptr;
1156         Elf *elf;
1157
1158         if (size < BUILD_ID_SIZE)
1159                 goto out;
1160
1161         fd = open(filename, O_RDONLY);
1162         if (fd < 0)
1163                 goto out;
1164
1165         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1166         if (elf == NULL) {
1167                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1168                 goto out_close;
1169         }
1170
1171         ek = elf_kind(elf);
1172         if (ek != ELF_K_ELF)
1173                 goto out_elf_end;
1174
1175         if (gelf_getehdr(elf, &ehdr) == NULL) {
1176                 pr_err("%s: cannot get elf header.\n", __func__);
1177                 goto out_elf_end;
1178         }
1179
1180         sec = elf_section_by_name(elf, &ehdr, &shdr,
1181                                   ".note.gnu.build-id", NULL);
1182         if (sec == NULL) {
1183                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1184                                           ".notes", NULL);
1185                 if (sec == NULL)
1186                         goto out_elf_end;
1187         }
1188
1189         data = elf_getdata(sec, NULL);
1190         if (data == NULL)
1191                 goto out_elf_end;
1192
1193         ptr = data->d_buf;
1194         while (ptr < (data->d_buf + data->d_size)) {
1195                 GElf_Nhdr *nhdr = ptr;
1196                 int namesz = NOTE_ALIGN(nhdr->n_namesz),
1197                     descsz = NOTE_ALIGN(nhdr->n_descsz);
1198                 const char *name;
1199
1200                 ptr += sizeof(*nhdr);
1201                 name = ptr;
1202                 ptr += namesz;
1203                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1204                     nhdr->n_namesz == sizeof("GNU")) {
1205                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1206                                 memcpy(bf, ptr, BUILD_ID_SIZE);
1207                                 err = BUILD_ID_SIZE;
1208                                 break;
1209                         }
1210                 }
1211                 ptr += descsz;
1212         }
1213 out_elf_end:
1214         elf_end(elf);
1215 out_close:
1216         close(fd);
1217 out:
1218         return err;
1219 }
1220
1221 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1222 {
1223         int fd, err = -1;
1224
1225         if (size < BUILD_ID_SIZE)
1226                 goto out;
1227
1228         fd = open(filename, O_RDONLY);
1229         if (fd < 0)
1230                 goto out;
1231
1232         while (1) {
1233                 char bf[BUFSIZ];
1234                 GElf_Nhdr nhdr;
1235                 int namesz, descsz;
1236
1237                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1238                         break;
1239
1240                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1241                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1242                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1243                     nhdr.n_namesz == sizeof("GNU")) {
1244                         if (read(fd, bf, namesz) != namesz)
1245                                 break;
1246                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1247                                 if (read(fd, build_id,
1248                                     BUILD_ID_SIZE) == BUILD_ID_SIZE) {
1249                                         err = 0;
1250                                         break;
1251                                 }
1252                         } else if (read(fd, bf, descsz) != descsz)
1253                                 break;
1254                 } else {
1255                         int n = namesz + descsz;
1256                         if (read(fd, bf, n) != n)
1257                                 break;
1258                 }
1259         }
1260         close(fd);
1261 out:
1262         return err;
1263 }
1264
1265 char dso__symtab_origin(const struct dso *self)
1266 {
1267         static const char origin[] = {
1268                 [DSO__ORIG_KERNEL] =   'k',
1269                 [DSO__ORIG_JAVA_JIT] = 'j',
1270                 [DSO__ORIG_BUILD_ID_CACHE] = 'B',
1271                 [DSO__ORIG_FEDORA] =   'f',
1272                 [DSO__ORIG_UBUNTU] =   'u',
1273                 [DSO__ORIG_BUILDID] =  'b',
1274                 [DSO__ORIG_DSO] =      'd',
1275                 [DSO__ORIG_KMODULE] =  'K',
1276                 [DSO__ORIG_GUEST_KERNEL] =  'g',
1277                 [DSO__ORIG_GUEST_KMODULE] =  'G',
1278         };
1279
1280         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
1281                 return '!';
1282         return origin[self->origin];
1283 }
1284
1285 int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1286 {
1287         int size = PATH_MAX;
1288         char *name;
1289         u8 build_id[BUILD_ID_SIZE];
1290         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1291         int ret = -1;
1292         int fd;
1293         struct kernel_info *kerninfo;
1294         const char *root_dir;
1295
1296         dso__set_loaded(self, map->type);
1297
1298         if (self->kernel == DSO_TYPE_KERNEL)
1299                 return dso__load_kernel_sym(self, map, filter);
1300         else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
1301                 return dso__load_guest_kernel_sym(self, map, filter);
1302
1303         if (map->groups && map->groups->this_kerninfo)
1304                 kerninfo = map->groups->this_kerninfo;
1305         else
1306                 kerninfo = NULL;
1307
1308         name = malloc(size);
1309         if (!name)
1310                 return -1;
1311
1312         self->adjust_symbols = 0;
1313
1314         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
1315                 ret = dso__load_perf_map(self, map, filter);
1316                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
1317                                          DSO__ORIG_NOT_FOUND;
1318                 return ret;
1319         }
1320
1321         self->origin = DSO__ORIG_BUILD_ID_CACHE;
1322
1323         if (self->has_build_id) {
1324                 build_id__sprintf(self->build_id, sizeof(self->build_id),
1325                                   build_id_hex);
1326                 snprintf(name, size, "%s/%s/.build-id/%.2s/%s",
1327                          getenv("HOME"), DEBUG_CACHE_DIR,
1328                          build_id_hex, build_id_hex + 2);
1329                 goto open_file;
1330         }
1331 more:
1332         do {
1333                 self->origin++;
1334                 switch (self->origin) {
1335                 case DSO__ORIG_FEDORA:
1336                         snprintf(name, size, "/usr/lib/debug%s.debug",
1337                                  self->long_name);
1338                         break;
1339                 case DSO__ORIG_UBUNTU:
1340                         snprintf(name, size, "/usr/lib/debug%s",
1341                                  self->long_name);
1342                         break;
1343                 case DSO__ORIG_BUILDID:
1344                         if (filename__read_build_id(self->long_name, build_id,
1345                                                     sizeof(build_id))) {
1346                                 build_id__sprintf(build_id, sizeof(build_id),
1347                                                   build_id_hex);
1348                                 snprintf(name, size,
1349                                          "/usr/lib/debug/.build-id/%.2s/%s.debug",
1350                                         build_id_hex, build_id_hex + 2);
1351                                 if (self->has_build_id)
1352                                         goto compare_build_id;
1353                                 break;
1354                         }
1355                         self->origin++;
1356                         /* Fall thru */
1357                 case DSO__ORIG_DSO:
1358                         snprintf(name, size, "%s", self->long_name);
1359                         break;
1360                 case DSO__ORIG_GUEST_KMODULE:
1361                         if (map->groups && map->groups->this_kerninfo)
1362                                 root_dir = map->groups->this_kerninfo->root_dir;
1363                         else
1364                                 root_dir = "";
1365                         snprintf(name, size, "%s%s", root_dir, self->long_name);
1366                         break;
1367
1368                 default:
1369                         goto out;
1370                 }
1371
1372                 if (self->has_build_id) {
1373                         if (filename__read_build_id(name, build_id,
1374                                                     sizeof(build_id)) < 0)
1375                                 goto more;
1376 compare_build_id:
1377                         if (!dso__build_id_equal(self, build_id))
1378                                 goto more;
1379                 }
1380 open_file:
1381                 fd = open(name, O_RDONLY);
1382         } while (fd < 0);
1383
1384         ret = dso__load_sym(self, map, name, fd, filter, 0);
1385         close(fd);
1386
1387         /*
1388          * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
1389          */
1390         if (!ret)
1391                 goto more;
1392
1393         if (ret > 0) {
1394                 int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
1395                 if (nr_plt > 0)
1396                         ret += nr_plt;
1397         }
1398 out:
1399         free(name);
1400         if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
1401                 return 0;
1402         return ret;
1403 }
1404
1405 struct map *map_groups__find_by_name(struct map_groups *self,
1406                                      enum map_type type, const char *name)
1407 {
1408         struct rb_node *nd;
1409
1410         for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
1411                 struct map *map = rb_entry(nd, struct map, rb_node);
1412
1413                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1414                         return map;
1415         }
1416
1417         return NULL;
1418 }
1419
1420 static int dso__kernel_module_get_build_id(struct dso *self,
1421                                 const char *root_dir)
1422 {
1423         char filename[PATH_MAX];
1424         /*
1425          * kernel module short names are of the form "[module]" and
1426          * we need just "module" here.
1427          */
1428         const char *name = self->short_name + 1;
1429
1430         snprintf(filename, sizeof(filename),
1431                  "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1432                  root_dir, (int)strlen(name) - 1, name);
1433
1434         if (sysfs__read_build_id(filename, self->build_id,
1435                                  sizeof(self->build_id)) == 0)
1436                 self->has_build_id = true;
1437
1438         return 0;
1439 }
1440
1441 static int map_groups__set_modules_path_dir(struct map_groups *self,
1442                                 const char *dir_name)
1443 {
1444         struct dirent *dent;
1445         DIR *dir = opendir(dir_name);
1446
1447         if (!dir) {
1448                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1449                 return -1;
1450         }
1451
1452         while ((dent = readdir(dir)) != NULL) {
1453                 char path[PATH_MAX];
1454                 struct stat st;
1455
1456                 /*sshfs might return bad dent->d_type, so we have to stat*/
1457                 sprintf(path, "%s/%s", dir_name, dent->d_name);
1458                 if (stat(path, &st))
1459                         continue;
1460
1461                 if (S_ISDIR(st.st_mode)) {
1462                         if (!strcmp(dent->d_name, ".") ||
1463                             !strcmp(dent->d_name, ".."))
1464                                 continue;
1465
1466                         snprintf(path, sizeof(path), "%s/%s",
1467                                  dir_name, dent->d_name);
1468                         if (map_groups__set_modules_path_dir(self, path) < 0)
1469                                 goto failure;
1470                 } else {
1471                         char *dot = strrchr(dent->d_name, '.'),
1472                              dso_name[PATH_MAX];
1473                         struct map *map;
1474                         char *long_name;
1475
1476                         if (dot == NULL || strcmp(dot, ".ko"))
1477                                 continue;
1478                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1479                                  (int)(dot - dent->d_name), dent->d_name);
1480
1481                         strxfrchar(dso_name, '-', '_');
1482                         map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
1483                         if (map == NULL)
1484                                 continue;
1485
1486                         snprintf(path, sizeof(path), "%s/%s",
1487                                  dir_name, dent->d_name);
1488
1489                         long_name = strdup(path);
1490                         if (long_name == NULL)
1491                                 goto failure;
1492                         dso__set_long_name(map->dso, long_name);
1493                         dso__kernel_module_get_build_id(map->dso, "");
1494                 }
1495         }
1496
1497         return 0;
1498 failure:
1499         closedir(dir);
1500         return -1;
1501 }
1502
1503 static char *get_kernel_version(const char *root_dir)
1504 {
1505         char version[PATH_MAX];
1506         FILE *file;
1507         char *name, *tmp;
1508         const char *prefix = "Linux version ";
1509
1510         sprintf(version, "%s/proc/version", root_dir);
1511         file = fopen(version, "r");
1512         if (!file)
1513                 return NULL;
1514
1515         version[0] = '\0';
1516         tmp = fgets(version, sizeof(version), file);
1517         fclose(file);
1518
1519         name = strstr(version, prefix);
1520         if (!name)
1521                 return NULL;
1522         name += strlen(prefix);
1523         tmp = strchr(name, ' ');
1524         if (tmp)
1525                 *tmp = '\0';
1526
1527         return strdup(name);
1528 }
1529
1530 static int map_groups__set_modules_path(struct map_groups *self,
1531                                 const char *root_dir)
1532 {
1533         char *version;
1534         char modules_path[PATH_MAX];
1535
1536         version = get_kernel_version(root_dir);
1537         if (!version)
1538                 return -1;
1539
1540         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1541                  root_dir, version);
1542         free(version);
1543
1544         return map_groups__set_modules_path_dir(self, modules_path);
1545 }
1546
1547 /*
1548  * Constructor variant for modules (where we know from /proc/modules where
1549  * they are loaded) and for vmlinux, where only after we load all the
1550  * symbols we'll know where it starts and ends.
1551  */
1552 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1553 {
1554         struct map *self = calloc(1, (sizeof(*self) +
1555                                       (dso->kernel ? sizeof(struct kmap) : 0)));
1556         if (self != NULL) {
1557                 /*
1558                  * ->end will be filled after we load all the symbols
1559                  */
1560                 map__init(self, type, start, 0, 0, dso);
1561         }
1562
1563         return self;
1564 }
1565
1566 struct map *map_groups__new_module(struct map_groups *self, u64 start,
1567                                 const char *filename,
1568                                 struct kernel_info *kerninfo)
1569 {
1570         struct map *map;
1571         struct dso *dso;
1572
1573         dso = __dsos__findnew(&kerninfo->dsos__kernel, filename);
1574         if (dso == NULL)
1575                 return NULL;
1576
1577         map = map__new2(start, dso, MAP__FUNCTION);
1578         if (map == NULL)
1579                 return NULL;
1580
1581         if (is_host_kernel(kerninfo))
1582                 dso->origin = DSO__ORIG_KMODULE;
1583         else
1584                 dso->origin = DSO__ORIG_GUEST_KMODULE;
1585         map_groups__insert(self, map);
1586         return map;
1587 }
1588
1589 static int map_groups__create_modules(struct kernel_info *kerninfo)
1590 {
1591         char *line = NULL;
1592         size_t n;
1593         FILE *file;
1594         struct map *map;
1595         const char *root_dir;
1596         const char *modules;
1597         char path[PATH_MAX];
1598
1599         if (is_default_guest(kerninfo))
1600                 modules = symbol_conf.default_guest_modules;
1601         else {
1602                 sprintf(path, "%s/proc/modules", kerninfo->root_dir);
1603                 modules = path;
1604         }
1605
1606         file = fopen(modules, "r");
1607         if (file == NULL)
1608                 return -1;
1609
1610         root_dir = kerninfo->root_dir;
1611
1612         while (!feof(file)) {
1613                 char name[PATH_MAX];
1614                 u64 start;
1615                 char *sep;
1616                 int line_len;
1617
1618                 line_len = getline(&line, &n, file);
1619                 if (line_len < 0)
1620                         break;
1621
1622                 if (!line)
1623                         goto out_failure;
1624
1625                 line[--line_len] = '\0'; /* \n */
1626
1627                 sep = strrchr(line, 'x');
1628                 if (sep == NULL)
1629                         continue;
1630
1631                 hex2u64(sep + 1, &start);
1632
1633                 sep = strchr(line, ' ');
1634                 if (sep == NULL)
1635                         continue;
1636
1637                 *sep = '\0';
1638
1639                 snprintf(name, sizeof(name), "[%s]", line);
1640                 map = map_groups__new_module(&kerninfo->kmaps,
1641                                 start, name, kerninfo);
1642                 if (map == NULL)
1643                         goto out_delete_line;
1644                 dso__kernel_module_get_build_id(map->dso, root_dir);
1645         }
1646
1647         free(line);
1648         fclose(file);
1649
1650         return map_groups__set_modules_path(&kerninfo->kmaps, root_dir);
1651
1652 out_delete_line:
1653         free(line);
1654 out_failure:
1655         return -1;
1656 }
1657
1658 static int dso__load_vmlinux(struct dso *self, struct map *map,
1659                              const char *vmlinux, symbol_filter_t filter)
1660 {
1661         int err = -1, fd;
1662
1663         if (self->has_build_id) {
1664                 u8 build_id[BUILD_ID_SIZE];
1665
1666                 if (filename__read_build_id(vmlinux, build_id,
1667                                             sizeof(build_id)) < 0) {
1668                         pr_debug("No build_id in %s, ignoring it\n", vmlinux);
1669                         return -1;
1670                 }
1671                 if (!dso__build_id_equal(self, build_id)) {
1672                         char expected_build_id[BUILD_ID_SIZE * 2 + 1],
1673                              vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
1674
1675                         build_id__sprintf(self->build_id,
1676                                           sizeof(self->build_id),
1677                                           expected_build_id);
1678                         build_id__sprintf(build_id, sizeof(build_id),
1679                                           vmlinux_build_id);
1680                         pr_debug("build_id in %s is %s while expected is %s, "
1681                                  "ignoring it\n", vmlinux, vmlinux_build_id,
1682                                  expected_build_id);
1683                         return -1;
1684                 }
1685         }
1686
1687         fd = open(vmlinux, O_RDONLY);
1688         if (fd < 0)
1689                 return -1;
1690
1691         dso__set_loaded(self, map->type);
1692         err = dso__load_sym(self, map, vmlinux, fd, filter, 0);
1693         close(fd);
1694
1695         if (err > 0)
1696                 pr_debug("Using %s for symbols\n", vmlinux);
1697
1698         return err;
1699 }
1700
1701 int dso__load_vmlinux_path(struct dso *self, struct map *map,
1702                            symbol_filter_t filter)
1703 {
1704         int i, err = 0;
1705
1706         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1707                  vmlinux_path__nr_entries);
1708
1709         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1710                 err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
1711                 if (err > 0) {
1712                         dso__set_long_name(self, strdup(vmlinux_path[i]));
1713                         break;
1714                 }
1715         }
1716
1717         return err;
1718 }
1719
1720 static int dso__load_kernel_sym(struct dso *self, struct map *map,
1721                                 symbol_filter_t filter)
1722 {
1723         int err;
1724         const char *kallsyms_filename = NULL;
1725         char *kallsyms_allocated_filename = NULL;
1726         /*
1727          * Step 1: if the user specified a vmlinux filename, use it and only
1728          * it, reporting errors to the user if it cannot be used.
1729          *
1730          * For instance, try to analyse an ARM perf.data file _without_ a
1731          * build-id, or if the user specifies the wrong path to the right
1732          * vmlinux file, obviously we can't fallback to another vmlinux (a
1733          * x86_86 one, on the machine where analysis is being performed, say),
1734          * or worse, /proc/kallsyms.
1735          *
1736          * If the specified file _has_ a build-id and there is a build-id
1737          * section in the perf.data file, we will still do the expected
1738          * validation in dso__load_vmlinux and will bail out if they don't
1739          * match.
1740          */
1741         if (symbol_conf.vmlinux_name != NULL) {
1742                 err = dso__load_vmlinux(self, map,
1743                                         symbol_conf.vmlinux_name, filter);
1744                 goto out_try_fixup;
1745         }
1746
1747         if (vmlinux_path != NULL) {
1748                 err = dso__load_vmlinux_path(self, map, filter);
1749                 if (err > 0)
1750                         goto out_fixup;
1751         }
1752
1753         /*
1754          * Say the kernel DSO was created when processing the build-id header table,
1755          * we have a build-id, so check if it is the same as the running kernel,
1756          * using it if it is.
1757          */
1758         if (self->has_build_id) {
1759                 u8 kallsyms_build_id[BUILD_ID_SIZE];
1760                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1761
1762                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1763                                          sizeof(kallsyms_build_id)) == 0) {
1764                         if (dso__build_id_equal(self, kallsyms_build_id)) {
1765                                 kallsyms_filename = "/proc/kallsyms";
1766                                 goto do_kallsyms;
1767                         }
1768                 }
1769                 /*
1770                  * Now look if we have it on the build-id cache in
1771                  * $HOME/.debug/[kernel.kallsyms].
1772                  */
1773                 build_id__sprintf(self->build_id, sizeof(self->build_id),
1774                                   sbuild_id);
1775
1776                 if (asprintf(&kallsyms_allocated_filename,
1777                              "%s/.debug/[kernel.kallsyms]/%s",
1778                              getenv("HOME"), sbuild_id) == -1) {
1779                         pr_err("Not enough memory for kallsyms file lookup\n");
1780                         return -1;
1781                 }
1782
1783                 kallsyms_filename = kallsyms_allocated_filename;
1784
1785                 if (access(kallsyms_filename, F_OK)) {
1786                         pr_err("No kallsyms or vmlinux with build-id %s "
1787                                "was found\n", sbuild_id);
1788                         free(kallsyms_allocated_filename);
1789                         return -1;
1790                 }
1791         } else {
1792                 /*
1793                  * Last resort, if we don't have a build-id and couldn't find
1794                  * any vmlinux file, try the running kernel kallsyms table.
1795                  */
1796                 kallsyms_filename = "/proc/kallsyms";
1797         }
1798
1799 do_kallsyms:
1800         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1801         if (err > 0)
1802                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1803         free(kallsyms_allocated_filename);
1804
1805 out_try_fixup:
1806         if (err > 0) {
1807 out_fixup:
1808                 if (kallsyms_filename != NULL)
1809                         dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1810                 map__fixup_start(map);
1811                 map__fixup_end(map);
1812         }
1813
1814         return err;
1815 }
1816
1817 static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1818                                 symbol_filter_t filter)
1819 {
1820         int err;
1821         const char *kallsyms_filename = NULL;
1822         struct kernel_info *kerninfo;
1823         char path[PATH_MAX];
1824
1825         if (!map->groups) {
1826                 pr_debug("Guest kernel map hasn't the point to groups\n");
1827                 return -1;
1828         }
1829         kerninfo = map->groups->this_kerninfo;
1830
1831         if (is_default_guest(kerninfo)) {
1832                 /*
1833                  * if the user specified a vmlinux filename, use it and only
1834                  * it, reporting errors to the user if it cannot be used.
1835                  * Or use file guest_kallsyms inputted by user on commandline
1836                  */
1837                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1838                         err = dso__load_vmlinux(self, map,
1839                                 symbol_conf.default_guest_vmlinux_name, filter);
1840                         goto out_try_fixup;
1841                 }
1842
1843                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1844                 if (!kallsyms_filename)
1845                         return -1;
1846         } else {
1847                 sprintf(path, "%s/proc/kallsyms", kerninfo->root_dir);
1848                 kallsyms_filename = path;
1849         }
1850
1851         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1852         if (err > 0)
1853                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1854
1855 out_try_fixup:
1856         if (err > 0) {
1857                 if (kallsyms_filename != NULL) {
1858                         kern_mmap_name(kerninfo, path);
1859                         dso__set_long_name(self,
1860                                 strdup(path));
1861                 }
1862                 map__fixup_start(map);
1863                 map__fixup_end(map);
1864         }
1865
1866         return err;
1867 }
1868
1869 static void dsos__add(struct list_head *head, struct dso *dso)
1870 {
1871         list_add_tail(&dso->node, head);
1872 }
1873
1874 static struct dso *dsos__find(struct list_head *head, const char *name)
1875 {
1876         struct dso *pos;
1877
1878         list_for_each_entry(pos, head, node)
1879                 if (strcmp(pos->long_name, name) == 0)
1880                         return pos;
1881         return NULL;
1882 }
1883
1884 struct dso *__dsos__findnew(struct list_head *head, const char *name)
1885 {
1886         struct dso *dso = dsos__find(head, name);
1887
1888         if (!dso) {
1889                 dso = dso__new(name);
1890                 if (dso != NULL) {
1891                         dsos__add(head, dso);
1892                         dso__set_basename(dso);
1893                 }
1894         }
1895
1896         return dso;
1897 }
1898
1899 static void __dsos__fprintf(struct list_head *head, FILE *fp)
1900 {
1901         struct dso *pos;
1902
1903         list_for_each_entry(pos, head, node) {
1904                 int i;
1905                 for (i = 0; i < MAP__NR_TYPES; ++i)
1906                         dso__fprintf(pos, i, fp);
1907         }
1908 }
1909
1910 void dsos__fprintf(struct rb_root *kerninfo_root, FILE *fp)
1911 {
1912         struct rb_node *nd;
1913
1914         for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) {
1915                 struct kernel_info *pos = rb_entry(nd, struct kernel_info,
1916                                 rb_node);
1917                 __dsos__fprintf(&pos->dsos__kernel, fp);
1918                 __dsos__fprintf(&pos->dsos__user, fp);
1919         }
1920 }
1921
1922 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
1923                                       bool with_hits)
1924 {
1925         struct dso *pos;
1926         size_t ret = 0;
1927
1928         list_for_each_entry(pos, head, node) {
1929                 if (with_hits && !pos->hit)
1930                         continue;
1931                 ret += dso__fprintf_buildid(pos, fp);
1932                 ret += fprintf(fp, " %s\n", pos->long_name);
1933         }
1934         return ret;
1935 }
1936
1937 size_t dsos__fprintf_buildid(struct rb_root *kerninfo_root,
1938                 FILE *fp, bool with_hits)
1939 {
1940         struct rb_node *nd;
1941         size_t ret = 0;
1942
1943         for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) {
1944                 struct kernel_info *pos = rb_entry(nd, struct kernel_info,
1945                                 rb_node);
1946                 ret += __dsos__fprintf_buildid(&pos->dsos__kernel,
1947                                         fp, with_hits);
1948                 ret += __dsos__fprintf_buildid(&pos->dsos__user,
1949                                         fp, with_hits);
1950         }
1951         return ret;
1952 }
1953
1954 struct dso *dso__new_kernel(const char *name)
1955 {
1956         struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
1957
1958         if (self != NULL) {
1959                 dso__set_short_name(self, "[kernel]");
1960                 self->kernel = DSO_TYPE_KERNEL;
1961         }
1962
1963         return self;
1964 }
1965
1966 static struct dso *dso__new_guest_kernel(struct kernel_info *kerninfo,
1967                                         const char *name)
1968 {
1969         char buff[PATH_MAX];
1970         struct dso *self;
1971
1972         kern_mmap_name(kerninfo, buff);
1973         self = dso__new(name ?: buff);
1974         if (self != NULL) {
1975                 dso__set_short_name(self, "[guest.kernel]");
1976                 self->kernel = DSO_TYPE_GUEST_KERNEL;
1977         }
1978
1979         return self;
1980 }
1981
1982 void dso__read_running_kernel_build_id(struct dso *self,
1983                         struct kernel_info *kerninfo)
1984 {
1985         char path[PATH_MAX];
1986
1987         if (is_default_guest(kerninfo))
1988                 return;
1989         sprintf(path, "%s/sys/kernel/notes", kerninfo->root_dir);
1990         if (sysfs__read_build_id(path, self->build_id,
1991                                  sizeof(self->build_id)) == 0)
1992                 self->has_build_id = true;
1993 }
1994
1995 static struct dso *dsos__create_kernel(struct kernel_info *kerninfo)
1996 {
1997         const char *vmlinux_name = NULL;
1998         struct dso *kernel;
1999
2000         if (is_host_kernel(kerninfo)) {
2001                 vmlinux_name = symbol_conf.vmlinux_name;
2002                 kernel = dso__new_kernel(vmlinux_name);
2003         } else {
2004                 if (is_default_guest(kerninfo))
2005                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2006                 kernel = dso__new_guest_kernel(kerninfo, vmlinux_name);
2007         }
2008
2009         if (kernel != NULL) {
2010                 dso__read_running_kernel_build_id(kernel, kerninfo);
2011                 dsos__add(&kerninfo->dsos__kernel, kernel);
2012         }
2013         return kernel;
2014 }
2015
2016 int __map_groups__create_kernel_maps(struct map_groups *self,
2017                                      struct map *vmlinux_maps[MAP__NR_TYPES],
2018                                      struct dso *kernel)
2019 {
2020         enum map_type type;
2021
2022         for (type = 0; type < MAP__NR_TYPES; ++type) {
2023                 struct kmap *kmap;
2024
2025                 vmlinux_maps[type] = map__new2(0, kernel, type);
2026                 if (vmlinux_maps[type] == NULL)
2027                         return -1;
2028
2029                 vmlinux_maps[type]->map_ip =
2030                         vmlinux_maps[type]->unmap_ip = identity__map_ip;
2031
2032                 kmap = map__kmap(vmlinux_maps[type]);
2033                 kmap->kmaps = self;
2034                 map_groups__insert(self, vmlinux_maps[type]);
2035         }
2036
2037         return 0;
2038 }
2039
2040 static void vmlinux_path__exit(void)
2041 {
2042         while (--vmlinux_path__nr_entries >= 0) {
2043                 free(vmlinux_path[vmlinux_path__nr_entries]);
2044                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2045         }
2046
2047         free(vmlinux_path);
2048         vmlinux_path = NULL;
2049 }
2050
2051 static int vmlinux_path__init(void)
2052 {
2053         struct utsname uts;
2054         char bf[PATH_MAX];
2055
2056         if (uname(&uts) < 0)
2057                 return -1;
2058
2059         vmlinux_path = malloc(sizeof(char *) * 5);
2060         if (vmlinux_path == NULL)
2061                 return -1;
2062
2063         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2064         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2065                 goto out_fail;
2066         ++vmlinux_path__nr_entries;
2067         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2068         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2069                 goto out_fail;
2070         ++vmlinux_path__nr_entries;
2071         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2072         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2073         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2074                 goto out_fail;
2075         ++vmlinux_path__nr_entries;
2076         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2077         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2078         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2079                 goto out_fail;
2080         ++vmlinux_path__nr_entries;
2081         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2082                  uts.release);
2083         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2084         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2085                 goto out_fail;
2086         ++vmlinux_path__nr_entries;
2087
2088         return 0;
2089
2090 out_fail:
2091         vmlinux_path__exit();
2092         return -1;
2093 }
2094
2095 size_t vmlinux_path__fprintf(FILE *fp)
2096 {
2097         int i;
2098         size_t printed = 0;
2099
2100         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2101                 printed += fprintf(fp, "[%d] %s\n", i, vmlinux_path[i]);
2102
2103         return printed;
2104 }
2105
2106 static int setup_list(struct strlist **list, const char *list_str,
2107                       const char *list_name)
2108 {
2109         if (list_str == NULL)
2110                 return 0;
2111
2112         *list = strlist__new(true, list_str);
2113         if (!*list) {
2114                 pr_err("problems parsing %s list\n", list_name);
2115                 return -1;
2116         }
2117         return 0;
2118 }
2119
2120 int symbol__init(void)
2121 {
2122         elf_version(EV_CURRENT);
2123         if (symbol_conf.sort_by_name)
2124                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2125                                           sizeof(struct symbol));
2126
2127         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2128                 return -1;
2129
2130         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2131                 pr_err("'.' is the only non valid --field-separator argument\n");
2132                 return -1;
2133         }
2134
2135         if (setup_list(&symbol_conf.dso_list,
2136                        symbol_conf.dso_list_str, "dso") < 0)
2137                 return -1;
2138
2139         if (setup_list(&symbol_conf.comm_list,
2140                        symbol_conf.comm_list_str, "comm") < 0)
2141                 goto out_free_dso_list;
2142
2143         if (setup_list(&symbol_conf.sym_list,
2144                        symbol_conf.sym_list_str, "symbol") < 0)
2145                 goto out_free_comm_list;
2146
2147         return 0;
2148
2149 out_free_dso_list:
2150         strlist__delete(symbol_conf.dso_list);
2151 out_free_comm_list:
2152         strlist__delete(symbol_conf.comm_list);
2153         return -1;
2154 }
2155
2156 int map_groups__create_kernel_maps(struct rb_root *kerninfo_root, pid_t pid)
2157 {
2158         struct kernel_info *kerninfo;
2159         struct dso *kernel;
2160
2161         kerninfo = kerninfo__findnew(kerninfo_root, pid);
2162         if (kerninfo == NULL)
2163                 return -1;
2164         kernel = dsos__create_kernel(kerninfo);
2165         if (kernel == NULL)
2166                 return -1;
2167
2168         if (__map_groups__create_kernel_maps(&kerninfo->kmaps,
2169                         kerninfo->vmlinux_maps, kernel) < 0)
2170                 return -1;
2171
2172         if (symbol_conf.use_modules &&
2173                 map_groups__create_modules(kerninfo) < 0)
2174                 pr_debug("Problems creating module maps, continuing anyway...\n");
2175         /*
2176          * Now that we have all the maps created, just set the ->end of them:
2177          */
2178         map_groups__fixup_end(&kerninfo->kmaps);
2179         return 0;
2180 }
2181
2182 static int hex(char ch)
2183 {
2184         if ((ch >= '0') && (ch <= '9'))
2185                 return ch - '0';
2186         if ((ch >= 'a') && (ch <= 'f'))
2187                 return ch - 'a' + 10;
2188         if ((ch >= 'A') && (ch <= 'F'))
2189                 return ch - 'A' + 10;
2190         return -1;
2191 }
2192
2193 /*
2194  * While we find nice hex chars, build a long_val.
2195  * Return number of chars processed.
2196  */
2197 int hex2u64(const char *ptr, u64 *long_val)
2198 {
2199         const char *p = ptr;
2200         *long_val = 0;
2201
2202         while (*p) {
2203                 const int hex_val = hex(*p);
2204
2205                 if (hex_val < 0)
2206                         break;
2207
2208                 *long_val = (*long_val << 4) | hex_val;
2209                 p++;
2210         }
2211
2212         return p - ptr;
2213 }
2214
2215 char *strxfrchar(char *s, char from, char to)
2216 {
2217         char *p = s;
2218
2219         while ((p = strchr(p, from)) != NULL)
2220                 *p++ = to;
2221
2222         return s;
2223 }
2224
2225 int map_groups__create_guest_kernel_maps(struct rb_root *kerninfo_root)
2226 {
2227         int ret = 0;
2228         struct dirent **namelist = NULL;
2229         int i, items = 0;
2230         char path[PATH_MAX];
2231         pid_t pid;
2232
2233         if (symbol_conf.default_guest_vmlinux_name ||
2234             symbol_conf.default_guest_modules ||
2235             symbol_conf.default_guest_kallsyms) {
2236                 map_groups__create_kernel_maps(kerninfo_root,
2237                                         DEFAULT_GUEST_KERNEL_ID);
2238         }
2239
2240         if (symbol_conf.guestmount) {
2241                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2242                 if (items <= 0)
2243                         return -ENOENT;
2244                 for (i = 0; i < items; i++) {
2245                         if (!isdigit(namelist[i]->d_name[0])) {
2246                                 /* Filter out . and .. */
2247                                 continue;
2248                         }
2249                         pid = atoi(namelist[i]->d_name);
2250                         sprintf(path, "%s/%s/proc/kallsyms",
2251                                 symbol_conf.guestmount,
2252                                 namelist[i]->d_name);
2253                         ret = access(path, R_OK);
2254                         if (ret) {
2255                                 pr_debug("Can't access file %s\n", path);
2256                                 goto failure;
2257                         }
2258                         map_groups__create_kernel_maps(kerninfo_root,
2259                                                         pid);
2260                 }
2261 failure:
2262                 free(namelist);
2263         }
2264
2265         return ret;
2266 }