?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v3.6.7
[linux-3.6.7-moxart.git] / tools / perf / util / symbol.c
blob8b63b678e127ba5253477db6c65355e28ae49e66
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 "symbol.h"
16 #include "strlist.h"
17
18 #include <libelf.h>
19 #include <gelf.h>
20 #include <elf.h>
21 #include <limits.h>
22 #include <sys/utsname.h>
23
24 #ifndef KSYM_NAME_LEN
25 #define KSYM_NAME_LEN 256
26 #endif
27
28 #ifndef NT_GNU_BUILD_ID
29 #define NT_GNU_BUILD_ID 3
30 #endif
31
32 static void dso_cache__free(struct rb_root *root);
33 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
34 static int elf_read_build_id(Elf *elf, void *bf, size_t size);
35 static void dsos__add(struct list_head *head, struct dso *dso);
36 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
37 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
38 symbol_filter_t filter);
39 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
40 symbol_filter_t filter);
41 static int vmlinux_path__nr_entries;
42 static char **vmlinux_path;
43
44 struct symbol_conf symbol_conf = {
45 .exclude_other = true,
46 .use_modules = true,
47 .try_vmlinux_path = true,
48 .annotate_src = true,
49 .symfs = "",
50 };
51
52 static enum dso_binary_type binary_type_symtab[] = {
53 DSO_BINARY_TYPE__KALLSYMS,
54 DSO_BINARY_TYPE__GUEST_KALLSYMS,
55 DSO_BINARY_TYPE__JAVA_JIT,
56 DSO_BINARY_TYPE__DEBUGLINK,
57 DSO_BINARY_TYPE__BUILD_ID_CACHE,
58 DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
59 DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
60 DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
61 DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
62 DSO_BINARY_TYPE__GUEST_KMODULE,
63 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
64 DSO_BINARY_TYPE__NOT_FOUND,
65 };
66
67 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
68
69 static enum dso_binary_type binary_type_data[] = {
70 DSO_BINARY_TYPE__BUILD_ID_CACHE,
71 DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
72 DSO_BINARY_TYPE__NOT_FOUND,
73 };
74
75 #define DSO_BINARY_TYPE__DATA_CNT ARRAY_SIZE(binary_type_data)
76
77 int dso__name_len(const struct dso *dso)
78 {
79 if (!dso)
80 return strlen("[unknown]");
81 if (verbose)
82 return dso->long_name_len;
83
84 return dso->short_name_len;
85 }
86
87 bool dso__loaded(const struct dso *dso, enum map_type type)
88 {
89 return dso->loaded & (1 << type);
90 }
91
92 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
93 {
94 return dso->sorted_by_name & (1 << type);
95 }
96
97 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
98 {
99 dso->sorted_by_name |= (1 << type);
100 }
101
102 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
103 {
104 symbol_type = toupper(symbol_type);
105
106 switch (map_type) {
107 case MAP__FUNCTION:
108 return symbol_type == 'T' || symbol_type == 'W';
109 case MAP__VARIABLE:
110 return symbol_type == 'D';
111 default:
112 return false;
113 }
114 }
115
116 static int prefix_underscores_count(const char *str)
117 {
118 const char *tail = str;
119
120 while (*tail == '_')
121 tail++;
122
123 return tail - str;
124 }
125
126 #define SYMBOL_A 0
127 #define SYMBOL_B 1
128
129 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
130 {
131 s64 a;
132 s64 b;
133
134 /* Prefer a symbol with non zero length */
135 a = syma->end - syma->start;
136 b = symb->end - symb->start;
137 if ((b == 0) && (a > 0))
138 return SYMBOL_A;
139 else if ((a == 0) && (b > 0))
140 return SYMBOL_B;
141
142 /* Prefer a non weak symbol over a weak one */
143 a = syma->binding == STB_WEAK;
144 b = symb->binding == STB_WEAK;
145 if (b && !a)
146 return SYMBOL_A;
147 if (a && !b)
148 return SYMBOL_B;
149
150 /* Prefer a global symbol over a non global one */
151 a = syma->binding == STB_GLOBAL;
152 b = symb->binding == STB_GLOBAL;
153 if (a && !b)
154 return SYMBOL_A;
155 if (b && !a)
156 return SYMBOL_B;
157
158 /* Prefer a symbol with less underscores */
159 a = prefix_underscores_count(syma->name);
160 b = prefix_underscores_count(symb->name);
161 if (b > a)
162 return SYMBOL_A;
163 else if (a > b)
164 return SYMBOL_B;
165
166 /* If all else fails, choose the symbol with the longest name */
167 if (strlen(syma->name) >= strlen(symb->name))
168 return SYMBOL_A;
169 else
170 return SYMBOL_B;
171 }
172
173 static void symbols__fixup_duplicate(struct rb_root *symbols)
174 {
175 struct rb_node *nd;
176 struct symbol *curr, *next;
177
178 nd = rb_first(symbols);
179
180 while (nd) {
181 curr = rb_entry(nd, struct symbol, rb_node);
182 again:
183 nd = rb_next(&curr->rb_node);
184 next = rb_entry(nd, struct symbol, rb_node);
185
186 if (!nd)
187 break;
188
189 if (curr->start != next->start)
190 continue;
191
192 if (choose_best_symbol(curr, next) == SYMBOL_A) {
193 rb_erase(&next->rb_node, symbols);
194 goto again;
195 } else {
196 nd = rb_next(&curr->rb_node);
197 rb_erase(&curr->rb_node, symbols);
198 }
199 }
200 }
201
202 static void symbols__fixup_end(struct rb_root *symbols)
203 {
204 struct rb_node *nd, *prevnd = rb_first(symbols);
205 struct symbol *curr, *prev;
206
207 if (prevnd == NULL)
208 return;
209
210 curr = rb_entry(prevnd, struct symbol, rb_node);
211
212 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
213 prev = curr;
214 curr = rb_entry(nd, struct symbol, rb_node);
215
216 if (prev->end == prev->start && prev->end != curr->start)
217 prev->end = curr->start - 1;
218 }
219
220 /* Last entry */
221 if (curr->end == curr->start)
222 curr->end = roundup(curr->start, 4096);
223 }
224
225 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
226 {
227 struct map *prev, *curr;
228 struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
229
230 if (prevnd == NULL)
231 return;
232
233 curr = rb_entry(prevnd, struct map, rb_node);
234
235 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
236 prev = curr;
237 curr = rb_entry(nd, struct map, rb_node);
238 prev->end = curr->start - 1;
239 }
240
241 /*
242 * We still haven't the actual symbols, so guess the
243 * last map final address.
244 */
245 curr->end = ~0ULL;
246 }
247
248 static void map_groups__fixup_end(struct map_groups *mg)
249 {
250 int i;
251 for (i = 0; i < MAP__NR_TYPES; ++i)
252 __map_groups__fixup_end(mg, i);
253 }
254
255 static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
256 const char *name)
257 {
258 size_t namelen = strlen(name) + 1;
259 struct symbol *sym = calloc(1, (symbol_conf.priv_size +
260 sizeof(*sym) + namelen));
261 if (sym == NULL)
262 return NULL;
263
264 if (symbol_conf.priv_size)
265 sym = ((void *)sym) + symbol_conf.priv_size;
266
267 sym->start = start;
268 sym->end = len ? start + len - 1 : start;
269 sym->binding = binding;
270 sym->namelen = namelen - 1;
271
272 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
273 __func__, name, start, sym->end);
274 memcpy(sym->name, name, namelen);
275
276 return sym;
277 }
278
279 void symbol__delete(struct symbol *sym)
280 {
281 free(((void *)sym) - symbol_conf.priv_size);
282 }
283
284 static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
285 {
286 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
287 sym->start, sym->end,
288 sym->binding == STB_GLOBAL ? 'g' :
289 sym->binding == STB_LOCAL ? 'l' : 'w',
290 sym->name);
291 }
292
293 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
294 const struct addr_location *al, FILE *fp)
295 {
296 unsigned long offset;
297 size_t length;
298
299 if (sym && sym->name) {
300 length = fprintf(fp, "%s", sym->name);
301 if (al) {
302 offset = al->addr - sym->start;
303 length += fprintf(fp, "+0x%lx", offset);
304 }
305 return length;
306 } else
307 return fprintf(fp, "[unknown]");
308 }
309
310 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
311 {
312 return symbol__fprintf_symname_offs(sym, NULL, fp);
313 }
314
315 void dso__set_long_name(struct dso *dso, char *name)
316 {
317 if (name == NULL)
318 return;
319 dso->long_name = name;
320 dso->long_name_len = strlen(name);
321 }
322
323 static void dso__set_short_name(struct dso *dso, const char *name)
324 {
325 if (name == NULL)
326 return;
327 dso->short_name = name;
328 dso->short_name_len = strlen(name);
329 }
330
331 static void dso__set_basename(struct dso *dso)
332 {
333 dso__set_short_name(dso, basename(dso->long_name));
334 }
335
336 struct dso *dso__new(const char *name)
337 {
338 struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
339
340 if (dso != NULL) {
341 int i;
342 strcpy(dso->name, name);
343 dso__set_long_name(dso, dso->name);
344 dso__set_short_name(dso, dso->name);
345 for (i = 0; i < MAP__NR_TYPES; ++i)
346 dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
347 dso->cache = RB_ROOT;
348 dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND;
349 dso->data_type = DSO_BINARY_TYPE__NOT_FOUND;
350 dso->loaded = 0;
351 dso->sorted_by_name = 0;
352 dso->has_build_id = 0;
353 dso->kernel = DSO_TYPE_USER;
354 dso->needs_swap = DSO_SWAP__UNSET;
355 INIT_LIST_HEAD(&dso->node);
356 }
357
358 return dso;
359 }
360
361 static void symbols__delete(struct rb_root *symbols)
362 {
363 struct symbol *pos;
364 struct rb_node *next = rb_first(symbols);
365
366 while (next) {
367 pos = rb_entry(next, struct symbol, rb_node);
368 next = rb_next(&pos->rb_node);
369 rb_erase(&pos->rb_node, symbols);
370 symbol__delete(pos);
371 }
372 }
373
374 void dso__delete(struct dso *dso)
375 {
376 int i;
377 for (i = 0; i < MAP__NR_TYPES; ++i)
378 symbols__delete(&dso->symbols[i]);
379 if (dso->sname_alloc)
380 free((char *)dso->short_name);
381 if (dso->lname_alloc)
382 free(dso->long_name);
383 dso_cache__free(&dso->cache);
384 free(dso);
385 }
386
387 void dso__set_build_id(struct dso *dso, void *build_id)
388 {
389 memcpy(dso->build_id, build_id, sizeof(dso->build_id));
390 dso->has_build_id = 1;
391 }
392
393 static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
394 {
395 struct rb_node **p = &symbols->rb_node;
396 struct rb_node *parent = NULL;
397 const u64 ip = sym->start;
398 struct symbol *s;
399
400 while (*p != NULL) {
401 parent = *p;
402 s = rb_entry(parent, struct symbol, rb_node);
403 if (ip < s->start)
404 p = &(*p)->rb_left;
405 else
406 p = &(*p)->rb_right;
407 }
408 rb_link_node(&sym->rb_node, parent, p);
409 rb_insert_color(&sym->rb_node, symbols);
410 }
411
412 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
413 {
414 struct rb_node *n;
415
416 if (symbols == NULL)
417 return NULL;
418
419 n = symbols->rb_node;
420
421 while (n) {
422 struct symbol *s = rb_entry(n, struct symbol, rb_node);
423
424 if (ip < s->start)
425 n = n->rb_left;
426 else if (ip > s->end)
427 n = n->rb_right;
428 else
429 return s;
430 }
431
432 return NULL;
433 }
434
435 struct symbol_name_rb_node {
436 struct rb_node rb_node;
437 struct symbol sym;
438 };
439
440 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
441 {
442 struct rb_node **p = &symbols->rb_node;
443 struct rb_node *parent = NULL;
444 struct symbol_name_rb_node *symn, *s;
445
446 symn = container_of(sym, struct symbol_name_rb_node, sym);
447
448 while (*p != NULL) {
449 parent = *p;
450 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
451 if (strcmp(sym->name, s->sym.name) < 0)
452 p = &(*p)->rb_left;
453 else
454 p = &(*p)->rb_right;
455 }
456 rb_link_node(&symn->rb_node, parent, p);
457 rb_insert_color(&symn->rb_node, symbols);
458 }
459
460 static void symbols__sort_by_name(struct rb_root *symbols,
461 struct rb_root *source)
462 {
463 struct rb_node *nd;
464
465 for (nd = rb_first(source); nd; nd = rb_next(nd)) {
466 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
467 symbols__insert_by_name(symbols, pos);
468 }
469 }
470
471 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
472 const char *name)
473 {
474 struct rb_node *n;
475
476 if (symbols == NULL)
477 return NULL;
478
479 n = symbols->rb_node;
480
481 while (n) {
482 struct symbol_name_rb_node *s;
483 int cmp;
484
485 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
486 cmp = strcmp(name, s->sym.name);
487
488 if (cmp < 0)
489 n = n->rb_left;
490 else if (cmp > 0)
491 n = n->rb_right;
492 else
493 return &s->sym;
494 }
495
496 return NULL;
497 }
498
499 struct symbol *dso__find_symbol(struct dso *dso,
500 enum map_type type, u64 addr)
501 {
502 return symbols__find(&dso->symbols[type], addr);
503 }
504
505 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
506 const char *name)
507 {
508 return symbols__find_by_name(&dso->symbol_names[type], name);
509 }
510
511 void dso__sort_by_name(struct dso *dso, enum map_type type)
512 {
513 dso__set_sorted_by_name(dso, type);
514 return symbols__sort_by_name(&dso->symbol_names[type],
515 &dso->symbols[type]);
516 }
517
518 int build_id__sprintf(const u8 *build_id, int len, char *bf)
519 {
520 char *bid = bf;
521 const u8 *raw = build_id;
522 int i;
523
524 for (i = 0; i < len; ++i) {
525 sprintf(bid, "%02x", *raw);
526 ++raw;
527 bid += 2;
528 }
529
530 return raw - build_id;
531 }
532
533 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
534 {
535 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
536
537 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
538 return fprintf(fp, "%s", sbuild_id);
539 }
540
541 size_t dso__fprintf_symbols_by_name(struct dso *dso,
542 enum map_type type, FILE *fp)
543 {
544 size_t ret = 0;
545 struct rb_node *nd;
546 struct symbol_name_rb_node *pos;
547
548 for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
549 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
550 fprintf(fp, "%s\n", pos->sym.name);
551 }
552
553 return ret;
554 }
555
556 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
557 {
558 struct rb_node *nd;
559 size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
560
561 if (dso->short_name != dso->long_name)
562 ret += fprintf(fp, "%s, ", dso->long_name);
563 ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
564 dso->loaded ? "" : "NOT ");
565 ret += dso__fprintf_buildid(dso, fp);
566 ret += fprintf(fp, ")\n");
567 for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
568 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
569 ret += symbol__fprintf(pos, fp);
570 }
571
572 return ret;
573 }
574
575 int kallsyms__parse(const char *filename, void *arg,
576 int (*process_symbol)(void *arg, const char *name,
577 char type, u64 start, u64 end))
578 {
579 char *line = NULL;
580 size_t n;
581 int err = -1;
582 FILE *file = fopen(filename, "r");
583
584 if (file == NULL)
585 goto out_failure;
586
587 err = 0;
588
589 while (!feof(file)) {
590 u64 start;
591 int line_len, len;
592 char symbol_type;
593 char *symbol_name;
594
595 line_len = getline(&line, &n, file);
596 if (line_len < 0 || !line)
597 break;
598
599 line[--line_len] = '\0'; /* \n */
600
601 len = hex2u64(line, &start);
602
603 len++;
604 if (len + 2 >= line_len)
605 continue;
606
607 symbol_type = line[len];
608 len += 2;
609 symbol_name = line + len;
610 len = line_len - len;
611
612 if (len >= KSYM_NAME_LEN) {
613 err = -1;
614 break;
615 }
616
617 /*
618 * module symbols are not sorted so we add all
619 * symbols with zero length and rely on
620 * symbols__fixup_end() to fix it up.
621 */
622 err = process_symbol(arg, symbol_name,
623 symbol_type, start, start);
624 if (err)
625 break;
626 }
627
628 free(line);
629 fclose(file);
630 return err;
631
632 out_failure:
633 return -1;
634 }
635
636 struct process_kallsyms_args {
637 struct map *map;
638 struct dso *dso;
639 };
640
641 static u8 kallsyms2elf_type(char type)
642 {
643 if (type == 'W')
644 return STB_WEAK;
645
646 return isupper(type) ? STB_GLOBAL : STB_LOCAL;
647 }
648
649 static int map__process_kallsym_symbol(void *arg, const char *name,
650 char type, u64 start, u64 end)
651 {
652 struct symbol *sym;
653 struct process_kallsyms_args *a = arg;
654 struct rb_root *root = &a->dso->symbols[a->map->type];
655
656 if (!symbol_type__is_a(type, a->map->type))
657 return 0;
658
659 sym = symbol__new(start, end - start + 1,
660 kallsyms2elf_type(type), name);
661 if (sym == NULL)
662 return -ENOMEM;
663 /*
664 * We will pass the symbols to the filter later, in
665 * map__split_kallsyms, when we have split the maps per module
666 */
667 symbols__insert(root, sym);
668
669 return 0;
670 }
671
672 /*
673 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
674 * so that we can in the next step set the symbol ->end address and then
675 * call kernel_maps__split_kallsyms.
676 */
677 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
678 struct map *map)
679 {
680 struct process_kallsyms_args args = { .map = map, .dso = dso, };
681 return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
682 }
683
684 /*
685 * Split the symbols into maps, making sure there are no overlaps, i.e. the
686 * kernel range is broken in several maps, named [kernel].N, as we don't have
687 * the original ELF section names vmlinux have.
688 */
689 static int dso__split_kallsyms(struct dso *dso, struct map *map,
690 symbol_filter_t filter)
691 {
692 struct map_groups *kmaps = map__kmap(map)->kmaps;
693 struct machine *machine = kmaps->machine;
694 struct map *curr_map = map;
695 struct symbol *pos;
696 int count = 0, moved = 0;
697 struct rb_root *root = &dso->symbols[map->type];
698 struct rb_node *next = rb_first(root);
699 int kernel_range = 0;
700
701 while (next) {
702 char *module;
703
704 pos = rb_entry(next, struct symbol, rb_node);
705 next = rb_next(&pos->rb_node);
706
707 module = strchr(pos->name, '\t');
708 if (module) {
709 if (!symbol_conf.use_modules)
710 goto discard_symbol;
711
712 *module++ = '\0';
713
714 if (strcmp(curr_map->dso->short_name, module)) {
715 if (curr_map != map &&
716 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
717 machine__is_default_guest(machine)) {
718 /*
719 * We assume all symbols of a module are
720 * continuous in * kallsyms, so curr_map
721 * points to a module and all its
722 * symbols are in its kmap. Mark it as
723 * loaded.
724 */
725 dso__set_loaded(curr_map->dso,
726 curr_map->type);
727 }
728
729 curr_map = map_groups__find_by_name(kmaps,
730 map->type, module);
731 if (curr_map == NULL) {
732 pr_debug("%s/proc/{kallsyms,modules} "
733 "inconsistency while looking "
734 "for \"%s\" module!\n",
735 machine->root_dir, module);
736 curr_map = map;
737 goto discard_symbol;
738 }
739
740 if (curr_map->dso->loaded &&
741 !machine__is_default_guest(machine))
742 goto discard_symbol;
743 }
744 /*
745 * So that we look just like we get from .ko files,
746 * i.e. not prelinked, relative to map->start.
747 */
748 pos->start = curr_map->map_ip(curr_map, pos->start);
749 pos->end = curr_map->map_ip(curr_map, pos->end);
750 } else if (curr_map != map) {
751 char dso_name[PATH_MAX];
752 struct dso *ndso;
753
754 if (count == 0) {
755 curr_map = map;
756 goto filter_symbol;
757 }
758
759 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
760 snprintf(dso_name, sizeof(dso_name),
761 "[guest.kernel].%d",
762 kernel_range++);
763 else
764 snprintf(dso_name, sizeof(dso_name),
765 "[kernel].%d",
766 kernel_range++);
767
768 ndso = dso__new(dso_name);
769 if (ndso == NULL)
770 return -1;
771
772 ndso->kernel = dso->kernel;
773
774 curr_map = map__new2(pos->start, ndso, map->type);
775 if (curr_map == NULL) {
776 dso__delete(ndso);
777 return -1;
778 }
779
780 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
781 map_groups__insert(kmaps, curr_map);
782 ++kernel_range;
783 }
784 filter_symbol:
785 if (filter && filter(curr_map, pos)) {
786 discard_symbol: rb_erase(&pos->rb_node, root);
787 symbol__delete(pos);
788 } else {
789 if (curr_map != map) {
790 rb_erase(&pos->rb_node, root);
791 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
792 ++moved;
793 } else
794 ++count;
795 }
796 }
797
798 if (curr_map != map &&
799 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
800 machine__is_default_guest(kmaps->machine)) {
801 dso__set_loaded(curr_map->dso, curr_map->type);
802 }
803
804 return count + moved;
805 }
806
807 static bool symbol__restricted_filename(const char *filename,
808 const char *restricted_filename)
809 {
810 bool restricted = false;
811
812 if (symbol_conf.kptr_restrict) {
813 char *r = realpath(filename, NULL);
814
815 if (r != NULL) {
816 restricted = strcmp(r, restricted_filename) == 0;
817 free(r);
818 return restricted;
819 }
820 }
821
822 return restricted;
823 }
824
825 int dso__load_kallsyms(struct dso *dso, const char *filename,
826 struct map *map, symbol_filter_t filter)
827 {
828 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
829 return -1;
830
831 if (dso__load_all_kallsyms(dso, filename, map) < 0)
832 return -1;
833
834 symbols__fixup_duplicate(&dso->symbols[map->type]);
835 symbols__fixup_end(&dso->symbols[map->type]);
836
837 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
838 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
839 else
840 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
841
842 return dso__split_kallsyms(dso, map, filter);
843 }
844
845 static int dso__load_perf_map(struct dso *dso, struct map *map,
846 symbol_filter_t filter)
847 {
848 char *line = NULL;
849 size_t n;
850 FILE *file;
851 int nr_syms = 0;
852
853 file = fopen(dso->long_name, "r");
854 if (file == NULL)
855 goto out_failure;
856
857 while (!feof(file)) {
858 u64 start, size;
859 struct symbol *sym;
860 int line_len, len;
861
862 line_len = getline(&line, &n, file);
863 if (line_len < 0)
864 break;
865
866 if (!line)
867 goto out_failure;
868
869 line[--line_len] = '\0'; /* \n */
870
871 len = hex2u64(line, &start);
872
873 len++;
874 if (len + 2 >= line_len)
875 continue;
876
877 len += hex2u64(line + len, &size);
878
879 len++;
880 if (len + 2 >= line_len)
881 continue;
882
883 sym = symbol__new(start, size, STB_GLOBAL, line + len);
884
885 if (sym == NULL)
886 goto out_delete_line;
887
888 if (filter && filter(map, sym))
889 symbol__delete(sym);
890 else {
891 symbols__insert(&dso->symbols[map->type], sym);
892 nr_syms++;
893 }
894 }
895
896 free(line);
897 fclose(file);
898
899 return nr_syms;
900
901 out_delete_line:
902 free(line);
903 out_failure:
904 return -1;
905 }
906
907 /**
908 * elf_symtab__for_each_symbol - iterate thru all the symbols
909 *
910 * @syms: struct elf_symtab instance to iterate
911 * @idx: uint32_t idx
912 * @sym: GElf_Sym iterator
913 */
914 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
915 for (idx = 0, gelf_getsym(syms, idx, &sym);\
916 idx < nr_syms; \
917 idx++, gelf_getsym(syms, idx, &sym))
918
919 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
920 {
921 return GELF_ST_TYPE(sym->st_info);
922 }
923
924 static inline int elf_sym__is_function(const GElf_Sym *sym)
925 {
926 return elf_sym__type(sym) == STT_FUNC &&
927 sym->st_name != 0 &&
928 sym->st_shndx != SHN_UNDEF;
929 }
930
931 static inline bool elf_sym__is_object(const GElf_Sym *sym)
932 {
933 return elf_sym__type(sym) == STT_OBJECT &&
934 sym->st_name != 0 &&
935 sym->st_shndx != SHN_UNDEF;
936 }
937
938 static inline int elf_sym__is_label(const GElf_Sym *sym)
939 {
940 return elf_sym__type(sym) == STT_NOTYPE &&
941 sym->st_name != 0 &&
942 sym->st_shndx != SHN_UNDEF &&
943 sym->st_shndx != SHN_ABS;
944 }
945
946 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
947 const Elf_Data *secstrs)
948 {
949 return secstrs->d_buf + shdr->sh_name;
950 }
951
952 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
953 const Elf_Data *secstrs)
954 {
955 return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
956 }
957
958 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
959 const Elf_Data *secstrs)
960 {
961 return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
962 }
963
964 static inline const char *elf_sym__name(const GElf_Sym *sym,
965 const Elf_Data *symstrs)
966 {
967 return symstrs->d_buf + sym->st_name;
968 }
969
970 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
971 GElf_Shdr *shp, const char *name,
972 size_t *idx)
973 {
974 Elf_Scn *sec = NULL;
975 size_t cnt = 1;
976
977 while ((sec = elf_nextscn(elf, sec)) != NULL) {
978 char *str;
979
980 gelf_getshdr(sec, shp);
981 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
982 if (!strcmp(name, str)) {
983 if (idx)
984 *idx = cnt;
985 break;
986 }
987 ++cnt;
988 }
989
990 return sec;
991 }
992
993 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
994 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
995 idx < nr_entries; \
996 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
997
998 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
999 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
1000 idx < nr_entries; \
1001 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
1002
1003 /*
1004 * We need to check if we have a .dynsym, so that we can handle the
1005 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
1006 * .dynsym or .symtab).
1007 * And always look at the original dso, not at debuginfo packages, that
1008 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
1009 */
1010 static int
1011 dso__synthesize_plt_symbols(struct dso *dso, char *name, struct map *map,
1012 symbol_filter_t filter)
1013 {
1014 uint32_t nr_rel_entries, idx;
1015 GElf_Sym sym;
1016 u64 plt_offset;
1017 GElf_Shdr shdr_plt;
1018 struct symbol *f;
1019 GElf_Shdr shdr_rel_plt, shdr_dynsym;
1020 Elf_Data *reldata, *syms, *symstrs;
1021 Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
1022 size_t dynsym_idx;
1023 GElf_Ehdr ehdr;
1024 char sympltname[1024];
1025 Elf *elf;
1026 int nr = 0, symidx, fd, err = 0;
1027
1028 fd = open(name, O_RDONLY);
1029 if (fd < 0)
1030 goto out;
1031
1032 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1033 if (elf == NULL)
1034 goto out_close;
1035
1036 if (gelf_getehdr(elf, &ehdr) == NULL)
1037 goto out_elf_end;
1038
1039 scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
1040 ".dynsym", &dynsym_idx);
1041 if (scn_dynsym == NULL)
1042 goto out_elf_end;
1043
1044 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
1045 ".rela.plt", NULL);
1046 if (scn_plt_rel == NULL) {
1047 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
1048 ".rel.plt", NULL);
1049 if (scn_plt_rel == NULL)
1050 goto out_elf_end;
1051 }
1052
1053 err = -1;
1054
1055 if (shdr_rel_plt.sh_link != dynsym_idx)
1056 goto out_elf_end;
1057
1058 if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
1059 goto out_elf_end;
1060
1061 /*
1062 * Fetch the relocation section to find the idxes to the GOT
1063 * and the symbols in the .dynsym they refer to.
1064 */
1065 reldata = elf_getdata(scn_plt_rel, NULL);
1066 if (reldata == NULL)
1067 goto out_elf_end;
1068
1069 syms = elf_getdata(scn_dynsym, NULL);
1070 if (syms == NULL)
1071 goto out_elf_end;
1072
1073 scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
1074 if (scn_symstrs == NULL)
1075 goto out_elf_end;
1076
1077 symstrs = elf_getdata(scn_symstrs, NULL);
1078 if (symstrs == NULL)
1079 goto out_elf_end;
1080
1081 nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
1082 plt_offset = shdr_plt.sh_offset;
1083
1084 if (shdr_rel_plt.sh_type == SHT_RELA) {
1085 GElf_Rela pos_mem, *pos;
1086
1087 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
1088 nr_rel_entries) {
1089 symidx = GELF_R_SYM(pos->r_info);
1090 plt_offset += shdr_plt.sh_entsize;
1091 gelf_getsym(syms, symidx, &sym);
1092 snprintf(sympltname, sizeof(sympltname),
1093 "%s@plt", elf_sym__name(&sym, symstrs));
1094
1095 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1096 STB_GLOBAL, sympltname);
1097 if (!f)
1098 goto out_elf_end;
1099
1100 if (filter && filter(map, f))
1101 symbol__delete(f);
1102 else {
1103 symbols__insert(&dso->symbols[map->type], f);
1104 ++nr;
1105 }
1106 }
1107 } else if (shdr_rel_plt.sh_type == SHT_REL) {
1108 GElf_Rel pos_mem, *pos;
1109 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
1110 nr_rel_entries) {
1111 symidx = GELF_R_SYM(pos->r_info);
1112 plt_offset += shdr_plt.sh_entsize;
1113 gelf_getsym(syms, symidx, &sym);
1114 snprintf(sympltname, sizeof(sympltname),
1115 "%s@plt", elf_sym__name(&sym, symstrs));
1116
1117 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1118 STB_GLOBAL, sympltname);
1119 if (!f)
1120 goto out_elf_end;
1121
1122 if (filter && filter(map, f))
1123 symbol__delete(f);
1124 else {
1125 symbols__insert(&dso->symbols[map->type], f);
1126 ++nr;
1127 }
1128 }
1129 }
1130
1131 err = 0;
1132 out_elf_end:
1133 elf_end(elf);
1134 out_close:
1135 close(fd);
1136
1137 if (err == 0)
1138 return nr;
1139 out:
1140 pr_debug("%s: problems reading %s PLT info.\n",
1141 __func__, dso->long_name);
1142 return 0;
1143 }
1144
1145 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
1146 {
1147 switch (type) {
1148 case MAP__FUNCTION:
1149 return elf_sym__is_function(sym);
1150 case MAP__VARIABLE:
1151 return elf_sym__is_object(sym);
1152 default:
1153 return false;
1154 }
1155 }
1156
1157 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
1158 enum map_type type)
1159 {
1160 switch (type) {
1161 case MAP__FUNCTION:
1162 return elf_sec__is_text(shdr, secstrs);
1163 case MAP__VARIABLE:
1164 return elf_sec__is_data(shdr, secstrs);
1165 default:
1166 return false;
1167 }
1168 }
1169
1170 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
1171 {
1172 Elf_Scn *sec = NULL;
1173 GElf_Shdr shdr;
1174 size_t cnt = 1;
1175
1176 while ((sec = elf_nextscn(elf, sec)) != NULL) {
1177 gelf_getshdr(sec, &shdr);
1178
1179 if ((addr >= shdr.sh_addr) &&
1180 (addr < (shdr.sh_addr + shdr.sh_size)))
1181 return cnt;
1182
1183 ++cnt;
1184 }
1185
1186 return -1;
1187 }
1188
1189 static int dso__swap_init(struct dso *dso, unsigned char eidata)
1190 {
1191 static unsigned int const endian = 1;
1192
1193 dso->needs_swap = DSO_SWAP__NO;
1194
1195 switch (eidata) {
1196 case ELFDATA2LSB:
1197 /* We are big endian, DSO is little endian. */
1198 if (*(unsigned char const *)&endian != 1)
1199 dso->needs_swap = DSO_SWAP__YES;
1200 break;
1201
1202 case ELFDATA2MSB:
1203 /* We are little endian, DSO is big endian. */
1204 if (*(unsigned char const *)&endian != 0)
1205 dso->needs_swap = DSO_SWAP__YES;
1206 break;
1207
1208 default:
1209 pr_err("unrecognized DSO data encoding %d\n", eidata);
1210 return -EINVAL;
1211 }
1212
1213 return 0;
1214 }
1215
1216 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
1217 int fd, symbol_filter_t filter, int kmodule,
1218 int want_symtab)
1219 {
1220 struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1221 struct map *curr_map = map;
1222 struct dso *curr_dso = dso;
1223 Elf_Data *symstrs, *secstrs;
1224 uint32_t nr_syms;
1225 int err = -1;
1226 uint32_t idx;
1227 GElf_Ehdr ehdr;
1228 GElf_Shdr shdr, opdshdr;
1229 Elf_Data *syms, *opddata = NULL;
1230 GElf_Sym sym;
1231 Elf_Scn *sec, *sec_strndx, *opdsec;
1232 Elf *elf;
1233 int nr = 0;
1234 size_t opdidx = 0;
1235
1236 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1237 if (elf == NULL) {
1238 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1239 goto out_close;
1240 }
1241
1242 if (gelf_getehdr(elf, &ehdr) == NULL) {
1243 pr_debug("%s: cannot get elf header.\n", __func__);
1244 goto out_elf_end;
1245 }
1246
1247 if (dso__swap_init(dso, ehdr.e_ident[EI_DATA]))
1248 goto out_elf_end;
1249
1250 /* Always reject images with a mismatched build-id: */
1251 if (dso->has_build_id) {
1252 u8 build_id[BUILD_ID_SIZE];
1253
1254 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
1255 goto out_elf_end;
1256
1257 if (!dso__build_id_equal(dso, build_id))
1258 goto out_elf_end;
1259 }
1260
1261 sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1262 if (sec == NULL) {
1263 if (want_symtab)
1264 goto out_elf_end;
1265
1266 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1267 if (sec == NULL)
1268 goto out_elf_end;
1269 }
1270
1271 opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1272 if (opdshdr.sh_type != SHT_PROGBITS)
1273 opdsec = NULL;
1274 if (opdsec)
1275 opddata = elf_rawdata(opdsec, NULL);
1276
1277 syms = elf_getdata(sec, NULL);
1278 if (syms == NULL)
1279 goto out_elf_end;
1280
1281 sec = elf_getscn(elf, shdr.sh_link);
1282 if (sec == NULL)
1283 goto out_elf_end;
1284
1285 symstrs = elf_getdata(sec, NULL);
1286 if (symstrs == NULL)
1287 goto out_elf_end;
1288
1289 sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1290 if (sec_strndx == NULL)
1291 goto out_elf_end;
1292
1293 secstrs = elf_getdata(sec_strndx, NULL);
1294 if (secstrs == NULL)
1295 goto out_elf_end;
1296
1297 nr_syms = shdr.sh_size / shdr.sh_entsize;
1298
1299 memset(&sym, 0, sizeof(sym));
1300 if (dso->kernel == DSO_TYPE_USER) {
1301 dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1302 elf_section_by_name(elf, &ehdr, &shdr,
1303 ".gnu.prelink_undo",
1304 NULL) != NULL);
1305 } else {
1306 dso->adjust_symbols = 0;
1307 }
1308 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1309 struct symbol *f;
1310 const char *elf_name = elf_sym__name(&sym, symstrs);
1311 char *demangled = NULL;
1312 int is_label = elf_sym__is_label(&sym);
1313 const char *section_name;
1314
1315 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1316 strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1317 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1318
1319 if (!is_label && !elf_sym__is_a(&sym, map->type))
1320 continue;
1321
1322 /* Reject ARM ELF "mapping symbols": these aren't unique and
1323 * don't identify functions, so will confuse the profile
1324 * output: */
1325 if (ehdr.e_machine == EM_ARM) {
1326 if (!strcmp(elf_name, "$a") ||
1327 !strcmp(elf_name, "$d") ||
1328 !strcmp(elf_name, "$t"))
1329 continue;
1330 }
1331
1332 if (opdsec && sym.st_shndx == opdidx) {
1333 u32 offset = sym.st_value - opdshdr.sh_addr;
1334 u64 *opd = opddata->d_buf + offset;
1335 sym.st_value = DSO__SWAP(dso, u64, *opd);
1336 sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1337 }
1338
1339 sec = elf_getscn(elf, sym.st_shndx);
1340 if (!sec)
1341 goto out_elf_end;
1342
1343 gelf_getshdr(sec, &shdr);
1344
1345 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1346 continue;
1347
1348 section_name = elf_sec__name(&shdr, secstrs);
1349
1350 /* On ARM, symbols for thumb functions have 1 added to
1351 * the symbol address as a flag - remove it */
1352 if ((ehdr.e_machine == EM_ARM) &&
1353 (map->type == MAP__FUNCTION) &&
1354 (sym.st_value & 1))
1355 --sym.st_value;
1356
1357 if (dso->kernel != DSO_TYPE_USER || kmodule) {
1358 char dso_name[PATH_MAX];
1359
1360 if (strcmp(section_name,
1361 (curr_dso->short_name +
1362 dso->short_name_len)) == 0)
1363 goto new_symbol;
1364
1365 if (strcmp(section_name, ".text") == 0) {
1366 curr_map = map;
1367 curr_dso = dso;
1368 goto new_symbol;
1369 }
1370
1371 snprintf(dso_name, sizeof(dso_name),
1372 "%s%s", dso->short_name, section_name);
1373
1374 curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1375 if (curr_map == NULL) {
1376 u64 start = sym.st_value;
1377
1378 if (kmodule)
1379 start += map->start + shdr.sh_offset;
1380
1381 curr_dso = dso__new(dso_name);
1382 if (curr_dso == NULL)
1383 goto out_elf_end;
1384 curr_dso->kernel = dso->kernel;
1385 curr_dso->long_name = dso->long_name;
1386 curr_dso->long_name_len = dso->long_name_len;
1387 curr_map = map__new2(start, curr_dso,
1388 map->type);
1389 if (curr_map == NULL) {
1390 dso__delete(curr_dso);
1391 goto out_elf_end;
1392 }
1393 curr_map->map_ip = identity__map_ip;
1394 curr_map->unmap_ip = identity__map_ip;
1395 curr_dso->symtab_type = dso->symtab_type;
1396 map_groups__insert(kmap->kmaps, curr_map);
1397 dsos__add(&dso->node, curr_dso);
1398 dso__set_loaded(curr_dso, map->type);
1399 } else
1400 curr_dso = curr_map->dso;
1401
1402 goto new_symbol;
1403 }
1404
1405 if (curr_dso->adjust_symbols) {
1406 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1407 "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1408 (u64)sym.st_value, (u64)shdr.sh_addr,
1409 (u64)shdr.sh_offset);
1410 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1411 }
1412 /*
1413 * We need to figure out if the object was created from C++ sources
1414 * DWARF DW_compile_unit has this, but we don't always have access
1415 * to it...
1416 */
1417 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1418 if (demangled != NULL)
1419 elf_name = demangled;
1420 new_symbol:
1421 f = symbol__new(sym.st_value, sym.st_size,
1422 GELF_ST_BIND(sym.st_info), elf_name);
1423 free(demangled);
1424 if (!f)
1425 goto out_elf_end;
1426
1427 if (filter && filter(curr_map, f))
1428 symbol__delete(f);
1429 else {
1430 symbols__insert(&curr_dso->symbols[curr_map->type], f);
1431 nr++;
1432 }
1433 }
1434
1435 /*
1436 * For misannotated, zeroed, ASM function sizes.
1437 */
1438 if (nr > 0) {
1439 symbols__fixup_duplicate(&dso->symbols[map->type]);
1440 symbols__fixup_end(&dso->symbols[map->type]);
1441 if (kmap) {
1442 /*
1443 * We need to fixup this here too because we create new
1444 * maps here, for things like vsyscall sections.
1445 */
1446 __map_groups__fixup_end(kmap->kmaps, map->type);
1447 }
1448 }
1449 err = nr;
1450 out_elf_end:
1451 elf_end(elf);
1452 out_close:
1453 return err;
1454 }
1455
1456 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
1457 {
1458 return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
1459 }
1460
1461 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1462 {
1463 bool have_build_id = false;
1464 struct dso *pos;
1465
1466 list_for_each_entry(pos, head, node) {
1467 if (with_hits && !pos->hit)
1468 continue;
1469 if (pos->has_build_id) {
1470 have_build_id = true;
1471 continue;
1472 }
1473 if (filename__read_build_id(pos->long_name, pos->build_id,
1474 sizeof(pos->build_id)) > 0) {
1475 have_build_id = true;
1476 pos->has_build_id = true;
1477 }
1478 }
1479
1480 return have_build_id;
1481 }
1482
1483 /*
1484 * Align offset to 4 bytes as needed for note name and descriptor data.
1485 */
1486 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1487
1488 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1489 {
1490 int err = -1;
1491 GElf_Ehdr ehdr;
1492 GElf_Shdr shdr;
1493 Elf_Data *data;
1494 Elf_Scn *sec;
1495 Elf_Kind ek;
1496 void *ptr;
1497
1498 if (size < BUILD_ID_SIZE)
1499 goto out;
1500
1501 ek = elf_kind(elf);
1502 if (ek != ELF_K_ELF)
1503 goto out;
1504
1505 if (gelf_getehdr(elf, &ehdr) == NULL) {
1506 pr_err("%s: cannot get elf header.\n", __func__);
1507 goto out;
1508 }
1509
1510 /*
1511 * Check following sections for notes:
1512 * '.note.gnu.build-id'
1513 * '.notes'
1514 * '.note' (VDSO specific)
1515 */
1516 do {
1517 sec = elf_section_by_name(elf, &ehdr, &shdr,
1518 ".note.gnu.build-id", NULL);
1519 if (sec)
1520 break;
1521
1522 sec = elf_section_by_name(elf, &ehdr, &shdr,
1523 ".notes", NULL);
1524 if (sec)
1525 break;
1526
1527 sec = elf_section_by_name(elf, &ehdr, &shdr,
1528 ".note", NULL);
1529 if (sec)
1530 break;
1531
1532 return err;
1533
1534 } while (0);
1535
1536 data = elf_getdata(sec, NULL);
1537 if (data == NULL)
1538 goto out;
1539
1540 ptr = data->d_buf;
1541 while (ptr < (data->d_buf + data->d_size)) {
1542 GElf_Nhdr *nhdr = ptr;
1543 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1544 descsz = NOTE_ALIGN(nhdr->n_descsz);
1545 const char *name;
1546
1547 ptr += sizeof(*nhdr);
1548 name = ptr;
1549 ptr += namesz;
1550 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1551 nhdr->n_namesz == sizeof("GNU")) {
1552 if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1553 size_t sz = min(size, descsz);
1554 memcpy(bf, ptr, sz);
1555 memset(bf + sz, 0, size - sz);
1556 err = descsz;
1557 break;
1558 }
1559 }
1560 ptr += descsz;
1561 }
1562
1563 out:
1564 return err;
1565 }
1566
1567 int filename__read_build_id(const char *filename, void *bf, size_t size)
1568 {
1569 int fd, err = -1;
1570 Elf *elf;
1571
1572 if (size < BUILD_ID_SIZE)
1573 goto out;
1574
1575 fd = open(filename, O_RDONLY);
1576 if (fd < 0)
1577 goto out;
1578
1579 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1580 if (elf == NULL) {
1581 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1582 goto out_close;
1583 }
1584
1585 err = elf_read_build_id(elf, bf, size);
1586
1587 elf_end(elf);
1588 out_close:
1589 close(fd);
1590 out:
1591 return err;
1592 }
1593
1594 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1595 {
1596 int fd, err = -1;
1597
1598 if (size < BUILD_ID_SIZE)
1599 goto out;
1600
1601 fd = open(filename, O_RDONLY);
1602 if (fd < 0)
1603 goto out;
1604
1605 while (1) {
1606 char bf[BUFSIZ];
1607 GElf_Nhdr nhdr;
1608 size_t namesz, descsz;
1609
1610 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1611 break;
1612
1613 namesz = NOTE_ALIGN(nhdr.n_namesz);
1614 descsz = NOTE_ALIGN(nhdr.n_descsz);
1615 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1616 nhdr.n_namesz == sizeof("GNU")) {
1617 if (read(fd, bf, namesz) != (ssize_t)namesz)
1618 break;
1619 if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1620 size_t sz = min(descsz, size);
1621 if (read(fd, build_id, sz) == (ssize_t)sz) {
1622 memset(build_id + sz, 0, size - sz);
1623 err = 0;
1624 break;
1625 }
1626 } else if (read(fd, bf, descsz) != (ssize_t)descsz)
1627 break;
1628 } else {
1629 int n = namesz + descsz;
1630 if (read(fd, bf, n) != n)
1631 break;
1632 }
1633 }
1634 close(fd);
1635 out:
1636 return err;
1637 }
1638
1639 static int filename__read_debuglink(const char *filename,
1640 char *debuglink, size_t size)
1641 {
1642 int fd, err = -1;
1643 Elf *elf;
1644 GElf_Ehdr ehdr;
1645 GElf_Shdr shdr;
1646 Elf_Data *data;
1647 Elf_Scn *sec;
1648 Elf_Kind ek;
1649
1650 fd = open(filename, O_RDONLY);
1651 if (fd < 0)
1652 goto out;
1653
1654 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1655 if (elf == NULL) {
1656 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1657 goto out_close;
1658 }
1659
1660 ek = elf_kind(elf);
1661 if (ek != ELF_K_ELF)
1662 goto out_close;
1663
1664 if (gelf_getehdr(elf, &ehdr) == NULL) {
1665 pr_err("%s: cannot get elf header.\n", __func__);
1666 goto out_close;
1667 }
1668
1669 sec = elf_section_by_name(elf, &ehdr, &shdr,
1670 ".gnu_debuglink", NULL);
1671 if (sec == NULL)
1672 goto out_close;
1673
1674 data = elf_getdata(sec, NULL);
1675 if (data == NULL)
1676 goto out_close;
1677
1678 /* the start of this section is a zero-terminated string */
1679 strncpy(debuglink, data->d_buf, size);
1680
1681 elf_end(elf);
1682
1683 out_close:
1684 close(fd);
1685 out:
1686 return err;
1687 }
1688
1689 char dso__symtab_origin(const struct dso *dso)
1690 {
1691 static const char origin[] = {
1692 [DSO_BINARY_TYPE__KALLSYMS] = 'k',
1693 [DSO_BINARY_TYPE__JAVA_JIT] = 'j',
1694 [DSO_BINARY_TYPE__DEBUGLINK] = 'l',
1695 [DSO_BINARY_TYPE__BUILD_ID_CACHE] = 'B',
1696 [DSO_BINARY_TYPE__FEDORA_DEBUGINFO] = 'f',
1697 [DSO_BINARY_TYPE__UBUNTU_DEBUGINFO] = 'u',
1698 [DSO_BINARY_TYPE__BUILDID_DEBUGINFO] = 'b',
1699 [DSO_BINARY_TYPE__SYSTEM_PATH_DSO] = 'd',
1700 [DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE] = 'K',
1701 [DSO_BINARY_TYPE__GUEST_KALLSYMS] = 'g',
1702 [DSO_BINARY_TYPE__GUEST_KMODULE] = 'G',
1703 };
1704
1705 if (dso == NULL || dso->symtab_type == DSO_BINARY_TYPE__NOT_FOUND)
1706 return '!';
1707 return origin[dso->symtab_type];
1708 }
1709
1710 int dso__binary_type_file(struct dso *dso, enum dso_binary_type type,
1711 char *root_dir, char *file, size_t size)
1712 {
1713 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1714 int ret = 0;
1715
1716 switch (type) {
1717 case DSO_BINARY_TYPE__DEBUGLINK: {
1718 char *debuglink;
1719
1720 strncpy(file, dso->long_name, size);
1721 debuglink = file + dso->long_name_len;
1722 while (debuglink != file && *debuglink != '/')
1723 debuglink--;
1724 if (*debuglink == '/')
1725 debuglink++;
1726 filename__read_debuglink(dso->long_name, debuglink,
1727 size - (debuglink - file));
1728 }
1729 break;
1730 case DSO_BINARY_TYPE__BUILD_ID_CACHE:
1731 /* skip the locally configured cache if a symfs is given */
1732 if (symbol_conf.symfs[0] ||
1733 (dso__build_id_filename(dso, file, size) == NULL))
1734 ret = -1;
1735 break;
1736
1737 case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
1738 snprintf(file, size, "%s/usr/lib/debug%s.debug",
1739 symbol_conf.symfs, dso->long_name);
1740 break;
1741
1742 case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
1743 snprintf(file, size, "%s/usr/lib/debug%s",
1744 symbol_conf.symfs, dso->long_name);
1745 break;
1746
1747 case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
1748 if (!dso->has_build_id) {
1749 ret = -1;
1750 break;
1751 }
1752
1753 build_id__sprintf(dso->build_id,
1754 sizeof(dso->build_id),
1755 build_id_hex);
1756 snprintf(file, size,
1757 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1758 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1759 break;
1760
1761 case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
1762 snprintf(file, size, "%s%s",
1763 symbol_conf.symfs, dso->long_name);
1764 break;
1765
1766 case DSO_BINARY_TYPE__GUEST_KMODULE:
1767 snprintf(file, size, "%s%s%s", symbol_conf.symfs,
1768 root_dir, dso->long_name);
1769 break;
1770
1771 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
1772 snprintf(file, size, "%s%s", symbol_conf.symfs,
1773 dso->long_name);
1774 break;
1775
1776 default:
1777 case DSO_BINARY_TYPE__KALLSYMS:
1778 case DSO_BINARY_TYPE__GUEST_KALLSYMS:
1779 case DSO_BINARY_TYPE__JAVA_JIT:
1780 case DSO_BINARY_TYPE__NOT_FOUND:
1781 ret = -1;
1782 break;
1783 }
1784
1785 return ret;
1786 }
1787
1788 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1789 {
1790 char *name;
1791 int ret = -1;
1792 int fd;
1793 u_int i;
1794 struct machine *machine;
1795 char *root_dir = (char *) "";
1796 int want_symtab;
1797
1798 dso__set_loaded(dso, map->type);
1799
1800 if (dso->kernel == DSO_TYPE_KERNEL)
1801 return dso__load_kernel_sym(dso, map, filter);
1802 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1803 return dso__load_guest_kernel_sym(dso, map, filter);
1804
1805 if (map->groups && map->groups->machine)
1806 machine = map->groups->machine;
1807 else
1808 machine = NULL;
1809
1810 name = malloc(PATH_MAX);
1811 if (!name)
1812 return -1;
1813
1814 dso->adjust_symbols = 0;
1815
1816 if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1817 struct stat st;
1818
1819 if (lstat(dso->name, &st) < 0)
1820 return -1;
1821
1822 if (st.st_uid && (st.st_uid != geteuid())) {
1823 pr_warning("File %s not owned by current user or root, "
1824 "ignoring it.\n", dso->name);
1825 return -1;
1826 }
1827
1828 ret = dso__load_perf_map(dso, map, filter);
1829 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
1830 DSO_BINARY_TYPE__NOT_FOUND;
1831 return ret;
1832 }
1833
1834 if (machine)
1835 root_dir = machine->root_dir;
1836
1837 /* Iterate over candidate debug images.
1838 * On the first pass, only load images if they have a full symtab.
1839 * Failing that, do a second pass where we accept .dynsym also
1840 */
1841 want_symtab = 1;
1842 restart:
1843 for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
1844
1845 dso->symtab_type = binary_type_symtab[i];
1846
1847 if (dso__binary_type_file(dso, dso->symtab_type,
1848 root_dir, name, PATH_MAX))
1849 continue;
1850
1851 /* Name is now the name of the next image to try */
1852 fd = open(name, O_RDONLY);
1853 if (fd < 0)
1854 continue;
1855
1856 ret = dso__load_sym(dso, map, name, fd, filter, 0,
1857 want_symtab);
1858 close(fd);
1859
1860 /*
1861 * Some people seem to have debuginfo files _WITHOUT_ debug
1862 * info!?!?
1863 */
1864 if (!ret)
1865 continue;
1866
1867 if (ret > 0) {
1868 int nr_plt;
1869
1870 nr_plt = dso__synthesize_plt_symbols(dso, name, map, filter);
1871 if (nr_plt > 0)
1872 ret += nr_plt;
1873 break;
1874 }
1875 }
1876
1877 /*
1878 * If we wanted a full symtab but no image had one,
1879 * relax our requirements and repeat the search.
1880 */
1881 if (ret <= 0 && want_symtab) {
1882 want_symtab = 0;
1883 goto restart;
1884 }
1885
1886 free(name);
1887 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1888 return 0;
1889 return ret;
1890 }
1891
1892 struct map *map_groups__find_by_name(struct map_groups *mg,
1893 enum map_type type, const char *name)
1894 {
1895 struct rb_node *nd;
1896
1897 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1898 struct map *map = rb_entry(nd, struct map, rb_node);
1899
1900 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1901 return map;
1902 }
1903
1904 return NULL;
1905 }
1906
1907 static int dso__kernel_module_get_build_id(struct dso *dso,
1908 const char *root_dir)
1909 {
1910 char filename[PATH_MAX];
1911 /*
1912 * kernel module short names are of the form "[module]" and
1913 * we need just "module" here.
1914 */
1915 const char *name = dso->short_name + 1;
1916
1917 snprintf(filename, sizeof(filename),
1918 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1919 root_dir, (int)strlen(name) - 1, name);
1920
1921 if (sysfs__read_build_id(filename, dso->build_id,
1922 sizeof(dso->build_id)) == 0)
1923 dso->has_build_id = true;
1924
1925 return 0;
1926 }
1927
1928 static int map_groups__set_modules_path_dir(struct map_groups *mg,
1929 const char *dir_name)
1930 {
1931 struct dirent *dent;
1932 DIR *dir = opendir(dir_name);
1933 int ret = 0;
1934
1935 if (!dir) {
1936 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1937 return -1;
1938 }
1939
1940 while ((dent = readdir(dir)) != NULL) {
1941 char path[PATH_MAX];
1942 struct stat st;
1943
1944 /*sshfs might return bad dent->d_type, so we have to stat*/
1945 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
1946 if (stat(path, &st))
1947 continue;
1948
1949 if (S_ISDIR(st.st_mode)) {
1950 if (!strcmp(dent->d_name, ".") ||
1951 !strcmp(dent->d_name, ".."))
1952 continue;
1953
1954 ret = map_groups__set_modules_path_dir(mg, path);
1955 if (ret < 0)
1956 goto out;
1957 } else {
1958 char *dot = strrchr(dent->d_name, '.'),
1959 dso_name[PATH_MAX];
1960 struct map *map;
1961 char *long_name;
1962
1963 if (dot == NULL || strcmp(dot, ".ko"))
1964 continue;
1965 snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1966 (int)(dot - dent->d_name), dent->d_name);
1967
1968 strxfrchar(dso_name, '-', '_');
1969 map = map_groups__find_by_name(mg, MAP__FUNCTION,
1970 dso_name);
1971 if (map == NULL)
1972 continue;
1973
1974 long_name = strdup(path);
1975 if (long_name == NULL) {
1976 ret = -1;
1977 goto out;
1978 }
1979 dso__set_long_name(map->dso, long_name);
1980 map->dso->lname_alloc = 1;
1981 dso__kernel_module_get_build_id(map->dso, "");
1982 }
1983 }
1984
1985 out:
1986 closedir(dir);
1987 return ret;
1988 }
1989
1990 static char *get_kernel_version(const char *root_dir)
1991 {
1992 char version[PATH_MAX];
1993 FILE *file;
1994 char *name, *tmp;
1995 const char *prefix = "Linux version ";
1996
1997 sprintf(version, "%s/proc/version", root_dir);
1998 file = fopen(version, "r");
1999 if (!file)
2000 return NULL;
2001
2002 version[0] = '\0';
2003 tmp = fgets(version, sizeof(version), file);
2004 fclose(file);
2005
2006 name = strstr(version, prefix);
2007 if (!name)
2008 return NULL;
2009 name += strlen(prefix);
2010 tmp = strchr(name, ' ');
2011 if (tmp)
2012 *tmp = '\0';
2013
2014 return strdup(name);
2015 }
2016
2017 static int machine__set_modules_path(struct machine *machine)
2018 {
2019 char *version;
2020 char modules_path[PATH_MAX];
2021
2022 version = get_kernel_version(machine->root_dir);
2023 if (!version)
2024 return -1;
2025
2026 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
2027 machine->root_dir, version);
2028 free(version);
2029
2030 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
2031 }
2032
2033 /*
2034 * Constructor variant for modules (where we know from /proc/modules where
2035 * they are loaded) and for vmlinux, where only after we load all the
2036 * symbols we'll know where it starts and ends.
2037 */
2038 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
2039 {
2040 struct map *map = calloc(1, (sizeof(*map) +
2041 (dso->kernel ? sizeof(struct kmap) : 0)));
2042 if (map != NULL) {
2043 /*
2044 * ->end will be filled after we load all the symbols
2045 */
2046 map__init(map, type, start, 0, 0, dso);
2047 }
2048
2049 return map;
2050 }
2051
2052 struct map *machine__new_module(struct machine *machine, u64 start,
2053 const char *filename)
2054 {
2055 struct map *map;
2056 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
2057
2058 if (dso == NULL)
2059 return NULL;
2060
2061 map = map__new2(start, dso, MAP__FUNCTION);
2062 if (map == NULL)
2063 return NULL;
2064
2065 if (machine__is_host(machine))
2066 dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
2067 else
2068 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
2069 map_groups__insert(&machine->kmaps, map);
2070 return map;
2071 }
2072
2073 static int machine__create_modules(struct machine *machine)
2074 {
2075 char *line = NULL;
2076 size_t n;
2077 FILE *file;
2078 struct map *map;
2079 const char *modules;
2080 char path[PATH_MAX];
2081
2082 if (machine__is_default_guest(machine))
2083 modules = symbol_conf.default_guest_modules;
2084 else {
2085 sprintf(path, "%s/proc/modules", machine->root_dir);
2086 modules = path;
2087 }
2088
2089 if (symbol__restricted_filename(path, "/proc/modules"))
2090 return -1;
2091
2092 file = fopen(modules, "r");
2093 if (file == NULL)
2094 return -1;
2095
2096 while (!feof(file)) {
2097 char name[PATH_MAX];
2098 u64 start;
2099 char *sep;
2100 int line_len;
2101
2102 line_len = getline(&line, &n, file);
2103 if (line_len < 0)
2104 break;
2105
2106 if (!line)
2107 goto out_failure;
2108
2109 line[--line_len] = '\0'; /* \n */
2110
2111 sep = strrchr(line, 'x');
2112 if (sep == NULL)
2113 continue;
2114
2115 hex2u64(sep + 1, &start);
2116
2117 sep = strchr(line, ' ');
2118 if (sep == NULL)
2119 continue;
2120
2121 *sep = '\0';
2122
2123 snprintf(name, sizeof(name), "[%s]", line);
2124 map = machine__new_module(machine, start, name);
2125 if (map == NULL)
2126 goto out_delete_line;
2127 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
2128 }
2129
2130 free(line);
2131 fclose(file);
2132
2133 return machine__set_modules_path(machine);
2134
2135 out_delete_line:
2136 free(line);
2137 out_failure:
2138 return -1;
2139 }
2140
2141 int dso__load_vmlinux(struct dso *dso, struct map *map,
2142 const char *vmlinux, symbol_filter_t filter)
2143 {
2144 int err = -1, fd;
2145 char symfs_vmlinux[PATH_MAX];
2146
2147 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
2148 symbol_conf.symfs, vmlinux);
2149 fd = open(symfs_vmlinux, O_RDONLY);
2150 if (fd < 0)
2151 return -1;
2152
2153 dso__set_long_name(dso, (char *)vmlinux);
2154 dso__set_loaded(dso, map->type);
2155 err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
2156 close(fd);
2157
2158 if (err > 0)
2159 pr_debug("Using %s for symbols\n", symfs_vmlinux);
2160
2161 return err;
2162 }
2163
2164 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
2165 symbol_filter_t filter)
2166 {
2167 int i, err = 0;
2168 char *filename;
2169
2170 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
2171 vmlinux_path__nr_entries + 1);
2172
2173 filename = dso__build_id_filename(dso, NULL, 0);
2174 if (filename != NULL) {
2175 err = dso__load_vmlinux(dso, map, filename, filter);
2176 if (err > 0) {
2177 dso__set_long_name(dso, filename);
2178 goto out;
2179 }
2180 free(filename);
2181 }
2182
2183 for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2184 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2185 if (err > 0) {
2186 dso__set_long_name(dso, strdup(vmlinux_path[i]));
2187 break;
2188 }
2189 }
2190 out:
2191 return err;
2192 }
2193
2194 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2195 symbol_filter_t filter)
2196 {
2197 int err;
2198 const char *kallsyms_filename = NULL;
2199 char *kallsyms_allocated_filename = NULL;
2200 /*
2201 * Step 1: if the user specified a kallsyms or vmlinux filename, use
2202 * it and only it, reporting errors to the user if it cannot be used.
2203 *
2204 * For instance, try to analyse an ARM perf.data file _without_ a
2205 * build-id, or if the user specifies the wrong path to the right
2206 * vmlinux file, obviously we can't fallback to another vmlinux (a
2207 * x86_86 one, on the machine where analysis is being performed, say),
2208 * or worse, /proc/kallsyms.
2209 *
2210 * If the specified file _has_ a build-id and there is a build-id
2211 * section in the perf.data file, we will still do the expected
2212 * validation in dso__load_vmlinux and will bail out if they don't
2213 * match.
2214 */
2215 if (symbol_conf.kallsyms_name != NULL) {
2216 kallsyms_filename = symbol_conf.kallsyms_name;
2217 goto do_kallsyms;
2218 }
2219
2220 if (symbol_conf.vmlinux_name != NULL) {
2221 err = dso__load_vmlinux(dso, map,
2222 symbol_conf.vmlinux_name, filter);
2223 if (err > 0) {
2224 dso__set_long_name(dso,
2225 strdup(symbol_conf.vmlinux_name));
2226 goto out_fixup;
2227 }
2228 return err;
2229 }
2230
2231 if (vmlinux_path != NULL) {
2232 err = dso__load_vmlinux_path(dso, map, filter);
2233 if (err > 0)
2234 goto out_fixup;
2235 }
2236
2237 /* do not try local files if a symfs was given */
2238 if (symbol_conf.symfs[0] != 0)
2239 return -1;
2240
2241 /*
2242 * Say the kernel DSO was created when processing the build-id header table,
2243 * we have a build-id, so check if it is the same as the running kernel,
2244 * using it if it is.
2245 */
2246 if (dso->has_build_id) {
2247 u8 kallsyms_build_id[BUILD_ID_SIZE];
2248 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2249
2250 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2251 sizeof(kallsyms_build_id)) == 0) {
2252 if (dso__build_id_equal(dso, kallsyms_build_id)) {
2253 kallsyms_filename = "/proc/kallsyms";
2254 goto do_kallsyms;
2255 }
2256 }
2257 /*
2258 * Now look if we have it on the build-id cache in
2259 * $HOME/.debug/[kernel.kallsyms].
2260 */
2261 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2262 sbuild_id);
2263
2264 if (asprintf(&kallsyms_allocated_filename,
2265 "%s/.debug/[kernel.kallsyms]/%s",
2266 getenv("HOME"), sbuild_id) == -1) {
2267 pr_err("Not enough memory for kallsyms file lookup\n");
2268 return -1;
2269 }
2270
2271 kallsyms_filename = kallsyms_allocated_filename;
2272
2273 if (access(kallsyms_filename, F_OK)) {
2274 pr_err("No kallsyms or vmlinux with build-id %s "
2275 "was found\n", sbuild_id);
2276 free(kallsyms_allocated_filename);
2277 return -1;
2278 }
2279 } else {
2280 /*
2281 * Last resort, if we don't have a build-id and couldn't find
2282 * any vmlinux file, try the running kernel kallsyms table.
2283 */
2284 kallsyms_filename = "/proc/kallsyms";
2285 }
2286
2287 do_kallsyms:
2288 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2289 if (err > 0)
2290 pr_debug("Using %s for symbols\n", kallsyms_filename);
2291 free(kallsyms_allocated_filename);
2292
2293 if (err > 0) {
2294 out_fixup:
2295 if (kallsyms_filename != NULL)
2296 dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2297 map__fixup_start(map);
2298 map__fixup_end(map);
2299 }
2300
2301 return err;
2302 }
2303
2304 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2305 symbol_filter_t filter)
2306 {
2307 int err;
2308 const char *kallsyms_filename = NULL;
2309 struct machine *machine;
2310 char path[PATH_MAX];
2311
2312 if (!map->groups) {
2313 pr_debug("Guest kernel map hasn't the point to groups\n");
2314 return -1;
2315 }
2316 machine = map->groups->machine;
2317
2318 if (machine__is_default_guest(machine)) {
2319 /*
2320 * if the user specified a vmlinux filename, use it and only
2321 * it, reporting errors to the user if it cannot be used.
2322 * Or use file guest_kallsyms inputted by user on commandline
2323 */
2324 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2325 err = dso__load_vmlinux(dso, map,
2326 symbol_conf.default_guest_vmlinux_name, filter);
2327 goto out_try_fixup;
2328 }
2329
2330 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2331 if (!kallsyms_filename)
2332 return -1;
2333 } else {
2334 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2335 kallsyms_filename = path;
2336 }
2337
2338 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2339 if (err > 0)
2340 pr_debug("Using %s for symbols\n", kallsyms_filename);
2341
2342 out_try_fixup:
2343 if (err > 0) {
2344 if (kallsyms_filename != NULL) {
2345 machine__mmap_name(machine, path, sizeof(path));
2346 dso__set_long_name(dso, strdup(path));
2347 }
2348 map__fixup_start(map);
2349 map__fixup_end(map);
2350 }
2351
2352 return err;
2353 }
2354
2355 static void dsos__add(struct list_head *head, struct dso *dso)
2356 {
2357 list_add_tail(&dso->node, head);
2358 }
2359
2360 static struct dso *dsos__find(struct list_head *head, const char *name)
2361 {
2362 struct dso *pos;
2363
2364 list_for_each_entry(pos, head, node)
2365 if (strcmp(pos->long_name, name) == 0)
2366 return pos;
2367 return NULL;
2368 }
2369
2370 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2371 {
2372 struct dso *dso = dsos__find(head, name);
2373
2374 if (!dso) {
2375 dso = dso__new(name);
2376 if (dso != NULL) {
2377 dsos__add(head, dso);
2378 dso__set_basename(dso);
2379 }
2380 }
2381
2382 return dso;
2383 }
2384
2385 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2386 {
2387 struct dso *pos;
2388 size_t ret = 0;
2389
2390 list_for_each_entry(pos, head, node) {
2391 int i;
2392 for (i = 0; i < MAP__NR_TYPES; ++i)
2393 ret += dso__fprintf(pos, i, fp);
2394 }
2395
2396 return ret;
2397 }
2398
2399 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2400 {
2401 struct rb_node *nd;
2402 size_t ret = 0;
2403
2404 for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2405 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2406 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2407 ret += __dsos__fprintf(&pos->user_dsos, fp);
2408 }
2409
2410 return ret;
2411 }
2412
2413 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2414 bool with_hits)
2415 {
2416 struct dso *pos;
2417 size_t ret = 0;
2418
2419 list_for_each_entry(pos, head, node) {
2420 if (with_hits && !pos->hit)
2421 continue;
2422 ret += dso__fprintf_buildid(pos, fp);
2423 ret += fprintf(fp, " %s\n", pos->long_name);
2424 }
2425 return ret;
2426 }
2427
2428 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2429 bool with_hits)
2430 {
2431 return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2432 __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2433 }
2434
2435 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2436 FILE *fp, bool with_hits)
2437 {
2438 struct rb_node *nd;
2439 size_t ret = 0;
2440
2441 for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2442 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2443 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2444 }
2445 return ret;
2446 }
2447
2448 static struct dso*
2449 dso__kernel_findnew(struct machine *machine, const char *name,
2450 const char *short_name, int dso_type)
2451 {
2452 /*
2453 * The kernel dso could be created by build_id processing.
2454 */
2455 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2456
2457 /*
2458 * We need to run this in all cases, since during the build_id
2459 * processing we had no idea this was the kernel dso.
2460 */
2461 if (dso != NULL) {
2462 dso__set_short_name(dso, short_name);
2463 dso->kernel = dso_type;
2464 }
2465
2466 return dso;
2467 }
2468
2469 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2470 {
2471 char path[PATH_MAX];
2472
2473 if (machine__is_default_guest(machine))
2474 return;
2475 sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2476 if (sysfs__read_build_id(path, dso->build_id,
2477 sizeof(dso->build_id)) == 0)
2478 dso->has_build_id = true;
2479 }
2480
2481 static struct dso *machine__get_kernel(struct machine *machine)
2482 {
2483 const char *vmlinux_name = NULL;
2484 struct dso *kernel;
2485
2486 if (machine__is_host(machine)) {
2487 vmlinux_name = symbol_conf.vmlinux_name;
2488 if (!vmlinux_name)
2489 vmlinux_name = "[kernel.kallsyms]";
2490
2491 kernel = dso__kernel_findnew(machine, vmlinux_name,
2492 "[kernel]",
2493 DSO_TYPE_KERNEL);
2494 } else {
2495 char bf[PATH_MAX];
2496
2497 if (machine__is_default_guest(machine))
2498 vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2499 if (!vmlinux_name)
2500 vmlinux_name = machine__mmap_name(machine, bf,
2501 sizeof(bf));
2502
2503 kernel = dso__kernel_findnew(machine, vmlinux_name,
2504 "[guest.kernel]",
2505 DSO_TYPE_GUEST_KERNEL);
2506 }
2507
2508 if (kernel != NULL && (!kernel->has_build_id))
2509 dso__read_running_kernel_build_id(kernel, machine);
2510
2511 return kernel;
2512 }
2513
2514 struct process_args {
2515 u64 start;
2516 };
2517
2518 static int symbol__in_kernel(void *arg, const char *name,
2519 char type __used, u64 start, u64 end __used)
2520 {
2521 struct process_args *args = arg;
2522
2523 if (strchr(name, '['))
2524 return 0;
2525
2526 args->start = start;
2527 return 1;
2528 }
2529
2530 /* Figure out the start address of kernel map from /proc/kallsyms */
2531 static u64 machine__get_kernel_start_addr(struct machine *machine)
2532 {
2533 const char *filename;
2534 char path[PATH_MAX];
2535 struct process_args args;
2536
2537 if (machine__is_host(machine)) {
2538 filename = "/proc/kallsyms";
2539 } else {
2540 if (machine__is_default_guest(machine))
2541 filename = (char *)symbol_conf.default_guest_kallsyms;
2542 else {
2543 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2544 filename = path;
2545 }
2546 }
2547
2548 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2549 return 0;
2550
2551 if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2552 return 0;
2553
2554 return args.start;
2555 }
2556
2557 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
2558 {
2559 enum map_type type;
2560 u64 start = machine__get_kernel_start_addr(machine);
2561
2562 for (type = 0; type < MAP__NR_TYPES; ++type) {
2563 struct kmap *kmap;
2564
2565 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2566 if (machine->vmlinux_maps[type] == NULL)
2567 return -1;
2568
2569 machine->vmlinux_maps[type]->map_ip =
2570 machine->vmlinux_maps[type]->unmap_ip =
2571 identity__map_ip;
2572 kmap = map__kmap(machine->vmlinux_maps[type]);
2573 kmap->kmaps = &machine->kmaps;
2574 map_groups__insert(&machine->kmaps,
2575 machine->vmlinux_maps[type]);
2576 }
2577
2578 return 0;
2579 }
2580
2581 void machine__destroy_kernel_maps(struct machine *machine)
2582 {
2583 enum map_type type;
2584
2585 for (type = 0; type < MAP__NR_TYPES; ++type) {
2586 struct kmap *kmap;
2587
2588 if (machine->vmlinux_maps[type] == NULL)
2589 continue;
2590
2591 kmap = map__kmap(machine->vmlinux_maps[type]);
2592 map_groups__remove(&machine->kmaps,
2593 machine->vmlinux_maps[type]);
2594 if (kmap->ref_reloc_sym) {
2595 /*
2596 * ref_reloc_sym is shared among all maps, so free just
2597 * on one of them.
2598 */
2599 if (type == MAP__FUNCTION) {
2600 free((char *)kmap->ref_reloc_sym->name);
2601 kmap->ref_reloc_sym->name = NULL;
2602 free(kmap->ref_reloc_sym);
2603 }
2604 kmap->ref_reloc_sym = NULL;
2605 }
2606
2607 map__delete(machine->vmlinux_maps[type]);
2608 machine->vmlinux_maps[type] = NULL;
2609 }
2610 }
2611
2612 int machine__create_kernel_maps(struct machine *machine)
2613 {
2614 struct dso *kernel = machine__get_kernel(machine);
2615
2616 if (kernel == NULL ||
2617 __machine__create_kernel_maps(machine, kernel) < 0)
2618 return -1;
2619
2620 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
2621 if (machine__is_host(machine))
2622 pr_debug("Problems creating module maps, "
2623 "continuing anyway...\n");
2624 else
2625 pr_debug("Problems creating module maps for guest %d, "
2626 "continuing anyway...\n", machine->pid);
2627 }
2628
2629 /*
2630 * Now that we have all the maps created, just set the ->end of them:
2631 */
2632 map_groups__fixup_end(&machine->kmaps);
2633 return 0;
2634 }
2635
2636 static void vmlinux_path__exit(void)
2637 {
2638 while (--vmlinux_path__nr_entries >= 0) {
2639 free(vmlinux_path[vmlinux_path__nr_entries]);
2640 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2641 }
2642
2643 free(vmlinux_path);
2644 vmlinux_path = NULL;
2645 }
2646
2647 static int vmlinux_path__init(void)
2648 {
2649 struct utsname uts;
2650 char bf[PATH_MAX];
2651
2652 vmlinux_path = malloc(sizeof(char *) * 5);
2653 if (vmlinux_path == NULL)
2654 return -1;
2655
2656 vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2657 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2658 goto out_fail;
2659 ++vmlinux_path__nr_entries;
2660 vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2661 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2662 goto out_fail;
2663 ++vmlinux_path__nr_entries;
2664
2665 /* only try running kernel version if no symfs was given */
2666 if (symbol_conf.symfs[0] != 0)
2667 return 0;
2668
2669 if (uname(&uts) < 0)
2670 return -1;
2671
2672 snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2673 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2674 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2675 goto out_fail;
2676 ++vmlinux_path__nr_entries;
2677 snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2678 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2679 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2680 goto out_fail;
2681 ++vmlinux_path__nr_entries;
2682 snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2683 uts.release);
2684 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2685 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2686 goto out_fail;
2687 ++vmlinux_path__nr_entries;
2688
2689 return 0;
2690
2691 out_fail:
2692 vmlinux_path__exit();
2693 return -1;
2694 }
2695
2696 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2697 {
2698 int i;
2699 size_t printed = 0;
2700 struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2701
2702 if (kdso->has_build_id) {
2703 char filename[PATH_MAX];
2704 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2705 printed += fprintf(fp, "[0] %s\n", filename);
2706 }
2707
2708 for (i = 0; i < vmlinux_path__nr_entries; ++i)
2709 printed += fprintf(fp, "[%d] %s\n",
2710 i + kdso->has_build_id, vmlinux_path[i]);
2711
2712 return printed;
2713 }
2714
2715 static int setup_list(struct strlist **list, const char *list_str,
2716 const char *list_name)
2717 {
2718 if (list_str == NULL)
2719 return 0;
2720
2721 *list = strlist__new(true, list_str);
2722 if (!*list) {
2723 pr_err("problems parsing %s list\n", list_name);
2724 return -1;
2725 }
2726 return 0;
2727 }
2728
2729 static bool symbol__read_kptr_restrict(void)
2730 {
2731 bool value = false;
2732
2733 if (geteuid() != 0) {
2734 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2735 if (fp != NULL) {
2736 char line[8];
2737
2738 if (fgets(line, sizeof(line), fp) != NULL)
2739 value = atoi(line) != 0;
2740
2741 fclose(fp);
2742 }
2743 }
2744
2745 return value;
2746 }
2747
2748 int symbol__init(void)
2749 {
2750 const char *symfs;
2751
2752 if (symbol_conf.initialized)
2753 return 0;
2754
2755 symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2756
2757 elf_version(EV_CURRENT);
2758 if (symbol_conf.sort_by_name)
2759 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2760 sizeof(struct symbol));
2761
2762 if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2763 return -1;
2764
2765 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2766 pr_err("'.' is the only non valid --field-separator argument\n");
2767 return -1;
2768 }
2769
2770 if (setup_list(&symbol_conf.dso_list,
2771 symbol_conf.dso_list_str, "dso") < 0)
2772 return -1;
2773
2774 if (setup_list(&symbol_conf.comm_list,
2775 symbol_conf.comm_list_str, "comm") < 0)
2776 goto out_free_dso_list;
2777
2778 if (setup_list(&symbol_conf.sym_list,
2779 symbol_conf.sym_list_str, "symbol") < 0)
2780 goto out_free_comm_list;
2781
2782 /*
2783 * A path to symbols of "/" is identical to ""
2784 * reset here for simplicity.
2785 */
2786 symfs = realpath(symbol_conf.symfs, NULL);
2787 if (symfs == NULL)
2788 symfs = symbol_conf.symfs;
2789 if (strcmp(symfs, "/") == 0)
2790 symbol_conf.symfs = "";
2791 if (symfs != symbol_conf.symfs)
2792 free((void *)symfs);
2793
2794 symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2795
2796 symbol_conf.initialized = true;
2797 return 0;
2798
2799 out_free_comm_list:
2800 strlist__delete(symbol_conf.comm_list);
2801 out_free_dso_list:
2802 strlist__delete(symbol_conf.dso_list);
2803 return -1;
2804 }
2805
2806 void symbol__exit(void)
2807 {
2808 if (!symbol_conf.initialized)
2809 return;
2810 strlist__delete(symbol_conf.sym_list);
2811 strlist__delete(symbol_conf.dso_list);
2812 strlist__delete(symbol_conf.comm_list);
2813 vmlinux_path__exit();
2814 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2815 symbol_conf.initialized = false;
2816 }
2817
2818 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2819 {
2820 struct machine *machine = machines__findnew(machines, pid);
2821
2822 if (machine == NULL)
2823 return -1;
2824
2825 return machine__create_kernel_maps(machine);
2826 }
2827
2828 static int hex(char ch)
2829 {
2830 if ((ch >= '0') && (ch <= '9'))
2831 return ch - '0';
2832 if ((ch >= 'a') && (ch <= 'f'))
2833 return ch - 'a' + 10;
2834 if ((ch >= 'A') && (ch <= 'F'))
2835 return ch - 'A' + 10;
2836 return -1;
2837 }
2838
2839 /*
2840 * While we find nice hex chars, build a long_val.
2841 * Return number of chars processed.
2842 */
2843 int hex2u64(const char *ptr, u64 *long_val)
2844 {
2845 const char *p = ptr;
2846 *long_val = 0;
2847
2848 while (*p) {
2849 const int hex_val = hex(*p);
2850
2851 if (hex_val < 0)
2852 break;
2853
2854 *long_val = (*long_val << 4) | hex_val;
2855 p++;
2856 }
2857
2858 return p - ptr;
2859 }
2860
2861 char *strxfrchar(char *s, char from, char to)
2862 {
2863 char *p = s;
2864
2865 while ((p = strchr(p, from)) != NULL)
2866 *p++ = to;
2867
2868 return s;
2869 }
2870
2871 int machines__create_guest_kernel_maps(struct rb_root *machines)
2872 {
2873 int ret = 0;
2874 struct dirent **namelist = NULL;
2875 int i, items = 0;
2876 char path[PATH_MAX];
2877 pid_t pid;
2878 char *endp;
2879
2880 if (symbol_conf.default_guest_vmlinux_name ||
2881 symbol_conf.default_guest_modules ||
2882 symbol_conf.default_guest_kallsyms) {
2883 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2884 }
2885
2886 if (symbol_conf.guestmount) {
2887 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2888 if (items <= 0)
2889 return -ENOENT;
2890 for (i = 0; i < items; i++) {
2891 if (!isdigit(namelist[i]->d_name[0])) {
2892 /* Filter out . and .. */
2893 continue;
2894 }
2895 pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10);
2896 if ((*endp != '\0') ||
2897 (endp == namelist[i]->d_name) ||
2898 (errno == ERANGE)) {
2899 pr_debug("invalid directory (%s). Skipping.\n",
2900 namelist[i]->d_name);
2901 continue;
2902 }
2903 sprintf(path, "%s/%s/proc/kallsyms",
2904 symbol_conf.guestmount,
2905 namelist[i]->d_name);
2906 ret = access(path, R_OK);
2907 if (ret) {
2908 pr_debug("Can't access file %s\n", path);
2909 goto failure;
2910 }
2911 machines__create_kernel_maps(machines, pid);
2912 }
2913 failure:
2914 free(namelist);
2915 }
2916
2917 return ret;
2918 }
2919
2920 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2921 {
2922 struct rb_node *next = rb_first(machines);
2923
2924 while (next) {
2925 struct machine *pos = rb_entry(next, struct machine, rb_node);
2926
2927 next = rb_next(&pos->rb_node);
2928 rb_erase(&pos->rb_node, machines);
2929 machine__delete(pos);
2930 }
2931 }
2932
2933 int machine__load_kallsyms(struct machine *machine, const char *filename,
2934 enum map_type type, symbol_filter_t filter)
2935 {
2936 struct map *map = machine->vmlinux_maps[type];
2937 int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2938
2939 if (ret > 0) {
2940 dso__set_loaded(map->dso, type);
2941 /*
2942 * Since /proc/kallsyms will have multiple sessions for the
2943 * kernel, with modules between them, fixup the end of all
2944 * sections.
2945 */
2946 __map_groups__fixup_end(&machine->kmaps, type);
2947 }
2948
2949 return ret;
2950 }
2951
2952 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2953 symbol_filter_t filter)
2954 {
2955 struct map *map = machine->vmlinux_maps[type];
2956 int ret = dso__load_vmlinux_path(map->dso, map, filter);
2957
2958 if (ret > 0) {
2959 dso__set_loaded(map->dso, type);
2960 map__reloc_vmlinux(map);
2961 }
2962
2963 return ret;
2964 }
2965
2966 struct map *dso__new_map(const char *name)
2967 {
2968 struct map *map = NULL;
2969 struct dso *dso = dso__new(name);
2970
2971 if (dso)
2972 map = map__new2(0, dso, MAP__FUNCTION);
2973
2974 return map;
2975 }
2976
2977 static int open_dso(struct dso *dso, struct machine *machine)
2978 {
2979 char *root_dir = (char *) "";
2980 char *name;
2981 int fd;
2982
2983 name = malloc(PATH_MAX);
2984 if (!name)
2985 return -ENOMEM;
2986
2987 if (machine)
2988 root_dir = machine->root_dir;
2989
2990 if (dso__binary_type_file(dso, dso->data_type,
2991 root_dir, name, PATH_MAX)) {
2992 free(name);
2993 return -EINVAL;
2994 }
2995
2996 fd = open(name, O_RDONLY);
2997 free(name);
2998 return fd;
2999 }
3000
3001 int dso__data_fd(struct dso *dso, struct machine *machine)
3002 {
3003 int i = 0;
3004
3005 if (dso->data_type != DSO_BINARY_TYPE__NOT_FOUND)
3006 return open_dso(dso, machine);
3007
3008 do {
3009 int fd;
3010
3011 dso->data_type = binary_type_data[i++];
3012
3013 fd = open_dso(dso, machine);
3014 if (fd >= 0)
3015 return fd;
3016
3017 } while (dso->data_type != DSO_BINARY_TYPE__NOT_FOUND);
3018
3019 return -EINVAL;
3020 }
3021
3022 static void
3023 dso_cache__free(struct rb_root *root)
3024 {
3025 struct rb_node *next = rb_first(root);
3026
3027 while (next) {
3028 struct dso_cache *cache;
3029
3030 cache = rb_entry(next, struct dso_cache, rb_node);
3031 next = rb_next(&cache->rb_node);
3032 rb_erase(&cache->rb_node, root);
3033 free(cache);
3034 }
3035 }
3036
3037 static struct dso_cache*
3038 dso_cache__find(struct rb_root *root, u64 offset)
3039 {
3040 struct rb_node **p = &root->rb_node;
3041 struct rb_node *parent = NULL;
3042 struct dso_cache *cache;
3043
3044 while (*p != NULL) {
3045 u64 end;
3046
3047 parent = *p;
3048 cache = rb_entry(parent, struct dso_cache, rb_node);
3049 end = cache->offset + DSO__DATA_CACHE_SIZE;
3050
3051 if (offset < cache->offset)
3052 p = &(*p)->rb_left;
3053 else if (offset >= end)
3054 p = &(*p)->rb_right;
3055 else
3056 return cache;
3057 }
3058 return NULL;
3059 }
3060
3061 static void
3062 dso_cache__insert(struct rb_root *root, struct dso_cache *new)
3063 {
3064 struct rb_node **p = &root->rb_node;
3065 struct rb_node *parent = NULL;
3066 struct dso_cache *cache;
3067 u64 offset = new->offset;
3068
3069 while (*p != NULL) {
3070 u64 end;
3071
3072 parent = *p;
3073 cache = rb_entry(parent, struct dso_cache, rb_node);
3074 end = cache->offset + DSO__DATA_CACHE_SIZE;
3075
3076 if (offset < cache->offset)
3077 p = &(*p)->rb_left;
3078 else if (offset >= end)
3079 p = &(*p)->rb_right;
3080 }
3081
3082 rb_link_node(&new->rb_node, parent, p);
3083 rb_insert_color(&new->rb_node, root);
3084 }
3085
3086 static ssize_t
3087 dso_cache__memcpy(struct dso_cache *cache, u64 offset,
3088 u8 *data, u64 size)
3089 {
3090 u64 cache_offset = offset - cache->offset;
3091 u64 cache_size = min(cache->size - cache_offset, size);
3092
3093 memcpy(data, cache->data + cache_offset, cache_size);
3094 return cache_size;
3095 }
3096
3097 static ssize_t
3098 dso_cache__read(struct dso *dso, struct machine *machine,
3099 u64 offset, u8 *data, ssize_t size)
3100 {
3101 struct dso_cache *cache;
3102 ssize_t ret;
3103 int fd;
3104
3105 fd = dso__data_fd(dso, machine);
3106 if (fd < 0)
3107 return -1;
3108
3109 do {
3110 u64 cache_offset;
3111
3112 ret = -ENOMEM;
3113
3114 cache = zalloc(sizeof(*cache) + DSO__DATA_CACHE_SIZE);
3115 if (!cache)
3116 break;
3117
3118 cache_offset = offset & DSO__DATA_CACHE_MASK;
3119 ret = -EINVAL;
3120
3121 if (-1 == lseek(fd, cache_offset, SEEK_SET))
3122 break;
3123
3124 ret = read(fd, cache->data, DSO__DATA_CACHE_SIZE);
3125 if (ret <= 0)
3126 break;
3127
3128 cache->offset = cache_offset;
3129 cache->size = ret;
3130 dso_cache__insert(&dso->cache, cache);
3131
3132 ret = dso_cache__memcpy(cache, offset, data, size);
3133
3134 } while (0);
3135
3136 if (ret <= 0)
3137 free(cache);
3138
3139 close(fd);
3140 return ret;
3141 }
3142
3143 static ssize_t dso_cache_read(struct dso *dso, struct machine *machine,
3144 u64 offset, u8 *data, ssize_t size)
3145 {
3146 struct dso_cache *cache;
3147
3148 cache = dso_cache__find(&dso->cache, offset);
3149 if (cache)
3150 return dso_cache__memcpy(cache, offset, data, size);
3151 else
3152 return dso_cache__read(dso, machine, offset, data, size);
3153 }
3154
3155 ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine,
3156 u64 offset, u8 *data, ssize_t size)
3157 {
3158 ssize_t r = 0;
3159 u8 *p = data;
3160
3161 do {
3162 ssize_t ret;
3163
3164 ret = dso_cache_read(dso, machine, offset, p, size);
3165 if (ret < 0)
3166 return ret;
3167
3168 /* Reached EOF, return what we have. */
3169 if (!ret)
3170 break;
3171
3172 BUG_ON(ret > size);
3173
3174 r += ret;
3175 p += ret;
3176 offset += ret;
3177 size -= ret;
3178
3179 } while (size);
3180
3181 return r;
3182 }
3183
3184 ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
3185 struct machine *machine, u64 addr,
3186 u8 *data, ssize_t size)
3187 {
3188 u64 offset = map->map_ip(map, addr);
3189 return dso__data_read_offset(dso, machine, offset, data, size);
3190 }
Linux ARM platform port for MOXA ART SoC