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