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