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