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