projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf tools: Introduce zalloc() for the common calloc(1, N) case
[deliverable/linux.git] / tools / perf / util / symbol.c
1 #include "util.h"
2 #include "../perf.h"
3 #include "string.h"
4 #include "symbol.h"
5 #include "thread.h"
6
7 #include "debug.h"
8
9 #include <asm/bug.h>
10 #include <libelf.h>
11 #include <gelf.h>
12 #include <elf.h>
13 #include <limits.h>
14 #include <sys/utsname.h>
15
16 #ifndef NT_GNU_BUILD_ID
17 #define NT_GNU_BUILD_ID 3
18 #endif
19
20 enum dso_origin {
21 DSO__ORIG_KERNEL = 0,
22 DSO__ORIG_JAVA_JIT,
23 DSO__ORIG_FEDORA,
24 DSO__ORIG_UBUNTU,
25 DSO__ORIG_BUILDID,
26 DSO__ORIG_DSO,
27 DSO__ORIG_KMODULE,
28 DSO__ORIG_NOT_FOUND,
29 };
30
31 static void dsos__add(struct dso *dso);
32 static struct dso *dsos__find(const char *name);
33 static struct map *map__new2(u64 start, struct dso *dso);
34 static void kernel_maps__insert(struct map *map);
35 static int dso__load_kernel_sym(struct dso *self, struct map *map,
36 symbol_filter_t filter);
37 unsigned int symbol__priv_size;
38 static int vmlinux_path__nr_entries;
39 static char **vmlinux_path;
40
41 static struct symbol_conf symbol_conf__defaults = {
42 .use_modules = true,
43 .try_vmlinux_path = true,
44 };
45
46 static struct rb_root kernel_maps;
47
48 static void dso__fixup_sym_end(struct dso *self)
49 {
50 struct rb_node *nd, *prevnd = rb_first(&self->syms);
51 struct symbol *curr, *prev;
52
53 if (prevnd == NULL)
54 return;
55
56 curr = rb_entry(prevnd, struct symbol, rb_node);
57
58 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
59 prev = curr;
60 curr = rb_entry(nd, struct symbol, rb_node);
61
62 if (prev->end == prev->start)
63 prev->end = curr->start - 1;
64 }
65
66 /* Last entry */
67 if (curr->end == curr->start)
68 curr->end = roundup(curr->start, 4096);
69 }
70
71 static void kernel_maps__fixup_end(void)
72 {
73 struct map *prev, *curr;
74 struct rb_node *nd, *prevnd = rb_first(&kernel_maps);
75
76 if (prevnd == NULL)
77 return;
78
79 curr = rb_entry(prevnd, struct map, rb_node);
80
81 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
82 prev = curr;
83 curr = rb_entry(nd, struct map, rb_node);
84 prev->end = curr->start - 1;
85 }
86
87 /*
88 * We still haven't the actual symbols, so guess the
89 * last map final address.
90 */
91 curr->end = ~0UL;
92 }
93
94 static struct symbol *symbol__new(u64 start, u64 len, const char *name)
95 {
96 size_t namelen = strlen(name) + 1;
97 struct symbol *self = zalloc(symbol__priv_size +
98 sizeof(*self) + namelen);
99 if (self == NULL)
100 return NULL;
101
102 if (symbol__priv_size)
103 self = ((void *)self) + symbol__priv_size;
104
105 self->start = start;
106 self->end = len ? start + len - 1 : start;
107
108 pr_debug3("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
109
110 memcpy(self->name, name, namelen);
111
112 return self;
113 }
114
115 static void symbol__delete(struct symbol *self)
116 {
117 free(((void *)self) - symbol__priv_size);
118 }
119
120 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
121 {
122 return fprintf(fp, " %llx-%llx %s\n",
123 self->start, self->end, self->name);
124 }
125
126 static void dso__set_long_name(struct dso *self, char *name)
127 {
128 if (name == NULL)
129 return;
130 self->long_name = name;
131 self->long_name_len = strlen(name);
132 }
133
134 static void dso__set_basename(struct dso *self)
135 {
136 self->short_name = basename(self->long_name);
137 }
138
139 struct dso *dso__new(const char *name)
140 {
141 struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
142
143 if (self != NULL) {
144 strcpy(self->name, name);
145 dso__set_long_name(self, self->name);
146 self->short_name = self->name;
147 self->syms = RB_ROOT;
148 self->find_symbol = dso__find_symbol;
149 self->slen_calculated = 0;
150 self->origin = DSO__ORIG_NOT_FOUND;
151 self->loaded = 0;
152 self->has_build_id = 0;
153 }
154
155 return self;
156 }
157
158 static void dso__delete_symbols(struct dso *self)
159 {
160 struct symbol *pos;
161 struct rb_node *next = rb_first(&self->syms);
162
163 while (next) {
164 pos = rb_entry(next, struct symbol, rb_node);
165 next = rb_next(&pos->rb_node);
166 rb_erase(&pos->rb_node, &self->syms);
167 symbol__delete(pos);
168 }
169 }
170
171 void dso__delete(struct dso *self)
172 {
173 dso__delete_symbols(self);
174 if (self->long_name != self->name)
175 free(self->long_name);
176 free(self);
177 }
178
179 void dso__set_build_id(struct dso *self, void *build_id)
180 {
181 memcpy(self->build_id, build_id, sizeof(self->build_id));
182 self->has_build_id = 1;
183 }
184
185 static void dso__insert_symbol(struct dso *self, struct symbol *sym)
186 {
187 struct rb_node **p = &self->syms.rb_node;
188 struct rb_node *parent = NULL;
189 const u64 ip = sym->start;
190 struct symbol *s;
191
192 while (*p != NULL) {
193 parent = *p;
194 s = rb_entry(parent, struct symbol, rb_node);
195 if (ip < s->start)
196 p = &(*p)->rb_left;
197 else
198 p = &(*p)->rb_right;
199 }
200 rb_link_node(&sym->rb_node, parent, p);
201 rb_insert_color(&sym->rb_node, &self->syms);
202 }
203
204 struct symbol *dso__find_symbol(struct dso *self, u64 ip)
205 {
206 struct rb_node *n;
207
208 if (self == NULL)
209 return NULL;
210
211 n = self->syms.rb_node;
212
213 while (n) {
214 struct symbol *s = rb_entry(n, struct symbol, rb_node);
215
216 if (ip < s->start)
217 n = n->rb_left;
218 else if (ip > s->end)
219 n = n->rb_right;
220 else
221 return s;
222 }
223
224 return NULL;
225 }
226
227 int build_id__sprintf(u8 *self, int len, char *bf)
228 {
229 char *bid = bf;
230 u8 *raw = self;
231 int i;
232
233 for (i = 0; i < len; ++i) {
234 sprintf(bid, "%02x", *raw);
235 ++raw;
236 bid += 2;
237 }
238
239 return raw - self;
240 }
241
242 size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
243 {
244 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
245
246 build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
247 return fprintf(fp, "%s", sbuild_id);
248 }
249
250 size_t dso__fprintf(struct dso *self, FILE *fp)
251 {
252 struct rb_node *nd;
253 size_t ret = fprintf(fp, "dso: %s (", self->short_name);
254
255 ret += dso__fprintf_buildid(self, fp);
256 ret += fprintf(fp, ")\n");
257
258 for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
259 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
260 ret += symbol__fprintf(pos, fp);
261 }
262
263 return ret;
264 }
265
266 /*
267 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
268 * so that we can in the next step set the symbol ->end address and then
269 * call kernel_maps__split_kallsyms.
270 */
271 static int kernel_maps__load_all_kallsyms(void)
272 {
273 char *line = NULL;
274 size_t n;
275 FILE *file = fopen("/proc/kallsyms", "r");
276
277 if (file == NULL)
278 goto out_failure;
279
280 while (!feof(file)) {
281 u64 start;
282 struct symbol *sym;
283 int line_len, len;
284 char symbol_type;
285 char *symbol_name;
286
287 line_len = getline(&line, &n, file);
288 if (line_len < 0)
289 break;
290
291 if (!line)
292 goto out_failure;
293
294 line[--line_len] = '\0'; /* \n */
295
296 len = hex2u64(line, &start);
297
298 len++;
299 if (len + 2 >= line_len)
300 continue;
301
302 symbol_type = toupper(line[len]);
303 /*
304 * We're interested only in code ('T'ext)
305 */
306 if (symbol_type != 'T' && symbol_type != 'W')
307 continue;
308
309 symbol_name = line + len + 2;
310 /*
311 * Will fix up the end later, when we have all symbols sorted.
312 */
313 sym = symbol__new(start, 0, symbol_name);
314
315 if (sym == NULL)
316 goto out_delete_line;
317
318 /*
319 * We will pass the symbols to the filter later, in
320 * kernel_maps__split_kallsyms, when we have split the
321 * maps per module
322 */
323 dso__insert_symbol(kernel_map->dso, sym);
324 }
325
326 free(line);
327 fclose(file);
328
329 return 0;
330
331 out_delete_line:
332 free(line);
333 out_failure:
334 return -1;
335 }
336
337 /*
338 * Split the symbols into maps, making sure there are no overlaps, i.e. the
339 * kernel range is broken in several maps, named [kernel].N, as we don't have
340 * the original ELF section names vmlinux have.
341 */
342 static int kernel_maps__split_kallsyms(symbol_filter_t filter)
343 {
344 struct map *map = kernel_map;
345 struct symbol *pos;
346 int count = 0;
347 struct rb_node *next = rb_first(&kernel_map->dso->syms);
348 int kernel_range = 0;
349
350 while (next) {
351 char *module;
352
353 pos = rb_entry(next, struct symbol, rb_node);
354 next = rb_next(&pos->rb_node);
355
356 module = strchr(pos->name, '\t');
357 if (module) {
358 *module++ = '\0';
359
360 if (strcmp(map->dso->name, module)) {
361 map = kernel_maps__find_by_dso_name(module);
362 if (!map) {
363 pr_err("/proc/{kallsyms,modules} "
364 "inconsistency!\n");
365 return -1;
366 }
367 }
368 /*
369 * So that we look just like we get from .ko files,
370 * i.e. not prelinked, relative to map->start.
371 */
372 pos->start = map->map_ip(map, pos->start);
373 pos->end = map->map_ip(map, pos->end);
374 } else if (map != kernel_map) {
375 char dso_name[PATH_MAX];
376 struct dso *dso;
377
378 snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
379 kernel_range++);
380
381 dso = dso__new(dso_name);
382 if (dso == NULL)
383 return -1;
384
385 map = map__new2(pos->start, dso);
386 if (map == NULL) {
387 dso__delete(dso);
388 return -1;
389 }
390
391 map->map_ip = map->unmap_ip = identity__map_ip;
392 kernel_maps__insert(map);
393 ++kernel_range;
394 }
395
396 if (filter && filter(map, pos)) {
397 rb_erase(&pos->rb_node, &kernel_map->dso->syms);
398 symbol__delete(pos);
399 } else {
400 if (map != kernel_map) {
401 rb_erase(&pos->rb_node, &kernel_map->dso->syms);
402 dso__insert_symbol(map->dso, pos);
403 }
404 count++;
405 }
406 }
407
408 return count;
409 }
410
411
412 static int kernel_maps__load_kallsyms(symbol_filter_t filter)
413 {
414 if (kernel_maps__load_all_kallsyms())
415 return -1;
416
417 dso__fixup_sym_end(kernel_map->dso);
418 kernel_map->dso->origin = DSO__ORIG_KERNEL;
419
420 return kernel_maps__split_kallsyms(filter);
421 }
422
423 size_t kernel_maps__fprintf(FILE *fp)
424 {
425 size_t printed = fprintf(fp, "Kernel maps:\n");
426 struct rb_node *nd;
427
428 for (nd = rb_first(&kernel_maps); nd; nd = rb_next(nd)) {
429 struct map *pos = rb_entry(nd, struct map, rb_node);
430
431 printed += fprintf(fp, "Map:");
432 printed += map__fprintf(pos, fp);
433 if (verbose > 1) {
434 printed += dso__fprintf(pos->dso, fp);
435 printed += fprintf(fp, "--\n");
436 }
437 }
438
439 return printed + fprintf(fp, "END kernel maps\n");
440 }
441
442 static int dso__load_perf_map(struct dso *self, struct map *map,
443 symbol_filter_t filter)
444 {
445 char *line = NULL;
446 size_t n;
447 FILE *file;
448 int nr_syms = 0;
449
450 file = fopen(self->long_name, "r");
451 if (file == NULL)
452 goto out_failure;
453
454 while (!feof(file)) {
455 u64 start, size;
456 struct symbol *sym;
457 int line_len, len;
458
459 line_len = getline(&line, &n, file);
460 if (line_len < 0)
461 break;
462
463 if (!line)
464 goto out_failure;
465
466 line[--line_len] = '\0'; /* \n */
467
468 len = hex2u64(line, &start);
469
470 len++;
471 if (len + 2 >= line_len)
472 continue;
473
474 len += hex2u64(line + len, &size);
475
476 len++;
477 if (len + 2 >= line_len)
478 continue;
479
480 sym = symbol__new(start, size, line + len);
481
482 if (sym == NULL)
483 goto out_delete_line;
484
485 if (filter && filter(map, sym))
486 symbol__delete(sym);
487 else {
488 dso__insert_symbol(self, sym);
489 nr_syms++;
490 }
491 }
492
493 free(line);
494 fclose(file);
495
496 return nr_syms;
497
498 out_delete_line:
499 free(line);
500 out_failure:
501 return -1;
502 }
503
504 /**
505 * elf_symtab__for_each_symbol - iterate thru all the symbols
506 *
507 * @self: struct elf_symtab instance to iterate
508 * @idx: uint32_t idx
509 * @sym: GElf_Sym iterator
510 */
511 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
512 for (idx = 0, gelf_getsym(syms, idx, &sym);\
513 idx < nr_syms; \
514 idx++, gelf_getsym(syms, idx, &sym))
515
516 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
517 {
518 return GELF_ST_TYPE(sym->st_info);
519 }
520
521 static inline int elf_sym__is_function(const GElf_Sym *sym)
522 {
523 return elf_sym__type(sym) == STT_FUNC &&
524 sym->st_name != 0 &&
525 sym->st_shndx != SHN_UNDEF;
526 }
527
528 static inline int elf_sym__is_label(const GElf_Sym *sym)
529 {
530 return elf_sym__type(sym) == STT_NOTYPE &&
531 sym->st_name != 0 &&
532 sym->st_shndx != SHN_UNDEF &&
533 sym->st_shndx != SHN_ABS;
534 }
535
536 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
537 const Elf_Data *secstrs)
538 {
539 return secstrs->d_buf + shdr->sh_name;
540 }
541
542 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
543 const Elf_Data *secstrs)
544 {
545 return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
546 }
547
548 static inline const char *elf_sym__name(const GElf_Sym *sym,
549 const Elf_Data *symstrs)
550 {
551 return symstrs->d_buf + sym->st_name;
552 }
553
554 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
555 GElf_Shdr *shp, const char *name,
556 size_t *idx)
557 {
558 Elf_Scn *sec = NULL;
559 size_t cnt = 1;
560
561 while ((sec = elf_nextscn(elf, sec)) != NULL) {
562 char *str;
563
564 gelf_getshdr(sec, shp);
565 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
566 if (!strcmp(name, str)) {
567 if (idx)
568 *idx = cnt;
569 break;
570 }
571 ++cnt;
572 }
573
574 return sec;
575 }
576
577 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
578 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
579 idx < nr_entries; \
580 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
581
582 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
583 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
584 idx < nr_entries; \
585 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
586
587 /*
588 * We need to check if we have a .dynsym, so that we can handle the
589 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
590 * .dynsym or .symtab).
591 * And always look at the original dso, not at debuginfo packages, that
592 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
593 */
594 static int dso__synthesize_plt_symbols(struct dso *self, struct map *map,
595 symbol_filter_t filter)
596 {
597 uint32_t nr_rel_entries, idx;
598 GElf_Sym sym;
599 u64 plt_offset;
600 GElf_Shdr shdr_plt;
601 struct symbol *f;
602 GElf_Shdr shdr_rel_plt, shdr_dynsym;
603 Elf_Data *reldata, *syms, *symstrs;
604 Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
605 size_t dynsym_idx;
606 GElf_Ehdr ehdr;
607 char sympltname[1024];
608 Elf *elf;
609 int nr = 0, symidx, fd, err = 0;
610
611 fd = open(self->long_name, O_RDONLY);
612 if (fd < 0)
613 goto out;
614
615 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
616 if (elf == NULL)
617 goto out_close;
618
619 if (gelf_getehdr(elf, &ehdr) == NULL)
620 goto out_elf_end;
621
622 scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
623 ".dynsym", &dynsym_idx);
624 if (scn_dynsym == NULL)
625 goto out_elf_end;
626
627 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
628 ".rela.plt", NULL);
629 if (scn_plt_rel == NULL) {
630 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
631 ".rel.plt", NULL);
632 if (scn_plt_rel == NULL)
633 goto out_elf_end;
634 }
635
636 err = -1;
637
638 if (shdr_rel_plt.sh_link != dynsym_idx)
639 goto out_elf_end;
640
641 if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
642 goto out_elf_end;
643
644 /*
645 * Fetch the relocation section to find the idxes to the GOT
646 * and the symbols in the .dynsym they refer to.
647 */
648 reldata = elf_getdata(scn_plt_rel, NULL);
649 if (reldata == NULL)
650 goto out_elf_end;
651
652 syms = elf_getdata(scn_dynsym, NULL);
653 if (syms == NULL)
654 goto out_elf_end;
655
656 scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
657 if (scn_symstrs == NULL)
658 goto out_elf_end;
659
660 symstrs = elf_getdata(scn_symstrs, NULL);
661 if (symstrs == NULL)
662 goto out_elf_end;
663
664 nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
665 plt_offset = shdr_plt.sh_offset;
666
667 if (shdr_rel_plt.sh_type == SHT_RELA) {
668 GElf_Rela pos_mem, *pos;
669
670 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
671 nr_rel_entries) {
672 symidx = GELF_R_SYM(pos->r_info);
673 plt_offset += shdr_plt.sh_entsize;
674 gelf_getsym(syms, symidx, &sym);
675 snprintf(sympltname, sizeof(sympltname),
676 "%s@plt", elf_sym__name(&sym, symstrs));
677
678 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
679 sympltname);
680 if (!f)
681 goto out_elf_end;
682
683 if (filter && filter(map, f))
684 symbol__delete(f);
685 else {
686 dso__insert_symbol(self, f);
687 ++nr;
688 }
689 }
690 } else if (shdr_rel_plt.sh_type == SHT_REL) {
691 GElf_Rel pos_mem, *pos;
692 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
693 nr_rel_entries) {
694 symidx = GELF_R_SYM(pos->r_info);
695 plt_offset += shdr_plt.sh_entsize;
696 gelf_getsym(syms, symidx, &sym);
697 snprintf(sympltname, sizeof(sympltname),
698 "%s@plt", elf_sym__name(&sym, symstrs));
699
700 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
701 sympltname);
702 if (!f)
703 goto out_elf_end;
704
705 if (filter && filter(map, f))
706 symbol__delete(f);
707 else {
708 dso__insert_symbol(self, f);
709 ++nr;
710 }
711 }
712 }
713
714 err = 0;
715 out_elf_end:
716 elf_end(elf);
717 out_close:
718 close(fd);
719
720 if (err == 0)
721 return nr;
722 out:
723 pr_warning("%s: problems reading %s PLT info.\n",
724 __func__, self->long_name);
725 return 0;
726 }
727
728 static int dso__load_sym(struct dso *self, struct map *map, const char *name,
729 int fd, symbol_filter_t filter, int kernel,
730 int kmodule)
731 {
732 struct map *curr_map = map;
733 struct dso *curr_dso = self;
734 size_t dso_name_len = strlen(self->short_name);
735 Elf_Data *symstrs, *secstrs;
736 uint32_t nr_syms;
737 int err = -1;
738 uint32_t idx;
739 GElf_Ehdr ehdr;
740 GElf_Shdr shdr;
741 Elf_Data *syms;
742 GElf_Sym sym;
743 Elf_Scn *sec, *sec_strndx;
744 Elf *elf;
745 int nr = 0;
746
747 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
748 if (elf == NULL) {
749 pr_err("%s: cannot read %s ELF file.\n", __func__, name);
750 goto out_close;
751 }
752
753 if (gelf_getehdr(elf, &ehdr) == NULL) {
754 pr_err("%s: cannot get elf header.\n", __func__);
755 goto out_elf_end;
756 }
757
758 sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
759 if (sec == NULL) {
760 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
761 if (sec == NULL)
762 goto out_elf_end;
763 }
764
765 syms = elf_getdata(sec, NULL);
766 if (syms == NULL)
767 goto out_elf_end;
768
769 sec = elf_getscn(elf, shdr.sh_link);
770 if (sec == NULL)
771 goto out_elf_end;
772
773 symstrs = elf_getdata(sec, NULL);
774 if (symstrs == NULL)
775 goto out_elf_end;
776
777 sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
778 if (sec_strndx == NULL)
779 goto out_elf_end;
780
781 secstrs = elf_getdata(sec_strndx, NULL);
782 if (secstrs == NULL)
783 goto out_elf_end;
784
785 nr_syms = shdr.sh_size / shdr.sh_entsize;
786
787 memset(&sym, 0, sizeof(sym));
788 if (!kernel) {
789 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
790 elf_section_by_name(elf, &ehdr, &shdr,
791 ".gnu.prelink_undo",
792 NULL) != NULL);
793 } else self->adjust_symbols = 0;
794
795 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
796 struct symbol *f;
797 const char *elf_name;
798 char *demangled = NULL;
799 int is_label = elf_sym__is_label(&sym);
800 const char *section_name;
801
802 if (!is_label && !elf_sym__is_function(&sym))
803 continue;
804
805 sec = elf_getscn(elf, sym.st_shndx);
806 if (!sec)
807 goto out_elf_end;
808
809 gelf_getshdr(sec, &shdr);
810
811 if (is_label && !elf_sec__is_text(&shdr, secstrs))
812 continue;
813
814 elf_name = elf_sym__name(&sym, symstrs);
815 section_name = elf_sec__name(&shdr, secstrs);
816
817 if (kernel || kmodule) {
818 char dso_name[PATH_MAX];
819
820 if (strcmp(section_name,
821 curr_dso->short_name + dso_name_len) == 0)
822 goto new_symbol;
823
824 if (strcmp(section_name, ".text") == 0) {
825 curr_map = map;
826 curr_dso = self;
827 goto new_symbol;
828 }
829
830 snprintf(dso_name, sizeof(dso_name),
831 "%s%s", self->short_name, section_name);
832
833 curr_map = kernel_maps__find_by_dso_name(dso_name);
834 if (curr_map == NULL) {
835 u64 start = sym.st_value;
836
837 if (kmodule)
838 start += map->start + shdr.sh_offset;
839
840 curr_dso = dso__new(dso_name);
841 if (curr_dso == NULL)
842 goto out_elf_end;
843 curr_map = map__new2(start, curr_dso);
844 if (curr_map == NULL) {
845 dso__delete(curr_dso);
846 goto out_elf_end;
847 }
848 curr_map->map_ip = identity__map_ip;
849 curr_map->unmap_ip = identity__map_ip;
850 curr_dso->origin = DSO__ORIG_KERNEL;
851 kernel_maps__insert(curr_map);
852 dsos__add(curr_dso);
853 } else
854 curr_dso = curr_map->dso;
855
856 goto new_symbol;
857 }
858
859 if (curr_dso->adjust_symbols) {
860 pr_debug2("adjusting symbol: st_value: %Lx sh_addr: "
861 "%Lx sh_offset: %Lx\n", (u64)sym.st_value,
862 (u64)shdr.sh_addr, (u64)shdr.sh_offset);
863 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
864 }
865 /*
866 * We need to figure out if the object was created from C++ sources
867 * DWARF DW_compile_unit has this, but we don't always have access
868 * to it...
869 */
870 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
871 if (demangled != NULL)
872 elf_name = demangled;
873 new_symbol:
874 f = symbol__new(sym.st_value, sym.st_size, elf_name);
875 free(demangled);
876 if (!f)
877 goto out_elf_end;
878
879 if (filter && filter(curr_map, f))
880 symbol__delete(f);
881 else {
882 dso__insert_symbol(curr_dso, f);
883 nr++;
884 }
885 }
886
887 /*
888 * For misannotated, zeroed, ASM function sizes.
889 */
890 if (nr > 0)
891 dso__fixup_sym_end(self);
892 err = nr;
893 out_elf_end:
894 elf_end(elf);
895 out_close:
896 return err;
897 }
898
899 static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
900 {
901 return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
902 }
903
904 bool dsos__read_build_ids(void)
905 {
906 bool have_build_id = false;
907 struct dso *pos;
908
909 list_for_each_entry(pos, &dsos, node)
910 if (filename__read_build_id(pos->long_name, pos->build_id,
911 sizeof(pos->build_id)) > 0) {
912 have_build_id = true;
913 pos->has_build_id = true;
914 }
915
916 return have_build_id;
917 }
918
919 /*
920 * Align offset to 4 bytes as needed for note name and descriptor data.
921 */
922 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
923
924 int filename__read_build_id(const char *filename, void *bf, size_t size)
925 {
926 int fd, err = -1;
927 GElf_Ehdr ehdr;
928 GElf_Shdr shdr;
929 Elf_Data *data;
930 Elf_Scn *sec;
931 Elf_Kind ek;
932 void *ptr;
933 Elf *elf;
934
935 if (size < BUILD_ID_SIZE)
936 goto out;
937
938 fd = open(filename, O_RDONLY);
939 if (fd < 0)
940 goto out;
941
942 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
943 if (elf == NULL) {
944 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
945 goto out_close;
946 }
947
948 ek = elf_kind(elf);
949 if (ek != ELF_K_ELF)
950 goto out_elf_end;
951
952 if (gelf_getehdr(elf, &ehdr) == NULL) {
953 pr_err("%s: cannot get elf header.\n", __func__);
954 goto out_elf_end;
955 }
956
957 sec = elf_section_by_name(elf, &ehdr, &shdr,
958 ".note.gnu.build-id", NULL);
959 if (sec == NULL) {
960 sec = elf_section_by_name(elf, &ehdr, &shdr,
961 ".notes", NULL);
962 if (sec == NULL)
963 goto out_elf_end;
964 }
965
966 data = elf_getdata(sec, NULL);
967 if (data == NULL)
968 goto out_elf_end;
969
970 ptr = data->d_buf;
971 while (ptr < (data->d_buf + data->d_size)) {
972 GElf_Nhdr *nhdr = ptr;
973 int namesz = NOTE_ALIGN(nhdr->n_namesz),
974 descsz = NOTE_ALIGN(nhdr->n_descsz);
975 const char *name;
976
977 ptr += sizeof(*nhdr);
978 name = ptr;
979 ptr += namesz;
980 if (nhdr->n_type == NT_GNU_BUILD_ID &&
981 nhdr->n_namesz == sizeof("GNU")) {
982 if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
983 memcpy(bf, ptr, BUILD_ID_SIZE);
984 err = BUILD_ID_SIZE;
985 break;
986 }
987 }
988 ptr += descsz;
989 }
990 out_elf_end:
991 elf_end(elf);
992 out_close:
993 close(fd);
994 out:
995 return err;
996 }
997
998 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
999 {
1000 int fd, err = -1;
1001
1002 if (size < BUILD_ID_SIZE)
1003 goto out;
1004
1005 fd = open(filename, O_RDONLY);
1006 if (fd < 0)
1007 goto out;
1008
1009 while (1) {
1010 char bf[BUFSIZ];
1011 GElf_Nhdr nhdr;
1012 int namesz, descsz;
1013
1014 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1015 break;
1016
1017 namesz = NOTE_ALIGN(nhdr.n_namesz);
1018 descsz = NOTE_ALIGN(nhdr.n_descsz);
1019 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1020 nhdr.n_namesz == sizeof("GNU")) {
1021 if (read(fd, bf, namesz) != namesz)
1022 break;
1023 if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1024 if (read(fd, build_id,
1025 BUILD_ID_SIZE) == BUILD_ID_SIZE) {
1026 err = 0;
1027 break;
1028 }
1029 } else if (read(fd, bf, descsz) != descsz)
1030 break;
1031 } else {
1032 int n = namesz + descsz;
1033 if (read(fd, bf, n) != n)
1034 break;
1035 }
1036 }
1037 close(fd);
1038 out:
1039 return err;
1040 }
1041
1042 char dso__symtab_origin(const struct dso *self)
1043 {
1044 static const char origin[] = {
1045 [DSO__ORIG_KERNEL] = 'k',
1046 [DSO__ORIG_JAVA_JIT] = 'j',
1047 [DSO__ORIG_FEDORA] = 'f',
1048 [DSO__ORIG_UBUNTU] = 'u',
1049 [DSO__ORIG_BUILDID] = 'b',
1050 [DSO__ORIG_DSO] = 'd',
1051 [DSO__ORIG_KMODULE] = 'K',
1052 };
1053
1054 if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
1055 return '!';
1056 return origin[self->origin];
1057 }
1058
1059 int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1060 {
1061 int size = PATH_MAX;
1062 char *name;
1063 u8 build_id[BUILD_ID_SIZE];
1064 int ret = -1;
1065 int fd;
1066
1067 self->loaded = 1;
1068
1069 if (self->kernel)
1070 return dso__load_kernel_sym(self, map, filter);
1071
1072 name = malloc(size);
1073 if (!name)
1074 return -1;
1075
1076 self->adjust_symbols = 0;
1077
1078 if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
1079 ret = dso__load_perf_map(self, map, filter);
1080 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
1081 DSO__ORIG_NOT_FOUND;
1082 return ret;
1083 }
1084
1085 self->origin = DSO__ORIG_FEDORA - 1;
1086
1087 more:
1088 do {
1089 self->origin++;
1090 switch (self->origin) {
1091 case DSO__ORIG_FEDORA:
1092 snprintf(name, size, "/usr/lib/debug%s.debug",
1093 self->long_name);
1094 break;
1095 case DSO__ORIG_UBUNTU:
1096 snprintf(name, size, "/usr/lib/debug%s",
1097 self->long_name);
1098 break;
1099 case DSO__ORIG_BUILDID:
1100 if (filename__read_build_id(self->long_name, build_id,
1101 sizeof(build_id))) {
1102 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1103
1104 build_id__sprintf(build_id, sizeof(build_id),
1105 build_id_hex);
1106 snprintf(name, size,
1107 "/usr/lib/debug/.build-id/%.2s/%s.debug",
1108 build_id_hex, build_id_hex + 2);
1109 if (self->has_build_id)
1110 goto compare_build_id;
1111 break;
1112 }
1113 self->origin++;
1114 /* Fall thru */
1115 case DSO__ORIG_DSO:
1116 snprintf(name, size, "%s", self->long_name);
1117 break;
1118
1119 default:
1120 goto out;
1121 }
1122
1123 if (self->has_build_id) {
1124 if (filename__read_build_id(name, build_id,
1125 sizeof(build_id)) < 0)
1126 goto more;
1127 compare_build_id:
1128 if (!dso__build_id_equal(self, build_id))
1129 goto more;
1130 }
1131
1132 fd = open(name, O_RDONLY);
1133 } while (fd < 0);
1134
1135 ret = dso__load_sym(self, map, name, fd, filter, 0, 0);
1136 close(fd);
1137
1138 /*
1139 * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
1140 */
1141 if (!ret)
1142 goto more;
1143
1144 if (ret > 0) {
1145 int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
1146 if (nr_plt > 0)
1147 ret += nr_plt;
1148 }
1149 out:
1150 free(name);
1151 if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
1152 return 0;
1153 return ret;
1154 }
1155
1156 struct map *kernel_map;
1157
1158 static void kernel_maps__insert(struct map *map)
1159 {
1160 maps__insert(&kernel_maps, map);
1161 }
1162
1163 struct symbol *kernel_maps__find_symbol(u64 ip, struct map **mapp,
1164 symbol_filter_t filter)
1165 {
1166 struct map *map = maps__find(&kernel_maps, ip);
1167
1168 if (mapp)
1169 *mapp = map;
1170
1171 if (map) {
1172 ip = map->map_ip(map, ip);
1173 return map__find_symbol(map, ip, filter);
1174 } else
1175 WARN_ONCE(RB_EMPTY_ROOT(&kernel_maps),
1176 "Empty kernel_maps, was symbol__init() called?\n");
1177
1178 return NULL;
1179 }
1180
1181 struct map *kernel_maps__find_by_dso_name(const char *name)
1182 {
1183 struct rb_node *nd;
1184
1185 for (nd = rb_first(&kernel_maps); nd; nd = rb_next(nd)) {
1186 struct map *map = rb_entry(nd, struct map, rb_node);
1187
1188 if (map->dso && strcmp(map->dso->name, name) == 0)
1189 return map;
1190 }
1191
1192 return NULL;
1193 }
1194
1195 static int dsos__set_modules_path_dir(char *dirname)
1196 {
1197 struct dirent *dent;
1198 DIR *dir = opendir(dirname);
1199
1200 if (!dir) {
1201 pr_debug("%s: cannot open %s dir\n", __func__, dirname);
1202 return -1;
1203 }
1204
1205 while ((dent = readdir(dir)) != NULL) {
1206 char path[PATH_MAX];
1207
1208 if (dent->d_type == DT_DIR) {
1209 if (!strcmp(dent->d_name, ".") ||
1210 !strcmp(dent->d_name, ".."))
1211 continue;
1212
1213 snprintf(path, sizeof(path), "%s/%s",
1214 dirname, dent->d_name);
1215 if (dsos__set_modules_path_dir(path) < 0)
1216 goto failure;
1217 } else {
1218 char *dot = strrchr(dent->d_name, '.'),
1219 dso_name[PATH_MAX];
1220 struct map *map;
1221 char *long_name;
1222
1223 if (dot == NULL || strcmp(dot, ".ko"))
1224 continue;
1225 snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1226 (int)(dot - dent->d_name), dent->d_name);
1227
1228 strxfrchar(dso_name, '-', '_');
1229 map = kernel_maps__find_by_dso_name(dso_name);
1230 if (map == NULL)
1231 continue;
1232
1233 snprintf(path, sizeof(path), "%s/%s",
1234 dirname, dent->d_name);
1235
1236 long_name = strdup(path);
1237 if (long_name == NULL)
1238 goto failure;
1239 dso__set_long_name(map->dso, long_name);
1240 }
1241 }
1242
1243 return 0;
1244 failure:
1245 closedir(dir);
1246 return -1;
1247 }
1248
1249 static int dsos__set_modules_path(void)
1250 {
1251 struct utsname uts;
1252 char modules_path[PATH_MAX];
1253
1254 if (uname(&uts) < 0)
1255 return -1;
1256
1257 snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
1258 uts.release);
1259
1260 return dsos__set_modules_path_dir(modules_path);
1261 }
1262
1263 /*
1264 * Constructor variant for modules (where we know from /proc/modules where
1265 * they are loaded) and for vmlinux, where only after we load all the
1266 * symbols we'll know where it starts and ends.
1267 */
1268 static struct map *map__new2(u64 start, struct dso *dso)
1269 {
1270 struct map *self = malloc(sizeof(*self));
1271
1272 if (self != NULL) {
1273 /*
1274 * ->end will be filled after we load all the symbols
1275 */
1276 map__init(self, start, 0, 0, dso);
1277 }
1278
1279 return self;
1280 }
1281
1282 static int kernel_maps__create_module_maps(void)
1283 {
1284 char *line = NULL;
1285 size_t n;
1286 FILE *file = fopen("/proc/modules", "r");
1287 struct map *map;
1288
1289 if (file == NULL)
1290 return -1;
1291
1292 while (!feof(file)) {
1293 char name[PATH_MAX];
1294 u64 start;
1295 struct dso *dso;
1296 char *sep;
1297 int line_len;
1298
1299 line_len = getline(&line, &n, file);
1300 if (line_len < 0)
1301 break;
1302
1303 if (!line)
1304 goto out_failure;
1305
1306 line[--line_len] = '\0'; /* \n */
1307
1308 sep = strrchr(line, 'x');
1309 if (sep == NULL)
1310 continue;
1311
1312 hex2u64(sep + 1, &start);
1313
1314 sep = strchr(line, ' ');
1315 if (sep == NULL)
1316 continue;
1317
1318 *sep = '\0';
1319
1320 snprintf(name, sizeof(name), "[%s]", line);
1321 dso = dso__new(name);
1322
1323 if (dso == NULL)
1324 goto out_delete_line;
1325
1326 map = map__new2(start, dso);
1327 if (map == NULL) {
1328 dso__delete(dso);
1329 goto out_delete_line;
1330 }
1331
1332 snprintf(name, sizeof(name),
1333 "/sys/module/%s/notes/.note.gnu.build-id", line);
1334 if (sysfs__read_build_id(name, dso->build_id,
1335 sizeof(dso->build_id)) == 0)
1336 dso->has_build_id = true;
1337
1338 dso->origin = DSO__ORIG_KMODULE;
1339 kernel_maps__insert(map);
1340 dsos__add(dso);
1341 }
1342
1343 free(line);
1344 fclose(file);
1345
1346 return dsos__set_modules_path();
1347
1348 out_delete_line:
1349 free(line);
1350 out_failure:
1351 return -1;
1352 }
1353
1354 static int dso__load_vmlinux(struct dso *self, struct map *map,
1355 const char *vmlinux, symbol_filter_t filter)
1356 {
1357 int err = -1, fd;
1358
1359 if (self->has_build_id) {
1360 u8 build_id[BUILD_ID_SIZE];
1361
1362 if (filename__read_build_id(vmlinux, build_id,
1363 sizeof(build_id)) < 0) {
1364 pr_debug("No build_id in %s, ignoring it\n", vmlinux);
1365 return -1;
1366 }
1367 if (!dso__build_id_equal(self, build_id)) {
1368 char expected_build_id[BUILD_ID_SIZE * 2 + 1],
1369 vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
1370
1371 build_id__sprintf(self->build_id,
1372 sizeof(self->build_id),
1373 expected_build_id);
1374 build_id__sprintf(build_id, sizeof(build_id),
1375 vmlinux_build_id);
1376 pr_debug("build_id in %s is %s while expected is %s, "
1377 "ignoring it\n", vmlinux, vmlinux_build_id,
1378 expected_build_id);
1379 return -1;
1380 }
1381 }
1382
1383 fd = open(vmlinux, O_RDONLY);
1384 if (fd < 0)
1385 return -1;
1386
1387 self->loaded = 1;
1388 err = dso__load_sym(self, map, self->long_name, fd, filter, 1, 0);
1389
1390 close(fd);
1391
1392 return err;
1393 }
1394
1395 static int dso__load_kernel_sym(struct dso *self, struct map *map,
1396 symbol_filter_t filter)
1397 {
1398 int err;
1399 bool is_kallsyms;
1400
1401 if (vmlinux_path != NULL) {
1402 int i;
1403 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1404 vmlinux_path__nr_entries);
1405 for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1406 err = dso__load_vmlinux(self, map, vmlinux_path[i],
1407 filter);
1408 if (err > 0) {
1409 pr_debug("Using %s for symbols\n",
1410 vmlinux_path[i]);
1411 dso__set_long_name(self,
1412 strdup(vmlinux_path[i]));
1413 goto out_fixup;
1414 }
1415 }
1416 }
1417
1418 is_kallsyms = self->long_name[0] == '[';
1419 if (is_kallsyms)
1420 goto do_kallsyms;
1421
1422 err = dso__load_vmlinux(self, map, self->long_name, filter);
1423 if (err <= 0) {
1424 pr_info("The file %s cannot be used, "
1425 "trying to use /proc/kallsyms...", self->long_name);
1426 sleep(2);
1427 do_kallsyms:
1428 err = kernel_maps__load_kallsyms(filter);
1429 if (err > 0 && !is_kallsyms)
1430 dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1431 }
1432
1433 if (err > 0) {
1434 out_fixup:
1435 map__fixup_start(map);
1436 map__fixup_end(map);
1437 }
1438
1439 return err;
1440 }
1441
1442 LIST_HEAD(dsos);
1443 struct dso *vdso;
1444
1445 static void dsos__add(struct dso *dso)
1446 {
1447 list_add_tail(&dso->node, &dsos);
1448 }
1449
1450 static struct dso *dsos__find(const char *name)
1451 {
1452 struct dso *pos;
1453
1454 list_for_each_entry(pos, &dsos, node)
1455 if (strcmp(pos->name, name) == 0)
1456 return pos;
1457 return NULL;
1458 }
1459
1460 struct dso *dsos__findnew(const char *name)
1461 {
1462 struct dso *dso = dsos__find(name);
1463
1464 if (!dso) {
1465 dso = dso__new(name);
1466 if (dso != NULL) {
1467 dsos__add(dso);
1468 dso__set_basename(dso);
1469 }
1470 }
1471
1472 return dso;
1473 }
1474
1475 void dsos__fprintf(FILE *fp)
1476 {
1477 struct dso *pos;
1478
1479 list_for_each_entry(pos, &dsos, node)
1480 dso__fprintf(pos, fp);
1481 }
1482
1483 size_t dsos__fprintf_buildid(FILE *fp)
1484 {
1485 struct dso *pos;
1486 size_t ret = 0;
1487
1488 list_for_each_entry(pos, &dsos, node) {
1489 ret += dso__fprintf_buildid(pos, fp);
1490 ret += fprintf(fp, " %s\n", pos->long_name);
1491 }
1492 return ret;
1493 }
1494
1495 static int kernel_maps__create_kernel_map(const struct symbol_conf *conf)
1496 {
1497 struct dso *kernel = dso__new(conf->vmlinux_name ?: "[kernel.kallsyms]");
1498
1499 if (kernel == NULL)
1500 return -1;
1501
1502 kernel_map = map__new2(0, kernel);
1503 if (kernel_map == NULL)
1504 goto out_delete_kernel_dso;
1505
1506 kernel_map->map_ip = kernel_map->unmap_ip = identity__map_ip;
1507 kernel->short_name = "[kernel]";
1508 kernel->kernel = 1;
1509
1510 vdso = dso__new("[vdso]");
1511 if (vdso == NULL)
1512 goto out_delete_kernel_map;
1513
1514 if (sysfs__read_build_id("/sys/kernel/notes", kernel->build_id,
1515 sizeof(kernel->build_id)) == 0)
1516 kernel->has_build_id = true;
1517
1518 kernel_maps__insert(kernel_map);
1519 dsos__add(kernel);
1520 dsos__add(vdso);
1521
1522 return 0;
1523
1524 out_delete_kernel_map:
1525 map__delete(kernel_map);
1526 kernel_map = NULL;
1527 out_delete_kernel_dso:
1528 dso__delete(kernel);
1529 return -1;
1530 }
1531
1532 static void vmlinux_path__exit(void)
1533 {
1534 while (--vmlinux_path__nr_entries >= 0) {
1535 free(vmlinux_path[vmlinux_path__nr_entries]);
1536 vmlinux_path[vmlinux_path__nr_entries] = NULL;
1537 }
1538
1539 free(vmlinux_path);
1540 vmlinux_path = NULL;
1541 }
1542
1543 static int vmlinux_path__init(void)
1544 {
1545 struct utsname uts;
1546 char bf[PATH_MAX];
1547
1548 if (uname(&uts) < 0)
1549 return -1;
1550
1551 vmlinux_path = malloc(sizeof(char *) * 5);
1552 if (vmlinux_path == NULL)
1553 return -1;
1554
1555 vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
1556 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1557 goto out_fail;
1558 ++vmlinux_path__nr_entries;
1559 vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
1560 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1561 goto out_fail;
1562 ++vmlinux_path__nr_entries;
1563 snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
1564 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1565 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1566 goto out_fail;
1567 ++vmlinux_path__nr_entries;
1568 snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
1569 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1570 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1571 goto out_fail;
1572 ++vmlinux_path__nr_entries;
1573 snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
1574 uts.release);
1575 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1576 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1577 goto out_fail;
1578 ++vmlinux_path__nr_entries;
1579
1580 return 0;
1581
1582 out_fail:
1583 vmlinux_path__exit();
1584 return -1;
1585 }
1586
1587 static int kernel_maps__init(const struct symbol_conf *conf)
1588 {
1589 const struct symbol_conf *pconf = conf ?: &symbol_conf__defaults;
1590
1591 symbol__priv_size = pconf->priv_size;
1592
1593 if (pconf->try_vmlinux_path && vmlinux_path__init() < 0)
1594 return -1;
1595
1596 if (kernel_maps__create_kernel_map(pconf) < 0) {
1597 vmlinux_path__exit();
1598 return -1;
1599 }
1600
1601 if (pconf->use_modules && kernel_maps__create_module_maps() < 0)
1602 pr_debug("Failed to load list of modules in use, "
1603 "continuing...\n");
1604 /*
1605 * Now that we have all the maps created, just set the ->end of them:
1606 */
1607 kernel_maps__fixup_end();
1608 return 0;
1609 }
1610
1611 int symbol__init(struct symbol_conf *conf)
1612 {
1613 elf_version(EV_CURRENT);
1614 return kernel_maps__init(conf);
1615 }
Linux kernel - Deliverables
This page took 0.116207 seconds and 5 git commands to generate.