632b50c7bc267839fe7593d6ca3343f5beec5652
[pandora-kernel.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 <inttypes.h>
15 #include "build-id.h"
16 #include "debug.h"
17 #include "symbol.h"
18 #include "strlist.h"
19
20 #include <libelf.h>
21 #include <gelf.h>
22 #include <elf.h>
23 #include <limits.h>
24 #include <sys/utsname.h>
25
26 #ifndef KSYM_NAME_LEN
27 #define KSYM_NAME_LEN 256
28 #endif
29
30 #ifndef NT_GNU_BUILD_ID
31 #define NT_GNU_BUILD_ID 3
32 #endif
33
34 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
35 static int elf_read_build_id(Elf *elf, void *bf, size_t size);
36 static void dsos__add(struct list_head *head, struct dso *dso);
37 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
38 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
39                                 symbol_filter_t filter);
40 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
41                         symbol_filter_t filter);
42 static int vmlinux_path__nr_entries;
43 static char **vmlinux_path;
44
45 struct symbol_conf symbol_conf = {
46         .exclude_other    = true,
47         .use_modules      = true,
48         .try_vmlinux_path = true,
49         .annotate_src     = true,
50         .symfs            = "",
51 };
52
53 int dso__name_len(const struct dso *dso)
54 {
55         if (verbose)
56                 return dso->long_name_len;
57
58         return dso->short_name_len;
59 }
60
61 bool dso__loaded(const struct dso *dso, enum map_type type)
62 {
63         return dso->loaded & (1 << type);
64 }
65
66 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
67 {
68         return dso->sorted_by_name & (1 << type);
69 }
70
71 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
72 {
73         dso->sorted_by_name |= (1 << type);
74 }
75
76 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
77 {
78         symbol_type = toupper(symbol_type);
79
80         switch (map_type) {
81         case MAP__FUNCTION:
82                 return symbol_type == 'T' || symbol_type == 'W';
83         case MAP__VARIABLE:
84                 return symbol_type == 'D';
85         default:
86                 return false;
87         }
88 }
89
90 static int prefix_underscores_count(const char *str)
91 {
92         const char *tail = str;
93
94         while (*tail == '_')
95                 tail++;
96
97         return tail - str;
98 }
99
100 #define SYMBOL_A 0
101 #define SYMBOL_B 1
102
103 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
104 {
105         s64 a;
106         s64 b;
107
108         /* Prefer a symbol with non zero length */
109         a = syma->end - syma->start;
110         b = symb->end - symb->start;
111         if ((b == 0) && (a > 0))
112                 return SYMBOL_A;
113         else if ((a == 0) && (b > 0))
114                 return SYMBOL_B;
115
116         /* Prefer a non weak symbol over a weak one */
117         a = syma->binding == STB_WEAK;
118         b = symb->binding == STB_WEAK;
119         if (b && !a)
120                 return SYMBOL_A;
121         if (a && !b)
122                 return SYMBOL_B;
123
124         /* Prefer a global symbol over a non global one */
125         a = syma->binding == STB_GLOBAL;
126         b = symb->binding == STB_GLOBAL;
127         if (a && !b)
128                 return SYMBOL_A;
129         if (b && !a)
130                 return SYMBOL_B;
131
132         /* Prefer a symbol with less underscores */
133         a = prefix_underscores_count(syma->name);
134         b = prefix_underscores_count(symb->name);
135         if (b > a)
136                 return SYMBOL_A;
137         else if (a > b)
138                 return SYMBOL_B;
139
140         /* If all else fails, choose the symbol with the longest name */
141         if (strlen(syma->name) >= strlen(symb->name))
142                 return SYMBOL_A;
143         else
144                 return SYMBOL_B;
145 }
146
147 static void symbols__fixup_duplicate(struct rb_root *symbols)
148 {
149         struct rb_node *nd;
150         struct symbol *curr, *next;
151
152         nd = rb_first(symbols);
153
154         while (nd) {
155                 curr = rb_entry(nd, struct symbol, rb_node);
156 again:
157                 nd = rb_next(&curr->rb_node);
158                 next = rb_entry(nd, struct symbol, rb_node);
159
160                 if (!nd)
161                         break;
162
163                 if (curr->start != next->start)
164                         continue;
165
166                 if (choose_best_symbol(curr, next) == SYMBOL_A) {
167                         rb_erase(&next->rb_node, symbols);
168                         goto again;
169                 } else {
170                         nd = rb_next(&curr->rb_node);
171                         rb_erase(&curr->rb_node, symbols);
172                 }
173         }
174 }
175
176 static void symbols__fixup_end(struct rb_root *symbols)
177 {
178         struct rb_node *nd, *prevnd = rb_first(symbols);
179         struct symbol *curr, *prev;
180
181         if (prevnd == NULL)
182                 return;
183
184         curr = rb_entry(prevnd, struct symbol, rb_node);
185
186         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
187                 prev = curr;
188                 curr = rb_entry(nd, struct symbol, rb_node);
189
190                 if (prev->end == prev->start && prev->end != curr->start)
191                         prev->end = curr->start - 1;
192         }
193
194         /* Last entry */
195         if (curr->end == curr->start)
196                 curr->end = roundup(curr->start, 4096);
197 }
198
199 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
200 {
201         struct map *prev, *curr;
202         struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
203
204         if (prevnd == NULL)
205                 return;
206
207         curr = rb_entry(prevnd, struct map, rb_node);
208
209         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
210                 prev = curr;
211                 curr = rb_entry(nd, struct map, rb_node);
212                 prev->end = curr->start - 1;
213         }
214
215         /*
216          * We still haven't the actual symbols, so guess the
217          * last map final address.
218          */
219         curr->end = ~0ULL;
220 }
221
222 static void map_groups__fixup_end(struct map_groups *mg)
223 {
224         int i;
225         for (i = 0; i < MAP__NR_TYPES; ++i)
226                 __map_groups__fixup_end(mg, i);
227 }
228
229 static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
230                                   const char *name)
231 {
232         size_t namelen = strlen(name) + 1;
233         struct symbol *sym = calloc(1, (symbol_conf.priv_size +
234                                         sizeof(*sym) + namelen));
235         if (sym == NULL)
236                 return NULL;
237
238         if (symbol_conf.priv_size)
239                 sym = ((void *)sym) + symbol_conf.priv_size;
240
241         sym->start   = start;
242         sym->end     = len ? start + len - 1 : start;
243         sym->binding = binding;
244         sym->namelen = namelen - 1;
245
246         pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
247                   __func__, name, start, sym->end);
248         memcpy(sym->name, name, namelen);
249
250         return sym;
251 }
252
253 void symbol__delete(struct symbol *sym)
254 {
255         free(((void *)sym) - symbol_conf.priv_size);
256 }
257
258 static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
259 {
260         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
261                        sym->start, sym->end,
262                        sym->binding == STB_GLOBAL ? 'g' :
263                        sym->binding == STB_LOCAL  ? 'l' : 'w',
264                        sym->name);
265 }
266
267 void dso__set_long_name(struct dso *dso, char *name)
268 {
269         if (name == NULL)
270                 return;
271         dso->long_name = name;
272         dso->long_name_len = strlen(name);
273 }
274
275 static void dso__set_short_name(struct dso *dso, const char *name)
276 {
277         if (name == NULL)
278                 return;
279         dso->short_name = name;
280         dso->short_name_len = strlen(name);
281 }
282
283 static void dso__set_basename(struct dso *dso)
284 {
285         dso__set_short_name(dso, basename(dso->long_name));
286 }
287
288 struct dso *dso__new(const char *name)
289 {
290         struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
291
292         if (dso != NULL) {
293                 int i;
294                 strcpy(dso->name, name);
295                 dso__set_long_name(dso, dso->name);
296                 dso__set_short_name(dso, dso->name);
297                 for (i = 0; i < MAP__NR_TYPES; ++i)
298                         dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
299                 dso->symtab_type = SYMTAB__NOT_FOUND;
300                 dso->loaded = 0;
301                 dso->sorted_by_name = 0;
302                 dso->has_build_id = 0;
303                 dso->kernel = DSO_TYPE_USER;
304                 INIT_LIST_HEAD(&dso->node);
305         }
306
307         return dso;
308 }
309
310 static void symbols__delete(struct rb_root *symbols)
311 {
312         struct symbol *pos;
313         struct rb_node *next = rb_first(symbols);
314
315         while (next) {
316                 pos = rb_entry(next, struct symbol, rb_node);
317                 next = rb_next(&pos->rb_node);
318                 rb_erase(&pos->rb_node, symbols);
319                 symbol__delete(pos);
320         }
321 }
322
323 void dso__delete(struct dso *dso)
324 {
325         int i;
326         for (i = 0; i < MAP__NR_TYPES; ++i)
327                 symbols__delete(&dso->symbols[i]);
328         if (dso->sname_alloc)
329                 free((char *)dso->short_name);
330         if (dso->lname_alloc)
331                 free(dso->long_name);
332         free(dso);
333 }
334
335 void dso__set_build_id(struct dso *dso, void *build_id)
336 {
337         memcpy(dso->build_id, build_id, sizeof(dso->build_id));
338         dso->has_build_id = 1;
339 }
340
341 static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
342 {
343         struct rb_node **p = &symbols->rb_node;
344         struct rb_node *parent = NULL;
345         const u64 ip = sym->start;
346         struct symbol *s;
347
348         while (*p != NULL) {
349                 parent = *p;
350                 s = rb_entry(parent, struct symbol, rb_node);
351                 if (ip < s->start)
352                         p = &(*p)->rb_left;
353                 else
354                         p = &(*p)->rb_right;
355         }
356         rb_link_node(&sym->rb_node, parent, p);
357         rb_insert_color(&sym->rb_node, symbols);
358 }
359
360 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
361 {
362         struct rb_node *n;
363
364         if (symbols == NULL)
365                 return NULL;
366
367         n = symbols->rb_node;
368
369         while (n) {
370                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
371
372                 if (ip < s->start)
373                         n = n->rb_left;
374                 else if (ip > s->end)
375                         n = n->rb_right;
376                 else
377                         return s;
378         }
379
380         return NULL;
381 }
382
383 struct symbol_name_rb_node {
384         struct rb_node  rb_node;
385         struct symbol   sym;
386 };
387
388 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
389 {
390         struct rb_node **p = &symbols->rb_node;
391         struct rb_node *parent = NULL;
392         struct symbol_name_rb_node *symn, *s;
393
394         symn = container_of(sym, struct symbol_name_rb_node, sym);
395
396         while (*p != NULL) {
397                 parent = *p;
398                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
399                 if (strcmp(sym->name, s->sym.name) < 0)
400                         p = &(*p)->rb_left;
401                 else
402                         p = &(*p)->rb_right;
403         }
404         rb_link_node(&symn->rb_node, parent, p);
405         rb_insert_color(&symn->rb_node, symbols);
406 }
407
408 static void symbols__sort_by_name(struct rb_root *symbols,
409                                   struct rb_root *source)
410 {
411         struct rb_node *nd;
412
413         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
414                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
415                 symbols__insert_by_name(symbols, pos);
416         }
417 }
418
419 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
420                                             const char *name)
421 {
422         struct rb_node *n;
423
424         if (symbols == NULL)
425                 return NULL;
426
427         n = symbols->rb_node;
428
429         while (n) {
430                 struct symbol_name_rb_node *s;
431                 int cmp;
432
433                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
434                 cmp = strcmp(name, s->sym.name);
435
436                 if (cmp < 0)
437                         n = n->rb_left;
438                 else if (cmp > 0)
439                         n = n->rb_right;
440                 else
441                         return &s->sym;
442         }
443
444         return NULL;
445 }
446
447 struct symbol *dso__find_symbol(struct dso *dso,
448                                 enum map_type type, u64 addr)
449 {
450         return symbols__find(&dso->symbols[type], addr);
451 }
452
453 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
454                                         const char *name)
455 {
456         return symbols__find_by_name(&dso->symbol_names[type], name);
457 }
458
459 void dso__sort_by_name(struct dso *dso, enum map_type type)
460 {
461         dso__set_sorted_by_name(dso, type);
462         return symbols__sort_by_name(&dso->symbol_names[type],
463                                      &dso->symbols[type]);
464 }
465
466 int build_id__sprintf(const u8 *build_id, int len, char *bf)
467 {
468         char *bid = bf;
469         const u8 *raw = build_id;
470         int i;
471
472         for (i = 0; i < len; ++i) {
473                 sprintf(bid, "%02x", *raw);
474                 ++raw;
475                 bid += 2;
476         }
477
478         return raw - build_id;
479 }
480
481 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
482 {
483         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
484
485         build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
486         return fprintf(fp, "%s", sbuild_id);
487 }
488
489 size_t dso__fprintf_symbols_by_name(struct dso *dso,
490                                     enum map_type type, FILE *fp)
491 {
492         size_t ret = 0;
493         struct rb_node *nd;
494         struct symbol_name_rb_node *pos;
495
496         for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
497                 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
498                 fprintf(fp, "%s\n", pos->sym.name);
499         }
500
501         return ret;
502 }
503
504 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
505 {
506         struct rb_node *nd;
507         size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
508
509         if (dso->short_name != dso->long_name)
510                 ret += fprintf(fp, "%s, ", dso->long_name);
511         ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
512                        dso->loaded ? "" : "NOT ");
513         ret += dso__fprintf_buildid(dso, fp);
514         ret += fprintf(fp, ")\n");
515         for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
516                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
517                 ret += symbol__fprintf(pos, fp);
518         }
519
520         return ret;
521 }
522
523 int kallsyms__parse(const char *filename, void *arg,
524                     int (*process_symbol)(void *arg, const char *name,
525                                           char type, u64 start, u64 end))
526 {
527         char *line = NULL;
528         size_t n;
529         int err = -1;
530         FILE *file = fopen(filename, "r");
531
532         if (file == NULL)
533                 goto out_failure;
534
535         err = 0;
536
537         while (!feof(file)) {
538                 u64 start;
539                 int line_len, len;
540                 char symbol_type;
541                 char *symbol_name;
542
543                 line_len = getline(&line, &n, file);
544                 if (line_len < 0 || !line)
545                         break;
546
547                 line[--line_len] = '\0'; /* \n */
548
549                 len = hex2u64(line, &start);
550
551                 len++;
552                 if (len + 2 >= line_len)
553                         continue;
554
555                 symbol_type = line[len];
556                 len += 2;
557                 symbol_name = line + len;
558                 len = line_len - len;
559
560                 if (len >= KSYM_NAME_LEN) {
561                         err = -1;
562                         break;
563                 }
564
565                 /*
566                  * module symbols are not sorted so we add all
567                  * symbols with zero length and rely on
568                  * symbols__fixup_end() to fix it up.
569                  */
570                 err = process_symbol(arg, symbol_name,
571                                      symbol_type, start, start);
572                 if (err)
573                         break;
574         }
575
576         free(line);
577         fclose(file);
578         return err;
579
580 out_failure:
581         return -1;
582 }
583
584 struct process_kallsyms_args {
585         struct map *map;
586         struct dso *dso;
587 };
588
589 static u8 kallsyms2elf_type(char type)
590 {
591         if (type == 'W')
592                 return STB_WEAK;
593
594         return isupper(type) ? STB_GLOBAL : STB_LOCAL;
595 }
596
597 static int map__process_kallsym_symbol(void *arg, const char *name,
598                                        char type, u64 start, u64 end)
599 {
600         struct symbol *sym;
601         struct process_kallsyms_args *a = arg;
602         struct rb_root *root = &a->dso->symbols[a->map->type];
603
604         if (!symbol_type__is_a(type, a->map->type))
605                 return 0;
606
607         sym = symbol__new(start, end - start + 1,
608                           kallsyms2elf_type(type), name);
609         if (sym == NULL)
610                 return -ENOMEM;
611         /*
612          * We will pass the symbols to the filter later, in
613          * map__split_kallsyms, when we have split the maps per module
614          */
615         symbols__insert(root, sym);
616
617         return 0;
618 }
619
620 /*
621  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
622  * so that we can in the next step set the symbol ->end address and then
623  * call kernel_maps__split_kallsyms.
624  */
625 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
626                                   struct map *map)
627 {
628         struct process_kallsyms_args args = { .map = map, .dso = dso, };
629         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
630 }
631
632 /*
633  * Split the symbols into maps, making sure there are no overlaps, i.e. the
634  * kernel range is broken in several maps, named [kernel].N, as we don't have
635  * the original ELF section names vmlinux have.
636  */
637 static int dso__split_kallsyms(struct dso *dso, struct map *map,
638                                symbol_filter_t filter)
639 {
640         struct map_groups *kmaps = map__kmap(map)->kmaps;
641         struct machine *machine = kmaps->machine;
642         struct map *curr_map = map;
643         struct symbol *pos;
644         int count = 0, moved = 0;       
645         struct rb_root *root = &dso->symbols[map->type];
646         struct rb_node *next = rb_first(root);
647         int kernel_range = 0;
648
649         while (next) {
650                 char *module;
651
652                 pos = rb_entry(next, struct symbol, rb_node);
653                 next = rb_next(&pos->rb_node);
654
655                 module = strchr(pos->name, '\t');
656                 if (module) {
657                         if (!symbol_conf.use_modules)
658                                 goto discard_symbol;
659
660                         *module++ = '\0';
661
662                         if (strcmp(curr_map->dso->short_name, module)) {
663                                 if (curr_map != map &&
664                                     dso->kernel == DSO_TYPE_GUEST_KERNEL &&
665                                     machine__is_default_guest(machine)) {
666                                         /*
667                                          * We assume all symbols of a module are
668                                          * continuous in * kallsyms, so curr_map
669                                          * points to a module and all its
670                                          * symbols are in its kmap. Mark it as
671                                          * loaded.
672                                          */
673                                         dso__set_loaded(curr_map->dso,
674                                                         curr_map->type);
675                                 }
676
677                                 curr_map = map_groups__find_by_name(kmaps,
678                                                         map->type, module);
679                                 if (curr_map == NULL) {
680                                         pr_debug("%s/proc/{kallsyms,modules} "
681                                                  "inconsistency while looking "
682                                                  "for \"%s\" module!\n",
683                                                  machine->root_dir, module);
684                                         curr_map = map;
685                                         goto discard_symbol;
686                                 }
687
688                                 if (curr_map->dso->loaded &&
689                                     !machine__is_default_guest(machine))
690                                         goto discard_symbol;
691                         }
692                         /*
693                          * So that we look just like we get from .ko files,
694                          * i.e. not prelinked, relative to map->start.
695                          */
696                         pos->start = curr_map->map_ip(curr_map, pos->start);
697                         pos->end   = curr_map->map_ip(curr_map, pos->end);
698                 } else if (curr_map != map) {
699                         char dso_name[PATH_MAX];
700                         struct dso *ndso;
701
702                         if (count == 0) {
703                                 curr_map = map;
704                                 goto filter_symbol;
705                         }
706
707                         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
708                                 snprintf(dso_name, sizeof(dso_name),
709                                         "[guest.kernel].%d",
710                                         kernel_range++);
711                         else
712                                 snprintf(dso_name, sizeof(dso_name),
713                                         "[kernel].%d",
714                                         kernel_range++);
715
716                         ndso = dso__new(dso_name);
717                         if (ndso == NULL)
718                                 return -1;
719
720                         ndso->kernel = dso->kernel;
721
722                         curr_map = map__new2(pos->start, ndso, map->type);
723                         if (curr_map == NULL) {
724                                 dso__delete(ndso);
725                                 return -1;
726                         }
727
728                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
729                         map_groups__insert(kmaps, curr_map);
730                         ++kernel_range;
731                 }
732 filter_symbol:
733                 if (filter && filter(curr_map, pos)) {
734 discard_symbol:         rb_erase(&pos->rb_node, root);
735                         symbol__delete(pos);
736                 } else {
737                         if (curr_map != map) {
738                                 rb_erase(&pos->rb_node, root);
739                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
740                                 ++moved;
741                         } else
742                                 ++count;
743                 }
744         }
745
746         if (curr_map != map &&
747             dso->kernel == DSO_TYPE_GUEST_KERNEL &&
748             machine__is_default_guest(kmaps->machine)) {
749                 dso__set_loaded(curr_map->dso, curr_map->type);
750         }
751
752         return count + moved;
753 }
754
755 static bool symbol__restricted_filename(const char *filename,
756                                         const char *restricted_filename)
757 {
758         bool restricted = false;
759
760         if (symbol_conf.kptr_restrict) {
761                 char *r = realpath(filename, NULL);
762
763                 if (r != NULL) {
764                         restricted = strcmp(r, restricted_filename) == 0;
765                         free(r);
766                         return restricted;
767                 }
768         }
769
770         return restricted;
771 }
772
773 int dso__load_kallsyms(struct dso *dso, const char *filename,
774                        struct map *map, symbol_filter_t filter)
775 {
776         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
777                 return -1;
778
779         if (dso__load_all_kallsyms(dso, filename, map) < 0)
780                 return -1;
781
782         symbols__fixup_duplicate(&dso->symbols[map->type]);
783         symbols__fixup_end(&dso->symbols[map->type]);
784
785         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
786                 dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
787         else
788                 dso->symtab_type = SYMTAB__KALLSYMS;
789
790         return dso__split_kallsyms(dso, map, filter);
791 }
792
793 static int dso__load_perf_map(struct dso *dso, struct map *map,
794                               symbol_filter_t filter)
795 {
796         char *line = NULL;
797         size_t n;
798         FILE *file;
799         int nr_syms = 0;
800
801         file = fopen(dso->long_name, "r");
802         if (file == NULL)
803                 goto out_failure;
804
805         while (!feof(file)) {
806                 u64 start, size;
807                 struct symbol *sym;
808                 int line_len, len;
809
810                 line_len = getline(&line, &n, file);
811                 if (line_len < 0)
812                         break;
813
814                 if (!line)
815                         goto out_failure;
816
817                 line[--line_len] = '\0'; /* \n */
818
819                 len = hex2u64(line, &start);
820
821                 len++;
822                 if (len + 2 >= line_len)
823                         continue;
824
825                 len += hex2u64(line + len, &size);
826
827                 len++;
828                 if (len + 2 >= line_len)
829                         continue;
830
831                 sym = symbol__new(start, size, STB_GLOBAL, line + len);
832
833                 if (sym == NULL)
834                         goto out_delete_line;
835
836                 if (filter && filter(map, sym))
837                         symbol__delete(sym);
838                 else {
839                         symbols__insert(&dso->symbols[map->type], sym);
840                         nr_syms++;
841                 }
842         }
843
844         free(line);
845         fclose(file);
846
847         return nr_syms;
848
849 out_delete_line:
850         free(line);
851 out_failure:
852         return -1;
853 }
854
855 /**
856  * elf_symtab__for_each_symbol - iterate thru all the symbols
857  *
858  * @syms: struct elf_symtab instance to iterate
859  * @idx: uint32_t idx
860  * @sym: GElf_Sym iterator
861  */
862 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
863         for (idx = 0, gelf_getsym(syms, idx, &sym);\
864              idx < nr_syms; \
865              idx++, gelf_getsym(syms, idx, &sym))
866
867 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
868 {
869         return GELF_ST_TYPE(sym->st_info);
870 }
871
872 static inline int elf_sym__is_function(const GElf_Sym *sym)
873 {
874         return elf_sym__type(sym) == STT_FUNC &&
875                sym->st_name != 0 &&
876                sym->st_shndx != SHN_UNDEF;
877 }
878
879 static inline bool elf_sym__is_object(const GElf_Sym *sym)
880 {
881         return elf_sym__type(sym) == STT_OBJECT &&
882                 sym->st_name != 0 &&
883                 sym->st_shndx != SHN_UNDEF;
884 }
885
886 static inline int elf_sym__is_label(const GElf_Sym *sym)
887 {
888         return elf_sym__type(sym) == STT_NOTYPE &&
889                 sym->st_name != 0 &&
890                 sym->st_shndx != SHN_UNDEF &&
891                 sym->st_shndx != SHN_ABS;
892 }
893
894 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
895                                         const Elf_Data *secstrs)
896 {
897         return secstrs->d_buf + shdr->sh_name;
898 }
899
900 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
901                                         const Elf_Data *secstrs)
902 {
903         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
904 }
905
906 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
907                                     const Elf_Data *secstrs)
908 {
909         return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
910 }
911
912 static inline const char *elf_sym__name(const GElf_Sym *sym,
913                                         const Elf_Data *symstrs)
914 {
915         return symstrs->d_buf + sym->st_name;
916 }
917
918 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
919                                     GElf_Shdr *shp, const char *name,
920                                     size_t *idx)
921 {
922         Elf_Scn *sec = NULL;
923         size_t cnt = 1;
924
925         while ((sec = elf_nextscn(elf, sec)) != NULL) {
926                 char *str;
927
928                 gelf_getshdr(sec, shp);
929                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
930                 if (!strcmp(name, str)) {
931                         if (idx)
932                                 *idx = cnt;
933                         break;
934                 }
935                 ++cnt;
936         }
937
938         return sec;
939 }
940
941 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
942         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
943              idx < nr_entries; \
944              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
945
946 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
947         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
948              idx < nr_entries; \
949              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
950
951 /*
952  * We need to check if we have a .dynsym, so that we can handle the
953  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
954  * .dynsym or .symtab).
955  * And always look at the original dso, not at debuginfo packages, that
956  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
957  */
958 static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
959                                        symbol_filter_t filter)
960 {
961         uint32_t nr_rel_entries, idx;
962         GElf_Sym sym;
963         u64 plt_offset;
964         GElf_Shdr shdr_plt;
965         struct symbol *f;
966         GElf_Shdr shdr_rel_plt, shdr_dynsym;
967         Elf_Data *reldata, *syms, *symstrs;
968         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
969         size_t dynsym_idx;
970         GElf_Ehdr ehdr;
971         char sympltname[1024];
972         Elf *elf;
973         int nr = 0, symidx, fd, err = 0;
974         char name[PATH_MAX];
975
976         snprintf(name, sizeof(name), "%s%s",
977                  symbol_conf.symfs, dso->long_name);
978         fd = open(name, O_RDONLY);
979         if (fd < 0)
980                 goto out;
981
982         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
983         if (elf == NULL)
984                 goto out_close;
985
986         if (gelf_getehdr(elf, &ehdr) == NULL)
987                 goto out_elf_end;
988
989         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
990                                          ".dynsym", &dynsym_idx);
991         if (scn_dynsym == NULL)
992                 goto out_elf_end;
993
994         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
995                                           ".rela.plt", NULL);
996         if (scn_plt_rel == NULL) {
997                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
998                                                   ".rel.plt", NULL);
999                 if (scn_plt_rel == NULL)
1000                         goto out_elf_end;
1001         }
1002
1003         err = -1;
1004
1005         if (shdr_rel_plt.sh_link != dynsym_idx)
1006                 goto out_elf_end;
1007
1008         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
1009                 goto out_elf_end;
1010
1011         /*
1012          * Fetch the relocation section to find the idxes to the GOT
1013          * and the symbols in the .dynsym they refer to.
1014          */
1015         reldata = elf_getdata(scn_plt_rel, NULL);
1016         if (reldata == NULL)
1017                 goto out_elf_end;
1018
1019         syms = elf_getdata(scn_dynsym, NULL);
1020         if (syms == NULL)
1021                 goto out_elf_end;
1022
1023         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
1024         if (scn_symstrs == NULL)
1025                 goto out_elf_end;
1026
1027         symstrs = elf_getdata(scn_symstrs, NULL);
1028         if (symstrs == NULL)
1029                 goto out_elf_end;
1030
1031         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
1032         plt_offset = shdr_plt.sh_offset;
1033
1034         if (shdr_rel_plt.sh_type == SHT_RELA) {
1035                 GElf_Rela pos_mem, *pos;
1036
1037                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
1038                                            nr_rel_entries) {
1039                         symidx = GELF_R_SYM(pos->r_info);
1040                         plt_offset += shdr_plt.sh_entsize;
1041                         gelf_getsym(syms, symidx, &sym);
1042                         snprintf(sympltname, sizeof(sympltname),
1043                                  "%s@plt", elf_sym__name(&sym, symstrs));
1044
1045                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1046                                         STB_GLOBAL, sympltname);
1047                         if (!f)
1048                                 goto out_elf_end;
1049
1050                         if (filter && filter(map, f))
1051                                 symbol__delete(f);
1052                         else {
1053                                 symbols__insert(&dso->symbols[map->type], f);
1054                                 ++nr;
1055                         }
1056                 }
1057         } else if (shdr_rel_plt.sh_type == SHT_REL) {
1058                 GElf_Rel pos_mem, *pos;
1059                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
1060                                           nr_rel_entries) {
1061                         symidx = GELF_R_SYM(pos->r_info);
1062                         plt_offset += shdr_plt.sh_entsize;
1063                         gelf_getsym(syms, symidx, &sym);
1064                         snprintf(sympltname, sizeof(sympltname),
1065                                  "%s@plt", elf_sym__name(&sym, symstrs));
1066
1067                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1068                                         STB_GLOBAL, sympltname);
1069                         if (!f)
1070                                 goto out_elf_end;
1071
1072                         if (filter && filter(map, f))
1073                                 symbol__delete(f);
1074                         else {
1075                                 symbols__insert(&dso->symbols[map->type], f);
1076                                 ++nr;
1077                         }
1078                 }
1079         }
1080
1081         err = 0;
1082 out_elf_end:
1083         elf_end(elf);
1084 out_close:
1085         close(fd);
1086
1087         if (err == 0)
1088                 return nr;
1089 out:
1090         pr_debug("%s: problems reading %s PLT info.\n",
1091                  __func__, dso->long_name);
1092         return 0;
1093 }
1094
1095 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
1096 {
1097         switch (type) {
1098         case MAP__FUNCTION:
1099                 return elf_sym__is_function(sym);
1100         case MAP__VARIABLE:
1101                 return elf_sym__is_object(sym);
1102         default:
1103                 return false;
1104         }
1105 }
1106
1107 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
1108                           enum map_type type)
1109 {
1110         switch (type) {
1111         case MAP__FUNCTION:
1112                 return elf_sec__is_text(shdr, secstrs);
1113         case MAP__VARIABLE:
1114                 return elf_sec__is_data(shdr, secstrs);
1115         default:
1116                 return false;
1117         }
1118 }
1119
1120 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
1121 {
1122         Elf_Scn *sec = NULL;
1123         GElf_Shdr shdr;
1124         size_t cnt = 1;
1125
1126         while ((sec = elf_nextscn(elf, sec)) != NULL) {
1127                 gelf_getshdr(sec, &shdr);
1128
1129                 if ((addr >= shdr.sh_addr) &&
1130                     (addr < (shdr.sh_addr + shdr.sh_size)))
1131                         return cnt;
1132
1133                 ++cnt;
1134         }
1135
1136         return -1;
1137 }
1138
1139 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
1140                          int fd, symbol_filter_t filter, int kmodule,
1141                          int want_symtab)
1142 {
1143         struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1144         struct map *curr_map = map;
1145         struct dso *curr_dso = dso;
1146         Elf_Data *symstrs, *secstrs;
1147         uint32_t nr_syms;
1148         int err = -1;
1149         uint32_t idx;
1150         GElf_Ehdr ehdr;
1151         GElf_Shdr shdr, opdshdr;
1152         Elf_Data *syms, *opddata = NULL;
1153         GElf_Sym sym;
1154         Elf_Scn *sec, *sec_strndx, *opdsec;
1155         Elf *elf;
1156         int nr = 0;
1157         size_t opdidx = 0;
1158
1159         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1160         if (elf == NULL) {
1161                 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1162                 goto out_close;
1163         }
1164
1165         if (gelf_getehdr(elf, &ehdr) == NULL) {
1166                 pr_debug("%s: cannot get elf header.\n", __func__);
1167                 goto out_elf_end;
1168         }
1169
1170         /* Always reject images with a mismatched build-id: */
1171         if (dso->has_build_id) {
1172                 u8 build_id[BUILD_ID_SIZE];
1173
1174                 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
1175                         goto out_elf_end;
1176
1177                 if (!dso__build_id_equal(dso, build_id))
1178                         goto out_elf_end;
1179         }
1180
1181         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1182         if (sec == NULL) {
1183                 if (want_symtab)
1184                         goto out_elf_end;
1185
1186                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1187                 if (sec == NULL)
1188                         goto out_elf_end;
1189         }
1190
1191         opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1192         if (opdshdr.sh_type != SHT_PROGBITS)
1193                 opdsec = NULL;
1194         if (opdsec)
1195                 opddata = elf_rawdata(opdsec, NULL);
1196
1197         syms = elf_getdata(sec, NULL);
1198         if (syms == NULL)
1199                 goto out_elf_end;
1200
1201         sec = elf_getscn(elf, shdr.sh_link);
1202         if (sec == NULL)
1203                 goto out_elf_end;
1204
1205         symstrs = elf_getdata(sec, NULL);
1206         if (symstrs == NULL)
1207                 goto out_elf_end;
1208
1209         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1210         if (sec_strndx == NULL)
1211                 goto out_elf_end;
1212
1213         secstrs = elf_getdata(sec_strndx, NULL);
1214         if (secstrs == NULL)
1215                 goto out_elf_end;
1216
1217         nr_syms = shdr.sh_size / shdr.sh_entsize;
1218
1219         memset(&sym, 0, sizeof(sym));
1220         if (dso->kernel == DSO_TYPE_USER) {
1221                 dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1222                                 elf_section_by_name(elf, &ehdr, &shdr,
1223                                                      ".gnu.prelink_undo",
1224                                                      NULL) != NULL);
1225         } else {
1226                 dso->adjust_symbols = 0;
1227         }
1228         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1229                 struct symbol *f;
1230                 const char *elf_name = elf_sym__name(&sym, symstrs);
1231                 char *demangled = NULL;
1232                 int is_label = elf_sym__is_label(&sym);
1233                 const char *section_name;
1234
1235                 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1236                     strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1237                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1238
1239                 if (!is_label && !elf_sym__is_a(&sym, map->type))
1240                         continue;
1241
1242                 /* Reject ARM ELF "mapping symbols": these aren't unique and
1243                  * don't identify functions, so will confuse the profile
1244                  * output: */
1245                 if (ehdr.e_machine == EM_ARM) {
1246                         if (!strcmp(elf_name, "$a") ||
1247                             !strcmp(elf_name, "$d") ||
1248                             !strcmp(elf_name, "$t"))
1249                                 continue;
1250                 }
1251
1252                 if (opdsec && sym.st_shndx == opdidx) {
1253                         u32 offset = sym.st_value - opdshdr.sh_addr;
1254                         u64 *opd = opddata->d_buf + offset;
1255                         sym.st_value = *opd;
1256                         sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1257                 }
1258
1259                 sec = elf_getscn(elf, sym.st_shndx);
1260                 if (!sec)
1261                         goto out_elf_end;
1262
1263                 gelf_getshdr(sec, &shdr);
1264
1265                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1266                         continue;
1267
1268                 section_name = elf_sec__name(&shdr, secstrs);
1269
1270                 /* On ARM, symbols for thumb functions have 1 added to
1271                  * the symbol address as a flag - remove it */
1272                 if ((ehdr.e_machine == EM_ARM) &&
1273                     (map->type == MAP__FUNCTION) &&
1274                     (sym.st_value & 1))
1275                         --sym.st_value;
1276
1277                 if (dso->kernel != DSO_TYPE_USER || kmodule) {
1278                         char dso_name[PATH_MAX];
1279
1280                         if (strcmp(section_name,
1281                                    (curr_dso->short_name +
1282                                     dso->short_name_len)) == 0)
1283                                 goto new_symbol;
1284
1285                         if (strcmp(section_name, ".text") == 0) {
1286                                 curr_map = map;
1287                                 curr_dso = dso;
1288                                 goto new_symbol;
1289                         }
1290
1291                         snprintf(dso_name, sizeof(dso_name),
1292                                  "%s%s", dso->short_name, section_name);
1293
1294                         curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1295                         if (curr_map == NULL) {
1296                                 u64 start = sym.st_value;
1297
1298                                 if (kmodule)
1299                                         start += map->start + shdr.sh_offset;
1300
1301                                 curr_dso = dso__new(dso_name);
1302                                 if (curr_dso == NULL)
1303                                         goto out_elf_end;
1304                                 curr_dso->kernel = dso->kernel;
1305                                 curr_dso->long_name = dso->long_name;
1306                                 curr_dso->long_name_len = dso->long_name_len;
1307                                 curr_map = map__new2(start, curr_dso,
1308                                                      map->type);
1309                                 if (curr_map == NULL) {
1310                                         dso__delete(curr_dso);
1311                                         goto out_elf_end;
1312                                 }
1313                                 curr_map->map_ip = identity__map_ip;
1314                                 curr_map->unmap_ip = identity__map_ip;
1315                                 curr_dso->symtab_type = dso->symtab_type;
1316                                 map_groups__insert(kmap->kmaps, curr_map);
1317                                 dsos__add(&dso->node, curr_dso);
1318                                 dso__set_loaded(curr_dso, map->type);
1319                         } else
1320                                 curr_dso = curr_map->dso;
1321
1322                         goto new_symbol;
1323                 }
1324
1325                 if (curr_dso->adjust_symbols) {
1326                         pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1327                                   "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1328                                   (u64)sym.st_value, (u64)shdr.sh_addr,
1329                                   (u64)shdr.sh_offset);
1330                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1331                 }
1332                 /*
1333                  * We need to figure out if the object was created from C++ sources
1334                  * DWARF DW_compile_unit has this, but we don't always have access
1335                  * to it...
1336                  */
1337                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1338                 if (demangled != NULL)
1339                         elf_name = demangled;
1340 new_symbol:
1341                 f = symbol__new(sym.st_value, sym.st_size,
1342                                 GELF_ST_BIND(sym.st_info), elf_name);
1343                 free(demangled);
1344                 if (!f)
1345                         goto out_elf_end;
1346
1347                 if (filter && filter(curr_map, f))
1348                         symbol__delete(f);
1349                 else {
1350                         symbols__insert(&curr_dso->symbols[curr_map->type], f);
1351                         nr++;
1352                 }
1353         }
1354
1355         /*
1356          * For misannotated, zeroed, ASM function sizes.
1357          */
1358         if (nr > 0) {
1359                 symbols__fixup_duplicate(&dso->symbols[map->type]);
1360                 symbols__fixup_end(&dso->symbols[map->type]);
1361                 if (kmap) {
1362                         /*
1363                          * We need to fixup this here too because we create new
1364                          * maps here, for things like vsyscall sections.
1365                          */
1366                         __map_groups__fixup_end(kmap->kmaps, map->type);
1367                 }
1368         }
1369         err = nr;
1370 out_elf_end:
1371         elf_end(elf);
1372 out_close:
1373         return err;
1374 }
1375
1376 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
1377 {
1378         return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
1379 }
1380
1381 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1382 {
1383         bool have_build_id = false;
1384         struct dso *pos;
1385
1386         list_for_each_entry(pos, head, node) {
1387                 if (with_hits && !pos->hit)
1388                         continue;
1389                 if (pos->has_build_id) {
1390                         have_build_id = true;
1391                         continue;
1392                 }
1393                 if (filename__read_build_id(pos->long_name, pos->build_id,
1394                                             sizeof(pos->build_id)) > 0) {
1395                         have_build_id     = true;
1396                         pos->has_build_id = true;
1397                 }
1398         }
1399
1400         return have_build_id;
1401 }
1402
1403 /*
1404  * Align offset to 4 bytes as needed for note name and descriptor data.
1405  */
1406 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1407
1408 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1409 {
1410         int err = -1;
1411         GElf_Ehdr ehdr;
1412         GElf_Shdr shdr;
1413         Elf_Data *data;
1414         Elf_Scn *sec;
1415         Elf_Kind ek;
1416         void *ptr;
1417
1418         if (size < BUILD_ID_SIZE)
1419                 goto out;
1420
1421         ek = elf_kind(elf);
1422         if (ek != ELF_K_ELF)
1423                 goto out;
1424
1425         if (gelf_getehdr(elf, &ehdr) == NULL) {
1426                 pr_err("%s: cannot get elf header.\n", __func__);
1427                 goto out;
1428         }
1429
1430         sec = elf_section_by_name(elf, &ehdr, &shdr,
1431                                   ".note.gnu.build-id", NULL);
1432         if (sec == NULL) {
1433                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1434                                           ".notes", NULL);
1435                 if (sec == NULL)
1436                         goto out;
1437         }
1438
1439         data = elf_getdata(sec, NULL);
1440         if (data == NULL)
1441                 goto out;
1442
1443         ptr = data->d_buf;
1444         while (ptr < (data->d_buf + data->d_size)) {
1445                 GElf_Nhdr *nhdr = ptr;
1446                 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1447                        descsz = NOTE_ALIGN(nhdr->n_descsz);
1448                 const char *name;
1449
1450                 ptr += sizeof(*nhdr);
1451                 name = ptr;
1452                 ptr += namesz;
1453                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1454                     nhdr->n_namesz == sizeof("GNU")) {
1455                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1456                                 size_t sz = min(size, descsz);
1457                                 memcpy(bf, ptr, sz);
1458                                 memset(bf + sz, 0, size - sz);
1459                                 err = descsz;
1460                                 break;
1461                         }
1462                 }
1463                 ptr += descsz;
1464         }
1465
1466 out:
1467         return err;
1468 }
1469
1470 int filename__read_build_id(const char *filename, void *bf, size_t size)
1471 {
1472         int fd, err = -1;
1473         Elf *elf;
1474
1475         if (size < BUILD_ID_SIZE)
1476                 goto out;
1477
1478         fd = open(filename, O_RDONLY);
1479         if (fd < 0)
1480                 goto out;
1481
1482         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1483         if (elf == NULL) {
1484                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1485                 goto out_close;
1486         }
1487
1488         err = elf_read_build_id(elf, bf, size);
1489
1490         elf_end(elf);
1491 out_close:
1492         close(fd);
1493 out:
1494         return err;
1495 }
1496
1497 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1498 {
1499         int fd, err = -1;
1500
1501         if (size < BUILD_ID_SIZE)
1502                 goto out;
1503
1504         fd = open(filename, O_RDONLY);
1505         if (fd < 0)
1506                 goto out;
1507
1508         while (1) {
1509                 char bf[BUFSIZ];
1510                 GElf_Nhdr nhdr;
1511                 size_t namesz, descsz;
1512
1513                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1514                         break;
1515
1516                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1517                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1518                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1519                     nhdr.n_namesz == sizeof("GNU")) {
1520                         if (read(fd, bf, namesz) != (ssize_t)namesz)
1521                                 break;
1522                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1523                                 size_t sz = min(descsz, size);
1524                                 if (read(fd, build_id, sz) == (ssize_t)sz) {
1525                                         memset(build_id + sz, 0, size - sz);
1526                                         err = 0;
1527                                         break;
1528                                 }
1529                         } else if (read(fd, bf, descsz) != (ssize_t)descsz)
1530                                 break;
1531                 } else {
1532                         int n = namesz + descsz;
1533                         if (read(fd, bf, n) != n)
1534                                 break;
1535                 }
1536         }
1537         close(fd);
1538 out:
1539         return err;
1540 }
1541
1542 char dso__symtab_origin(const struct dso *dso)
1543 {
1544         static const char origin[] = {
1545                 [SYMTAB__KALLSYMS]            = 'k',
1546                 [SYMTAB__JAVA_JIT]            = 'j',
1547                 [SYMTAB__BUILD_ID_CACHE]      = 'B',
1548                 [SYMTAB__FEDORA_DEBUGINFO]    = 'f',
1549                 [SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
1550                 [SYMTAB__BUILDID_DEBUGINFO]   = 'b',
1551                 [SYMTAB__SYSTEM_PATH_DSO]     = 'd',
1552                 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
1553                 [SYMTAB__GUEST_KALLSYMS]      =  'g',
1554                 [SYMTAB__GUEST_KMODULE]       =  'G',
1555         };
1556
1557         if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
1558                 return '!';
1559         return origin[dso->symtab_type];
1560 }
1561
1562 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1563 {
1564         int size = PATH_MAX;
1565         char *name;
1566         int ret = -1;
1567         int fd;
1568         struct machine *machine;
1569         const char *root_dir;
1570         int want_symtab;
1571
1572         dso__set_loaded(dso, map->type);
1573
1574         if (dso->kernel == DSO_TYPE_KERNEL)
1575                 return dso__load_kernel_sym(dso, map, filter);
1576         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1577                 return dso__load_guest_kernel_sym(dso, map, filter);
1578
1579         if (map->groups && map->groups->machine)
1580                 machine = map->groups->machine;
1581         else
1582                 machine = NULL;
1583
1584         name = malloc(size);
1585         if (!name)
1586                 return -1;
1587
1588         dso->adjust_symbols = 0;
1589
1590         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1591                 struct stat st;
1592
1593                 if (lstat(dso->name, &st) < 0)
1594                         return -1;
1595
1596                 if (st.st_uid && (st.st_uid != geteuid())) {
1597                         pr_warning("File %s not owned by current user or root, "
1598                                 "ignoring it.\n", dso->name);
1599                         return -1;
1600                 }
1601
1602                 ret = dso__load_perf_map(dso, map, filter);
1603                 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
1604                                               SYMTAB__NOT_FOUND;
1605                 return ret;
1606         }
1607
1608         /* Iterate over candidate debug images.
1609          * On the first pass, only load images if they have a full symtab.
1610          * Failing that, do a second pass where we accept .dynsym also
1611          */
1612         want_symtab = 1;
1613 restart:
1614         for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
1615              dso->symtab_type != SYMTAB__NOT_FOUND;
1616              dso->symtab_type++) {
1617                 switch (dso->symtab_type) {
1618                 case SYMTAB__BUILD_ID_CACHE:
1619                         /* skip the locally configured cache if a symfs is given */
1620                         if (symbol_conf.symfs[0] ||
1621                             (dso__build_id_filename(dso, name, size) == NULL)) {
1622                                 continue;
1623                         }
1624                         break;
1625                 case SYMTAB__FEDORA_DEBUGINFO:
1626                         snprintf(name, size, "%s/usr/lib/debug%s.debug",
1627                                  symbol_conf.symfs, dso->long_name);
1628                         break;
1629                 case SYMTAB__UBUNTU_DEBUGINFO:
1630                         snprintf(name, size, "%s/usr/lib/debug%s",
1631                                  symbol_conf.symfs, dso->long_name);
1632                         break;
1633                 case SYMTAB__BUILDID_DEBUGINFO: {
1634                         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1635
1636                         if (!dso->has_build_id)
1637                                 continue;
1638
1639                         build_id__sprintf(dso->build_id,
1640                                           sizeof(dso->build_id),
1641                                           build_id_hex);
1642                         snprintf(name, size,
1643                                  "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1644                                  symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1645                         }
1646                         break;
1647                 case SYMTAB__SYSTEM_PATH_DSO:
1648                         snprintf(name, size, "%s%s",
1649                              symbol_conf.symfs, dso->long_name);
1650                         break;
1651                 case SYMTAB__GUEST_KMODULE:
1652                         if (map->groups && machine)
1653                                 root_dir = machine->root_dir;
1654                         else
1655                                 root_dir = "";
1656                         snprintf(name, size, "%s%s%s", symbol_conf.symfs,
1657                                  root_dir, dso->long_name);
1658                         break;
1659
1660                 case SYMTAB__SYSTEM_PATH_KMODULE:
1661                         snprintf(name, size, "%s%s", symbol_conf.symfs,
1662                                  dso->long_name);
1663                         break;
1664                 default:;
1665                 }
1666
1667                 /* Name is now the name of the next image to try */
1668                 fd = open(name, O_RDONLY);
1669                 if (fd < 0)
1670                         continue;
1671
1672                 ret = dso__load_sym(dso, map, name, fd, filter, 0,
1673                                     want_symtab);
1674                 close(fd);
1675
1676                 /*
1677                  * Some people seem to have debuginfo files _WITHOUT_ debug
1678                  * info!?!?
1679                  */
1680                 if (!ret)
1681                         continue;
1682
1683                 if (ret > 0) {
1684                         int nr_plt = dso__synthesize_plt_symbols(dso, map,
1685                                                                  filter);
1686                         if (nr_plt > 0)
1687                                 ret += nr_plt;
1688                         break;
1689                 }
1690         }
1691
1692         /*
1693          * If we wanted a full symtab but no image had one,
1694          * relax our requirements and repeat the search.
1695          */
1696         if (ret <= 0 && want_symtab) {
1697                 want_symtab = 0;
1698                 goto restart;
1699         }
1700
1701         free(name);
1702         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1703                 return 0;
1704         return ret;
1705 }
1706
1707 struct map *map_groups__find_by_name(struct map_groups *mg,
1708                                      enum map_type type, const char *name)
1709 {
1710         struct rb_node *nd;
1711
1712         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1713                 struct map *map = rb_entry(nd, struct map, rb_node);
1714
1715                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1716                         return map;
1717         }
1718
1719         return NULL;
1720 }
1721
1722 static int dso__kernel_module_get_build_id(struct dso *dso,
1723                                            const char *root_dir)
1724 {
1725         char filename[PATH_MAX];
1726         /*
1727          * kernel module short names are of the form "[module]" and
1728          * we need just "module" here.
1729          */
1730         const char *name = dso->short_name + 1;
1731
1732         snprintf(filename, sizeof(filename),
1733                  "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1734                  root_dir, (int)strlen(name) - 1, name);
1735
1736         if (sysfs__read_build_id(filename, dso->build_id,
1737                                  sizeof(dso->build_id)) == 0)
1738                 dso->has_build_id = true;
1739
1740         return 0;
1741 }
1742
1743 static int map_groups__set_modules_path_dir(struct map_groups *mg,
1744                                 const char *dir_name)
1745 {
1746         struct dirent *dent;
1747         DIR *dir = opendir(dir_name);
1748         int ret = 0;
1749
1750         if (!dir) {
1751                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1752                 return -1;
1753         }
1754
1755         while ((dent = readdir(dir)) != NULL) {
1756                 char path[PATH_MAX];
1757                 struct stat st;
1758
1759                 /*sshfs might return bad dent->d_type, so we have to stat*/
1760                 sprintf(path, "%s/%s", dir_name, dent->d_name);
1761                 if (stat(path, &st))
1762                         continue;
1763
1764                 if (S_ISDIR(st.st_mode)) {
1765                         if (!strcmp(dent->d_name, ".") ||
1766                             !strcmp(dent->d_name, ".."))
1767                                 continue;
1768
1769                         snprintf(path, sizeof(path), "%s/%s",
1770                                  dir_name, dent->d_name);
1771                         ret = map_groups__set_modules_path_dir(mg, path);
1772                         if (ret < 0)
1773                                 goto out;
1774                 } else {
1775                         char *dot = strrchr(dent->d_name, '.'),
1776                              dso_name[PATH_MAX];
1777                         struct map *map;
1778                         char *long_name;
1779
1780                         if (dot == NULL || strcmp(dot, ".ko"))
1781                                 continue;
1782                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1783                                  (int)(dot - dent->d_name), dent->d_name);
1784
1785                         strxfrchar(dso_name, '-', '_');
1786                         map = map_groups__find_by_name(mg, MAP__FUNCTION,
1787                                                        dso_name);
1788                         if (map == NULL)
1789                                 continue;
1790
1791                         snprintf(path, sizeof(path), "%s/%s",
1792                                  dir_name, dent->d_name);
1793
1794                         long_name = strdup(path);
1795                         if (long_name == NULL) {
1796                                 ret = -1;
1797                                 goto out;
1798                         }
1799                         dso__set_long_name(map->dso, long_name);
1800                         map->dso->lname_alloc = 1;
1801                         dso__kernel_module_get_build_id(map->dso, "");
1802                 }
1803         }
1804
1805 out:
1806         closedir(dir);
1807         return ret;
1808 }
1809
1810 static char *get_kernel_version(const char *root_dir)
1811 {
1812         char version[PATH_MAX];
1813         FILE *file;
1814         char *name, *tmp;
1815         const char *prefix = "Linux version ";
1816
1817         sprintf(version, "%s/proc/version", root_dir);
1818         file = fopen(version, "r");
1819         if (!file)
1820                 return NULL;
1821
1822         version[0] = '\0';
1823         tmp = fgets(version, sizeof(version), file);
1824         fclose(file);
1825
1826         name = strstr(version, prefix);
1827         if (!name)
1828                 return NULL;
1829         name += strlen(prefix);
1830         tmp = strchr(name, ' ');
1831         if (tmp)
1832                 *tmp = '\0';
1833
1834         return strdup(name);
1835 }
1836
1837 static int machine__set_modules_path(struct machine *machine)
1838 {
1839         char *version;
1840         char modules_path[PATH_MAX];
1841
1842         version = get_kernel_version(machine->root_dir);
1843         if (!version)
1844                 return -1;
1845
1846         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1847                  machine->root_dir, version);
1848         free(version);
1849
1850         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
1851 }
1852
1853 /*
1854  * Constructor variant for modules (where we know from /proc/modules where
1855  * they are loaded) and for vmlinux, where only after we load all the
1856  * symbols we'll know where it starts and ends.
1857  */
1858 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1859 {
1860         struct map *map = calloc(1, (sizeof(*map) +
1861                                      (dso->kernel ? sizeof(struct kmap) : 0)));
1862         if (map != NULL) {
1863                 /*
1864                  * ->end will be filled after we load all the symbols
1865                  */
1866                 map__init(map, type, start, 0, 0, dso);
1867         }
1868
1869         return map;
1870 }
1871
1872 struct map *machine__new_module(struct machine *machine, u64 start,
1873                                 const char *filename)
1874 {
1875         struct map *map;
1876         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
1877
1878         if (dso == NULL)
1879                 return NULL;
1880
1881         map = map__new2(start, dso, MAP__FUNCTION);
1882         if (map == NULL)
1883                 return NULL;
1884
1885         if (machine__is_host(machine))
1886                 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
1887         else
1888                 dso->symtab_type = SYMTAB__GUEST_KMODULE;
1889         map_groups__insert(&machine->kmaps, map);
1890         return map;
1891 }
1892
1893 static int machine__create_modules(struct machine *machine)
1894 {
1895         char *line = NULL;
1896         size_t n;
1897         FILE *file;
1898         struct map *map;
1899         const char *modules;
1900         char path[PATH_MAX];
1901
1902         if (machine__is_default_guest(machine))
1903                 modules = symbol_conf.default_guest_modules;
1904         else {
1905                 sprintf(path, "%s/proc/modules", machine->root_dir);
1906                 modules = path;
1907         }
1908
1909         if (symbol__restricted_filename(path, "/proc/modules"))
1910                 return -1;
1911
1912         file = fopen(modules, "r");
1913         if (file == NULL)
1914                 return -1;
1915
1916         while (!feof(file)) {
1917                 char name[PATH_MAX];
1918                 u64 start;
1919                 char *sep;
1920                 int line_len;
1921
1922                 line_len = getline(&line, &n, file);
1923                 if (line_len < 0)
1924                         break;
1925
1926                 if (!line)
1927                         goto out_failure;
1928
1929                 line[--line_len] = '\0'; /* \n */
1930
1931                 sep = strrchr(line, 'x');
1932                 if (sep == NULL)
1933                         continue;
1934
1935                 hex2u64(sep + 1, &start);
1936
1937                 sep = strchr(line, ' ');
1938                 if (sep == NULL)
1939                         continue;
1940
1941                 *sep = '\0';
1942
1943                 snprintf(name, sizeof(name), "[%s]", line);
1944                 map = machine__new_module(machine, start, name);
1945                 if (map == NULL)
1946                         goto out_delete_line;
1947                 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1948         }
1949
1950         free(line);
1951         fclose(file);
1952
1953         return machine__set_modules_path(machine);
1954
1955 out_delete_line:
1956         free(line);
1957 out_failure:
1958         return -1;
1959 }
1960
1961 int dso__load_vmlinux(struct dso *dso, struct map *map,
1962                       const char *vmlinux, symbol_filter_t filter)
1963 {
1964         int err = -1, fd;
1965         char symfs_vmlinux[PATH_MAX];
1966
1967         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
1968                  symbol_conf.symfs, vmlinux);
1969         fd = open(symfs_vmlinux, O_RDONLY);
1970         if (fd < 0)
1971                 return -1;
1972
1973         dso__set_long_name(dso, (char *)vmlinux);
1974         dso__set_loaded(dso, map->type);
1975         err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
1976         close(fd);
1977
1978         if (err > 0)
1979                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1980
1981         return err;
1982 }
1983
1984 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
1985                            symbol_filter_t filter)
1986 {
1987         int i, err = 0;
1988         char *filename;
1989
1990         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1991                  vmlinux_path__nr_entries + 1);
1992
1993         filename = dso__build_id_filename(dso, NULL, 0);
1994         if (filename != NULL) {
1995                 err = dso__load_vmlinux(dso, map, filename, filter);
1996                 if (err > 0) {
1997                         dso__set_long_name(dso, filename);
1998                         goto out;
1999                 }
2000                 free(filename);
2001         }
2002
2003         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2004                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2005                 if (err > 0) {
2006                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
2007                         break;
2008                 }
2009         }
2010 out:
2011         return err;
2012 }
2013
2014 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2015                                 symbol_filter_t filter)
2016 {
2017         int err;
2018         const char *kallsyms_filename = NULL;
2019         char *kallsyms_allocated_filename = NULL;
2020         /*
2021          * Step 1: if the user specified a kallsyms or vmlinux filename, use
2022          * it and only it, reporting errors to the user if it cannot be used.
2023          *
2024          * For instance, try to analyse an ARM perf.data file _without_ a
2025          * build-id, or if the user specifies the wrong path to the right
2026          * vmlinux file, obviously we can't fallback to another vmlinux (a
2027          * x86_86 one, on the machine where analysis is being performed, say),
2028          * or worse, /proc/kallsyms.
2029          *
2030          * If the specified file _has_ a build-id and there is a build-id
2031          * section in the perf.data file, we will still do the expected
2032          * validation in dso__load_vmlinux and will bail out if they don't
2033          * match.
2034          */
2035         if (symbol_conf.kallsyms_name != NULL) {
2036                 kallsyms_filename = symbol_conf.kallsyms_name;
2037                 goto do_kallsyms;
2038         }
2039
2040         if (symbol_conf.vmlinux_name != NULL) {
2041                 err = dso__load_vmlinux(dso, map,
2042                                         symbol_conf.vmlinux_name, filter);
2043                 if (err > 0) {
2044                         dso__set_long_name(dso,
2045                                            strdup(symbol_conf.vmlinux_name));
2046                         goto out_fixup;
2047                 }
2048                 return err;
2049         }
2050
2051         if (vmlinux_path != NULL) {
2052                 err = dso__load_vmlinux_path(dso, map, filter);
2053                 if (err > 0)
2054                         goto out_fixup;
2055         }
2056
2057         /* do not try local files if a symfs was given */
2058         if (symbol_conf.symfs[0] != 0)
2059                 return -1;
2060
2061         /*
2062          * Say the kernel DSO was created when processing the build-id header table,
2063          * we have a build-id, so check if it is the same as the running kernel,
2064          * using it if it is.
2065          */
2066         if (dso->has_build_id) {
2067                 u8 kallsyms_build_id[BUILD_ID_SIZE];
2068                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2069
2070                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2071                                          sizeof(kallsyms_build_id)) == 0) {
2072                         if (dso__build_id_equal(dso, kallsyms_build_id)) {
2073                                 kallsyms_filename = "/proc/kallsyms";
2074                                 goto do_kallsyms;
2075                         }
2076                 }
2077                 /*
2078                  * Now look if we have it on the build-id cache in
2079                  * $HOME/.debug/[kernel.kallsyms].
2080                  */
2081                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2082                                   sbuild_id);
2083
2084                 if (asprintf(&kallsyms_allocated_filename,
2085                              "%s/.debug/[kernel.kallsyms]/%s",
2086                              getenv("HOME"), sbuild_id) == -1) {
2087                         pr_err("Not enough memory for kallsyms file lookup\n");
2088                         return -1;
2089                 }
2090
2091                 kallsyms_filename = kallsyms_allocated_filename;
2092
2093                 if (access(kallsyms_filename, F_OK)) {
2094                         pr_err("No kallsyms or vmlinux with build-id %s "
2095                                "was found\n", sbuild_id);
2096                         free(kallsyms_allocated_filename);
2097                         return -1;
2098                 }
2099         } else {
2100                 /*
2101                  * Last resort, if we don't have a build-id and couldn't find
2102                  * any vmlinux file, try the running kernel kallsyms table.
2103                  */
2104                 kallsyms_filename = "/proc/kallsyms";
2105         }
2106
2107 do_kallsyms:
2108         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2109         if (err > 0)
2110                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2111         free(kallsyms_allocated_filename);
2112
2113         if (err > 0) {
2114 out_fixup:
2115                 if (kallsyms_filename != NULL)
2116                         dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2117                 map__fixup_start(map);
2118                 map__fixup_end(map);
2119         }
2120
2121         return err;
2122 }
2123
2124 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2125                                       symbol_filter_t filter)
2126 {
2127         int err;
2128         const char *kallsyms_filename = NULL;
2129         struct machine *machine;
2130         char path[PATH_MAX];
2131
2132         if (!map->groups) {
2133                 pr_debug("Guest kernel map hasn't the point to groups\n");
2134                 return -1;
2135         }
2136         machine = map->groups->machine;
2137
2138         if (machine__is_default_guest(machine)) {
2139                 /*
2140                  * if the user specified a vmlinux filename, use it and only
2141                  * it, reporting errors to the user if it cannot be used.
2142                  * Or use file guest_kallsyms inputted by user on commandline
2143                  */
2144                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2145                         err = dso__load_vmlinux(dso, map,
2146                                 symbol_conf.default_guest_vmlinux_name, filter);
2147                         goto out_try_fixup;
2148                 }
2149
2150                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2151                 if (!kallsyms_filename)
2152                         return -1;
2153         } else {
2154                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2155                 kallsyms_filename = path;
2156         }
2157
2158         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2159         if (err > 0)
2160                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2161
2162 out_try_fixup:
2163         if (err > 0) {
2164                 if (kallsyms_filename != NULL) {
2165                         machine__mmap_name(machine, path, sizeof(path));
2166                         dso__set_long_name(dso, strdup(path));
2167                 }
2168                 map__fixup_start(map);
2169                 map__fixup_end(map);
2170         }
2171
2172         return err;
2173 }
2174
2175 static void dsos__add(struct list_head *head, struct dso *dso)
2176 {
2177         list_add_tail(&dso->node, head);
2178 }
2179
2180 static struct dso *dsos__find(struct list_head *head, const char *name)
2181 {
2182         struct dso *pos;
2183
2184         list_for_each_entry(pos, head, node)
2185                 if (strcmp(pos->long_name, name) == 0)
2186                         return pos;
2187         return NULL;
2188 }
2189
2190 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2191 {
2192         struct dso *dso = dsos__find(head, name);
2193
2194         if (!dso) {
2195                 dso = dso__new(name);
2196                 if (dso != NULL) {
2197                         dsos__add(head, dso);
2198                         dso__set_basename(dso);
2199                 }
2200         }
2201
2202         return dso;
2203 }
2204
2205 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2206 {
2207         struct dso *pos;
2208         size_t ret = 0;
2209
2210         list_for_each_entry(pos, head, node) {
2211                 int i;
2212                 for (i = 0; i < MAP__NR_TYPES; ++i)
2213                         ret += dso__fprintf(pos, i, fp);
2214         }
2215
2216         return ret;
2217 }
2218
2219 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2220 {
2221         struct rb_node *nd;
2222         size_t ret = 0;
2223
2224         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2225                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2226                 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2227                 ret += __dsos__fprintf(&pos->user_dsos, fp);
2228         }
2229
2230         return ret;
2231 }
2232
2233 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2234                                       bool with_hits)
2235 {
2236         struct dso *pos;
2237         size_t ret = 0;
2238
2239         list_for_each_entry(pos, head, node) {
2240                 if (with_hits && !pos->hit)
2241                         continue;
2242                 ret += dso__fprintf_buildid(pos, fp);
2243                 ret += fprintf(fp, " %s\n", pos->long_name);
2244         }
2245         return ret;
2246 }
2247
2248 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2249                                      bool with_hits)
2250 {
2251         return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2252                __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2253 }
2254
2255 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2256                                       FILE *fp, bool with_hits)
2257 {
2258         struct rb_node *nd;
2259         size_t ret = 0;
2260
2261         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2262                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2263                 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2264         }
2265         return ret;
2266 }
2267
2268 static struct dso*
2269 dso__kernel_findnew(struct machine *machine, const char *name,
2270                     const char *short_name, int dso_type)
2271 {
2272         /*
2273          * The kernel dso could be created by build_id processing.
2274          */
2275         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2276
2277         /*
2278          * We need to run this in all cases, since during the build_id
2279          * processing we had no idea this was the kernel dso.
2280          */
2281         if (dso != NULL) {
2282                 dso__set_short_name(dso, short_name);
2283                 dso->kernel = dso_type;
2284         }
2285
2286         return dso;
2287 }
2288
2289 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2290 {
2291         char path[PATH_MAX];
2292
2293         if (machine__is_default_guest(machine))
2294                 return;
2295         sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2296         if (sysfs__read_build_id(path, dso->build_id,
2297                                  sizeof(dso->build_id)) == 0)
2298                 dso->has_build_id = true;
2299 }
2300
2301 static struct dso *machine__get_kernel(struct machine *machine)
2302 {
2303         const char *vmlinux_name = NULL;
2304         struct dso *kernel;
2305
2306         if (machine__is_host(machine)) {
2307                 vmlinux_name = symbol_conf.vmlinux_name;
2308                 if (!vmlinux_name)
2309                         vmlinux_name = "[kernel.kallsyms]";
2310
2311                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2312                                              "[kernel]",
2313                                              DSO_TYPE_KERNEL);
2314         } else {
2315                 char bf[PATH_MAX];
2316
2317                 if (machine__is_default_guest(machine))
2318                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2319                 if (!vmlinux_name)
2320                         vmlinux_name = machine__mmap_name(machine, bf,
2321                                                           sizeof(bf));
2322
2323                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2324                                              "[guest.kernel]",
2325                                              DSO_TYPE_GUEST_KERNEL);
2326         }
2327
2328         if (kernel != NULL && (!kernel->has_build_id))
2329                 dso__read_running_kernel_build_id(kernel, machine);
2330
2331         return kernel;
2332 }
2333
2334 struct process_args {
2335         u64 start;
2336 };
2337
2338 static int symbol__in_kernel(void *arg, const char *name,
2339                              char type __used, u64 start, u64 end __used)
2340 {
2341         struct process_args *args = arg;
2342
2343         if (strchr(name, '['))
2344                 return 0;
2345
2346         args->start = start;
2347         return 1;
2348 }
2349
2350 /* Figure out the start address of kernel map from /proc/kallsyms */
2351 static u64 machine__get_kernel_start_addr(struct machine *machine)
2352 {
2353         const char *filename;
2354         char path[PATH_MAX];
2355         struct process_args args;
2356
2357         if (machine__is_host(machine)) {
2358                 filename = "/proc/kallsyms";
2359         } else {
2360                 if (machine__is_default_guest(machine))
2361                         filename = (char *)symbol_conf.default_guest_kallsyms;
2362                 else {
2363                         sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2364                         filename = path;
2365                 }
2366         }
2367
2368         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2369                 return 0;
2370
2371         if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2372                 return 0;
2373
2374         return args.start;
2375 }
2376
2377 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
2378 {
2379         enum map_type type;
2380         u64 start = machine__get_kernel_start_addr(machine);
2381
2382         for (type = 0; type < MAP__NR_TYPES; ++type) {
2383                 struct kmap *kmap;
2384
2385                 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2386                 if (machine->vmlinux_maps[type] == NULL)
2387                         return -1;
2388
2389                 machine->vmlinux_maps[type]->map_ip =
2390                         machine->vmlinux_maps[type]->unmap_ip =
2391                                 identity__map_ip;
2392                 kmap = map__kmap(machine->vmlinux_maps[type]);
2393                 kmap->kmaps = &machine->kmaps;
2394                 map_groups__insert(&machine->kmaps,
2395                                    machine->vmlinux_maps[type]);
2396         }
2397
2398         return 0;
2399 }
2400
2401 void machine__destroy_kernel_maps(struct machine *machine)
2402 {
2403         enum map_type type;
2404
2405         for (type = 0; type < MAP__NR_TYPES; ++type) {
2406                 struct kmap *kmap;
2407
2408                 if (machine->vmlinux_maps[type] == NULL)
2409                         continue;
2410
2411                 kmap = map__kmap(machine->vmlinux_maps[type]);
2412                 map_groups__remove(&machine->kmaps,
2413                                    machine->vmlinux_maps[type]);
2414                 if (kmap->ref_reloc_sym) {
2415                         /*
2416                          * ref_reloc_sym is shared among all maps, so free just
2417                          * on one of them.
2418                          */
2419                         if (type == MAP__FUNCTION) {
2420                                 free((char *)kmap->ref_reloc_sym->name);
2421                                 kmap->ref_reloc_sym->name = NULL;
2422                                 free(kmap->ref_reloc_sym);
2423                         }
2424                         kmap->ref_reloc_sym = NULL;
2425                 }
2426
2427                 map__delete(machine->vmlinux_maps[type]);
2428                 machine->vmlinux_maps[type] = NULL;
2429         }
2430 }
2431
2432 int machine__create_kernel_maps(struct machine *machine)
2433 {
2434         struct dso *kernel = machine__get_kernel(machine);
2435
2436         if (kernel == NULL ||
2437             __machine__create_kernel_maps(machine, kernel) < 0)
2438                 return -1;
2439
2440         if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
2441                 pr_debug("Problems creating module maps, continuing anyway...\n");
2442         /*
2443          * Now that we have all the maps created, just set the ->end of them:
2444          */
2445         map_groups__fixup_end(&machine->kmaps);
2446         return 0;
2447 }
2448
2449 static void vmlinux_path__exit(void)
2450 {
2451         while (--vmlinux_path__nr_entries >= 0) {
2452                 free(vmlinux_path[vmlinux_path__nr_entries]);
2453                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2454         }
2455
2456         free(vmlinux_path);
2457         vmlinux_path = NULL;
2458 }
2459
2460 static int vmlinux_path__init(void)
2461 {
2462         struct utsname uts;
2463         char bf[PATH_MAX];
2464
2465         vmlinux_path = malloc(sizeof(char *) * 5);
2466         if (vmlinux_path == NULL)
2467                 return -1;
2468
2469         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2470         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2471                 goto out_fail;
2472         ++vmlinux_path__nr_entries;
2473         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2474         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2475                 goto out_fail;
2476         ++vmlinux_path__nr_entries;
2477
2478         /* only try running kernel version if no symfs was given */
2479         if (symbol_conf.symfs[0] != 0)
2480                 return 0;
2481
2482         if (uname(&uts) < 0)
2483                 return -1;
2484
2485         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2486         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2487         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2488                 goto out_fail;
2489         ++vmlinux_path__nr_entries;
2490         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2491         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2492         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2493                 goto out_fail;
2494         ++vmlinux_path__nr_entries;
2495         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2496                  uts.release);
2497         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2498         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2499                 goto out_fail;
2500         ++vmlinux_path__nr_entries;
2501
2502         return 0;
2503
2504 out_fail:
2505         vmlinux_path__exit();
2506         return -1;
2507 }
2508
2509 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2510 {
2511         int i;
2512         size_t printed = 0;
2513         struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2514
2515         if (kdso->has_build_id) {
2516                 char filename[PATH_MAX];
2517                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2518                         printed += fprintf(fp, "[0] %s\n", filename);
2519         }
2520
2521         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2522                 printed += fprintf(fp, "[%d] %s\n",
2523                                    i + kdso->has_build_id, vmlinux_path[i]);
2524
2525         return printed;
2526 }
2527
2528 static int setup_list(struct strlist **list, const char *list_str,
2529                       const char *list_name)
2530 {
2531         if (list_str == NULL)
2532                 return 0;
2533
2534         *list = strlist__new(true, list_str);
2535         if (!*list) {
2536                 pr_err("problems parsing %s list\n", list_name);
2537                 return -1;
2538         }
2539         return 0;
2540 }
2541
2542 static bool symbol__read_kptr_restrict(void)
2543 {
2544         bool value = false;
2545
2546         if (geteuid() != 0) {
2547                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2548                 if (fp != NULL) {
2549                         char line[8];
2550
2551                         if (fgets(line, sizeof(line), fp) != NULL)
2552                                 value = atoi(line) != 0;
2553
2554                         fclose(fp);
2555                 }
2556         }
2557
2558         return value;
2559 }
2560
2561 int symbol__init(void)
2562 {
2563         const char *symfs;
2564
2565         if (symbol_conf.initialized)
2566                 return 0;
2567
2568         symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2569
2570         elf_version(EV_CURRENT);
2571         if (symbol_conf.sort_by_name)
2572                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2573                                           sizeof(struct symbol));
2574
2575         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2576                 return -1;
2577
2578         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2579                 pr_err("'.' is the only non valid --field-separator argument\n");
2580                 return -1;
2581         }
2582
2583         if (setup_list(&symbol_conf.dso_list,
2584                        symbol_conf.dso_list_str, "dso") < 0)
2585                 return -1;
2586
2587         if (setup_list(&symbol_conf.comm_list,
2588                        symbol_conf.comm_list_str, "comm") < 0)
2589                 goto out_free_dso_list;
2590
2591         if (setup_list(&symbol_conf.sym_list,
2592                        symbol_conf.sym_list_str, "symbol") < 0)
2593                 goto out_free_comm_list;
2594
2595         /*
2596          * A path to symbols of "/" is identical to ""
2597          * reset here for simplicity.
2598          */
2599         symfs = realpath(symbol_conf.symfs, NULL);
2600         if (symfs == NULL)
2601                 symfs = symbol_conf.symfs;
2602         if (strcmp(symfs, "/") == 0)
2603                 symbol_conf.symfs = "";
2604         if (symfs != symbol_conf.symfs)
2605                 free((void *)symfs);
2606
2607         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2608
2609         symbol_conf.initialized = true;
2610         return 0;
2611
2612 out_free_dso_list:
2613         strlist__delete(symbol_conf.dso_list);
2614 out_free_comm_list:
2615         strlist__delete(symbol_conf.comm_list);
2616         return -1;
2617 }
2618
2619 void symbol__exit(void)
2620 {
2621         if (!symbol_conf.initialized)
2622                 return;
2623         strlist__delete(symbol_conf.sym_list);
2624         strlist__delete(symbol_conf.dso_list);
2625         strlist__delete(symbol_conf.comm_list);
2626         vmlinux_path__exit();
2627         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2628         symbol_conf.initialized = false;
2629 }
2630
2631 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2632 {
2633         struct machine *machine = machines__findnew(machines, pid);
2634
2635         if (machine == NULL)
2636                 return -1;
2637
2638         return machine__create_kernel_maps(machine);
2639 }
2640
2641 static int hex(char ch)
2642 {
2643         if ((ch >= '0') && (ch <= '9'))
2644                 return ch - '0';
2645         if ((ch >= 'a') && (ch <= 'f'))
2646                 return ch - 'a' + 10;
2647         if ((ch >= 'A') && (ch <= 'F'))
2648                 return ch - 'A' + 10;
2649         return -1;
2650 }
2651
2652 /*
2653  * While we find nice hex chars, build a long_val.
2654  * Return number of chars processed.
2655  */
2656 int hex2u64(const char *ptr, u64 *long_val)
2657 {
2658         const char *p = ptr;
2659         *long_val = 0;
2660
2661         while (*p) {
2662                 const int hex_val = hex(*p);
2663
2664                 if (hex_val < 0)
2665                         break;
2666
2667                 *long_val = (*long_val << 4) | hex_val;
2668                 p++;
2669         }
2670
2671         return p - ptr;
2672 }
2673
2674 char *strxfrchar(char *s, char from, char to)
2675 {
2676         char *p = s;
2677
2678         while ((p = strchr(p, from)) != NULL)
2679                 *p++ = to;
2680
2681         return s;
2682 }
2683
2684 int machines__create_guest_kernel_maps(struct rb_root *machines)
2685 {
2686         int ret = 0;
2687         struct dirent **namelist = NULL;
2688         int i, items = 0;
2689         char path[PATH_MAX];
2690         pid_t pid;
2691
2692         if (symbol_conf.default_guest_vmlinux_name ||
2693             symbol_conf.default_guest_modules ||
2694             symbol_conf.default_guest_kallsyms) {
2695                 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2696         }
2697
2698         if (symbol_conf.guestmount) {
2699                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2700                 if (items <= 0)
2701                         return -ENOENT;
2702                 for (i = 0; i < items; i++) {
2703                         if (!isdigit(namelist[i]->d_name[0])) {
2704                                 /* Filter out . and .. */
2705                                 continue;
2706                         }
2707                         pid = atoi(namelist[i]->d_name);
2708                         sprintf(path, "%s/%s/proc/kallsyms",
2709                                 symbol_conf.guestmount,
2710                                 namelist[i]->d_name);
2711                         ret = access(path, R_OK);
2712                         if (ret) {
2713                                 pr_debug("Can't access file %s\n", path);
2714                                 goto failure;
2715                         }
2716                         machines__create_kernel_maps(machines, pid);
2717                 }
2718 failure:
2719                 free(namelist);
2720         }
2721
2722         return ret;
2723 }
2724
2725 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2726 {
2727         struct rb_node *next = rb_first(machines);
2728
2729         while (next) {
2730                 struct machine *pos = rb_entry(next, struct machine, rb_node);
2731
2732                 next = rb_next(&pos->rb_node);
2733                 rb_erase(&pos->rb_node, machines);
2734                 machine__delete(pos);
2735         }
2736 }
2737
2738 int machine__load_kallsyms(struct machine *machine, const char *filename,
2739                            enum map_type type, symbol_filter_t filter)
2740 {
2741         struct map *map = machine->vmlinux_maps[type];
2742         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2743
2744         if (ret > 0) {
2745                 dso__set_loaded(map->dso, type);
2746                 /*
2747                  * Since /proc/kallsyms will have multiple sessions for the
2748                  * kernel, with modules between them, fixup the end of all
2749                  * sections.
2750                  */
2751                 __map_groups__fixup_end(&machine->kmaps, type);
2752         }
2753
2754         return ret;
2755 }
2756
2757 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2758                                symbol_filter_t filter)
2759 {
2760         struct map *map = machine->vmlinux_maps[type];
2761         int ret = dso__load_vmlinux_path(map->dso, map, filter);
2762
2763         if (ret > 0) {
2764                 dso__set_loaded(map->dso, type);
2765                 map__reloc_vmlinux(map);
2766         }
2767
2768         return ret;
2769 }