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