~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/symbol.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include <dirent.h>
  2 #include <errno.h>
  3 #include <stdlib.h>
  4 #include <stdio.h>
  5 #include <string.h>
  6 #include <sys/types.h>
  7 #include <sys/stat.h>
  8 #include <sys/param.h>
  9 #include <fcntl.h>
 10 #include <unistd.h>
 11 #include <inttypes.h>
 12 #include "build-id.h"
 13 #include "util.h"
 14 #include "debug.h"
 15 #include "machine.h"
 16 #include "symbol.h"
 17 #include "strlist.h"
 18 
 19 #include <elf.h>
 20 #include <limits.h>
 21 #include <sys/utsname.h>
 22 
 23 #ifndef KSYM_NAME_LEN
 24 #define KSYM_NAME_LEN 256
 25 #endif
 26 
 27 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 28                                 symbol_filter_t filter);
 29 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 30                         symbol_filter_t filter);
 31 int vmlinux_path__nr_entries;
 32 char **vmlinux_path;
 33 
 34 struct symbol_conf symbol_conf = {
 35         .exclude_other    = true,
 36         .use_modules      = true,
 37         .try_vmlinux_path = true,
 38         .annotate_src     = true,
 39         .demangle         = true,
 40         .symfs            = "",
 41 };
 42 
 43 static enum dso_binary_type binary_type_symtab[] = {
 44         DSO_BINARY_TYPE__KALLSYMS,
 45         DSO_BINARY_TYPE__GUEST_KALLSYMS,
 46         DSO_BINARY_TYPE__JAVA_JIT,
 47         DSO_BINARY_TYPE__DEBUGLINK,
 48         DSO_BINARY_TYPE__BUILD_ID_CACHE,
 49         DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
 50         DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
 51         DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
 52         DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
 53         DSO_BINARY_TYPE__GUEST_KMODULE,
 54         DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
 55         DSO_BINARY_TYPE__NOT_FOUND,
 56 };
 57 
 58 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
 59 
 60 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 61 {
 62         symbol_type = toupper(symbol_type);
 63 
 64         switch (map_type) {
 65         case MAP__FUNCTION:
 66                 return symbol_type == 'T' || symbol_type == 'W';
 67         case MAP__VARIABLE:
 68                 return symbol_type == 'D';
 69         default:
 70                 return false;
 71         }
 72 }
 73 
 74 static int prefix_underscores_count(const char *str)
 75 {
 76         const char *tail = str;
 77 
 78         while (*tail == '_')
 79                 tail++;
 80 
 81         return tail - str;
 82 }
 83 
 84 #define SYMBOL_A 0
 85 #define SYMBOL_B 1
 86 
 87 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 88 {
 89         s64 a;
 90         s64 b;
 91 
 92         /* Prefer a symbol with non zero length */
 93         a = syma->end - syma->start;
 94         b = symb->end - symb->start;
 95         if ((b == 0) && (a > 0))
 96                 return SYMBOL_A;
 97         else if ((a == 0) && (b > 0))
 98                 return SYMBOL_B;
 99 
100         /* Prefer a non weak symbol over a weak one */
101         a = syma->binding == STB_WEAK;
102         b = symb->binding == STB_WEAK;
103         if (b && !a)
104                 return SYMBOL_A;
105         if (a && !b)
106                 return SYMBOL_B;
107 
108         /* Prefer a global symbol over a non global one */
109         a = syma->binding == STB_GLOBAL;
110         b = symb->binding == STB_GLOBAL;
111         if (a && !b)
112                 return SYMBOL_A;
113         if (b && !a)
114                 return SYMBOL_B;
115 
116         /* Prefer a symbol with less underscores */
117         a = prefix_underscores_count(syma->name);
118         b = prefix_underscores_count(symb->name);
119         if (b > a)
120                 return SYMBOL_A;
121         else if (a > b)
122                 return SYMBOL_B;
123 
124         /* If all else fails, choose the symbol with the longest name */
125         if (strlen(syma->name) >= strlen(symb->name))
126                 return SYMBOL_A;
127         else
128                 return SYMBOL_B;
129 }
130 
131 void symbols__fixup_duplicate(struct rb_root *symbols)
132 {
133         struct rb_node *nd;
134         struct symbol *curr, *next;
135 
136         nd = rb_first(symbols);
137 
138         while (nd) {
139                 curr = rb_entry(nd, struct symbol, rb_node);
140 again:
141                 nd = rb_next(&curr->rb_node);
142                 next = rb_entry(nd, struct symbol, rb_node);
143 
144                 if (!nd)
145                         break;
146 
147                 if (curr->start != next->start)
148                         continue;
149 
150                 if (choose_best_symbol(curr, next) == SYMBOL_A) {
151                         rb_erase(&next->rb_node, symbols);
152                         goto again;
153                 } else {
154                         nd = rb_next(&curr->rb_node);
155                         rb_erase(&curr->rb_node, symbols);
156                 }
157         }
158 }
159 
160 void symbols__fixup_end(struct rb_root *symbols)
161 {
162         struct rb_node *nd, *prevnd = rb_first(symbols);
163         struct symbol *curr, *prev;
164 
165         if (prevnd == NULL)
166                 return;
167 
168         curr = rb_entry(prevnd, struct symbol, rb_node);
169 
170         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
171                 prev = curr;
172                 curr = rb_entry(nd, struct symbol, rb_node);
173 
174                 if (prev->end == prev->start && prev->end != curr->start)
175                         prev->end = curr->start - 1;
176         }
177 
178         /* Last entry */
179         if (curr->end == curr->start)
180                 curr->end = roundup(curr->start, 4096);
181 }
182 
183 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
184 {
185         struct map *prev, *curr;
186         struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
187 
188         if (prevnd == NULL)
189                 return;
190 
191         curr = rb_entry(prevnd, struct map, rb_node);
192 
193         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
194                 prev = curr;
195                 curr = rb_entry(nd, struct map, rb_node);
196                 prev->end = curr->start - 1;
197         }
198 
199         /*
200          * We still haven't the actual symbols, so guess the
201          * last map final address.
202          */
203         curr->end = ~0ULL;
204 }
205 
206 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
207 {
208         size_t namelen = strlen(name) + 1;
209         struct symbol *sym = calloc(1, (symbol_conf.priv_size +
210                                         sizeof(*sym) + namelen));
211         if (sym == NULL)
212                 return NULL;
213 
214         if (symbol_conf.priv_size)
215                 sym = ((void *)sym) + symbol_conf.priv_size;
216 
217         sym->start   = start;
218         sym->end     = len ? start + len - 1 : start;
219         sym->binding = binding;
220         sym->namelen = namelen - 1;
221 
222         pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
223                   __func__, name, start, sym->end);
224         memcpy(sym->name, name, namelen);
225 
226         return sym;
227 }
228 
229 void symbol__delete(struct symbol *sym)
230 {
231         free(((void *)sym) - symbol_conf.priv_size);
232 }
233 
234 size_t symbol__fprintf(struct symbol *sym, FILE *fp)
235 {
236         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
237                        sym->start, sym->end,
238                        sym->binding == STB_GLOBAL ? 'g' :
239                        sym->binding == STB_LOCAL  ? 'l' : 'w',
240                        sym->name);
241 }
242 
243 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
244                                     const struct addr_location *al, FILE *fp)
245 {
246         unsigned long offset;
247         size_t length;
248 
249         if (sym && sym->name) {
250                 length = fprintf(fp, "%s", sym->name);
251                 if (al) {
252                         offset = al->addr - sym->start;
253                         length += fprintf(fp, "+0x%lx", offset);
254                 }
255                 return length;
256         } else
257                 return fprintf(fp, "[unknown]");
258 }
259 
260 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
261 {
262         return symbol__fprintf_symname_offs(sym, NULL, fp);
263 }
264 
265 void symbols__delete(struct rb_root *symbols)
266 {
267         struct symbol *pos;
268         struct rb_node *next = rb_first(symbols);
269 
270         while (next) {
271                 pos = rb_entry(next, struct symbol, rb_node);
272                 next = rb_next(&pos->rb_node);
273                 rb_erase(&pos->rb_node, symbols);
274                 symbol__delete(pos);
275         }
276 }
277 
278 void symbols__insert(struct rb_root *symbols, struct symbol *sym)
279 {
280         struct rb_node **p = &symbols->rb_node;
281         struct rb_node *parent = NULL;
282         const u64 ip = sym->start;
283         struct symbol *s;
284 
285         while (*p != NULL) {
286                 parent = *p;
287                 s = rb_entry(parent, struct symbol, rb_node);
288                 if (ip < s->start)
289                         p = &(*p)->rb_left;
290                 else
291                         p = &(*p)->rb_right;
292         }
293         rb_link_node(&sym->rb_node, parent, p);
294         rb_insert_color(&sym->rb_node, symbols);
295 }
296 
297 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
298 {
299         struct rb_node *n;
300 
301         if (symbols == NULL)
302                 return NULL;
303 
304         n = symbols->rb_node;
305 
306         while (n) {
307                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
308 
309                 if (ip < s->start)
310                         n = n->rb_left;
311                 else if (ip > s->end)
312                         n = n->rb_right;
313                 else
314                         return s;
315         }
316 
317         return NULL;
318 }
319 
320 struct symbol_name_rb_node {
321         struct rb_node  rb_node;
322         struct symbol   sym;
323 };
324 
325 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
326 {
327         struct rb_node **p = &symbols->rb_node;
328         struct rb_node *parent = NULL;
329         struct symbol_name_rb_node *symn, *s;
330 
331         symn = container_of(sym, struct symbol_name_rb_node, sym);
332 
333         while (*p != NULL) {
334                 parent = *p;
335                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
336                 if (strcmp(sym->name, s->sym.name) < 0)
337                         p = &(*p)->rb_left;
338                 else
339                         p = &(*p)->rb_right;
340         }
341         rb_link_node(&symn->rb_node, parent, p);
342         rb_insert_color(&symn->rb_node, symbols);
343 }
344 
345 static void symbols__sort_by_name(struct rb_root *symbols,
346                                   struct rb_root *source)
347 {
348         struct rb_node *nd;
349 
350         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
351                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
352                 symbols__insert_by_name(symbols, pos);
353         }
354 }
355 
356 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
357                                             const char *name)
358 {
359         struct rb_node *n;
360 
361         if (symbols == NULL)
362                 return NULL;
363 
364         n = symbols->rb_node;
365 
366         while (n) {
367                 struct symbol_name_rb_node *s;
368                 int cmp;
369 
370                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
371                 cmp = strcmp(name, s->sym.name);
372 
373                 if (cmp < 0)
374                         n = n->rb_left;
375                 else if (cmp > 0)
376                         n = n->rb_right;
377                 else
378                         return &s->sym;
379         }
380 
381         return NULL;
382 }
383 
384 struct symbol *dso__find_symbol(struct dso *dso,
385                                 enum map_type type, u64 addr)
386 {
387         return symbols__find(&dso->symbols[type], addr);
388 }
389 
390 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
391                                         const char *name)
392 {
393         return symbols__find_by_name(&dso->symbol_names[type], name);
394 }
395 
396 void dso__sort_by_name(struct dso *dso, enum map_type type)
397 {
398         dso__set_sorted_by_name(dso, type);
399         return symbols__sort_by_name(&dso->symbol_names[type],
400                                      &dso->symbols[type]);
401 }
402 
403 size_t dso__fprintf_symbols_by_name(struct dso *dso,
404                                     enum map_type type, FILE *fp)
405 {
406         size_t ret = 0;
407         struct rb_node *nd;
408         struct symbol_name_rb_node *pos;
409 
410         for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
411                 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
412                 fprintf(fp, "%s\n", pos->sym.name);
413         }
414 
415         return ret;
416 }
417 
418 int kallsyms__parse(const char *filename, void *arg,
419                     int (*process_symbol)(void *arg, const char *name,
420                                           char type, u64 start))
421 {
422         char *line = NULL;
423         size_t n;
424         int err = -1;
425         FILE *file = fopen(filename, "r");
426 
427         if (file == NULL)
428                 goto out_failure;
429 
430         err = 0;
431 
432         while (!feof(file)) {
433                 u64 start;
434                 int line_len, len;
435                 char symbol_type;
436                 char *symbol_name;
437 
438                 line_len = getline(&line, &n, file);
439                 if (line_len < 0 || !line)
440                         break;
441 
442                 line[--line_len] = '\0'; /* \n */
443 
444                 len = hex2u64(line, &start);
445 
446                 len++;
447                 if (len + 2 >= line_len)
448                         continue;
449 
450                 symbol_type = line[len];
451                 len += 2;
452                 symbol_name = line + len;
453                 len = line_len - len;
454 
455                 if (len >= KSYM_NAME_LEN) {
456                         err = -1;
457                         break;
458                 }
459 
460                 err = process_symbol(arg, symbol_name,
461                                      symbol_type, start);
462                 if (err)
463                         break;
464         }
465 
466         free(line);
467         fclose(file);
468         return err;
469 
470 out_failure:
471         return -1;
472 }
473 
474 struct process_kallsyms_args {
475         struct map *map;
476         struct dso *dso;
477 };
478 
479 static u8 kallsyms2elf_type(char type)
480 {
481         if (type == 'W')
482                 return STB_WEAK;
483 
484         return isupper(type) ? STB_GLOBAL : STB_LOCAL;
485 }
486 
487 static int map__process_kallsym_symbol(void *arg, const char *name,
488                                        char type, u64 start)
489 {
490         struct symbol *sym;
491         struct process_kallsyms_args *a = arg;
492         struct rb_root *root = &a->dso->symbols[a->map->type];
493 
494         if (!symbol_type__is_a(type, a->map->type))
495                 return 0;
496 
497         /*
498          * module symbols are not sorted so we add all
499          * symbols, setting length to 0, and rely on
500          * symbols__fixup_end() to fix it up.
501          */
502         sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
503         if (sym == NULL)
504                 return -ENOMEM;
505         /*
506          * We will pass the symbols to the filter later, in
507          * map__split_kallsyms, when we have split the maps per module
508          */
509         symbols__insert(root, sym);
510 
511         return 0;
512 }
513 
514 /*
515  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
516  * so that we can in the next step set the symbol ->end address and then
517  * call kernel_maps__split_kallsyms.
518  */
519 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
520                                   struct map *map)
521 {
522         struct process_kallsyms_args args = { .map = map, .dso = dso, };
523         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
524 }
525 
526 /*
527  * Split the symbols into maps, making sure there are no overlaps, i.e. the
528  * kernel range is broken in several maps, named [kernel].N, as we don't have
529  * the original ELF section names vmlinux have.
530  */
531 static int dso__split_kallsyms(struct dso *dso, struct map *map,
532                                symbol_filter_t filter)
533 {
534         struct map_groups *kmaps = map__kmap(map)->kmaps;
535         struct machine *machine = kmaps->machine;
536         struct map *curr_map = map;
537         struct symbol *pos;
538         int count = 0, moved = 0;       
539         struct rb_root *root = &dso->symbols[map->type];
540         struct rb_node *next = rb_first(root);
541         int kernel_range = 0;
542 
543         while (next) {
544                 char *module;
545 
546                 pos = rb_entry(next, struct symbol, rb_node);
547                 next = rb_next(&pos->rb_node);
548 
549                 module = strchr(pos->name, '\t');
550                 if (module) {
551                         if (!symbol_conf.use_modules)
552                                 goto discard_symbol;
553 
554                         *module++ = '\0';
555 
556                         if (strcmp(curr_map->dso->short_name, module)) {
557                                 if (curr_map != map &&
558                                     dso->kernel == DSO_TYPE_GUEST_KERNEL &&
559                                     machine__is_default_guest(machine)) {
560                                         /*
561                                          * We assume all symbols of a module are
562                                          * continuous in * kallsyms, so curr_map
563                                          * points to a module and all its
564                                          * symbols are in its kmap. Mark it as
565                                          * loaded.
566                                          */
567                                         dso__set_loaded(curr_map->dso,
568                                                         curr_map->type);
569                                 }
570 
571                                 curr_map = map_groups__find_by_name(kmaps,
572                                                         map->type, module);
573                                 if (curr_map == NULL) {
574                                         pr_debug("%s/proc/{kallsyms,modules} "
575                                                  "inconsistency while looking "
576                                                  "for \"%s\" module!\n",
577                                                  machine->root_dir, module);
578                                         curr_map = map;
579                                         goto discard_symbol;
580                                 }
581 
582                                 if (curr_map->dso->loaded &&
583                                     !machine__is_default_guest(machine))
584                                         goto discard_symbol;
585                         }
586                         /*
587                          * So that we look just like we get from .ko files,
588                          * i.e. not prelinked, relative to map->start.
589                          */
590                         pos->start = curr_map->map_ip(curr_map, pos->start);
591                         pos->end   = curr_map->map_ip(curr_map, pos->end);
592                 } else if (curr_map != map) {
593                         char dso_name[PATH_MAX];
594                         struct dso *ndso;
595 
596                         if (count == 0) {
597                                 curr_map = map;
598                                 goto filter_symbol;
599                         }
600 
601                         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
602                                 snprintf(dso_name, sizeof(dso_name),
603                                         "[guest.kernel].%d",
604                                         kernel_range++);
605                         else
606                                 snprintf(dso_name, sizeof(dso_name),
607                                         "[kernel].%d",
608                                         kernel_range++);
609 
610                         ndso = dso__new(dso_name);
611                         if (ndso == NULL)
612                                 return -1;
613 
614                         ndso->kernel = dso->kernel;
615 
616                         curr_map = map__new2(pos->start, ndso, map->type);
617                         if (curr_map == NULL) {
618                                 dso__delete(ndso);
619                                 return -1;
620                         }
621 
622                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
623                         map_groups__insert(kmaps, curr_map);
624                         ++kernel_range;
625                 }
626 filter_symbol:
627                 if (filter && filter(curr_map, pos)) {
628 discard_symbol:         rb_erase(&pos->rb_node, root);
629                         symbol__delete(pos);
630                 } else {
631                         if (curr_map != map) {
632                                 rb_erase(&pos->rb_node, root);
633                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
634                                 ++moved;
635                         } else
636                                 ++count;
637                 }
638         }
639 
640         if (curr_map != map &&
641             dso->kernel == DSO_TYPE_GUEST_KERNEL &&
642             machine__is_default_guest(kmaps->machine)) {
643                 dso__set_loaded(curr_map->dso, curr_map->type);
644         }
645 
646         return count + moved;
647 }
648 
649 bool symbol__restricted_filename(const char *filename,
650                                  const char *restricted_filename)
651 {
652         bool restricted = false;
653 
654         if (symbol_conf.kptr_restrict) {
655                 char *r = realpath(filename, NULL);
656 
657                 if (r != NULL) {
658                         restricted = strcmp(r, restricted_filename) == 0;
659                         free(r);
660                         return restricted;
661                 }
662         }
663 
664         return restricted;
665 }
666 
667 int dso__load_kallsyms(struct dso *dso, const char *filename,
668                        struct map *map, symbol_filter_t filter)
669 {
670         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
671                 return -1;
672 
673         if (dso__load_all_kallsyms(dso, filename, map) < 0)
674                 return -1;
675 
676         symbols__fixup_end(&dso->symbols[map->type]);
677         symbols__fixup_duplicate(&dso->symbols[map->type]);
678 
679         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
680                 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
681         else
682                 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
683 
684         return dso__split_kallsyms(dso, map, filter);
685 }
686 
687 static int dso__load_perf_map(struct dso *dso, struct map *map,
688                               symbol_filter_t filter)
689 {
690         char *line = NULL;
691         size_t n;
692         FILE *file;
693         int nr_syms = 0;
694 
695         file = fopen(dso->long_name, "r");
696         if (file == NULL)
697                 goto out_failure;
698 
699         while (!feof(file)) {
700                 u64 start, size;
701                 struct symbol *sym;
702                 int line_len, len;
703 
704                 line_len = getline(&line, &n, file);
705                 if (line_len < 0)
706                         break;
707 
708                 if (!line)
709                         goto out_failure;
710 
711                 line[--line_len] = '\0'; /* \n */
712 
713                 len = hex2u64(line, &start);
714 
715                 len++;
716                 if (len + 2 >= line_len)
717                         continue;
718 
719                 len += hex2u64(line + len, &size);
720 
721                 len++;
722                 if (len + 2 >= line_len)
723                         continue;
724 
725                 sym = symbol__new(start, size, STB_GLOBAL, line + len);
726 
727                 if (sym == NULL)
728                         goto out_delete_line;
729 
730                 if (filter && filter(map, sym))
731                         symbol__delete(sym);
732                 else {
733                         symbols__insert(&dso->symbols[map->type], sym);
734                         nr_syms++;
735                 }
736         }
737 
738         free(line);
739         fclose(file);
740 
741         return nr_syms;
742 
743 out_delete_line:
744         free(line);
745 out_failure:
746         return -1;
747 }
748 
749 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
750 {
751         char *name;
752         int ret = -1;
753         u_int i;
754         struct machine *machine;
755         char *root_dir = (char *) "";
756         int ss_pos = 0;
757         struct symsrc ss_[2];
758         struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
759 
760         dso__set_loaded(dso, map->type);
761 
762         if (dso->kernel == DSO_TYPE_KERNEL)
763                 return dso__load_kernel_sym(dso, map, filter);
764         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
765                 return dso__load_guest_kernel_sym(dso, map, filter);
766 
767         if (map->groups && map->groups->machine)
768                 machine = map->groups->machine;
769         else
770                 machine = NULL;
771 
772         dso->adjust_symbols = 0;
773 
774         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
775                 struct stat st;
776 
777                 if (lstat(dso->name, &st) < 0)
778                         return -1;
779 
780                 if (st.st_uid && (st.st_uid != geteuid())) {
781                         pr_warning("File %s not owned by current user or root, "
782                                 "ignoring it.\n", dso->name);
783                         return -1;
784                 }
785 
786                 ret = dso__load_perf_map(dso, map, filter);
787                 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
788                                              DSO_BINARY_TYPE__NOT_FOUND;
789                 return ret;
790         }
791 
792         if (machine)
793                 root_dir = machine->root_dir;
794 
795         name = malloc(PATH_MAX);
796         if (!name)
797                 return -1;
798 
799         /* Iterate over candidate debug images.
800          * Keep track of "interesting" ones (those which have a symtab, dynsym,
801          * and/or opd section) for processing.
802          */
803         for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
804                 struct symsrc *ss = &ss_[ss_pos];
805                 bool next_slot = false;
806 
807                 enum dso_binary_type symtab_type = binary_type_symtab[i];
808 
809                 if (dso__binary_type_file(dso, symtab_type,
810                                           root_dir, name, PATH_MAX))
811                         continue;
812 
813                 /* Name is now the name of the next image to try */
814                 if (symsrc__init(ss, dso, name, symtab_type) < 0)
815                         continue;
816 
817                 if (!syms_ss && symsrc__has_symtab(ss)) {
818                         syms_ss = ss;
819                         next_slot = true;
820                 }
821 
822                 if (!runtime_ss && symsrc__possibly_runtime(ss)) {
823                         runtime_ss = ss;
824                         next_slot = true;
825                 }
826 
827                 if (next_slot) {
828                         ss_pos++;
829 
830                         if (syms_ss && runtime_ss)
831                                 break;
832                 }
833 
834         }
835 
836         if (!runtime_ss && !syms_ss)
837                 goto out_free;
838 
839         if (runtime_ss && !syms_ss) {
840                 syms_ss = runtime_ss;
841         }
842 
843         /* We'll have to hope for the best */
844         if (!runtime_ss && syms_ss)
845                 runtime_ss = syms_ss;
846 
847         if (syms_ss)
848                 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, 0);
849         else
850                 ret = -1;
851 
852         if (ret > 0) {
853                 int nr_plt;
854 
855                 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
856                 if (nr_plt > 0)
857                         ret += nr_plt;
858         }
859 
860         for (; ss_pos > 0; ss_pos--)
861                 symsrc__destroy(&ss_[ss_pos - 1]);
862 out_free:
863         free(name);
864         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
865                 return 0;
866         return ret;
867 }
868 
869 struct map *map_groups__find_by_name(struct map_groups *mg,
870                                      enum map_type type, const char *name)
871 {
872         struct rb_node *nd;
873 
874         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
875                 struct map *map = rb_entry(nd, struct map, rb_node);
876 
877                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
878                         return map;
879         }
880 
881         return NULL;
882 }
883 
884 int dso__load_vmlinux(struct dso *dso, struct map *map,
885                       const char *vmlinux, symbol_filter_t filter)
886 {
887         int err = -1;
888         struct symsrc ss;
889         char symfs_vmlinux[PATH_MAX];
890         enum dso_binary_type symtab_type;
891 
892         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
893                  symbol_conf.symfs, vmlinux);
894 
895         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
896                 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
897         else
898                 symtab_type = DSO_BINARY_TYPE__VMLINUX;
899 
900         if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
901                 return -1;
902 
903         err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
904         symsrc__destroy(&ss);
905 
906         if (err > 0) {
907                 dso__set_long_name(dso, (char *)vmlinux);
908                 dso__set_loaded(dso, map->type);
909                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
910         }
911 
912         return err;
913 }
914 
915 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
916                            symbol_filter_t filter)
917 {
918         int i, err = 0;
919         char *filename;
920 
921         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
922                  vmlinux_path__nr_entries + 1);
923 
924         filename = dso__build_id_filename(dso, NULL, 0);
925         if (filename != NULL) {
926                 err = dso__load_vmlinux(dso, map, filename, filter);
927                 if (err > 0) {
928                         dso->lname_alloc = 1;
929                         goto out;
930                 }
931                 free(filename);
932         }
933 
934         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
935                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
936                 if (err > 0) {
937                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
938                         dso->lname_alloc = 1;
939                         break;
940                 }
941         }
942 out:
943         return err;
944 }
945 
946 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
947                                 symbol_filter_t filter)
948 {
949         int err;
950         const char *kallsyms_filename = NULL;
951         char *kallsyms_allocated_filename = NULL;
952         /*
953          * Step 1: if the user specified a kallsyms or vmlinux filename, use
954          * it and only it, reporting errors to the user if it cannot be used.
955          *
956          * For instance, try to analyse an ARM perf.data file _without_ a
957          * build-id, or if the user specifies the wrong path to the right
958          * vmlinux file, obviously we can't fallback to another vmlinux (a
959          * x86_86 one, on the machine where analysis is being performed, say),
960          * or worse, /proc/kallsyms.
961          *
962          * If the specified file _has_ a build-id and there is a build-id
963          * section in the perf.data file, we will still do the expected
964          * validation in dso__load_vmlinux and will bail out if they don't
965          * match.
966          */
967         if (symbol_conf.kallsyms_name != NULL) {
968                 kallsyms_filename = symbol_conf.kallsyms_name;
969                 goto do_kallsyms;
970         }
971 
972         if (symbol_conf.vmlinux_name != NULL) {
973                 err = dso__load_vmlinux(dso, map,
974                                         symbol_conf.vmlinux_name, filter);
975                 if (err > 0) {
976                         dso__set_long_name(dso,
977                                            strdup(symbol_conf.vmlinux_name));
978                         dso->lname_alloc = 1;
979                         goto out_fixup;
980                 }
981                 return err;
982         }
983 
984         if (vmlinux_path != NULL) {
985                 err = dso__load_vmlinux_path(dso, map, filter);
986                 if (err > 0)
987                         goto out_fixup;
988         }
989 
990         /* do not try local files if a symfs was given */
991         if (symbol_conf.symfs[0] != 0)
992                 return -1;
993 
994         /*
995          * Say the kernel DSO was created when processing the build-id header table,
996          * we have a build-id, so check if it is the same as the running kernel,
997          * using it if it is.
998          */
999         if (dso->has_build_id) {
1000                 u8 kallsyms_build_id[BUILD_ID_SIZE];
1001                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1002 
1003                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1004                                          sizeof(kallsyms_build_id)) == 0) {
1005                         if (dso__build_id_equal(dso, kallsyms_build_id)) {
1006                                 kallsyms_filename = "/proc/kallsyms";
1007                                 goto do_kallsyms;
1008                         }
1009                 }
1010                 /*
1011                  * Now look if we have it on the build-id cache in
1012                  * $HOME/.debug/[kernel.kallsyms].
1013                  */
1014                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1015                                   sbuild_id);
1016 
1017                 if (asprintf(&kallsyms_allocated_filename,
1018                              "%s/.debug/[kernel.kallsyms]/%s",
1019                              getenv("HOME"), sbuild_id) == -1) {
1020                         pr_err("Not enough memory for kallsyms file lookup\n");
1021                         return -1;
1022                 }
1023 
1024                 kallsyms_filename = kallsyms_allocated_filename;
1025 
1026                 if (access(kallsyms_filename, F_OK)) {
1027                         pr_err("No kallsyms or vmlinux with build-id %s "
1028                                "was found\n", sbuild_id);
1029                         free(kallsyms_allocated_filename);
1030                         return -1;
1031                 }
1032         } else {
1033                 /*
1034                  * Last resort, if we don't have a build-id and couldn't find
1035                  * any vmlinux file, try the running kernel kallsyms table.
1036                  */
1037                 kallsyms_filename = "/proc/kallsyms";
1038         }
1039 
1040 do_kallsyms:
1041         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1042         if (err > 0)
1043                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1044         free(kallsyms_allocated_filename);
1045 
1046         if (err > 0) {
1047                 dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
1048 out_fixup:
1049                 map__fixup_start(map);
1050                 map__fixup_end(map);
1051         }
1052 
1053         return err;
1054 }
1055 
1056 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
1057                                       symbol_filter_t filter)
1058 {
1059         int err;
1060         const char *kallsyms_filename = NULL;
1061         struct machine *machine;
1062         char path[PATH_MAX];
1063 
1064         if (!map->groups) {
1065                 pr_debug("Guest kernel map hasn't the point to groups\n");
1066                 return -1;
1067         }
1068         machine = map->groups->machine;
1069 
1070         if (machine__is_default_guest(machine)) {
1071                 /*
1072                  * if the user specified a vmlinux filename, use it and only
1073                  * it, reporting errors to the user if it cannot be used.
1074                  * Or use file guest_kallsyms inputted by user on commandline
1075                  */
1076                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1077                         err = dso__load_vmlinux(dso, map,
1078                                 symbol_conf.default_guest_vmlinux_name, filter);
1079                         goto out_try_fixup;
1080                 }
1081 
1082                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1083                 if (!kallsyms_filename)
1084                         return -1;
1085         } else {
1086                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1087                 kallsyms_filename = path;
1088         }
1089 
1090         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1091         if (err > 0)
1092                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1093 
1094 out_try_fixup:
1095         if (err > 0) {
1096                 if (kallsyms_filename != NULL) {
1097                         machine__mmap_name(machine, path, sizeof(path));
1098                         dso__set_long_name(dso, strdup(path));
1099                 }
1100                 map__fixup_start(map);
1101                 map__fixup_end(map);
1102         }
1103 
1104         return err;
1105 }
1106 
1107 static void vmlinux_path__exit(void)
1108 {
1109         while (--vmlinux_path__nr_entries >= 0) {
1110                 free(vmlinux_path[vmlinux_path__nr_entries]);
1111                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
1112         }
1113 
1114         free(vmlinux_path);
1115         vmlinux_path = NULL;
1116 }
1117 
1118 static int vmlinux_path__init(void)
1119 {
1120         struct utsname uts;
1121         char bf[PATH_MAX];
1122 
1123         vmlinux_path = malloc(sizeof(char *) * 5);
1124         if (vmlinux_path == NULL)
1125                 return -1;
1126 
1127         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
1128         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1129                 goto out_fail;
1130         ++vmlinux_path__nr_entries;
1131         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
1132         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1133                 goto out_fail;
1134         ++vmlinux_path__nr_entries;
1135 
1136         /* only try running kernel version if no symfs was given */
1137         if (symbol_conf.symfs[0] != 0)
1138                 return 0;
1139 
1140         if (uname(&uts) < 0)
1141                 return -1;
1142 
1143         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
1144         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1145         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1146                 goto out_fail;
1147         ++vmlinux_path__nr_entries;
1148         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
1149         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1150         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1151                 goto out_fail;
1152         ++vmlinux_path__nr_entries;
1153         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
1154                  uts.release);
1155         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1156         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1157                 goto out_fail;
1158         ++vmlinux_path__nr_entries;
1159 
1160         return 0;
1161 
1162 out_fail:
1163         vmlinux_path__exit();
1164         return -1;
1165 }
1166 
1167 static int setup_list(struct strlist **list, const char *list_str,
1168                       const char *list_name)
1169 {
1170         if (list_str == NULL)
1171                 return 0;
1172 
1173         *list = strlist__new(true, list_str);
1174         if (!*list) {
1175                 pr_err("problems parsing %s list\n", list_name);
1176                 return -1;
1177         }
1178         return 0;
1179 }
1180 
1181 static bool symbol__read_kptr_restrict(void)
1182 {
1183         bool value = false;
1184 
1185         if (geteuid() != 0) {
1186                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
1187                 if (fp != NULL) {
1188                         char line[8];
1189 
1190                         if (fgets(line, sizeof(line), fp) != NULL)
1191                                 value = atoi(line) != 0;
1192 
1193                         fclose(fp);
1194                 }
1195         }
1196 
1197         return value;
1198 }
1199 
1200 int symbol__init(void)
1201 {
1202         const char *symfs;
1203 
1204         if (symbol_conf.initialized)
1205                 return 0;
1206 
1207         symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
1208 
1209         symbol__elf_init();
1210 
1211         if (symbol_conf.sort_by_name)
1212                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
1213                                           sizeof(struct symbol));
1214 
1215         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
1216                 return -1;
1217 
1218         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
1219                 pr_err("'.' is the only non valid --field-separator argument\n");
1220                 return -1;
1221         }
1222 
1223         if (setup_list(&symbol_conf.dso_list,
1224                        symbol_conf.dso_list_str, "dso") < 0)
1225                 return -1;
1226 
1227         if (setup_list(&symbol_conf.comm_list,
1228                        symbol_conf.comm_list_str, "comm") < 0)
1229                 goto out_free_dso_list;
1230 
1231         if (setup_list(&symbol_conf.sym_list,
1232                        symbol_conf.sym_list_str, "symbol") < 0)
1233                 goto out_free_comm_list;
1234 
1235         /*
1236          * A path to symbols of "/" is identical to ""
1237          * reset here for simplicity.
1238          */
1239         symfs = realpath(symbol_conf.symfs, NULL);
1240         if (symfs == NULL)
1241                 symfs = symbol_conf.symfs;
1242         if (strcmp(symfs, "/") == 0)
1243                 symbol_conf.symfs = "";
1244         if (symfs != symbol_conf.symfs)
1245                 free((void *)symfs);
1246 
1247         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
1248 
1249         symbol_conf.initialized = true;
1250         return 0;
1251 
1252 out_free_comm_list:
1253         strlist__delete(symbol_conf.comm_list);
1254 out_free_dso_list:
1255         strlist__delete(symbol_conf.dso_list);
1256         return -1;
1257 }
1258 
1259 void symbol__exit(void)
1260 {
1261         if (!symbol_conf.initialized)
1262                 return;
1263         strlist__delete(symbol_conf.sym_list);
1264         strlist__delete(symbol_conf.dso_list);
1265         strlist__delete(symbol_conf.comm_list);
1266         vmlinux_path__exit();
1267         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
1268         symbol_conf.initialized = false;
1269 }
1270 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp