?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[linux/fpc-iii.git] / tools / perf / util / symbol.c
blobe7588dc915181729394c1d2195c78576c47d20df
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 "machine.h"
16 #include "symbol.h"
17 #include "strlist.h"
18 #include "intlist.h"
19 #include "header.h"
20
21 #include <elf.h>
22 #include <limits.h>
23 #include <symbol/kallsyms.h>
24 #include <sys/utsname.h>
25
26 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
27 symbol_filter_t filter);
28 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
29 symbol_filter_t filter);
30 int vmlinux_path__nr_entries;
31 char **vmlinux_path;
32
33 struct symbol_conf symbol_conf = {
34 .use_modules = true,
35 .try_vmlinux_path = true,
36 .annotate_src = true,
37 .demangle = true,
38 .demangle_kernel = false,
39 .cumulate_callchain = true,
40 .show_hist_headers = true,
41 .symfs = "",
42 .event_group = true,
43 };
44
45 static enum dso_binary_type binary_type_symtab[] = {
46 DSO_BINARY_TYPE__KALLSYMS,
47 DSO_BINARY_TYPE__GUEST_KALLSYMS,
48 DSO_BINARY_TYPE__JAVA_JIT,
49 DSO_BINARY_TYPE__DEBUGLINK,
50 DSO_BINARY_TYPE__BUILD_ID_CACHE,
51 DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
52 DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
53 DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
54 DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
55 DSO_BINARY_TYPE__GUEST_KMODULE,
56 DSO_BINARY_TYPE__GUEST_KMODULE_COMP,
57 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
58 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP,
59 DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
60 DSO_BINARY_TYPE__NOT_FOUND,
61 };
62
63 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
64
65 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
66 {
67 symbol_type = toupper(symbol_type);
68
69 switch (map_type) {
70 case MAP__FUNCTION:
71 return symbol_type == 'T' || symbol_type == 'W';
72 case MAP__VARIABLE:
73 return symbol_type == 'D';
74 default:
75 return false;
76 }
77 }
78
79 static int prefix_underscores_count(const char *str)
80 {
81 const char *tail = str;
82
83 while (*tail == '_')
84 tail++;
85
86 return tail - str;
87 }
88
89 int __weak arch__choose_best_symbol(struct symbol *syma,
90 struct symbol *symb __maybe_unused)
91 {
92 /* Avoid "SyS" kernel syscall aliases */
93 if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3))
94 return SYMBOL_B;
95 if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10))
96 return SYMBOL_B;
97
98 return SYMBOL_A;
99 }
100
101 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
102 {
103 s64 a;
104 s64 b;
105 size_t na, nb;
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 /* Choose the symbol with the longest name */
140 na = strlen(syma->name);
141 nb = strlen(symb->name);
142 if (na > nb)
143 return SYMBOL_A;
144 else if (na < nb)
145 return SYMBOL_B;
146
147 return arch__choose_best_symbol(syma, symb);
148 }
149
150 void symbols__fixup_duplicate(struct rb_root *symbols)
151 {
152 struct rb_node *nd;
153 struct symbol *curr, *next;
154
155 nd = rb_first(symbols);
156
157 while (nd) {
158 curr = rb_entry(nd, struct symbol, rb_node);
159 again:
160 nd = rb_next(&curr->rb_node);
161 next = rb_entry(nd, struct symbol, rb_node);
162
163 if (!nd)
164 break;
165
166 if (curr->start != next->start)
167 continue;
168
169 if (choose_best_symbol(curr, next) == SYMBOL_A) {
170 rb_erase(&next->rb_node, symbols);
171 symbol__delete(next);
172 goto again;
173 } else {
174 nd = rb_next(&curr->rb_node);
175 rb_erase(&curr->rb_node, symbols);
176 symbol__delete(curr);
177 }
178 }
179 }
180
181 void symbols__fixup_end(struct rb_root *symbols)
182 {
183 struct rb_node *nd, *prevnd = rb_first(symbols);
184 struct symbol *curr, *prev;
185
186 if (prevnd == NULL)
187 return;
188
189 curr = rb_entry(prevnd, struct symbol, rb_node);
190
191 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
192 prev = curr;
193 curr = rb_entry(nd, struct symbol, rb_node);
194
195 if (prev->end == prev->start && prev->end != curr->start)
196 prev->end = curr->start;
197 }
198
199 /* Last entry */
200 if (curr->end == curr->start)
201 curr->end = roundup(curr->start, 4096);
202 }
203
204 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
205 {
206 struct maps *maps = &mg->maps[type];
207 struct map *next, *curr;
208
209 pthread_rwlock_wrlock(&maps->lock);
210
211 curr = maps__first(maps);
212 if (curr == NULL)
213 goto out_unlock;
214
215 for (next = map__next(curr); next; next = map__next(curr)) {
216 curr->end = next->start;
217 curr = next;
218 }
219
220 /*
221 * We still haven't the actual symbols, so guess the
222 * last map final address.
223 */
224 curr->end = ~0ULL;
225
226 out_unlock:
227 pthread_rwlock_unlock(&maps->lock);
228 }
229
230 struct symbol *symbol__new(u64 start, u64 len, u8 binding, 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 : 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 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 if (al->addr < sym->end)
277 offset = al->addr - sym->start;
278 else
279 offset = al->addr - al->map->start - sym->start;
280 length += fprintf(fp, "+0x%lx", offset);
281 }
282 return length;
283 } else
284 return fprintf(fp, "[unknown]");
285 }
286
287 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
288 {
289 return symbol__fprintf_symname_offs(sym, NULL, fp);
290 }
291
292 void symbols__delete(struct rb_root *symbols)
293 {
294 struct symbol *pos;
295 struct rb_node *next = rb_first(symbols);
296
297 while (next) {
298 pos = rb_entry(next, struct symbol, rb_node);
299 next = rb_next(&pos->rb_node);
300 rb_erase(&pos->rb_node, symbols);
301 symbol__delete(pos);
302 }
303 }
304
305 void symbols__insert(struct rb_root *symbols, struct symbol *sym)
306 {
307 struct rb_node **p = &symbols->rb_node;
308 struct rb_node *parent = NULL;
309 const u64 ip = sym->start;
310 struct symbol *s;
311
312 while (*p != NULL) {
313 parent = *p;
314 s = rb_entry(parent, struct symbol, rb_node);
315 if (ip < s->start)
316 p = &(*p)->rb_left;
317 else
318 p = &(*p)->rb_right;
319 }
320 rb_link_node(&sym->rb_node, parent, p);
321 rb_insert_color(&sym->rb_node, symbols);
322 }
323
324 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
325 {
326 struct rb_node *n;
327
328 if (symbols == NULL)
329 return NULL;
330
331 n = symbols->rb_node;
332
333 while (n) {
334 struct symbol *s = rb_entry(n, struct symbol, rb_node);
335
336 if (ip < s->start)
337 n = n->rb_left;
338 else if (ip >= s->end)
339 n = n->rb_right;
340 else
341 return s;
342 }
343
344 return NULL;
345 }
346
347 static struct symbol *symbols__first(struct rb_root *symbols)
348 {
349 struct rb_node *n = rb_first(symbols);
350
351 if (n)
352 return rb_entry(n, struct symbol, rb_node);
353
354 return NULL;
355 }
356
357 static struct symbol *symbols__next(struct symbol *sym)
358 {
359 struct rb_node *n = rb_next(&sym->rb_node);
360
361 if (n)
362 return rb_entry(n, struct symbol, rb_node);
363
364 return NULL;
365 }
366
367 struct symbol_name_rb_node {
368 struct rb_node rb_node;
369 struct symbol sym;
370 };
371
372 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
373 {
374 struct rb_node **p = &symbols->rb_node;
375 struct rb_node *parent = NULL;
376 struct symbol_name_rb_node *symn, *s;
377
378 symn = container_of(sym, struct symbol_name_rb_node, sym);
379
380 while (*p != NULL) {
381 parent = *p;
382 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
383 if (strcmp(sym->name, s->sym.name) < 0)
384 p = &(*p)->rb_left;
385 else
386 p = &(*p)->rb_right;
387 }
388 rb_link_node(&symn->rb_node, parent, p);
389 rb_insert_color(&symn->rb_node, symbols);
390 }
391
392 static void symbols__sort_by_name(struct rb_root *symbols,
393 struct rb_root *source)
394 {
395 struct rb_node *nd;
396
397 for (nd = rb_first(source); nd; nd = rb_next(nd)) {
398 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
399 symbols__insert_by_name(symbols, pos);
400 }
401 }
402
403 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
404 const char *name)
405 {
406 struct rb_node *n;
407 struct symbol_name_rb_node *s = NULL;
408
409 if (symbols == NULL)
410 return NULL;
411
412 n = symbols->rb_node;
413
414 while (n) {
415 int cmp;
416
417 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
418 cmp = arch__compare_symbol_names(name, s->sym.name);
419
420 if (cmp < 0)
421 n = n->rb_left;
422 else if (cmp > 0)
423 n = n->rb_right;
424 else
425 break;
426 }
427
428 if (n == NULL)
429 return NULL;
430
431 /* return first symbol that has same name (if any) */
432 for (n = rb_prev(n); n; n = rb_prev(n)) {
433 struct symbol_name_rb_node *tmp;
434
435 tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
436 if (arch__compare_symbol_names(tmp->sym.name, s->sym.name))
437 break;
438
439 s = tmp;
440 }
441
442 return &s->sym;
443 }
444
445 void dso__reset_find_symbol_cache(struct dso *dso)
446 {
447 enum map_type type;
448
449 for (type = MAP__FUNCTION; type <= MAP__VARIABLE; ++type) {
450 dso->last_find_result[type].addr = 0;
451 dso->last_find_result[type].symbol = NULL;
452 }
453 }
454
455 struct symbol *dso__find_symbol(struct dso *dso,
456 enum map_type type, u64 addr)
457 {
458 if (dso->last_find_result[type].addr != addr) {
459 dso->last_find_result[type].addr = addr;
460 dso->last_find_result[type].symbol = symbols__find(&dso->symbols[type], addr);
461 }
462
463 return dso->last_find_result[type].symbol;
464 }
465
466 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
467 {
468 return symbols__first(&dso->symbols[type]);
469 }
470
471 struct symbol *dso__next_symbol(struct symbol *sym)
472 {
473 return symbols__next(sym);
474 }
475
476 struct symbol *symbol__next_by_name(struct symbol *sym)
477 {
478 struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym);
479 struct rb_node *n = rb_next(&s->rb_node);
480
481 return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL;
482 }
483
484 /*
485 * Teturns first symbol that matched with @name.
486 */
487 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
488 const char *name)
489 {
490 return symbols__find_by_name(&dso->symbol_names[type], name);
491 }
492
493 void dso__sort_by_name(struct dso *dso, enum map_type type)
494 {
495 dso__set_sorted_by_name(dso, type);
496 return symbols__sort_by_name(&dso->symbol_names[type],
497 &dso->symbols[type]);
498 }
499
500 size_t dso__fprintf_symbols_by_name(struct dso *dso,
501 enum map_type type, FILE *fp)
502 {
503 size_t ret = 0;
504 struct rb_node *nd;
505 struct symbol_name_rb_node *pos;
506
507 for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
508 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
509 fprintf(fp, "%s\n", pos->sym.name);
510 }
511
512 return ret;
513 }
514
515 int modules__parse(const char *filename, void *arg,
516 int (*process_module)(void *arg, const char *name,
517 u64 start))
518 {
519 char *line = NULL;
520 size_t n;
521 FILE *file;
522 int err = 0;
523
524 file = fopen(filename, "r");
525 if (file == NULL)
526 return -1;
527
528 while (1) {
529 char name[PATH_MAX];
530 u64 start;
531 char *sep;
532 ssize_t line_len;
533
534 line_len = getline(&line, &n, file);
535 if (line_len < 0) {
536 if (feof(file))
537 break;
538 err = -1;
539 goto out;
540 }
541
542 if (!line) {
543 err = -1;
544 goto out;
545 }
546
547 line[--line_len] = '\0'; /* \n */
548
549 sep = strrchr(line, 'x');
550 if (sep == NULL)
551 continue;
552
553 hex2u64(sep + 1, &start);
554
555 sep = strchr(line, ' ');
556 if (sep == NULL)
557 continue;
558
559 *sep = '\0';
560
561 scnprintf(name, sizeof(name), "[%s]", line);
562
563 err = process_module(arg, name, start);
564 if (err)
565 break;
566 }
567 out:
568 free(line);
569 fclose(file);
570 return err;
571 }
572
573 struct process_kallsyms_args {
574 struct map *map;
575 struct dso *dso;
576 };
577
578 /*
579 * These are symbols in the kernel image, so make sure that
580 * sym is from a kernel DSO.
581 */
582 bool symbol__is_idle(struct symbol *sym)
583 {
584 const char * const idle_symbols[] = {
585 "cpu_idle",
586 "cpu_startup_entry",
587 "intel_idle",
588 "default_idle",
589 "native_safe_halt",
590 "enter_idle",
591 "exit_idle",
592 "mwait_idle",
593 "mwait_idle_with_hints",
594 "poll_idle",
595 "ppc64_runlatch_off",
596 "pseries_dedicated_idle_sleep",
597 NULL
598 };
599
600 int i;
601
602 if (!sym)
603 return false;
604
605 for (i = 0; idle_symbols[i]; i++) {
606 if (!strcmp(idle_symbols[i], sym->name))
607 return true;
608 }
609
610 return false;
611 }
612
613 static int map__process_kallsym_symbol(void *arg, const char *name,
614 char type, u64 start)
615 {
616 struct symbol *sym;
617 struct process_kallsyms_args *a = arg;
618 struct rb_root *root = &a->dso->symbols[a->map->type];
619
620 if (!symbol_type__is_a(type, a->map->type))
621 return 0;
622
623 /*
624 * module symbols are not sorted so we add all
625 * symbols, setting length to 0, and rely on
626 * symbols__fixup_end() to fix it up.
627 */
628 sym = symbol__new(start, 0, kallsyms2elf_binding(type), name);
629 if (sym == NULL)
630 return -ENOMEM;
631 /*
632 * We will pass the symbols to the filter later, in
633 * map__split_kallsyms, when we have split the maps per module
634 */
635 symbols__insert(root, sym);
636
637 return 0;
638 }
639
640 /*
641 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
642 * so that we can in the next step set the symbol ->end address and then
643 * call kernel_maps__split_kallsyms.
644 */
645 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
646 struct map *map)
647 {
648 struct process_kallsyms_args args = { .map = map, .dso = dso, };
649 return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
650 }
651
652 static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
653 symbol_filter_t filter)
654 {
655 struct map_groups *kmaps = map__kmaps(map);
656 struct map *curr_map;
657 struct symbol *pos;
658 int count = 0;
659 struct rb_root old_root = dso->symbols[map->type];
660 struct rb_root *root = &dso->symbols[map->type];
661 struct rb_node *next = rb_first(root);
662
663 if (!kmaps)
664 return -1;
665
666 *root = RB_ROOT;
667
668 while (next) {
669 char *module;
670
671 pos = rb_entry(next, struct symbol, rb_node);
672 next = rb_next(&pos->rb_node);
673
674 rb_erase_init(&pos->rb_node, &old_root);
675
676 module = strchr(pos->name, '\t');
677 if (module)
678 *module = '\0';
679
680 curr_map = map_groups__find(kmaps, map->type, pos->start);
681
682 if (!curr_map || (filter && filter(curr_map, pos))) {
683 symbol__delete(pos);
684 continue;
685 }
686
687 pos->start -= curr_map->start - curr_map->pgoff;
688 if (pos->end)
689 pos->end -= curr_map->start - curr_map->pgoff;
690 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
691 ++count;
692 }
693
694 /* Symbols have been adjusted */
695 dso->adjust_symbols = 1;
696
697 return count;
698 }
699
700 /*
701 * Split the symbols into maps, making sure there are no overlaps, i.e. the
702 * kernel range is broken in several maps, named [kernel].N, as we don't have
703 * the original ELF section names vmlinux have.
704 */
705 static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
706 symbol_filter_t filter)
707 {
708 struct map_groups *kmaps = map__kmaps(map);
709 struct machine *machine;
710 struct map *curr_map = map;
711 struct symbol *pos;
712 int count = 0, moved = 0;
713 struct rb_root *root = &dso->symbols[map->type];
714 struct rb_node *next = rb_first(root);
715 int kernel_range = 0;
716
717 if (!kmaps)
718 return -1;
719
720 machine = kmaps->machine;
721
722 while (next) {
723 char *module;
724
725 pos = rb_entry(next, struct symbol, rb_node);
726 next = rb_next(&pos->rb_node);
727
728 module = strchr(pos->name, '\t');
729 if (module) {
730 if (!symbol_conf.use_modules)
731 goto discard_symbol;
732
733 *module++ = '\0';
734
735 if (strcmp(curr_map->dso->short_name, module)) {
736 if (curr_map != map &&
737 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
738 machine__is_default_guest(machine)) {
739 /*
740 * We assume all symbols of a module are
741 * continuous in * kallsyms, so curr_map
742 * points to a module and all its
743 * symbols are in its kmap. Mark it as
744 * loaded.
745 */
746 dso__set_loaded(curr_map->dso,
747 curr_map->type);
748 }
749
750 curr_map = map_groups__find_by_name(kmaps,
751 map->type, module);
752 if (curr_map == NULL) {
753 pr_debug("%s/proc/{kallsyms,modules} "
754 "inconsistency while looking "
755 "for \"%s\" module!\n",
756 machine->root_dir, module);
757 curr_map = map;
758 goto discard_symbol;
759 }
760
761 if (curr_map->dso->loaded &&
762 !machine__is_default_guest(machine))
763 goto discard_symbol;
764 }
765 /*
766 * So that we look just like we get from .ko files,
767 * i.e. not prelinked, relative to map->start.
768 */
769 pos->start = curr_map->map_ip(curr_map, pos->start);
770 pos->end = curr_map->map_ip(curr_map, pos->end);
771 } else if (curr_map != map) {
772 char dso_name[PATH_MAX];
773 struct dso *ndso;
774
775 if (delta) {
776 /* Kernel was relocated at boot time */
777 pos->start -= delta;
778 pos->end -= delta;
779 }
780
781 if (count == 0) {
782 curr_map = map;
783 goto filter_symbol;
784 }
785
786 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
787 snprintf(dso_name, sizeof(dso_name),
788 "[guest.kernel].%d",
789 kernel_range++);
790 else
791 snprintf(dso_name, sizeof(dso_name),
792 "[kernel].%d",
793 kernel_range++);
794
795 ndso = dso__new(dso_name);
796 if (ndso == NULL)
797 return -1;
798
799 ndso->kernel = dso->kernel;
800
801 curr_map = map__new2(pos->start, ndso, map->type);
802 if (curr_map == NULL) {
803 dso__put(ndso);
804 return -1;
805 }
806
807 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
808 map_groups__insert(kmaps, curr_map);
809 ++kernel_range;
810 } else if (delta) {
811 /* Kernel was relocated at boot time */
812 pos->start -= delta;
813 pos->end -= delta;
814 }
815 filter_symbol:
816 if (filter && filter(curr_map, pos)) {
817 discard_symbol: rb_erase(&pos->rb_node, root);
818 symbol__delete(pos);
819 } else {
820 if (curr_map != map) {
821 rb_erase(&pos->rb_node, root);
822 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
823 ++moved;
824 } else
825 ++count;
826 }
827 }
828
829 if (curr_map != map &&
830 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
831 machine__is_default_guest(kmaps->machine)) {
832 dso__set_loaded(curr_map->dso, curr_map->type);
833 }
834
835 return count + moved;
836 }
837
838 bool symbol__restricted_filename(const char *filename,
839 const char *restricted_filename)
840 {
841 bool restricted = false;
842
843 if (symbol_conf.kptr_restrict) {
844 char *r = realpath(filename, NULL);
845
846 if (r != NULL) {
847 restricted = strcmp(r, restricted_filename) == 0;
848 free(r);
849 return restricted;
850 }
851 }
852
853 return restricted;
854 }
855
856 struct module_info {
857 struct rb_node rb_node;
858 char *name;
859 u64 start;
860 };
861
862 static void add_module(struct module_info *mi, struct rb_root *modules)
863 {
864 struct rb_node **p = &modules->rb_node;
865 struct rb_node *parent = NULL;
866 struct module_info *m;
867
868 while (*p != NULL) {
869 parent = *p;
870 m = rb_entry(parent, struct module_info, rb_node);
871 if (strcmp(mi->name, m->name) < 0)
872 p = &(*p)->rb_left;
873 else
874 p = &(*p)->rb_right;
875 }
876 rb_link_node(&mi->rb_node, parent, p);
877 rb_insert_color(&mi->rb_node, modules);
878 }
879
880 static void delete_modules(struct rb_root *modules)
881 {
882 struct module_info *mi;
883 struct rb_node *next = rb_first(modules);
884
885 while (next) {
886 mi = rb_entry(next, struct module_info, rb_node);
887 next = rb_next(&mi->rb_node);
888 rb_erase(&mi->rb_node, modules);
889 zfree(&mi->name);
890 free(mi);
891 }
892 }
893
894 static struct module_info *find_module(const char *name,
895 struct rb_root *modules)
896 {
897 struct rb_node *n = modules->rb_node;
898
899 while (n) {
900 struct module_info *m;
901 int cmp;
902
903 m = rb_entry(n, struct module_info, rb_node);
904 cmp = strcmp(name, m->name);
905 if (cmp < 0)
906 n = n->rb_left;
907 else if (cmp > 0)
908 n = n->rb_right;
909 else
910 return m;
911 }
912
913 return NULL;
914 }
915
916 static int __read_proc_modules(void *arg, const char *name, u64 start)
917 {
918 struct rb_root *modules = arg;
919 struct module_info *mi;
920
921 mi = zalloc(sizeof(struct module_info));
922 if (!mi)
923 return -ENOMEM;
924
925 mi->name = strdup(name);
926 mi->start = start;
927
928 if (!mi->name) {
929 free(mi);
930 return -ENOMEM;
931 }
932
933 add_module(mi, modules);
934
935 return 0;
936 }
937
938 static int read_proc_modules(const char *filename, struct rb_root *modules)
939 {
940 if (symbol__restricted_filename(filename, "/proc/modules"))
941 return -1;
942
943 if (modules__parse(filename, modules, __read_proc_modules)) {
944 delete_modules(modules);
945 return -1;
946 }
947
948 return 0;
949 }
950
951 int compare_proc_modules(const char *from, const char *to)
952 {
953 struct rb_root from_modules = RB_ROOT;
954 struct rb_root to_modules = RB_ROOT;
955 struct rb_node *from_node, *to_node;
956 struct module_info *from_m, *to_m;
957 int ret = -1;
958
959 if (read_proc_modules(from, &from_modules))
960 return -1;
961
962 if (read_proc_modules(to, &to_modules))
963 goto out_delete_from;
964
965 from_node = rb_first(&from_modules);
966 to_node = rb_first(&to_modules);
967 while (from_node) {
968 if (!to_node)
969 break;
970
971 from_m = rb_entry(from_node, struct module_info, rb_node);
972 to_m = rb_entry(to_node, struct module_info, rb_node);
973
974 if (from_m->start != to_m->start ||
975 strcmp(from_m->name, to_m->name))
976 break;
977
978 from_node = rb_next(from_node);
979 to_node = rb_next(to_node);
980 }
981
982 if (!from_node && !to_node)
983 ret = 0;
984
985 delete_modules(&to_modules);
986 out_delete_from:
987 delete_modules(&from_modules);
988
989 return ret;
990 }
991
992 static int do_validate_kcore_modules(const char *filename, struct map *map,
993 struct map_groups *kmaps)
994 {
995 struct rb_root modules = RB_ROOT;
996 struct map *old_map;
997 int err;
998
999 err = read_proc_modules(filename, &modules);
1000 if (err)
1001 return err;
1002
1003 old_map = map_groups__first(kmaps, map->type);
1004 while (old_map) {
1005 struct map *next = map_groups__next(old_map);
1006 struct module_info *mi;
1007
1008 if (old_map == map || old_map->start == map->start) {
1009 /* The kernel map */
1010 old_map = next;
1011 continue;
1012 }
1013
1014 /* Module must be in memory at the same address */
1015 mi = find_module(old_map->dso->short_name, &modules);
1016 if (!mi || mi->start != old_map->start) {
1017 err = -EINVAL;
1018 goto out;
1019 }
1020
1021 old_map = next;
1022 }
1023 out:
1024 delete_modules(&modules);
1025 return err;
1026 }
1027
1028 /*
1029 * If kallsyms is referenced by name then we look for filename in the same
1030 * directory.
1031 */
1032 static bool filename_from_kallsyms_filename(char *filename,
1033 const char *base_name,
1034 const char *kallsyms_filename)
1035 {
1036 char *name;
1037
1038 strcpy(filename, kallsyms_filename);
1039 name = strrchr(filename, '/');
1040 if (!name)
1041 return false;
1042
1043 name += 1;
1044
1045 if (!strcmp(name, "kallsyms")) {
1046 strcpy(name, base_name);
1047 return true;
1048 }
1049
1050 return false;
1051 }
1052
1053 static int validate_kcore_modules(const char *kallsyms_filename,
1054 struct map *map)
1055 {
1056 struct map_groups *kmaps = map__kmaps(map);
1057 char modules_filename[PATH_MAX];
1058
1059 if (!kmaps)
1060 return -EINVAL;
1061
1062 if (!filename_from_kallsyms_filename(modules_filename, "modules",
1063 kallsyms_filename))
1064 return -EINVAL;
1065
1066 if (do_validate_kcore_modules(modules_filename, map, kmaps))
1067 return -EINVAL;
1068
1069 return 0;
1070 }
1071
1072 static int validate_kcore_addresses(const char *kallsyms_filename,
1073 struct map *map)
1074 {
1075 struct kmap *kmap = map__kmap(map);
1076
1077 if (!kmap)
1078 return -EINVAL;
1079
1080 if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
1081 u64 start;
1082
1083 start = kallsyms__get_function_start(kallsyms_filename,
1084 kmap->ref_reloc_sym->name);
1085 if (start != kmap->ref_reloc_sym->addr)
1086 return -EINVAL;
1087 }
1088
1089 return validate_kcore_modules(kallsyms_filename, map);
1090 }
1091
1092 struct kcore_mapfn_data {
1093 struct dso *dso;
1094 enum map_type type;
1095 struct list_head maps;
1096 };
1097
1098 static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
1099 {
1100 struct kcore_mapfn_data *md = data;
1101 struct map *map;
1102
1103 map = map__new2(start, md->dso, md->type);
1104 if (map == NULL)
1105 return -ENOMEM;
1106
1107 map->end = map->start + len;
1108 map->pgoff = pgoff;
1109
1110 list_add(&map->node, &md->maps);
1111
1112 return 0;
1113 }
1114
1115 static int dso__load_kcore(struct dso *dso, struct map *map,
1116 const char *kallsyms_filename)
1117 {
1118 struct map_groups *kmaps = map__kmaps(map);
1119 struct machine *machine;
1120 struct kcore_mapfn_data md;
1121 struct map *old_map, *new_map, *replacement_map = NULL;
1122 bool is_64_bit;
1123 int err, fd;
1124 char kcore_filename[PATH_MAX];
1125 struct symbol *sym;
1126
1127 if (!kmaps)
1128 return -EINVAL;
1129
1130 machine = kmaps->machine;
1131
1132 /* This function requires that the map is the kernel map */
1133 if (map != machine->vmlinux_maps[map->type])
1134 return -EINVAL;
1135
1136 if (!filename_from_kallsyms_filename(kcore_filename, "kcore",
1137 kallsyms_filename))
1138 return -EINVAL;
1139
1140 /* Modules and kernel must be present at their original addresses */
1141 if (validate_kcore_addresses(kallsyms_filename, map))
1142 return -EINVAL;
1143
1144 md.dso = dso;
1145 md.type = map->type;
1146 INIT_LIST_HEAD(&md.maps);
1147
1148 fd = open(kcore_filename, O_RDONLY);
1149 if (fd < 0) {
1150 pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n",
1151 kcore_filename);
1152 return -EINVAL;
1153 }
1154
1155 /* Read new maps into temporary lists */
1156 err = file__read_maps(fd, md.type == MAP__FUNCTION, kcore_mapfn, &md,
1157 &is_64_bit);
1158 if (err)
1159 goto out_err;
1160 dso->is_64_bit = is_64_bit;
1161
1162 if (list_empty(&md.maps)) {
1163 err = -EINVAL;
1164 goto out_err;
1165 }
1166
1167 /* Remove old maps */
1168 old_map = map_groups__first(kmaps, map->type);
1169 while (old_map) {
1170 struct map *next = map_groups__next(old_map);
1171
1172 if (old_map != map)
1173 map_groups__remove(kmaps, old_map);
1174 old_map = next;
1175 }
1176
1177 /* Find the kernel map using the first symbol */
1178 sym = dso__first_symbol(dso, map->type);
1179 list_for_each_entry(new_map, &md.maps, node) {
1180 if (sym && sym->start >= new_map->start &&
1181 sym->start < new_map->end) {
1182 replacement_map = new_map;
1183 break;
1184 }
1185 }
1186
1187 if (!replacement_map)
1188 replacement_map = list_entry(md.maps.next, struct map, node);
1189
1190 /* Add new maps */
1191 while (!list_empty(&md.maps)) {
1192 new_map = list_entry(md.maps.next, struct map, node);
1193 list_del_init(&new_map->node);
1194 if (new_map == replacement_map) {
1195 map->start = new_map->start;
1196 map->end = new_map->end;
1197 map->pgoff = new_map->pgoff;
1198 map->map_ip = new_map->map_ip;
1199 map->unmap_ip = new_map->unmap_ip;
1200 /* Ensure maps are correctly ordered */
1201 map__get(map);
1202 map_groups__remove(kmaps, map);
1203 map_groups__insert(kmaps, map);
1204 map__put(map);
1205 } else {
1206 map_groups__insert(kmaps, new_map);
1207 }
1208
1209 map__put(new_map);
1210 }
1211
1212 /*
1213 * Set the data type and long name so that kcore can be read via
1214 * dso__data_read_addr().
1215 */
1216 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1217 dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE;
1218 else
1219 dso->binary_type = DSO_BINARY_TYPE__KCORE;
1220 dso__set_long_name(dso, strdup(kcore_filename), true);
1221
1222 close(fd);
1223
1224 if (map->type == MAP__FUNCTION)
1225 pr_debug("Using %s for kernel object code\n", kcore_filename);
1226 else
1227 pr_debug("Using %s for kernel data\n", kcore_filename);
1228
1229 return 0;
1230
1231 out_err:
1232 while (!list_empty(&md.maps)) {
1233 map = list_entry(md.maps.next, struct map, node);
1234 list_del_init(&map->node);
1235 map__put(map);
1236 }
1237 close(fd);
1238 return -EINVAL;
1239 }
1240
1241 /*
1242 * If the kernel is relocated at boot time, kallsyms won't match. Compute the
1243 * delta based on the relocation reference symbol.
1244 */
1245 static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
1246 {
1247 struct kmap *kmap = map__kmap(map);
1248 u64 addr;
1249
1250 if (!kmap)
1251 return -1;
1252
1253 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
1254 return 0;
1255
1256 addr = kallsyms__get_function_start(filename,
1257 kmap->ref_reloc_sym->name);
1258 if (!addr)
1259 return -1;
1260
1261 *delta = addr - kmap->ref_reloc_sym->addr;
1262 return 0;
1263 }
1264
1265 int dso__load_kallsyms(struct dso *dso, const char *filename,
1266 struct map *map, symbol_filter_t filter)
1267 {
1268 u64 delta = 0;
1269
1270 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
1271 return -1;
1272
1273 if (dso__load_all_kallsyms(dso, filename, map) < 0)
1274 return -1;
1275
1276 if (kallsyms__delta(map, filename, &delta))
1277 return -1;
1278
1279 symbols__fixup_duplicate(&dso->symbols[map->type]);
1280 symbols__fixup_end(&dso->symbols[map->type]);
1281
1282 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1283 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1284 else
1285 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
1286
1287 if (!dso__load_kcore(dso, map, filename))
1288 return dso__split_kallsyms_for_kcore(dso, map, filter);
1289 else
1290 return dso__split_kallsyms(dso, map, delta, filter);
1291 }
1292
1293 static int dso__load_perf_map(struct dso *dso, struct map *map,
1294 symbol_filter_t filter)
1295 {
1296 char *line = NULL;
1297 size_t n;
1298 FILE *file;
1299 int nr_syms = 0;
1300
1301 file = fopen(dso->long_name, "r");
1302 if (file == NULL)
1303 goto out_failure;
1304
1305 while (!feof(file)) {
1306 u64 start, size;
1307 struct symbol *sym;
1308 int line_len, len;
1309
1310 line_len = getline(&line, &n, file);
1311 if (line_len < 0)
1312 break;
1313
1314 if (!line)
1315 goto out_failure;
1316
1317 line[--line_len] = '\0'; /* \n */
1318
1319 len = hex2u64(line, &start);
1320
1321 len++;
1322 if (len + 2 >= line_len)
1323 continue;
1324
1325 len += hex2u64(line + len, &size);
1326
1327 len++;
1328 if (len + 2 >= line_len)
1329 continue;
1330
1331 sym = symbol__new(start, size, STB_GLOBAL, line + len);
1332
1333 if (sym == NULL)
1334 goto out_delete_line;
1335
1336 if (filter && filter(map, sym))
1337 symbol__delete(sym);
1338 else {
1339 symbols__insert(&dso->symbols[map->type], sym);
1340 nr_syms++;
1341 }
1342 }
1343
1344 free(line);
1345 fclose(file);
1346
1347 return nr_syms;
1348
1349 out_delete_line:
1350 free(line);
1351 out_failure:
1352 return -1;
1353 }
1354
1355 static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
1356 enum dso_binary_type type)
1357 {
1358 switch (type) {
1359 case DSO_BINARY_TYPE__JAVA_JIT:
1360 case DSO_BINARY_TYPE__DEBUGLINK:
1361 case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
1362 case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
1363 case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
1364 case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
1365 case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
1366 return !kmod && dso->kernel == DSO_TYPE_USER;
1367
1368 case DSO_BINARY_TYPE__KALLSYMS:
1369 case DSO_BINARY_TYPE__VMLINUX:
1370 case DSO_BINARY_TYPE__KCORE:
1371 return dso->kernel == DSO_TYPE_KERNEL;
1372
1373 case DSO_BINARY_TYPE__GUEST_KALLSYMS:
1374 case DSO_BINARY_TYPE__GUEST_VMLINUX:
1375 case DSO_BINARY_TYPE__GUEST_KCORE:
1376 return dso->kernel == DSO_TYPE_GUEST_KERNEL;
1377
1378 case DSO_BINARY_TYPE__GUEST_KMODULE:
1379 case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
1380 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
1381 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
1382 /*
1383 * kernel modules know their symtab type - it's set when
1384 * creating a module dso in machine__findnew_module_map().
1385 */
1386 return kmod && dso->symtab_type == type;
1387
1388 case DSO_BINARY_TYPE__BUILD_ID_CACHE:
1389 return true;
1390
1391 case DSO_BINARY_TYPE__NOT_FOUND:
1392 default:
1393 return false;
1394 }
1395 }
1396
1397 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1398 {
1399 char *name;
1400 int ret = -1;
1401 u_int i;
1402 struct machine *machine;
1403 char *root_dir = (char *) "";
1404 int ss_pos = 0;
1405 struct symsrc ss_[2];
1406 struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
1407 bool kmod;
1408 unsigned char build_id[BUILD_ID_SIZE];
1409
1410 pthread_mutex_lock(&dso->lock);
1411
1412 /* check again under the dso->lock */
1413 if (dso__loaded(dso, map->type)) {
1414 ret = 1;
1415 goto out;
1416 }
1417
1418 if (dso->kernel) {
1419 if (dso->kernel == DSO_TYPE_KERNEL)
1420 ret = dso__load_kernel_sym(dso, map, filter);
1421 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1422 ret = dso__load_guest_kernel_sym(dso, map, filter);
1423
1424 goto out;
1425 }
1426
1427 if (map->groups && map->groups->machine)
1428 machine = map->groups->machine;
1429 else
1430 machine = NULL;
1431
1432 dso->adjust_symbols = 0;
1433
1434 if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1435 struct stat st;
1436
1437 if (lstat(dso->name, &st) < 0)
1438 goto out;
1439
1440 if (!symbol_conf.force && st.st_uid && (st.st_uid != geteuid())) {
1441 pr_warning("File %s not owned by current user or root, "
1442 "ignoring it (use -f to override).\n", dso->name);
1443 goto out;
1444 }
1445
1446 ret = dso__load_perf_map(dso, map, filter);
1447 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
1448 DSO_BINARY_TYPE__NOT_FOUND;
1449 goto out;
1450 }
1451
1452 if (machine)
1453 root_dir = machine->root_dir;
1454
1455 name = malloc(PATH_MAX);
1456 if (!name)
1457 goto out;
1458
1459 kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
1460 dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
1461 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
1462 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
1463
1464
1465 /*
1466 * Read the build id if possible. This is required for
1467 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work
1468 */
1469 if (is_regular_file(name) &&
1470 filename__read_build_id(dso->long_name, build_id, BUILD_ID_SIZE) > 0)
1471 dso__set_build_id(dso, build_id);
1472
1473 /*
1474 * Iterate over candidate debug images.
1475 * Keep track of "interesting" ones (those which have a symtab, dynsym,
1476 * and/or opd section) for processing.
1477 */
1478 for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
1479 struct symsrc *ss = &ss_[ss_pos];
1480 bool next_slot = false;
1481
1482 enum dso_binary_type symtab_type = binary_type_symtab[i];
1483
1484 if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type))
1485 continue;
1486
1487 if (dso__read_binary_type_filename(dso, symtab_type,
1488 root_dir, name, PATH_MAX))
1489 continue;
1490
1491 if (!is_regular_file(name))
1492 continue;
1493
1494 /* Name is now the name of the next image to try */
1495 if (symsrc__init(ss, dso, name, symtab_type) < 0)
1496 continue;
1497
1498 if (!syms_ss && symsrc__has_symtab(ss)) {
1499 syms_ss = ss;
1500 next_slot = true;
1501 if (!dso->symsrc_filename)
1502 dso->symsrc_filename = strdup(name);
1503 }
1504
1505 if (!runtime_ss && symsrc__possibly_runtime(ss)) {
1506 runtime_ss = ss;
1507 next_slot = true;
1508 }
1509
1510 if (next_slot) {
1511 ss_pos++;
1512
1513 if (syms_ss && runtime_ss)
1514 break;
1515 } else {
1516 symsrc__destroy(ss);
1517 }
1518
1519 }
1520
1521 if (!runtime_ss && !syms_ss)
1522 goto out_free;
1523
1524 if (runtime_ss && !syms_ss) {
1525 syms_ss = runtime_ss;
1526 }
1527
1528 /* We'll have to hope for the best */
1529 if (!runtime_ss && syms_ss)
1530 runtime_ss = syms_ss;
1531
1532 if (syms_ss && syms_ss->type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
1533 if (dso__build_id_is_kmod(dso, name, PATH_MAX))
1534 kmod = true;
1535
1536 if (syms_ss)
1537 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, kmod);
1538 else
1539 ret = -1;
1540
1541 if (ret > 0) {
1542 int nr_plt;
1543
1544 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
1545 if (nr_plt > 0)
1546 ret += nr_plt;
1547 }
1548
1549 for (; ss_pos > 0; ss_pos--)
1550 symsrc__destroy(&ss_[ss_pos - 1]);
1551 out_free:
1552 free(name);
1553 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1554 ret = 0;
1555 out:
1556 dso__set_loaded(dso, map->type);
1557 pthread_mutex_unlock(&dso->lock);
1558
1559 return ret;
1560 }
1561
1562 struct map *map_groups__find_by_name(struct map_groups *mg,
1563 enum map_type type, const char *name)
1564 {
1565 struct maps *maps = &mg->maps[type];
1566 struct map *map;
1567
1568 pthread_rwlock_rdlock(&maps->lock);
1569
1570 for (map = maps__first(maps); map; map = map__next(map)) {
1571 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1572 goto out_unlock;
1573 }
1574
1575 map = NULL;
1576
1577 out_unlock:
1578 pthread_rwlock_unlock(&maps->lock);
1579 return map;
1580 }
1581
1582 int dso__load_vmlinux(struct dso *dso, struct map *map,
1583 const char *vmlinux, bool vmlinux_allocated,
1584 symbol_filter_t filter)
1585 {
1586 int err = -1;
1587 struct symsrc ss;
1588 char symfs_vmlinux[PATH_MAX];
1589 enum dso_binary_type symtab_type;
1590
1591 if (vmlinux[0] == '/')
1592 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
1593 else
1594 symbol__join_symfs(symfs_vmlinux, vmlinux);
1595
1596 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1597 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1598 else
1599 symtab_type = DSO_BINARY_TYPE__VMLINUX;
1600
1601 if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
1602 return -1;
1603
1604 err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
1605 symsrc__destroy(&ss);
1606
1607 if (err > 0) {
1608 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1609 dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1610 else
1611 dso->binary_type = DSO_BINARY_TYPE__VMLINUX;
1612 dso__set_long_name(dso, vmlinux, vmlinux_allocated);
1613 dso__set_loaded(dso, map->type);
1614 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1615 }
1616
1617 return err;
1618 }
1619
1620 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
1621 symbol_filter_t filter)
1622 {
1623 int i, err = 0;
1624 char *filename = NULL;
1625
1626 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1627 vmlinux_path__nr_entries + 1);
1628
1629 for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1630 err = dso__load_vmlinux(dso, map, vmlinux_path[i], false, filter);
1631 if (err > 0)
1632 goto out;
1633 }
1634
1635 if (!symbol_conf.ignore_vmlinux_buildid)
1636 filename = dso__build_id_filename(dso, NULL, 0);
1637 if (filename != NULL) {
1638 err = dso__load_vmlinux(dso, map, filename, true, filter);
1639 if (err > 0)
1640 goto out;
1641 free(filename);
1642 }
1643 out:
1644 return err;
1645 }
1646
1647 static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
1648 {
1649 char kallsyms_filename[PATH_MAX];
1650 struct dirent *dent;
1651 int ret = -1;
1652 DIR *d;
1653
1654 d = opendir(dir);
1655 if (!d)
1656 return -1;
1657
1658 while (1) {
1659 dent = readdir(d);
1660 if (!dent)
1661 break;
1662 if (dent->d_type != DT_DIR)
1663 continue;
1664 scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
1665 "%s/%s/kallsyms", dir, dent->d_name);
1666 if (!validate_kcore_addresses(kallsyms_filename, map)) {
1667 strlcpy(dir, kallsyms_filename, dir_sz);
1668 ret = 0;
1669 break;
1670 }
1671 }
1672
1673 closedir(d);
1674
1675 return ret;
1676 }
1677
1678 static char *dso__find_kallsyms(struct dso *dso, struct map *map)
1679 {
1680 u8 host_build_id[BUILD_ID_SIZE];
1681 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1682 bool is_host = false;
1683 char path[PATH_MAX];
1684
1685 if (!dso->has_build_id) {
1686 /*
1687 * Last resort, if we don't have a build-id and couldn't find
1688 * any vmlinux file, try the running kernel kallsyms table.
1689 */
1690 goto proc_kallsyms;
1691 }
1692
1693 if (sysfs__read_build_id("/sys/kernel/notes", host_build_id,
1694 sizeof(host_build_id)) == 0)
1695 is_host = dso__build_id_equal(dso, host_build_id);
1696
1697 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
1698
1699 scnprintf(path, sizeof(path), "%s/[kernel.kcore]/%s", buildid_dir,
1700 sbuild_id);
1701
1702 /* Use /proc/kallsyms if possible */
1703 if (is_host) {
1704 DIR *d;
1705 int fd;
1706
1707 /* If no cached kcore go with /proc/kallsyms */
1708 d = opendir(path);
1709 if (!d)
1710 goto proc_kallsyms;
1711 closedir(d);
1712
1713 /*
1714 * Do not check the build-id cache, until we know we cannot use
1715 * /proc/kcore.
1716 */
1717 fd = open("/proc/kcore", O_RDONLY);
1718 if (fd != -1) {
1719 close(fd);
1720 /* If module maps match go with /proc/kallsyms */
1721 if (!validate_kcore_addresses("/proc/kallsyms", map))
1722 goto proc_kallsyms;
1723 }
1724
1725 /* Find kallsyms in build-id cache with kcore */
1726 if (!find_matching_kcore(map, path, sizeof(path)))
1727 return strdup(path);
1728
1729 goto proc_kallsyms;
1730 }
1731
1732 /* Find kallsyms in build-id cache with kcore */
1733 if (!find_matching_kcore(map, path, sizeof(path)))
1734 return strdup(path);
1735
1736 scnprintf(path, sizeof(path), "%s/[kernel.kallsyms]/%s",
1737 buildid_dir, sbuild_id);
1738
1739 if (access(path, F_OK)) {
1740 pr_err("No kallsyms or vmlinux with build-id %s was found\n",
1741 sbuild_id);
1742 return NULL;
1743 }
1744
1745 return strdup(path);
1746
1747 proc_kallsyms:
1748 return strdup("/proc/kallsyms");
1749 }
1750
1751 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
1752 symbol_filter_t filter)
1753 {
1754 int err;
1755 const char *kallsyms_filename = NULL;
1756 char *kallsyms_allocated_filename = NULL;
1757 /*
1758 * Step 1: if the user specified a kallsyms or vmlinux filename, use
1759 * it and only it, reporting errors to the user if it cannot be used.
1760 *
1761 * For instance, try to analyse an ARM perf.data file _without_ a
1762 * build-id, or if the user specifies the wrong path to the right
1763 * vmlinux file, obviously we can't fallback to another vmlinux (a
1764 * x86_86 one, on the machine where analysis is being performed, say),
1765 * or worse, /proc/kallsyms.
1766 *
1767 * If the specified file _has_ a build-id and there is a build-id
1768 * section in the perf.data file, we will still do the expected
1769 * validation in dso__load_vmlinux and will bail out if they don't
1770 * match.
1771 */
1772 if (symbol_conf.kallsyms_name != NULL) {
1773 kallsyms_filename = symbol_conf.kallsyms_name;
1774 goto do_kallsyms;
1775 }
1776
1777 if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
1778 return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name,
1779 false, filter);
1780 }
1781
1782 if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
1783 err = dso__load_vmlinux_path(dso, map, filter);
1784 if (err > 0)
1785 return err;
1786 }
1787
1788 /* do not try local files if a symfs was given */
1789 if (symbol_conf.symfs[0] != 0)
1790 return -1;
1791
1792 kallsyms_allocated_filename = dso__find_kallsyms(dso, map);
1793 if (!kallsyms_allocated_filename)
1794 return -1;
1795
1796 kallsyms_filename = kallsyms_allocated_filename;
1797
1798 do_kallsyms:
1799 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1800 if (err > 0)
1801 pr_debug("Using %s for symbols\n", kallsyms_filename);
1802 free(kallsyms_allocated_filename);
1803
1804 if (err > 0 && !dso__is_kcore(dso)) {
1805 dso->binary_type = DSO_BINARY_TYPE__KALLSYMS;
1806 dso__set_long_name(dso, "[kernel.kallsyms]", false);
1807 map__fixup_start(map);
1808 map__fixup_end(map);
1809 }
1810
1811 return err;
1812 }
1813
1814 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
1815 symbol_filter_t filter)
1816 {
1817 int err;
1818 const char *kallsyms_filename = NULL;
1819 struct machine *machine;
1820 char path[PATH_MAX];
1821
1822 if (!map->groups) {
1823 pr_debug("Guest kernel map hasn't the point to groups\n");
1824 return -1;
1825 }
1826 machine = map->groups->machine;
1827
1828 if (machine__is_default_guest(machine)) {
1829 /*
1830 * if the user specified a vmlinux filename, use it and only
1831 * it, reporting errors to the user if it cannot be used.
1832 * Or use file guest_kallsyms inputted by user on commandline
1833 */
1834 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1835 err = dso__load_vmlinux(dso, map,
1836 symbol_conf.default_guest_vmlinux_name,
1837 false, filter);
1838 return err;
1839 }
1840
1841 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1842 if (!kallsyms_filename)
1843 return -1;
1844 } else {
1845 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1846 kallsyms_filename = path;
1847 }
1848
1849 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1850 if (err > 0)
1851 pr_debug("Using %s for symbols\n", kallsyms_filename);
1852 if (err > 0 && !dso__is_kcore(dso)) {
1853 dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1854 machine__mmap_name(machine, path, sizeof(path));
1855 dso__set_long_name(dso, strdup(path), true);
1856 map__fixup_start(map);
1857 map__fixup_end(map);
1858 }
1859
1860 return err;
1861 }
1862
1863 static void vmlinux_path__exit(void)
1864 {
1865 while (--vmlinux_path__nr_entries >= 0)
1866 zfree(&vmlinux_path[vmlinux_path__nr_entries]);
1867 vmlinux_path__nr_entries = 0;
1868
1869 zfree(&vmlinux_path);
1870 }
1871
1872 static const char * const vmlinux_paths[] = {
1873 "vmlinux",
1874 "/boot/vmlinux"
1875 };
1876
1877 static const char * const vmlinux_paths_upd[] = {
1878 "/boot/vmlinux-%s",
1879 "/usr/lib/debug/boot/vmlinux-%s",
1880 "/lib/modules/%s/build/vmlinux",
1881 "/usr/lib/debug/lib/modules/%s/vmlinux",
1882 "/usr/lib/debug/boot/vmlinux-%s.debug"
1883 };
1884
1885 static int vmlinux_path__add(const char *new_entry)
1886 {
1887 vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry);
1888 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1889 return -1;
1890 ++vmlinux_path__nr_entries;
1891
1892 return 0;
1893 }
1894
1895 static int vmlinux_path__init(struct perf_env *env)
1896 {
1897 struct utsname uts;
1898 char bf[PATH_MAX];
1899 char *kernel_version;
1900 unsigned int i;
1901
1902 vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) +
1903 ARRAY_SIZE(vmlinux_paths_upd)));
1904 if (vmlinux_path == NULL)
1905 return -1;
1906
1907 for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++)
1908 if (vmlinux_path__add(vmlinux_paths[i]) < 0)
1909 goto out_fail;
1910
1911 /* only try kernel version if no symfs was given */
1912 if (symbol_conf.symfs[0] != 0)
1913 return 0;
1914
1915 if (env) {
1916 kernel_version = env->os_release;
1917 } else {
1918 if (uname(&uts) < 0)
1919 goto out_fail;
1920
1921 kernel_version = uts.release;
1922 }
1923
1924 for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) {
1925 snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version);
1926 if (vmlinux_path__add(bf) < 0)
1927 goto out_fail;
1928 }
1929
1930 return 0;
1931
1932 out_fail:
1933 vmlinux_path__exit();
1934 return -1;
1935 }
1936
1937 int setup_list(struct strlist **list, const char *list_str,
1938 const char *list_name)
1939 {
1940 if (list_str == NULL)
1941 return 0;
1942
1943 *list = strlist__new(list_str, NULL);
1944 if (!*list) {
1945 pr_err("problems parsing %s list\n", list_name);
1946 return -1;
1947 }
1948
1949 symbol_conf.has_filter = true;
1950 return 0;
1951 }
1952
1953 int setup_intlist(struct intlist **list, const char *list_str,
1954 const char *list_name)
1955 {
1956 if (list_str == NULL)
1957 return 0;
1958
1959 *list = intlist__new(list_str);
1960 if (!*list) {
1961 pr_err("problems parsing %s list\n", list_name);
1962 return -1;
1963 }
1964 return 0;
1965 }
1966
1967 static bool symbol__read_kptr_restrict(void)
1968 {
1969 bool value = false;
1970
1971 if (geteuid() != 0) {
1972 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
1973 if (fp != NULL) {
1974 char line[8];
1975
1976 if (fgets(line, sizeof(line), fp) != NULL)
1977 value = atoi(line) != 0;
1978
1979 fclose(fp);
1980 }
1981 }
1982
1983 return value;
1984 }
1985
1986 int symbol__init(struct perf_env *env)
1987 {
1988 const char *symfs;
1989
1990 if (symbol_conf.initialized)
1991 return 0;
1992
1993 symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
1994
1995 symbol__elf_init();
1996
1997 if (symbol_conf.sort_by_name)
1998 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
1999 sizeof(struct symbol));
2000
2001 if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
2002 return -1;
2003
2004 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2005 pr_err("'.' is the only non valid --field-separator argument\n");
2006 return -1;
2007 }
2008
2009 if (setup_list(&symbol_conf.dso_list,
2010 symbol_conf.dso_list_str, "dso") < 0)
2011 return -1;
2012
2013 if (setup_list(&symbol_conf.comm_list,
2014 symbol_conf.comm_list_str, "comm") < 0)
2015 goto out_free_dso_list;
2016
2017 if (setup_intlist(&symbol_conf.pid_list,
2018 symbol_conf.pid_list_str, "pid") < 0)
2019 goto out_free_comm_list;
2020
2021 if (setup_intlist(&symbol_conf.tid_list,
2022 symbol_conf.tid_list_str, "tid") < 0)
2023 goto out_free_pid_list;
2024
2025 if (setup_list(&symbol_conf.sym_list,
2026 symbol_conf.sym_list_str, "symbol") < 0)
2027 goto out_free_tid_list;
2028
2029 /*
2030 * A path to symbols of "/" is identical to ""
2031 * reset here for simplicity.
2032 */
2033 symfs = realpath(symbol_conf.symfs, NULL);
2034 if (symfs == NULL)
2035 symfs = symbol_conf.symfs;
2036 if (strcmp(symfs, "/") == 0)
2037 symbol_conf.symfs = "";
2038 if (symfs != symbol_conf.symfs)
2039 free((void *)symfs);
2040
2041 symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2042
2043 symbol_conf.initialized = true;
2044 return 0;
2045
2046 out_free_tid_list:
2047 intlist__delete(symbol_conf.tid_list);
2048 out_free_pid_list:
2049 intlist__delete(symbol_conf.pid_list);
2050 out_free_comm_list:
2051 strlist__delete(symbol_conf.comm_list);
2052 out_free_dso_list:
2053 strlist__delete(symbol_conf.dso_list);
2054 return -1;
2055 }
2056
2057 void symbol__exit(void)
2058 {
2059 if (!symbol_conf.initialized)
2060 return;
2061 strlist__delete(symbol_conf.sym_list);
2062 strlist__delete(symbol_conf.dso_list);
2063 strlist__delete(symbol_conf.comm_list);
2064 intlist__delete(symbol_conf.tid_list);
2065 intlist__delete(symbol_conf.pid_list);
2066 vmlinux_path__exit();
2067 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2068 symbol_conf.initialized = false;
2069 }
Linux with added FPC-III support