1
2#include <dirent.h>
3#include <errno.h>
4#include <stdlib.h>
5#include <stdio.h>
6#include <string.h>
7#include <linux/kernel.h>
8#include <linux/mman.h>
9#include <linux/time64.h>
10#include <sys/types.h>
11#include <sys/stat.h>
12#include <sys/param.h>
13#include <fcntl.h>
14#include <unistd.h>
15#include <inttypes.h>
16#include "annotate.h"
17#include "build-id.h"
18#include "util.h"
19#include "debug.h"
20#include "machine.h"
21#include "map.h"
22#include "symbol.h"
23#include "strlist.h"
24#include "intlist.h"
25#include "namespaces.h"
26#include "header.h"
27#include "path.h"
28#include <linux/ctype.h>
29#include <linux/zalloc.h>
30
31#include <elf.h>
32#include <limits.h>
33#include <symbol/kallsyms.h>
34#include <sys/utsname.h>
35
36static int dso__load_kernel_sym(struct dso *dso, struct map *map);
37static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map);
38static bool symbol__is_idle(const char *name);
39
40int vmlinux_path__nr_entries;
41char **vmlinux_path;
42
43struct symbol_conf symbol_conf = {
44 .nanosecs = false,
45 .use_modules = true,
46 .try_vmlinux_path = true,
47 .demangle = true,
48 .demangle_kernel = false,
49 .cumulate_callchain = true,
50 .time_quantum = 100 * NSEC_PER_MSEC,
51 .show_hist_headers = true,
52 .symfs = "",
53 .event_group = true,
54 .inline_name = true,
55 .res_sample = 0,
56};
57
58static enum dso_binary_type binary_type_symtab[] = {
59 DSO_BINARY_TYPE__KALLSYMS,
60 DSO_BINARY_TYPE__GUEST_KALLSYMS,
61 DSO_BINARY_TYPE__JAVA_JIT,
62 DSO_BINARY_TYPE__DEBUGLINK,
63 DSO_BINARY_TYPE__BUILD_ID_CACHE,
64 DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO,
65 DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
66 DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
67 DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
68 DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
69 DSO_BINARY_TYPE__GUEST_KMODULE,
70 DSO_BINARY_TYPE__GUEST_KMODULE_COMP,
71 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
72 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP,
73 DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
74 DSO_BINARY_TYPE__NOT_FOUND,
75};
76
77#define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
78
79static bool symbol_type__filter(char symbol_type)
80{
81 symbol_type = toupper(symbol_type);
82 return symbol_type == 'T' || symbol_type == 'W' || symbol_type == 'D' || symbol_type == 'B';
83}
84
85static int prefix_underscores_count(const char *str)
86{
87 const char *tail = str;
88
89 while (*tail == '_')
90 tail++;
91
92 return tail - str;
93}
94
95void __weak arch__symbols__fixup_end(struct symbol *p, struct symbol *c)
96{
97 p->end = c->start;
98}
99
100const char * __weak arch__normalize_symbol_name(const char *name)
101{
102 return name;
103}
104
105int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
106{
107 return strcmp(namea, nameb);
108}
109
110int __weak arch__compare_symbol_names_n(const char *namea, const char *nameb,
111 unsigned int n)
112{
113 return strncmp(namea, nameb, n);
114}
115
116int __weak arch__choose_best_symbol(struct symbol *syma,
117 struct symbol *symb __maybe_unused)
118{
119
120 if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3))
121 return SYMBOL_B;
122 if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10))
123 return SYMBOL_B;
124
125 return SYMBOL_A;
126}
127
128static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
129{
130 s64 a;
131 s64 b;
132 size_t na, nb;
133
134
135 a = syma->end - syma->start;
136 b = symb->end - symb->start;
137 if ((b == 0) && (a > 0))
138 return SYMBOL_A;
139 else if ((a == 0) && (b > 0))
140 return SYMBOL_B;
141
142
143 a = syma->binding == STB_WEAK;
144 b = symb->binding == STB_WEAK;
145 if (b && !a)
146 return SYMBOL_A;
147 if (a && !b)
148 return SYMBOL_B;
149
150
151 a = syma->binding == STB_GLOBAL;
152 b = symb->binding == STB_GLOBAL;
153 if (a && !b)
154 return SYMBOL_A;
155 if (b && !a)
156 return SYMBOL_B;
157
158
159 a = prefix_underscores_count(syma->name);
160 b = prefix_underscores_count(symb->name);
161 if (b > a)
162 return SYMBOL_A;
163 else if (a > b)
164 return SYMBOL_B;
165
166
167 na = strlen(syma->name);
168 nb = strlen(symb->name);
169 if (na > nb)
170 return SYMBOL_A;
171 else if (na < nb)
172 return SYMBOL_B;
173
174 return arch__choose_best_symbol(syma, symb);
175}
176
177void symbols__fixup_duplicate(struct rb_root_cached *symbols)
178{
179 struct rb_node *nd;
180 struct symbol *curr, *next;
181
182 if (symbol_conf.allow_aliases)
183 return;
184
185 nd = rb_first_cached(symbols);
186
187 while (nd) {
188 curr = rb_entry(nd, struct symbol, rb_node);
189again:
190 nd = rb_next(&curr->rb_node);
191 next = rb_entry(nd, struct symbol, rb_node);
192
193 if (!nd)
194 break;
195
196 if (curr->start != next->start)
197 continue;
198
199 if (choose_best_symbol(curr, next) == SYMBOL_A) {
200 rb_erase_cached(&next->rb_node, symbols);
201 symbol__delete(next);
202 goto again;
203 } else {
204 nd = rb_next(&curr->rb_node);
205 rb_erase_cached(&curr->rb_node, symbols);
206 symbol__delete(curr);
207 }
208 }
209}
210
211void symbols__fixup_end(struct rb_root_cached *symbols)
212{
213 struct rb_node *nd, *prevnd = rb_first_cached(symbols);
214 struct symbol *curr, *prev;
215
216 if (prevnd == NULL)
217 return;
218
219 curr = rb_entry(prevnd, struct symbol, rb_node);
220
221 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
222 prev = curr;
223 curr = rb_entry(nd, struct symbol, rb_node);
224
225 if (prev->end == prev->start && prev->end != curr->start)
226 arch__symbols__fixup_end(prev, curr);
227 }
228
229
230 if (curr->end == curr->start)
231 curr->end = roundup(curr->start, 4096) + 4096;
232}
233
234void map_groups__fixup_end(struct map_groups *mg)
235{
236 struct maps *maps = &mg->maps;
237 struct map *next, *curr;
238
239 down_write(&maps->lock);
240
241 curr = maps__first(maps);
242 if (curr == NULL)
243 goto out_unlock;
244
245 for (next = map__next(curr); next; next = map__next(curr)) {
246 if (!curr->end)
247 curr->end = next->start;
248 curr = next;
249 }
250
251
252
253
254
255 if (!curr->end)
256 curr->end = ~0ULL;
257
258out_unlock:
259 up_write(&maps->lock);
260}
261
262struct symbol *symbol__new(u64 start, u64 len, u8 binding, u8 type, const char *name)
263{
264 size_t namelen = strlen(name) + 1;
265 struct symbol *sym = calloc(1, (symbol_conf.priv_size +
266 sizeof(*sym) + namelen));
267 if (sym == NULL)
268 return NULL;
269
270 if (symbol_conf.priv_size) {
271 if (symbol_conf.init_annotation) {
272 struct annotation *notes = (void *)sym;
273 pthread_mutex_init(¬es->lock, NULL);
274 }
275 sym = ((void *)sym) + symbol_conf.priv_size;
276 }
277
278 sym->start = start;
279 sym->end = len ? start + len : start;
280 sym->type = type;
281 sym->binding = binding;
282 sym->namelen = namelen - 1;
283
284 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
285 __func__, name, start, sym->end);
286 memcpy(sym->name, name, namelen);
287
288 return sym;
289}
290
291void symbol__delete(struct symbol *sym)
292{
293 free(((void *)sym) - symbol_conf.priv_size);
294}
295
296void symbols__delete(struct rb_root_cached *symbols)
297{
298 struct symbol *pos;
299 struct rb_node *next = rb_first_cached(symbols);
300
301 while (next) {
302 pos = rb_entry(next, struct symbol, rb_node);
303 next = rb_next(&pos->rb_node);
304 rb_erase_cached(&pos->rb_node, symbols);
305 symbol__delete(pos);
306 }
307}
308
309void __symbols__insert(struct rb_root_cached *symbols,
310 struct symbol *sym, bool kernel)
311{
312 struct rb_node **p = &symbols->rb_root.rb_node;
313 struct rb_node *parent = NULL;
314 const u64 ip = sym->start;
315 struct symbol *s;
316 bool leftmost = true;
317
318 if (kernel) {
319 const char *name = sym->name;
320
321
322
323
324 if (name[0] == '.')
325 name++;
326 sym->idle = symbol__is_idle(name);
327 }
328
329 while (*p != NULL) {
330 parent = *p;
331 s = rb_entry(parent, struct symbol, rb_node);
332 if (ip < s->start)
333 p = &(*p)->rb_left;
334 else {
335 p = &(*p)->rb_right;
336 leftmost = false;
337 }
338 }
339 rb_link_node(&sym->rb_node, parent, p);
340 rb_insert_color_cached(&sym->rb_node, symbols, leftmost);
341}
342
343void symbols__insert(struct rb_root_cached *symbols, struct symbol *sym)
344{
345 __symbols__insert(symbols, sym, false);
346}
347
348static struct symbol *symbols__find(struct rb_root_cached *symbols, u64 ip)
349{
350 struct rb_node *n;
351
352 if (symbols == NULL)
353 return NULL;
354
355 n = symbols->rb_root.rb_node;
356
357 while (n) {
358 struct symbol *s = rb_entry(n, struct symbol, rb_node);
359
360 if (ip < s->start)
361 n = n->rb_left;
362 else if (ip > s->end || (ip == s->end && ip != s->start))
363 n = n->rb_right;
364 else
365 return s;
366 }
367
368 return NULL;
369}
370
371static struct symbol *symbols__first(struct rb_root_cached *symbols)
372{
373 struct rb_node *n = rb_first_cached(symbols);
374
375 if (n)
376 return rb_entry(n, struct symbol, rb_node);
377
378 return NULL;
379}
380
381static struct symbol *symbols__last(struct rb_root_cached *symbols)
382{
383 struct rb_node *n = rb_last(&symbols->rb_root);
384
385 if (n)
386 return rb_entry(n, struct symbol, rb_node);
387
388 return NULL;
389}
390
391static struct symbol *symbols__next(struct symbol *sym)
392{
393 struct rb_node *n = rb_next(&sym->rb_node);
394
395 if (n)
396 return rb_entry(n, struct symbol, rb_node);
397
398 return NULL;
399}
400
401static void symbols__insert_by_name(struct rb_root_cached *symbols, struct symbol *sym)
402{
403 struct rb_node **p = &symbols->rb_root.rb_node;
404 struct rb_node *parent = NULL;
405 struct symbol_name_rb_node *symn, *s;
406 bool leftmost = true;
407
408 symn = container_of(sym, struct symbol_name_rb_node, sym);
409
410 while (*p != NULL) {
411 parent = *p;
412 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
413 if (strcmp(sym->name, s->sym.name) < 0)
414 p = &(*p)->rb_left;
415 else {
416 p = &(*p)->rb_right;
417 leftmost = false;
418 }
419 }
420 rb_link_node(&symn->rb_node, parent, p);
421 rb_insert_color_cached(&symn->rb_node, symbols, leftmost);
422}
423
424static void symbols__sort_by_name(struct rb_root_cached *symbols,
425 struct rb_root_cached *source)
426{
427 struct rb_node *nd;
428
429 for (nd = rb_first_cached(source); nd; nd = rb_next(nd)) {
430 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
431 symbols__insert_by_name(symbols, pos);
432 }
433}
434
435int symbol__match_symbol_name(const char *name, const char *str,
436 enum symbol_tag_include includes)
437{
438 const char *versioning;
439
440 if (includes == SYMBOL_TAG_INCLUDE__DEFAULT_ONLY &&
441 (versioning = strstr(name, "@@"))) {
442 int len = strlen(str);
443
444 if (len < versioning - name)
445 len = versioning - name;
446
447 return arch__compare_symbol_names_n(name, str, len);
448 } else
449 return arch__compare_symbol_names(name, str);
450}
451
452static struct symbol *symbols__find_by_name(struct rb_root_cached *symbols,
453 const char *name,
454 enum symbol_tag_include includes)
455{
456 struct rb_node *n;
457 struct symbol_name_rb_node *s = NULL;
458
459 if (symbols == NULL)
460 return NULL;
461
462 n = symbols->rb_root.rb_node;
463
464 while (n) {
465 int cmp;
466
467 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
468 cmp = symbol__match_symbol_name(s->sym.name, name, includes);
469
470 if (cmp > 0)
471 n = n->rb_left;
472 else if (cmp < 0)
473 n = n->rb_right;
474 else
475 break;
476 }
477
478 if (n == NULL)
479 return NULL;
480
481 if (includes != SYMBOL_TAG_INCLUDE__DEFAULT_ONLY)
482
483 for (n = rb_prev(n); n; n = rb_prev(n)) {
484 struct symbol_name_rb_node *tmp;
485
486 tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
487 if (arch__compare_symbol_names(tmp->sym.name, s->sym.name))
488 break;
489
490 s = tmp;
491 }
492
493 return &s->sym;
494}
495
496void dso__reset_find_symbol_cache(struct dso *dso)
497{
498 dso->last_find_result.addr = 0;
499 dso->last_find_result.symbol = NULL;
500}
501
502void dso__insert_symbol(struct dso *dso, struct symbol *sym)
503{
504 __symbols__insert(&dso->symbols, sym, dso->kernel);
505
506
507 if (dso->last_find_result.addr >= sym->start &&
508 (dso->last_find_result.addr < sym->end ||
509 sym->start == sym->end)) {
510 dso->last_find_result.symbol = sym;
511 }
512}
513
514struct symbol *dso__find_symbol(struct dso *dso, u64 addr)
515{
516 if (dso->last_find_result.addr != addr || dso->last_find_result.symbol == NULL) {
517 dso->last_find_result.addr = addr;
518 dso->last_find_result.symbol = symbols__find(&dso->symbols, addr);
519 }
520
521 return dso->last_find_result.symbol;
522}
523
524struct symbol *dso__first_symbol(struct dso *dso)
525{
526 return symbols__first(&dso->symbols);
527}
528
529struct symbol *dso__last_symbol(struct dso *dso)
530{
531 return symbols__last(&dso->symbols);
532}
533
534struct symbol *dso__next_symbol(struct symbol *sym)
535{
536 return symbols__next(sym);
537}
538
539struct symbol *symbol__next_by_name(struct symbol *sym)
540{
541 struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym);
542 struct rb_node *n = rb_next(&s->rb_node);
543
544 return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL;
545}
546
547
548
549
550struct symbol *dso__find_symbol_by_name(struct dso *dso, const char *name)
551{
552 struct symbol *s = symbols__find_by_name(&dso->symbol_names, name,
553 SYMBOL_TAG_INCLUDE__NONE);
554 if (!s)
555 s = symbols__find_by_name(&dso->symbol_names, name,
556 SYMBOL_TAG_INCLUDE__DEFAULT_ONLY);
557 return s;
558}
559
560void dso__sort_by_name(struct dso *dso)
561{
562 dso__set_sorted_by_name(dso);
563 return symbols__sort_by_name(&dso->symbol_names, &dso->symbols);
564}
565
566int modules__parse(const char *filename, void *arg,
567 int (*process_module)(void *arg, const char *name,
568 u64 start, u64 size))
569{
570 char *line = NULL;
571 size_t n;
572 FILE *file;
573 int err = 0;
574
575 file = fopen(filename, "r");
576 if (file == NULL)
577 return -1;
578
579 while (1) {
580 char name[PATH_MAX];
581 u64 start, size;
582 char *sep, *endptr;
583 ssize_t line_len;
584
585 line_len = getline(&line, &n, file);
586 if (line_len < 0) {
587 if (feof(file))
588 break;
589 err = -1;
590 goto out;
591 }
592
593 if (!line) {
594 err = -1;
595 goto out;
596 }
597
598 line[--line_len] = '\0';
599
600 sep = strrchr(line, 'x');
601 if (sep == NULL)
602 continue;
603
604 hex2u64(sep + 1, &start);
605
606 sep = strchr(line, ' ');
607 if (sep == NULL)
608 continue;
609
610 *sep = '\0';
611
612 scnprintf(name, sizeof(name), "[%s]", line);
613
614 size = strtoul(sep + 1, &endptr, 0);
615 if (*endptr != ' ' && *endptr != '\t')
616 continue;
617
618 err = process_module(arg, name, start, size);
619 if (err)
620 break;
621 }
622out:
623 free(line);
624 fclose(file);
625 return err;
626}
627
628
629
630
631
632static bool symbol__is_idle(const char *name)
633{
634 const char * const idle_symbols[] = {
635 "arch_cpu_idle",
636 "cpu_idle",
637 "cpu_startup_entry",
638 "intel_idle",
639 "default_idle",
640 "native_safe_halt",
641 "enter_idle",
642 "exit_idle",
643 "mwait_idle",
644 "mwait_idle_with_hints",
645 "poll_idle",
646 "ppc64_runlatch_off",
647 "pseries_dedicated_idle_sleep",
648 NULL
649 };
650 int i;
651
652 for (i = 0; idle_symbols[i]; i++) {
653 if (!strcmp(idle_symbols[i], name))
654 return true;
655 }
656
657 return false;
658}
659
660static int map__process_kallsym_symbol(void *arg, const char *name,
661 char type, u64 start)
662{
663 struct symbol *sym;
664 struct dso *dso = arg;
665 struct rb_root_cached *root = &dso->symbols;
666
667 if (!symbol_type__filter(type))
668 return 0;
669
670
671
672
673
674
675 sym = symbol__new(start, 0, kallsyms2elf_binding(type), kallsyms2elf_type(type), name);
676 if (sym == NULL)
677 return -ENOMEM;
678
679
680
681
682 __symbols__insert(root, sym, !strchr(name, '['));
683
684 return 0;
685}
686
687
688
689
690
691
692static int dso__load_all_kallsyms(struct dso *dso, const char *filename)
693{
694 return kallsyms__parse(filename, dso, map__process_kallsym_symbol);
695}
696
697static int map_groups__split_kallsyms_for_kcore(struct map_groups *kmaps, struct dso *dso)
698{
699 struct map *curr_map;
700 struct symbol *pos;
701 int count = 0;
702 struct rb_root_cached old_root = dso->symbols;
703 struct rb_root_cached *root = &dso->symbols;
704 struct rb_node *next = rb_first_cached(root);
705
706 if (!kmaps)
707 return -1;
708
709 *root = RB_ROOT_CACHED;
710
711 while (next) {
712 char *module;
713
714 pos = rb_entry(next, struct symbol, rb_node);
715 next = rb_next(&pos->rb_node);
716
717 rb_erase_cached(&pos->rb_node, &old_root);
718 RB_CLEAR_NODE(&pos->rb_node);
719 module = strchr(pos->name, '\t');
720 if (module)
721 *module = '\0';
722
723 curr_map = map_groups__find(kmaps, pos->start);
724
725 if (!curr_map) {
726 symbol__delete(pos);
727 continue;
728 }
729
730 pos->start -= curr_map->start - curr_map->pgoff;
731 if (pos->end > curr_map->end)
732 pos->end = curr_map->end;
733 if (pos->end)
734 pos->end -= curr_map->start - curr_map->pgoff;
735 symbols__insert(&curr_map->dso->symbols, pos);
736 ++count;
737 }
738
739
740 dso->adjust_symbols = 1;
741
742 return count;
743}
744
745
746
747
748
749
750static int map_groups__split_kallsyms(struct map_groups *kmaps, struct dso *dso, u64 delta,
751 struct map *initial_map)
752{
753 struct machine *machine;
754 struct map *curr_map = initial_map;
755 struct symbol *pos;
756 int count = 0, moved = 0;
757 struct rb_root_cached *root = &dso->symbols;
758 struct rb_node *next = rb_first_cached(root);
759 int kernel_range = 0;
760 bool x86_64;
761
762 if (!kmaps)
763 return -1;
764
765 machine = kmaps->machine;
766
767 x86_64 = machine__is(machine, "x86_64");
768
769 while (next) {
770 char *module;
771
772 pos = rb_entry(next, struct symbol, rb_node);
773 next = rb_next(&pos->rb_node);
774
775 module = strchr(pos->name, '\t');
776 if (module) {
777 if (!symbol_conf.use_modules)
778 goto discard_symbol;
779
780 *module++ = '\0';
781
782 if (strcmp(curr_map->dso->short_name, module)) {
783 if (curr_map != initial_map &&
784 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
785 machine__is_default_guest(machine)) {
786
787
788
789
790
791
792
793 dso__set_loaded(curr_map->dso);
794 }
795
796 curr_map = map_groups__find_by_name(kmaps, module);
797 if (curr_map == NULL) {
798 pr_debug("%s/proc/{kallsyms,modules} "
799 "inconsistency while looking "
800 "for \"%s\" module!\n",
801 machine->root_dir, module);
802 curr_map = initial_map;
803 goto discard_symbol;
804 }
805
806 if (curr_map->dso->loaded &&
807 !machine__is_default_guest(machine))
808 goto discard_symbol;
809 }
810
811
812
813
814 pos->start = curr_map->map_ip(curr_map, pos->start);
815 pos->end = curr_map->map_ip(curr_map, pos->end);
816 } else if (x86_64 && is_entry_trampoline(pos->name)) {
817
818
819
820
821
822
823
824
825 goto discard_symbol;
826 } else if (curr_map != initial_map) {
827 char dso_name[PATH_MAX];
828 struct dso *ndso;
829
830 if (delta) {
831
832 pos->start -= delta;
833 pos->end -= delta;
834 }
835
836 if (count == 0) {
837 curr_map = initial_map;
838 goto add_symbol;
839 }
840
841 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
842 snprintf(dso_name, sizeof(dso_name),
843 "[guest.kernel].%d",
844 kernel_range++);
845 else
846 snprintf(dso_name, sizeof(dso_name),
847 "[kernel].%d",
848 kernel_range++);
849
850 ndso = dso__new(dso_name);
851 if (ndso == NULL)
852 return -1;
853
854 ndso->kernel = dso->kernel;
855
856 curr_map = map__new2(pos->start, ndso);
857 if (curr_map == NULL) {
858 dso__put(ndso);
859 return -1;
860 }
861
862 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
863 map_groups__insert(kmaps, curr_map);
864 ++kernel_range;
865 } else if (delta) {
866
867 pos->start -= delta;
868 pos->end -= delta;
869 }
870add_symbol:
871 if (curr_map != initial_map) {
872 rb_erase_cached(&pos->rb_node, root);
873 symbols__insert(&curr_map->dso->symbols, pos);
874 ++moved;
875 } else
876 ++count;
877
878 continue;
879discard_symbol:
880 rb_erase_cached(&pos->rb_node, root);
881 symbol__delete(pos);
882 }
883
884 if (curr_map != initial_map &&
885 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
886 machine__is_default_guest(kmaps->machine)) {
887 dso__set_loaded(curr_map->dso);
888 }
889
890 return count + moved;
891}
892
893bool symbol__restricted_filename(const char *filename,
894 const char *restricted_filename)
895{
896 bool restricted = false;
897
898 if (symbol_conf.kptr_restrict) {
899 char *r = realpath(filename, NULL);
900
901 if (r != NULL) {
902 restricted = strcmp(r, restricted_filename) == 0;
903 free(r);
904 return restricted;
905 }
906 }
907
908 return restricted;
909}
910
911struct module_info {
912 struct rb_node rb_node;
913 char *name;
914 u64 start;
915};
916
917static void add_module(struct module_info *mi, struct rb_root *modules)
918{
919 struct rb_node **p = &modules->rb_node;
920 struct rb_node *parent = NULL;
921 struct module_info *m;
922
923 while (*p != NULL) {
924 parent = *p;
925 m = rb_entry(parent, struct module_info, rb_node);
926 if (strcmp(mi->name, m->name) < 0)
927 p = &(*p)->rb_left;
928 else
929 p = &(*p)->rb_right;
930 }
931 rb_link_node(&mi->rb_node, parent, p);
932 rb_insert_color(&mi->rb_node, modules);
933}
934
935static void delete_modules(struct rb_root *modules)
936{
937 struct module_info *mi;
938 struct rb_node *next = rb_first(modules);
939
940 while (next) {
941 mi = rb_entry(next, struct module_info, rb_node);
942 next = rb_next(&mi->rb_node);
943 rb_erase(&mi->rb_node, modules);
944 zfree(&mi->name);
945 free(mi);
946 }
947}
948
949static struct module_info *find_module(const char *name,
950 struct rb_root *modules)
951{
952 struct rb_node *n = modules->rb_node;
953
954 while (n) {
955 struct module_info *m;
956 int cmp;
957
958 m = rb_entry(n, struct module_info, rb_node);
959 cmp = strcmp(name, m->name);
960 if (cmp < 0)
961 n = n->rb_left;
962 else if (cmp > 0)
963 n = n->rb_right;
964 else
965 return m;
966 }
967
968 return NULL;
969}
970
971static int __read_proc_modules(void *arg, const char *name, u64 start,
972 u64 size __maybe_unused)
973{
974 struct rb_root *modules = arg;
975 struct module_info *mi;
976
977 mi = zalloc(sizeof(struct module_info));
978 if (!mi)
979 return -ENOMEM;
980
981 mi->name = strdup(name);
982 mi->start = start;
983
984 if (!mi->name) {
985 free(mi);
986 return -ENOMEM;
987 }
988
989 add_module(mi, modules);
990
991 return 0;
992}
993
994static int read_proc_modules(const char *filename, struct rb_root *modules)
995{
996 if (symbol__restricted_filename(filename, "/proc/modules"))
997 return -1;
998
999 if (modules__parse(filename, modules, __read_proc_modules)) {
1000 delete_modules(modules);
1001 return -1;
1002 }
1003
1004 return 0;
1005}
1006
1007int compare_proc_modules(const char *from, const char *to)
1008{
1009 struct rb_root from_modules = RB_ROOT;
1010 struct rb_root to_modules = RB_ROOT;
1011 struct rb_node *from_node, *to_node;
1012 struct module_info *from_m, *to_m;
1013 int ret = -1;
1014
1015 if (read_proc_modules(from, &from_modules))
1016 return -1;
1017
1018 if (read_proc_modules(to, &to_modules))
1019 goto out_delete_from;
1020
1021 from_node = rb_first(&from_modules);
1022 to_node = rb_first(&to_modules);
1023 while (from_node) {
1024 if (!to_node)
1025 break;
1026
1027 from_m = rb_entry(from_node, struct module_info, rb_node);
1028 to_m = rb_entry(to_node, struct module_info, rb_node);
1029
1030 if (from_m->start != to_m->start ||
1031 strcmp(from_m->name, to_m->name))
1032 break;
1033
1034 from_node = rb_next(from_node);
1035 to_node = rb_next(to_node);
1036 }
1037
1038 if (!from_node && !to_node)
1039 ret = 0;
1040
1041 delete_modules(&to_modules);
1042out_delete_from:
1043 delete_modules(&from_modules);
1044
1045 return ret;
1046}
1047
1048struct map *map_groups__first(struct map_groups *mg)
1049{
1050 return maps__first(&mg->maps);
1051}
1052
1053static int do_validate_kcore_modules(const char *filename,
1054 struct map_groups *kmaps)
1055{
1056 struct rb_root modules = RB_ROOT;
1057 struct map *old_map;
1058 int err;
1059
1060 err = read_proc_modules(filename, &modules);
1061 if (err)
1062 return err;
1063
1064 old_map = map_groups__first(kmaps);
1065 while (old_map) {
1066 struct map *next = map_groups__next(old_map);
1067 struct module_info *mi;
1068
1069 if (!__map__is_kmodule(old_map)) {
1070 old_map = next;
1071 continue;
1072 }
1073
1074
1075 mi = find_module(old_map->dso->short_name, &modules);
1076 if (!mi || mi->start != old_map->start) {
1077 err = -EINVAL;
1078 goto out;
1079 }
1080
1081 old_map = next;
1082 }
1083out:
1084 delete_modules(&modules);
1085 return err;
1086}
1087
1088
1089
1090
1091
1092static bool filename_from_kallsyms_filename(char *filename,
1093 const char *base_name,
1094 const char *kallsyms_filename)
1095{
1096 char *name;
1097
1098 strcpy(filename, kallsyms_filename);
1099 name = strrchr(filename, '/');
1100 if (!name)
1101 return false;
1102
1103 name += 1;
1104
1105 if (!strcmp(name, "kallsyms")) {
1106 strcpy(name, base_name);
1107 return true;
1108 }
1109
1110 return false;
1111}
1112
1113static int validate_kcore_modules(const char *kallsyms_filename,
1114 struct map *map)
1115{
1116 struct map_groups *kmaps = map__kmaps(map);
1117 char modules_filename[PATH_MAX];
1118
1119 if (!kmaps)
1120 return -EINVAL;
1121
1122 if (!filename_from_kallsyms_filename(modules_filename, "modules",
1123 kallsyms_filename))
1124 return -EINVAL;
1125
1126 if (do_validate_kcore_modules(modules_filename, kmaps))
1127 return -EINVAL;
1128
1129 return 0;
1130}
1131
1132static int validate_kcore_addresses(const char *kallsyms_filename,
1133 struct map *map)
1134{
1135 struct kmap *kmap = map__kmap(map);
1136
1137 if (!kmap)
1138 return -EINVAL;
1139
1140 if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
1141 u64 start;
1142
1143 if (kallsyms__get_function_start(kallsyms_filename,
1144 kmap->ref_reloc_sym->name, &start))
1145 return -ENOENT;
1146 if (start != kmap->ref_reloc_sym->addr)
1147 return -EINVAL;
1148 }
1149
1150 return validate_kcore_modules(kallsyms_filename, map);
1151}
1152
1153struct kcore_mapfn_data {
1154 struct dso *dso;
1155 struct list_head maps;
1156};
1157
1158static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
1159{
1160 struct kcore_mapfn_data *md = data;
1161 struct map *map;
1162
1163 map = map__new2(start, md->dso);
1164 if (map == NULL)
1165 return -ENOMEM;
1166
1167 map->end = map->start + len;
1168 map->pgoff = pgoff;
1169
1170 list_add(&map->node, &md->maps);
1171
1172 return 0;
1173}
1174
1175
1176
1177
1178
1179int map_groups__merge_in(struct map_groups *kmaps, struct map *new_map)
1180{
1181 struct map *old_map;
1182 LIST_HEAD(merged);
1183
1184 for (old_map = map_groups__first(kmaps); old_map;
1185 old_map = map_groups__next(old_map)) {
1186
1187
1188 if (new_map->end < old_map->start ||
1189 new_map->start >= old_map->end)
1190 continue;
1191
1192 if (new_map->start < old_map->start) {
1193
1194
1195
1196
1197 if (new_map->end < old_map->end) {
1198
1199
1200
1201
1202 new_map->end = old_map->start;
1203 } else {
1204
1205
1206
1207
1208 struct map *m = map__clone(new_map);
1209
1210 if (!m)
1211 return -ENOMEM;
1212
1213 m->end = old_map->start;
1214 list_add_tail(&m->node, &merged);
1215 new_map->start = old_map->end;
1216 }
1217 } else {
1218
1219
1220
1221
1222 if (new_map->end < old_map->end) {
1223
1224
1225
1226
1227 map__put(new_map);
1228 new_map = NULL;
1229 break;
1230 } else {
1231
1232
1233
1234
1235 new_map->start = old_map->end;
1236 }
1237 }
1238 }
1239
1240 while (!list_empty(&merged)) {
1241 old_map = list_entry(merged.next, struct map, node);
1242 list_del_init(&old_map->node);
1243 map_groups__insert(kmaps, old_map);
1244 map__put(old_map);
1245 }
1246
1247 if (new_map) {
1248 map_groups__insert(kmaps, new_map);
1249 map__put(new_map);
1250 }
1251 return 0;
1252}
1253
1254static int dso__load_kcore(struct dso *dso, struct map *map,
1255 const char *kallsyms_filename)
1256{
1257 struct map_groups *kmaps = map__kmaps(map);
1258 struct kcore_mapfn_data md;
1259 struct map *old_map, *new_map, *replacement_map = NULL;
1260 struct machine *machine;
1261 bool is_64_bit;
1262 int err, fd;
1263 char kcore_filename[PATH_MAX];
1264 u64 stext;
1265
1266 if (!kmaps)
1267 return -EINVAL;
1268
1269 machine = kmaps->machine;
1270
1271
1272 if (!__map__is_kernel(map))
1273 return -EINVAL;
1274
1275 if (!filename_from_kallsyms_filename(kcore_filename, "kcore",
1276 kallsyms_filename))
1277 return -EINVAL;
1278
1279
1280 if (validate_kcore_addresses(kallsyms_filename, map))
1281 return -EINVAL;
1282
1283 md.dso = dso;
1284 INIT_LIST_HEAD(&md.maps);
1285
1286 fd = open(kcore_filename, O_RDONLY);
1287 if (fd < 0) {
1288 pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n",
1289 kcore_filename);
1290 return -EINVAL;
1291 }
1292
1293
1294 err = file__read_maps(fd, map->prot & PROT_EXEC, kcore_mapfn, &md,
1295 &is_64_bit);
1296 if (err)
1297 goto out_err;
1298 dso->is_64_bit = is_64_bit;
1299
1300 if (list_empty(&md.maps)) {
1301 err = -EINVAL;
1302 goto out_err;
1303 }
1304
1305
1306 old_map = map_groups__first(kmaps);
1307 while (old_map) {
1308 struct map *next = map_groups__next(old_map);
1309
1310
1311
1312
1313
1314
1315 if (old_map != map && !__map__is_bpf_prog(old_map))
1316 map_groups__remove(kmaps, old_map);
1317 old_map = next;
1318 }
1319 machine->trampolines_mapped = false;
1320
1321
1322 if (!kallsyms__get_function_start(kallsyms_filename, "_stext", &stext)) {
1323 list_for_each_entry(new_map, &md.maps, node) {
1324 if (stext >= new_map->start && stext < new_map->end) {
1325 replacement_map = new_map;
1326 break;
1327 }
1328 }
1329 }
1330
1331 if (!replacement_map)
1332 replacement_map = list_entry(md.maps.next, struct map, node);
1333
1334
1335 while (!list_empty(&md.maps)) {
1336 new_map = list_entry(md.maps.next, struct map, node);
1337 list_del_init(&new_map->node);
1338 if (new_map == replacement_map) {
1339 map->start = new_map->start;
1340 map->end = new_map->end;
1341 map->pgoff = new_map->pgoff;
1342 map->map_ip = new_map->map_ip;
1343 map->unmap_ip = new_map->unmap_ip;
1344
1345 map__get(map);
1346 map_groups__remove(kmaps, map);
1347 map_groups__insert(kmaps, map);
1348 map__put(map);
1349 map__put(new_map);
1350 } else {
1351
1352
1353
1354
1355
1356 if (map_groups__merge_in(kmaps, new_map))
1357 goto out_err;
1358 }
1359 }
1360
1361 if (machine__is(machine, "x86_64")) {
1362 u64 addr;
1363
1364
1365
1366
1367
1368 if (!kallsyms__get_function_start(kallsyms_filename,
1369 ENTRY_TRAMPOLINE_NAME,
1370 &addr))
1371 machine->trampolines_mapped = true;
1372 }
1373
1374
1375
1376
1377
1378 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1379 dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE;
1380 else
1381 dso->binary_type = DSO_BINARY_TYPE__KCORE;
1382 dso__set_long_name(dso, strdup(kcore_filename), true);
1383
1384 close(fd);
1385
1386 if (map->prot & PROT_EXEC)
1387 pr_debug("Using %s for kernel object code\n", kcore_filename);
1388 else
1389 pr_debug("Using %s for kernel data\n", kcore_filename);
1390
1391 return 0;
1392
1393out_err:
1394 while (!list_empty(&md.maps)) {
1395 map = list_entry(md.maps.next, struct map, node);
1396 list_del_init(&map->node);
1397 map__put(map);
1398 }
1399 close(fd);
1400 return -EINVAL;
1401}
1402
1403
1404
1405
1406
1407static int kallsyms__delta(struct kmap *kmap, const char *filename, u64 *delta)
1408{
1409 u64 addr;
1410
1411 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
1412 return 0;
1413
1414 if (kallsyms__get_function_start(filename, kmap->ref_reloc_sym->name, &addr))
1415 return -1;
1416
1417 *delta = addr - kmap->ref_reloc_sym->addr;
1418 return 0;
1419}
1420
1421int __dso__load_kallsyms(struct dso *dso, const char *filename,
1422 struct map *map, bool no_kcore)
1423{
1424 struct kmap *kmap = map__kmap(map);
1425 u64 delta = 0;
1426
1427 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
1428 return -1;
1429
1430 if (!kmap || !kmap->kmaps)
1431 return -1;
1432
1433 if (dso__load_all_kallsyms(dso, filename) < 0)
1434 return -1;
1435
1436 if (kallsyms__delta(kmap, filename, &delta))
1437 return -1;
1438
1439 symbols__fixup_end(&dso->symbols);
1440 symbols__fixup_duplicate(&dso->symbols);
1441
1442 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1443 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1444 else
1445 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
1446
1447 if (!no_kcore && !dso__load_kcore(dso, map, filename))
1448 return map_groups__split_kallsyms_for_kcore(kmap->kmaps, dso);
1449 else
1450 return map_groups__split_kallsyms(kmap->kmaps, dso, delta, map);
1451}
1452
1453int dso__load_kallsyms(struct dso *dso, const char *filename,
1454 struct map *map)
1455{
1456 return __dso__load_kallsyms(dso, filename, map, false);
1457}
1458
1459static int dso__load_perf_map(const char *map_path, struct dso *dso)
1460{
1461 char *line = NULL;
1462 size_t n;
1463 FILE *file;
1464 int nr_syms = 0;
1465
1466 file = fopen(map_path, "r");
1467 if (file == NULL)
1468 goto out_failure;
1469
1470 while (!feof(file)) {
1471 u64 start, size;
1472 struct symbol *sym;
1473 int line_len, len;
1474
1475 line_len = getline(&line, &n, file);
1476 if (line_len < 0)
1477 break;
1478
1479 if (!line)
1480 goto out_failure;
1481
1482 line[--line_len] = '\0';
1483
1484 len = hex2u64(line, &start);
1485
1486 len++;
1487 if (len + 2 >= line_len)
1488 continue;
1489
1490 len += hex2u64(line + len, &size);
1491
1492 len++;
1493 if (len + 2 >= line_len)
1494 continue;
1495
1496 sym = symbol__new(start, size, STB_GLOBAL, STT_FUNC, line + len);
1497
1498 if (sym == NULL)
1499 goto out_delete_line;
1500
1501 symbols__insert(&dso->symbols, sym);
1502 nr_syms++;
1503 }
1504
1505 free(line);
1506 fclose(file);
1507
1508 return nr_syms;
1509
1510out_delete_line:
1511 free(line);
1512out_failure:
1513 return -1;
1514}
1515
1516static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
1517 enum dso_binary_type type)
1518{
1519 switch (type) {
1520 case DSO_BINARY_TYPE__JAVA_JIT:
1521 case DSO_BINARY_TYPE__DEBUGLINK:
1522 case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
1523 case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
1524 case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
1525 case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
1526 case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
1527 return !kmod && dso->kernel == DSO_TYPE_USER;
1528
1529 case DSO_BINARY_TYPE__KALLSYMS:
1530 case DSO_BINARY_TYPE__VMLINUX:
1531 case DSO_BINARY_TYPE__KCORE:
1532 return dso->kernel == DSO_TYPE_KERNEL;
1533
1534 case DSO_BINARY_TYPE__GUEST_KALLSYMS:
1535 case DSO_BINARY_TYPE__GUEST_VMLINUX:
1536 case DSO_BINARY_TYPE__GUEST_KCORE:
1537 return dso->kernel == DSO_TYPE_GUEST_KERNEL;
1538
1539 case DSO_BINARY_TYPE__GUEST_KMODULE:
1540 case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
1541 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
1542 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
1543
1544
1545
1546
1547 return kmod && dso->symtab_type == type;
1548
1549 case DSO_BINARY_TYPE__BUILD_ID_CACHE:
1550 case DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO:
1551 return true;
1552
1553 case DSO_BINARY_TYPE__BPF_PROG_INFO:
1554 case DSO_BINARY_TYPE__NOT_FOUND:
1555 default:
1556 return false;
1557 }
1558}
1559
1560
1561
1562
1563
1564
1565
1566static int dso__find_perf_map(char *filebuf, size_t bufsz,
1567 struct nsinfo **nsip)
1568{
1569 struct nscookie nsc;
1570 struct nsinfo *nsi;
1571 struct nsinfo *nnsi;
1572 int rc = -1;
1573
1574 nsi = *nsip;
1575
1576 if (nsi->need_setns) {
1577 snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsi->nstgid);
1578 nsinfo__mountns_enter(nsi, &nsc);
1579 rc = access(filebuf, R_OK);
1580 nsinfo__mountns_exit(&nsc);
1581 if (rc == 0)
1582 return rc;
1583 }
1584
1585 nnsi = nsinfo__copy(nsi);
1586 if (nnsi) {
1587 nsinfo__put(nsi);
1588
1589 nnsi->need_setns = false;
1590 snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nnsi->tgid);
1591 *nsip = nnsi;
1592 rc = 0;
1593 }
1594
1595 return rc;
1596}
1597
1598int dso__load(struct dso *dso, struct map *map)
1599{
1600 char *name;
1601 int ret = -1;
1602 u_int i;
1603 struct machine *machine;
1604 char *root_dir = (char *) "";
1605 int ss_pos = 0;
1606 struct symsrc ss_[2];
1607 struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
1608 bool kmod;
1609 bool perfmap;
1610 unsigned char build_id[BUILD_ID_SIZE];
1611 struct nscookie nsc;
1612 char newmapname[PATH_MAX];
1613 const char *map_path = dso->long_name;
1614
1615 perfmap = strncmp(dso->name, "/tmp/perf-", 10) == 0;
1616 if (perfmap) {
1617 if (dso->nsinfo && (dso__find_perf_map(newmapname,
1618 sizeof(newmapname), &dso->nsinfo) == 0)) {
1619 map_path = newmapname;
1620 }
1621 }
1622
1623 nsinfo__mountns_enter(dso->nsinfo, &nsc);
1624 pthread_mutex_lock(&dso->lock);
1625
1626
1627 if (dso__loaded(dso)) {
1628 ret = 1;
1629 goto out;
1630 }
1631
1632 if (map->groups && map->groups->machine)
1633 machine = map->groups->machine;
1634 else
1635 machine = NULL;
1636
1637 if (dso->kernel) {
1638 if (dso->kernel == DSO_TYPE_KERNEL)
1639 ret = dso__load_kernel_sym(dso, map);
1640 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1641 ret = dso__load_guest_kernel_sym(dso, map);
1642
1643 if (machine__is(machine, "x86_64"))
1644 machine__map_x86_64_entry_trampolines(machine, dso);
1645 goto out;
1646 }
1647
1648 dso->adjust_symbols = 0;
1649
1650 if (perfmap) {
1651 ret = dso__load_perf_map(map_path, dso);
1652 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
1653 DSO_BINARY_TYPE__NOT_FOUND;
1654 goto out;
1655 }
1656
1657 if (machine)
1658 root_dir = machine->root_dir;
1659
1660 name = malloc(PATH_MAX);
1661 if (!name)
1662 goto out;
1663
1664 kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
1665 dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
1666 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
1667 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
1668
1669
1670
1671
1672
1673
1674 if (!dso->has_build_id &&
1675 is_regular_file(dso->long_name)) {
1676 __symbol__join_symfs(name, PATH_MAX, dso->long_name);
1677 if (filename__read_build_id(name, build_id, BUILD_ID_SIZE) > 0)
1678 dso__set_build_id(dso, build_id);
1679 }
1680
1681
1682
1683
1684
1685
1686 for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
1687 struct symsrc *ss = &ss_[ss_pos];
1688 bool next_slot = false;
1689 bool is_reg;
1690 bool nsexit;
1691 int sirc = -1;
1692
1693 enum dso_binary_type symtab_type = binary_type_symtab[i];
1694
1695 nsexit = (symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE ||
1696 symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO);
1697
1698 if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type))
1699 continue;
1700
1701 if (dso__read_binary_type_filename(dso, symtab_type,
1702 root_dir, name, PATH_MAX))
1703 continue;
1704
1705 if (nsexit)
1706 nsinfo__mountns_exit(&nsc);
1707
1708 is_reg = is_regular_file(name);
1709 if (is_reg)
1710 sirc = symsrc__init(ss, dso, name, symtab_type);
1711
1712 if (nsexit)
1713 nsinfo__mountns_enter(dso->nsinfo, &nsc);
1714
1715 if (!is_reg || sirc < 0)
1716 continue;
1717
1718 if (!syms_ss && symsrc__has_symtab(ss)) {
1719 syms_ss = ss;
1720 next_slot = true;
1721 if (!dso->symsrc_filename)
1722 dso->symsrc_filename = strdup(name);
1723 }
1724
1725 if (!runtime_ss && symsrc__possibly_runtime(ss)) {
1726 runtime_ss = ss;
1727 next_slot = true;
1728 }
1729
1730 if (next_slot) {
1731 ss_pos++;
1732
1733 if (syms_ss && runtime_ss)
1734 break;
1735 } else {
1736 symsrc__destroy(ss);
1737 }
1738
1739 }
1740
1741 if (!runtime_ss && !syms_ss)
1742 goto out_free;
1743
1744 if (runtime_ss && !syms_ss) {
1745 syms_ss = runtime_ss;
1746 }
1747
1748
1749 if (!runtime_ss && syms_ss)
1750 runtime_ss = syms_ss;
1751
1752 if (syms_ss)
1753 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod);
1754 else
1755 ret = -1;
1756
1757 if (ret > 0) {
1758 int nr_plt;
1759
1760 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss);
1761 if (nr_plt > 0)
1762 ret += nr_plt;
1763 }
1764
1765 for (; ss_pos > 0; ss_pos--)
1766 symsrc__destroy(&ss_[ss_pos - 1]);
1767out_free:
1768 free(name);
1769 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1770 ret = 0;
1771out:
1772 dso__set_loaded(dso);
1773 pthread_mutex_unlock(&dso->lock);
1774 nsinfo__mountns_exit(&nsc);
1775
1776 return ret;
1777}
1778
1779struct map *map_groups__find_by_name(struct map_groups *mg, const char *name)
1780{
1781 struct maps *maps = &mg->maps;
1782 struct map *map;
1783 struct rb_node *node;
1784
1785 down_read(&maps->lock);
1786
1787 for (node = maps->names.rb_node; node; ) {
1788 int rc;
1789
1790 map = rb_entry(node, struct map, rb_node_name);
1791
1792 rc = strcmp(map->dso->short_name, name);
1793 if (rc < 0)
1794 node = node->rb_left;
1795 else if (rc > 0)
1796 node = node->rb_right;
1797 else
1798
1799 goto out_unlock;
1800 }
1801
1802 map = NULL;
1803
1804out_unlock:
1805 up_read(&maps->lock);
1806 return map;
1807}
1808
1809int dso__load_vmlinux(struct dso *dso, struct map *map,
1810 const char *vmlinux, bool vmlinux_allocated)
1811{
1812 int err = -1;
1813 struct symsrc ss;
1814 char symfs_vmlinux[PATH_MAX];
1815 enum dso_binary_type symtab_type;
1816
1817 if (vmlinux[0] == '/')
1818 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
1819 else
1820 symbol__join_symfs(symfs_vmlinux, vmlinux);
1821
1822 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1823 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1824 else
1825 symtab_type = DSO_BINARY_TYPE__VMLINUX;
1826
1827 if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
1828 return -1;
1829
1830 err = dso__load_sym(dso, map, &ss, &ss, 0);
1831 symsrc__destroy(&ss);
1832
1833 if (err > 0) {
1834 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1835 dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1836 else
1837 dso->binary_type = DSO_BINARY_TYPE__VMLINUX;
1838 dso__set_long_name(dso, vmlinux, vmlinux_allocated);
1839 dso__set_loaded(dso);
1840 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1841 }
1842
1843 return err;
1844}
1845
1846int dso__load_vmlinux_path(struct dso *dso, struct map *map)
1847{
1848 int i, err = 0;
1849 char *filename = NULL;
1850
1851 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1852 vmlinux_path__nr_entries + 1);
1853
1854 for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1855 err = dso__load_vmlinux(dso, map, vmlinux_path[i], false);
1856 if (err > 0)
1857 goto out;
1858 }
1859
1860 if (!symbol_conf.ignore_vmlinux_buildid)
1861 filename = dso__build_id_filename(dso, NULL, 0, false);
1862 if (filename != NULL) {
1863 err = dso__load_vmlinux(dso, map, filename, true);
1864 if (err > 0)
1865 goto out;
1866 free(filename);
1867 }
1868out:
1869 return err;
1870}
1871
1872static bool visible_dir_filter(const char *name, struct dirent *d)
1873{
1874 if (d->d_type != DT_DIR)
1875 return false;
1876 return lsdir_no_dot_filter(name, d);
1877}
1878
1879static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
1880{
1881 char kallsyms_filename[PATH_MAX];
1882 int ret = -1;
1883 struct strlist *dirs;
1884 struct str_node *nd;
1885
1886 dirs = lsdir(dir, visible_dir_filter);
1887 if (!dirs)
1888 return -1;
1889
1890 strlist__for_each_entry(nd, dirs) {
1891 scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
1892 "%s/%s/kallsyms", dir, nd->s);
1893 if (!validate_kcore_addresses(kallsyms_filename, map)) {
1894 strlcpy(dir, kallsyms_filename, dir_sz);
1895 ret = 0;
1896 break;
1897 }
1898 }
1899
1900 strlist__delete(dirs);
1901
1902 return ret;
1903}
1904
1905
1906
1907
1908
1909
1910static bool filename__readable(const char *file)
1911{
1912 int fd = open(file, O_RDONLY);
1913 if (fd < 0)
1914 return false;
1915 close(fd);
1916 return true;
1917}
1918
1919static char *dso__find_kallsyms(struct dso *dso, struct map *map)
1920{
1921 u8 host_build_id[BUILD_ID_SIZE];
1922 char sbuild_id[SBUILD_ID_SIZE];
1923 bool is_host = false;
1924 char path[PATH_MAX];
1925
1926 if (!dso->has_build_id) {
1927
1928
1929
1930
1931 goto proc_kallsyms;
1932 }
1933
1934 if (sysfs__read_build_id("/sys/kernel/notes", host_build_id,
1935 sizeof(host_build_id)) == 0)
1936 is_host = dso__build_id_equal(dso, host_build_id);
1937
1938
1939 if (is_host) {
1940
1941
1942
1943
1944
1945
1946
1947 if (filename__readable("/proc/kcore") &&
1948 !validate_kcore_addresses("/proc/kallsyms", map))
1949 goto proc_kallsyms;
1950 }
1951
1952 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
1953
1954
1955 scnprintf(path, sizeof(path), "%s/%s/%s",
1956 buildid_dir, DSO__NAME_KCORE, sbuild_id);
1957
1958 if (!find_matching_kcore(map, path, sizeof(path)))
1959 return strdup(path);
1960
1961
1962 if (is_host) {
1963proc_kallsyms:
1964 return strdup("/proc/kallsyms");
1965 }
1966
1967
1968 if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) {
1969 pr_err("No kallsyms or vmlinux with build-id %s was found\n",
1970 sbuild_id);
1971 return NULL;
1972 }
1973
1974 return strdup(path);
1975}
1976
1977static int dso__load_kernel_sym(struct dso *dso, struct map *map)
1978{
1979 int err;
1980 const char *kallsyms_filename = NULL;
1981 char *kallsyms_allocated_filename = NULL;
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997 if (symbol_conf.kallsyms_name != NULL) {
1998 kallsyms_filename = symbol_conf.kallsyms_name;
1999 goto do_kallsyms;
2000 }
2001
2002 if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
2003 return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false);
2004 }
2005
2006 if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
2007 err = dso__load_vmlinux_path(dso, map);
2008 if (err > 0)
2009 return err;
2010 }
2011
2012
2013 if (symbol_conf.symfs[0] != 0)
2014 return -1;
2015
2016 kallsyms_allocated_filename = dso__find_kallsyms(dso, map);
2017 if (!kallsyms_allocated_filename)
2018 return -1;
2019
2020 kallsyms_filename = kallsyms_allocated_filename;
2021
2022do_kallsyms:
2023 err = dso__load_kallsyms(dso, kallsyms_filename, map);
2024 if (err > 0)
2025 pr_debug("Using %s for symbols\n", kallsyms_filename);
2026 free(kallsyms_allocated_filename);
2027
2028 if (err > 0 && !dso__is_kcore(dso)) {
2029 dso->binary_type = DSO_BINARY_TYPE__KALLSYMS;
2030 dso__set_long_name(dso, DSO__NAME_KALLSYMS, false);
2031 map__fixup_start(map);
2032 map__fixup_end(map);
2033 }
2034
2035 return err;
2036}
2037
2038static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map)
2039{
2040 int err;
2041 const char *kallsyms_filename = NULL;
2042 struct machine *machine;
2043 char path[PATH_MAX];
2044
2045 if (!map->groups) {
2046 pr_debug("Guest kernel map hasn't the point to groups\n");
2047 return -1;
2048 }
2049 machine = map->groups->machine;
2050
2051 if (machine__is_default_guest(machine)) {
2052
2053
2054
2055
2056
2057 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2058 err = dso__load_vmlinux(dso, map,
2059 symbol_conf.default_guest_vmlinux_name,
2060 false);
2061 return err;
2062 }
2063
2064 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2065 if (!kallsyms_filename)
2066 return -1;
2067 } else {
2068 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2069 kallsyms_filename = path;
2070 }
2071
2072 err = dso__load_kallsyms(dso, kallsyms_filename, map);
2073 if (err > 0)
2074 pr_debug("Using %s for symbols\n", kallsyms_filename);
2075 if (err > 0 && !dso__is_kcore(dso)) {
2076 dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
2077 dso__set_long_name(dso, machine->mmap_name, false);
2078 map__fixup_start(map);
2079 map__fixup_end(map);
2080 }
2081
2082 return err;
2083}
2084
2085static void vmlinux_path__exit(void)
2086{
2087 while (--vmlinux_path__nr_entries >= 0)
2088 zfree(&vmlinux_path[vmlinux_path__nr_entries]);
2089 vmlinux_path__nr_entries = 0;
2090
2091 zfree(&vmlinux_path);
2092}
2093
2094static const char * const vmlinux_paths[] = {
2095 "vmlinux",
2096 "/boot/vmlinux"
2097};
2098
2099static const char * const vmlinux_paths_upd[] = {
2100 "/boot/vmlinux-%s",
2101 "/usr/lib/debug/boot/vmlinux-%s",
2102 "/lib/modules/%s/build/vmlinux",
2103 "/usr/lib/debug/lib/modules/%s/vmlinux",
2104 "/usr/lib/debug/boot/vmlinux-%s.debug"
2105};
2106
2107static int vmlinux_path__add(const char *new_entry)
2108{
2109 vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry);
2110 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2111 return -1;
2112 ++vmlinux_path__nr_entries;
2113
2114 return 0;
2115}
2116
2117static int vmlinux_path__init(struct perf_env *env)
2118{
2119 struct utsname uts;
2120 char bf[PATH_MAX];
2121 char *kernel_version;
2122 unsigned int i;
2123
2124 vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) +
2125 ARRAY_SIZE(vmlinux_paths_upd)));
2126 if (vmlinux_path == NULL)
2127 return -1;
2128
2129 for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++)
2130 if (vmlinux_path__add(vmlinux_paths[i]) < 0)
2131 goto out_fail;
2132
2133
2134 if (symbol_conf.symfs[0] != 0)
2135 return 0;
2136
2137 if (env) {
2138 kernel_version = env->os_release;
2139 } else {
2140 if (uname(&uts) < 0)
2141 goto out_fail;
2142
2143 kernel_version = uts.release;
2144 }
2145
2146 for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) {
2147 snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version);
2148 if (vmlinux_path__add(bf) < 0)
2149 goto out_fail;
2150 }
2151
2152 return 0;
2153
2154out_fail:
2155 vmlinux_path__exit();
2156 return -1;
2157}
2158
2159int setup_list(struct strlist **list, const char *list_str,
2160 const char *list_name)
2161{
2162 if (list_str == NULL)
2163 return 0;
2164
2165 *list = strlist__new(list_str, NULL);
2166 if (!*list) {
2167 pr_err("problems parsing %s list\n", list_name);
2168 return -1;
2169 }
2170
2171 symbol_conf.has_filter = true;
2172 return 0;
2173}
2174
2175int setup_intlist(struct intlist **list, const char *list_str,
2176 const char *list_name)
2177{
2178 if (list_str == NULL)
2179 return 0;
2180
2181 *list = intlist__new(list_str);
2182 if (!*list) {
2183 pr_err("problems parsing %s list\n", list_name);
2184 return -1;
2185 }
2186 return 0;
2187}
2188
2189static bool symbol__read_kptr_restrict(void)
2190{
2191 bool value = false;
2192 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2193
2194 if (fp != NULL) {
2195 char line[8];
2196
2197 if (fgets(line, sizeof(line), fp) != NULL)
2198 value = ((geteuid() != 0) || (getuid() != 0)) ?
2199 (atoi(line) != 0) :
2200 (atoi(line) == 2);
2201
2202 fclose(fp);
2203 }
2204
2205 return value;
2206}
2207
2208int symbol__annotation_init(void)
2209{
2210 if (symbol_conf.init_annotation)
2211 return 0;
2212
2213 if (symbol_conf.initialized) {
2214 pr_err("Annotation needs to be init before symbol__init()\n");
2215 return -1;
2216 }
2217
2218 symbol_conf.priv_size += sizeof(struct annotation);
2219 symbol_conf.init_annotation = true;
2220 return 0;
2221}
2222
2223int symbol__init(struct perf_env *env)
2224{
2225 const char *symfs;
2226
2227 if (symbol_conf.initialized)
2228 return 0;
2229
2230 symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
2231
2232 symbol__elf_init();
2233
2234 if (symbol_conf.sort_by_name)
2235 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2236 sizeof(struct symbol));
2237
2238 if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
2239 return -1;
2240
2241 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2242 pr_err("'.' is the only non valid --field-separator argument\n");
2243 return -1;
2244 }
2245
2246 if (setup_list(&symbol_conf.dso_list,
2247 symbol_conf.dso_list_str, "dso") < 0)
2248 return -1;
2249
2250 if (setup_list(&symbol_conf.comm_list,
2251 symbol_conf.comm_list_str, "comm") < 0)
2252 goto out_free_dso_list;
2253
2254 if (setup_intlist(&symbol_conf.pid_list,
2255 symbol_conf.pid_list_str, "pid") < 0)
2256 goto out_free_comm_list;
2257
2258 if (setup_intlist(&symbol_conf.tid_list,
2259 symbol_conf.tid_list_str, "tid") < 0)
2260 goto out_free_pid_list;
2261
2262 if (setup_list(&symbol_conf.sym_list,
2263 symbol_conf.sym_list_str, "symbol") < 0)
2264 goto out_free_tid_list;
2265
2266 if (setup_list(&symbol_conf.bt_stop_list,
2267 symbol_conf.bt_stop_list_str, "symbol") < 0)
2268 goto out_free_sym_list;
2269
2270
2271
2272
2273
2274 symfs = realpath(symbol_conf.symfs, NULL);
2275 if (symfs == NULL)
2276 symfs = symbol_conf.symfs;
2277 if (strcmp(symfs, "/") == 0)
2278 symbol_conf.symfs = "";
2279 if (symfs != symbol_conf.symfs)
2280 free((void *)symfs);
2281
2282 symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2283
2284 symbol_conf.initialized = true;
2285 return 0;
2286
2287out_free_sym_list:
2288 strlist__delete(symbol_conf.sym_list);
2289out_free_tid_list:
2290 intlist__delete(symbol_conf.tid_list);
2291out_free_pid_list:
2292 intlist__delete(symbol_conf.pid_list);
2293out_free_comm_list:
2294 strlist__delete(symbol_conf.comm_list);
2295out_free_dso_list:
2296 strlist__delete(symbol_conf.dso_list);
2297 return -1;
2298}
2299
2300void symbol__exit(void)
2301{
2302 if (!symbol_conf.initialized)
2303 return;
2304 strlist__delete(symbol_conf.bt_stop_list);
2305 strlist__delete(symbol_conf.sym_list);
2306 strlist__delete(symbol_conf.dso_list);
2307 strlist__delete(symbol_conf.comm_list);
2308 intlist__delete(symbol_conf.tid_list);
2309 intlist__delete(symbol_conf.pid_list);
2310 vmlinux_path__exit();
2311 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2312 symbol_conf.bt_stop_list = NULL;
2313 symbol_conf.initialized = false;
2314}
2315
2316int symbol__config_symfs(const struct option *opt __maybe_unused,
2317 const char *dir, int unset __maybe_unused)
2318{
2319 char *bf = NULL;
2320 int ret;
2321
2322 symbol_conf.symfs = strdup(dir);
2323 if (symbol_conf.symfs == NULL)
2324 return -ENOMEM;
2325
2326
2327
2328
2329 ret = asprintf(&bf, "%s/%s", dir, ".debug");
2330 if (ret < 0)
2331 return -ENOMEM;
2332
2333 set_buildid_dir(bf);
2334
2335 free(bf);
2336 return 0;
2337}
2338
2339struct mem_info *mem_info__get(struct mem_info *mi)
2340{
2341 if (mi)
2342 refcount_inc(&mi->refcnt);
2343 return mi;
2344}
2345
2346void mem_info__put(struct mem_info *mi)
2347{
2348 if (mi && refcount_dec_and_test(&mi->refcnt))
2349 free(mi);
2350}
2351
2352struct mem_info *mem_info__new(void)
2353{
2354 struct mem_info *mi = zalloc(sizeof(*mi));
2355
2356 if (mi)
2357 refcount_set(&mi->refcnt, 1);
2358 return mi;
2359}
2360
2361struct block_info *block_info__get(struct block_info *bi)
2362{
2363 if (bi)
2364 refcount_inc(&bi->refcnt);
2365 return bi;
2366}
2367
2368void block_info__put(struct block_info *bi)
2369{
2370 if (bi && refcount_dec_and_test(&bi->refcnt))
2371 free(bi);
2372}
2373
2374struct block_info *block_info__new(void)
2375{
2376 struct block_info *bi = zalloc(sizeof(*bi));
2377
2378 if (bi)
2379 refcount_set(&bi->refcnt, 1);
2380 return bi;
2381}
2382