1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 25aab621bSArnaldo Carvalho de Melo #include <dirent.h> 35aab621bSArnaldo Carvalho de Melo #include <errno.h> 45aab621bSArnaldo Carvalho de Melo #include <stdlib.h> 55aab621bSArnaldo Carvalho de Melo #include <stdio.h> 65aab621bSArnaldo Carvalho de Melo #include <string.h> 78859aedeSIgor Lubashev #include <linux/capability.h> 8877a7a11SArnaldo Carvalho de Melo #include <linux/kernel.h> 9e9814df8SArnaldo Carvalho de Melo #include <linux/mman.h> 108520a98dSArnaldo Carvalho de Melo #include <linux/string.h> 112a1292cbSAndi Kleen #include <linux/time64.h> 125aab621bSArnaldo Carvalho de Melo #include <sys/types.h> 135aab621bSArnaldo Carvalho de Melo #include <sys/stat.h> 145aab621bSArnaldo Carvalho de Melo #include <sys/param.h> 155aab621bSArnaldo Carvalho de Melo #include <fcntl.h> 165aab621bSArnaldo Carvalho de Melo #include <unistd.h> 179486aa38SArnaldo Carvalho de Melo #include <inttypes.h> 18b01141f4SArnaldo Carvalho de Melo #include "annotate.h" 19b36f19d5SArnaldo Carvalho de Melo #include "build-id.h" 208859aedeSIgor Lubashev #include "cap.h" 21fac583fdSArnaldo Carvalho de Melo #include "dso.h" 22fb71c86cSArnaldo Carvalho de Melo #include "util.h" // lsdir() 238a6c5b26SArnaldo Carvalho de Melo #include "debug.h" 248859aedeSIgor Lubashev #include "event.h" 2569d2591aSArnaldo Carvalho de Melo #include "machine.h" 261101f69aSArnaldo Carvalho de Melo #include "map.h" 2786470930SIngo Molnar #include "symbol.h" 28d3300a3cSArnaldo Carvalho de Melo #include "map_symbol.h" 29d3300a3cSArnaldo Carvalho de Melo #include "mem-events.h" 30b1d1b094SArnaldo Carvalho de Melo #include "symsrc.h" 315aab621bSArnaldo Carvalho de Melo #include "strlist.h" 32e03eaa40SDavid Ahern #include "intlist.h" 33843ff37bSKrister Johansen #include "namespaces.h" 340a7e6d1bSNamhyung Kim #include "header.h" 359a3993d4SArnaldo Carvalho de Melo #include "path.h" 363052ba56SArnaldo Carvalho de Melo #include <linux/ctype.h> 377f7c536fSArnaldo Carvalho de Melo #include <linux/zalloc.h> 3886470930SIngo Molnar 3986470930SIngo Molnar #include <elf.h> 40f1617b40SArnaldo Carvalho de Melo #include <limits.h> 41c506c96bSArnaldo Carvalho de Melo #include <symbol/kallsyms.h> 42439d473bSArnaldo Carvalho de Melo #include <sys/utsname.h> 432cdbc46dSPeter Zijlstra 44be39db9fSArnaldo Carvalho de Melo static int dso__load_kernel_sym(struct dso *dso, struct map *map); 45be39db9fSArnaldo Carvalho de Melo static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map); 46608c34deSArnaldo Carvalho de Melo static bool symbol__is_idle(const char *name); 47608c34deSArnaldo Carvalho de Melo 483f067dcaSArnaldo Carvalho de Melo int vmlinux_path__nr_entries; 493f067dcaSArnaldo Carvalho de Melo char **vmlinux_path; 50439d473bSArnaldo Carvalho de Melo 5175be6cf4SArnaldo Carvalho de Melo struct symbol_conf symbol_conf = { 5252bab886SAndi Kleen .nanosecs = false, 53b32d133aSArnaldo Carvalho de Melo .use_modules = true, 54b32d133aSArnaldo Carvalho de Melo .try_vmlinux_path = true, 55328ccdacSNamhyung Kim .demangle = true, 56763122adSAvi Kivity .demangle_kernel = false, 57e511db5eSNamhyung Kim .cumulate_callchain = true, 582a1292cbSAndi Kleen .time_quantum = 100 * NSEC_PER_MSEC, /* 100ms */ 59c8302367SJiri Olsa .show_hist_headers = true, 60ec5761eaSDavid Ahern .symfs = "", 611e9abf8bSNamhyung Kim .event_group = true, 62d8a88dd2SMilian Wolff .inline_name = true, 634968ac8fSAndi Kleen .res_sample = 0, 64b32d133aSArnaldo Carvalho de Melo }; 65b32d133aSArnaldo Carvalho de Melo 6644f24cb3SJiri Olsa static enum dso_binary_type binary_type_symtab[] = { 6744f24cb3SJiri Olsa DSO_BINARY_TYPE__KALLSYMS, 6844f24cb3SJiri Olsa DSO_BINARY_TYPE__GUEST_KALLSYMS, 6944f24cb3SJiri Olsa DSO_BINARY_TYPE__JAVA_JIT, 7044f24cb3SJiri Olsa DSO_BINARY_TYPE__DEBUGLINK, 7144f24cb3SJiri Olsa DSO_BINARY_TYPE__BUILD_ID_CACHE, 72d2396999SKrister Johansen DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO, 7344f24cb3SJiri Olsa DSO_BINARY_TYPE__FEDORA_DEBUGINFO, 7444f24cb3SJiri Olsa DSO_BINARY_TYPE__UBUNTU_DEBUGINFO, 7544f24cb3SJiri Olsa DSO_BINARY_TYPE__BUILDID_DEBUGINFO, 7644f24cb3SJiri Olsa DSO_BINARY_TYPE__SYSTEM_PATH_DSO, 7744f24cb3SJiri Olsa DSO_BINARY_TYPE__GUEST_KMODULE, 78c00c48fcSNamhyung Kim DSO_BINARY_TYPE__GUEST_KMODULE_COMP, 7944f24cb3SJiri Olsa DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE, 80c00c48fcSNamhyung Kim DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP, 819cd00941SRicardo Ribalda Delgado DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO, 8285afd355SAdrian Hunter DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO, 8344f24cb3SJiri Olsa DSO_BINARY_TYPE__NOT_FOUND, 8444f24cb3SJiri Olsa }; 8544f24cb3SJiri Olsa 86028df767SJiri Olsa #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab) 8744f24cb3SJiri Olsa 883183f8caSArnaldo Carvalho de Melo static bool symbol_type__filter(char symbol_type) 896893d4eeSArnaldo Carvalho de Melo { 9031877908SAnton Blanchard symbol_type = toupper(symbol_type); 912be732c0SArnaldo Carvalho de Melo return symbol_type == 'T' || symbol_type == 'W' || symbol_type == 'D' || symbol_type == 'B'; 926893d4eeSArnaldo Carvalho de Melo } 936893d4eeSArnaldo Carvalho de Melo 94694bf407SAnton Blanchard static int prefix_underscores_count(const char *str) 95694bf407SAnton Blanchard { 96694bf407SAnton Blanchard const char *tail = str; 97694bf407SAnton Blanchard 98694bf407SAnton Blanchard while (*tail == '_') 99694bf407SAnton Blanchard tail++; 100694bf407SAnton Blanchard 101694bf407SAnton Blanchard return tail - str; 102694bf407SAnton Blanchard } 103694bf407SAnton Blanchard 104b9c0a649SThomas Richter void __weak arch__symbols__fixup_end(struct symbol *p, struct symbol *c) 105b9c0a649SThomas Richter { 106b9c0a649SThomas Richter p->end = c->start; 107b9c0a649SThomas Richter } 108b9c0a649SThomas Richter 1094b3a2716SMasami Hiramatsu const char * __weak arch__normalize_symbol_name(const char *name) 1104b3a2716SMasami Hiramatsu { 1114b3a2716SMasami Hiramatsu return name; 1124b3a2716SMasami Hiramatsu } 1134b3a2716SMasami Hiramatsu 114d8040645SPaul Clarke int __weak arch__compare_symbol_names(const char *namea, const char *nameb) 115d8040645SPaul Clarke { 116d8040645SPaul Clarke return strcmp(namea, nameb); 117d8040645SPaul Clarke } 118d8040645SPaul Clarke 119d8040645SPaul Clarke int __weak arch__compare_symbol_names_n(const char *namea, const char *nameb, 120d8040645SPaul Clarke unsigned int n) 121d8040645SPaul Clarke { 122d8040645SPaul Clarke return strncmp(namea, nameb, n); 123d8040645SPaul Clarke } 124d8040645SPaul Clarke 125fb6d5942SNaveen N. Rao int __weak arch__choose_best_symbol(struct symbol *syma, 126fb6d5942SNaveen N. Rao struct symbol *symb __maybe_unused) 127fb6d5942SNaveen N. Rao { 128fb6d5942SNaveen N. Rao /* Avoid "SyS" kernel syscall aliases */ 129fb6d5942SNaveen N. Rao if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3)) 130fb6d5942SNaveen N. Rao return SYMBOL_B; 131fb6d5942SNaveen N. Rao if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10)) 132fb6d5942SNaveen N. Rao return SYMBOL_B; 133fb6d5942SNaveen N. Rao 134fb6d5942SNaveen N. Rao return SYMBOL_A; 135fb6d5942SNaveen N. Rao } 136694bf407SAnton Blanchard 137694bf407SAnton Blanchard static int choose_best_symbol(struct symbol *syma, struct symbol *symb) 138694bf407SAnton Blanchard { 139694bf407SAnton Blanchard s64 a; 140694bf407SAnton Blanchard s64 b; 1413445432bSAdrian Hunter size_t na, nb; 142694bf407SAnton Blanchard 143694bf407SAnton Blanchard /* Prefer a symbol with non zero length */ 144694bf407SAnton Blanchard a = syma->end - syma->start; 145694bf407SAnton Blanchard b = symb->end - symb->start; 146694bf407SAnton Blanchard if ((b == 0) && (a > 0)) 147694bf407SAnton Blanchard return SYMBOL_A; 148694bf407SAnton Blanchard else if ((a == 0) && (b > 0)) 149694bf407SAnton Blanchard return SYMBOL_B; 150694bf407SAnton Blanchard 151694bf407SAnton Blanchard /* Prefer a non weak symbol over a weak one */ 152694bf407SAnton Blanchard a = syma->binding == STB_WEAK; 153694bf407SAnton Blanchard b = symb->binding == STB_WEAK; 154694bf407SAnton Blanchard if (b && !a) 155694bf407SAnton Blanchard return SYMBOL_A; 156694bf407SAnton Blanchard if (a && !b) 157694bf407SAnton Blanchard return SYMBOL_B; 158694bf407SAnton Blanchard 159694bf407SAnton Blanchard /* Prefer a global symbol over a non global one */ 160694bf407SAnton Blanchard a = syma->binding == STB_GLOBAL; 161694bf407SAnton Blanchard b = symb->binding == STB_GLOBAL; 162694bf407SAnton Blanchard if (a && !b) 163694bf407SAnton Blanchard return SYMBOL_A; 164694bf407SAnton Blanchard if (b && !a) 165694bf407SAnton Blanchard return SYMBOL_B; 166694bf407SAnton Blanchard 167694bf407SAnton Blanchard /* Prefer a symbol with less underscores */ 168694bf407SAnton Blanchard a = prefix_underscores_count(syma->name); 169694bf407SAnton Blanchard b = prefix_underscores_count(symb->name); 170694bf407SAnton Blanchard if (b > a) 171694bf407SAnton Blanchard return SYMBOL_A; 172694bf407SAnton Blanchard else if (a > b) 173694bf407SAnton Blanchard return SYMBOL_B; 174694bf407SAnton Blanchard 1753445432bSAdrian Hunter /* Choose the symbol with the longest name */ 1763445432bSAdrian Hunter na = strlen(syma->name); 1773445432bSAdrian Hunter nb = strlen(symb->name); 1783445432bSAdrian Hunter if (na > nb) 179694bf407SAnton Blanchard return SYMBOL_A; 1803445432bSAdrian Hunter else if (na < nb) 181694bf407SAnton Blanchard return SYMBOL_B; 1823445432bSAdrian Hunter 183fb6d5942SNaveen N. Rao return arch__choose_best_symbol(syma, symb); 184694bf407SAnton Blanchard } 185694bf407SAnton Blanchard 1867137ff50SDavidlohr Bueso void symbols__fixup_duplicate(struct rb_root_cached *symbols) 187694bf407SAnton Blanchard { 188694bf407SAnton Blanchard struct rb_node *nd; 189694bf407SAnton Blanchard struct symbol *curr, *next; 190694bf407SAnton Blanchard 191c97b40e4SArnaldo Carvalho de Melo if (symbol_conf.allow_aliases) 192c97b40e4SArnaldo Carvalho de Melo return; 193c97b40e4SArnaldo Carvalho de Melo 1947137ff50SDavidlohr Bueso nd = rb_first_cached(symbols); 195694bf407SAnton Blanchard 196694bf407SAnton Blanchard while (nd) { 197694bf407SAnton Blanchard curr = rb_entry(nd, struct symbol, rb_node); 198694bf407SAnton Blanchard again: 199694bf407SAnton Blanchard nd = rb_next(&curr->rb_node); 200694bf407SAnton Blanchard next = rb_entry(nd, struct symbol, rb_node); 201694bf407SAnton Blanchard 202694bf407SAnton Blanchard if (!nd) 203694bf407SAnton Blanchard break; 204694bf407SAnton Blanchard 205694bf407SAnton Blanchard if (curr->start != next->start) 206694bf407SAnton Blanchard continue; 207694bf407SAnton Blanchard 208694bf407SAnton Blanchard if (choose_best_symbol(curr, next) == SYMBOL_A) { 2097137ff50SDavidlohr Bueso rb_erase_cached(&next->rb_node, symbols); 210d4f74eb8SChenggang Qin symbol__delete(next); 211694bf407SAnton Blanchard goto again; 212694bf407SAnton Blanchard } else { 213694bf407SAnton Blanchard nd = rb_next(&curr->rb_node); 2147137ff50SDavidlohr Bueso rb_erase_cached(&curr->rb_node, symbols); 215d4f74eb8SChenggang Qin symbol__delete(curr); 216694bf407SAnton Blanchard } 217694bf407SAnton Blanchard } 218694bf407SAnton Blanchard } 219694bf407SAnton Blanchard 2207137ff50SDavidlohr Bueso void symbols__fixup_end(struct rb_root_cached *symbols) 221af427bf5SArnaldo Carvalho de Melo { 2227137ff50SDavidlohr Bueso struct rb_node *nd, *prevnd = rb_first_cached(symbols); 2232e538c4aSArnaldo Carvalho de Melo struct symbol *curr, *prev; 224af427bf5SArnaldo Carvalho de Melo 225af427bf5SArnaldo Carvalho de Melo if (prevnd == NULL) 226af427bf5SArnaldo Carvalho de Melo return; 227af427bf5SArnaldo Carvalho de Melo 2282e538c4aSArnaldo Carvalho de Melo curr = rb_entry(prevnd, struct symbol, rb_node); 2292e538c4aSArnaldo Carvalho de Melo 230af427bf5SArnaldo Carvalho de Melo for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 2312e538c4aSArnaldo Carvalho de Melo prev = curr; 2322e538c4aSArnaldo Carvalho de Melo curr = rb_entry(nd, struct symbol, rb_node); 233af427bf5SArnaldo Carvalho de Melo 2343b01a413SArnaldo Carvalho de Melo if (prev->end == prev->start && prev->end != curr->start) 235b9c0a649SThomas Richter arch__symbols__fixup_end(prev, curr); 236af427bf5SArnaldo Carvalho de Melo } 237af427bf5SArnaldo Carvalho de Melo 2382e538c4aSArnaldo Carvalho de Melo /* Last entry */ 2392e538c4aSArnaldo Carvalho de Melo if (curr->end == curr->start) 240e7ede72aSDaniel Borkmann curr->end = roundup(curr->start, 4096) + 4096; 2412e538c4aSArnaldo Carvalho de Melo } 2422e538c4aSArnaldo Carvalho de Melo 2439a29ceeeSArnaldo Carvalho de Melo void maps__fixup_end(struct maps *maps) 244af427bf5SArnaldo Carvalho de Melo { 2458efc4f05SArnaldo Carvalho de Melo struct map *prev = NULL, *curr; 246af427bf5SArnaldo Carvalho de Melo 2470a7c74eaSArnaldo Carvalho de Melo down_write(&maps->lock); 2486a2ffcddSArnaldo Carvalho de Melo 2498efc4f05SArnaldo Carvalho de Melo maps__for_each_entry(maps, curr) { 2508efc4f05SArnaldo Carvalho de Melo if (prev != NULL && !prev->end) 2518efc4f05SArnaldo Carvalho de Melo prev->end = curr->start; 252af427bf5SArnaldo Carvalho de Melo 2538efc4f05SArnaldo Carvalho de Melo prev = curr; 2542e538c4aSArnaldo Carvalho de Melo } 25590c83218SArnaldo Carvalho de Melo 25690c83218SArnaldo Carvalho de Melo /* 25790c83218SArnaldo Carvalho de Melo * We still haven't the actual symbols, so guess the 25890c83218SArnaldo Carvalho de Melo * last map final address. 25990c83218SArnaldo Carvalho de Melo */ 2608efc4f05SArnaldo Carvalho de Melo if (curr && !curr->end) 2619d1faba5SIan Munsie curr->end = ~0ULL; 2626a2ffcddSArnaldo Carvalho de Melo 2630a7c74eaSArnaldo Carvalho de Melo up_write(&maps->lock); 264af427bf5SArnaldo Carvalho de Melo } 265af427bf5SArnaldo Carvalho de Melo 266af30bffaSArnaldo Carvalho de Melo struct symbol *symbol__new(u64 start, u64 len, u8 binding, u8 type, const char *name) 26786470930SIngo Molnar { 26886470930SIngo Molnar size_t namelen = strlen(name) + 1; 269aeafcbafSArnaldo Carvalho de Melo struct symbol *sym = calloc(1, (symbol_conf.priv_size + 270aeafcbafSArnaldo Carvalho de Melo sizeof(*sym) + namelen)); 271aeafcbafSArnaldo Carvalho de Melo if (sym == NULL) 27286470930SIngo Molnar return NULL; 27386470930SIngo Molnar 274b01141f4SArnaldo Carvalho de Melo if (symbol_conf.priv_size) { 275b01141f4SArnaldo Carvalho de Melo if (symbol_conf.init_annotation) { 276b01141f4SArnaldo Carvalho de Melo struct annotation *notes = (void *)sym; 277b01141f4SArnaldo Carvalho de Melo pthread_mutex_init(¬es->lock, NULL); 278b01141f4SArnaldo Carvalho de Melo } 279aeafcbafSArnaldo Carvalho de Melo sym = ((void *)sym) + symbol_conf.priv_size; 280b01141f4SArnaldo Carvalho de Melo } 28136479484SArnaldo Carvalho de Melo 282aeafcbafSArnaldo Carvalho de Melo sym->start = start; 2832c241bd3SArnaldo Carvalho de Melo sym->end = len ? start + len : start; 284af30bffaSArnaldo Carvalho de Melo sym->type = type; 285aeafcbafSArnaldo Carvalho de Melo sym->binding = binding; 286aeafcbafSArnaldo Carvalho de Melo sym->namelen = namelen - 1; 287e4204992SArnaldo Carvalho de Melo 288aeafcbafSArnaldo Carvalho de Melo pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n", 289aeafcbafSArnaldo Carvalho de Melo __func__, name, start, sym->end); 290aeafcbafSArnaldo Carvalho de Melo memcpy(sym->name, name, namelen); 291e4204992SArnaldo Carvalho de Melo 292aeafcbafSArnaldo Carvalho de Melo return sym; 29386470930SIngo Molnar } 29486470930SIngo Molnar 295aeafcbafSArnaldo Carvalho de Melo void symbol__delete(struct symbol *sym) 29686470930SIngo Molnar { 297aeafcbafSArnaldo Carvalho de Melo free(((void *)sym) - symbol_conf.priv_size); 29886470930SIngo Molnar } 29986470930SIngo Molnar 3007137ff50SDavidlohr Bueso void symbols__delete(struct rb_root_cached *symbols) 30186470930SIngo Molnar { 30286470930SIngo Molnar struct symbol *pos; 3037137ff50SDavidlohr Bueso struct rb_node *next = rb_first_cached(symbols); 30486470930SIngo Molnar 30586470930SIngo Molnar while (next) { 30686470930SIngo Molnar pos = rb_entry(next, struct symbol, rb_node); 30786470930SIngo Molnar next = rb_next(&pos->rb_node); 3087137ff50SDavidlohr Bueso rb_erase_cached(&pos->rb_node, symbols); 30900a192b3SArnaldo Carvalho de Melo symbol__delete(pos); 31086470930SIngo Molnar } 31186470930SIngo Molnar } 31286470930SIngo Molnar 3137137ff50SDavidlohr Bueso void __symbols__insert(struct rb_root_cached *symbols, 3147137ff50SDavidlohr Bueso struct symbol *sym, bool kernel) 31586470930SIngo Molnar { 3167137ff50SDavidlohr Bueso struct rb_node **p = &symbols->rb_root.rb_node; 31786470930SIngo Molnar struct rb_node *parent = NULL; 3189cffa8d5SPaul Mackerras const u64 ip = sym->start; 31986470930SIngo Molnar struct symbol *s; 3207137ff50SDavidlohr Bueso bool leftmost = true; 32186470930SIngo Molnar 322608c34deSArnaldo Carvalho de Melo if (kernel) { 323608c34deSArnaldo Carvalho de Melo const char *name = sym->name; 324608c34deSArnaldo Carvalho de Melo /* 325608c34deSArnaldo Carvalho de Melo * ppc64 uses function descriptors and appends a '.' to the 326608c34deSArnaldo Carvalho de Melo * start of every instruction address. Remove it. 327608c34deSArnaldo Carvalho de Melo */ 328608c34deSArnaldo Carvalho de Melo if (name[0] == '.') 329608c34deSArnaldo Carvalho de Melo name++; 330608c34deSArnaldo Carvalho de Melo sym->idle = symbol__is_idle(name); 331608c34deSArnaldo Carvalho de Melo } 332608c34deSArnaldo Carvalho de Melo 33386470930SIngo Molnar while (*p != NULL) { 33486470930SIngo Molnar parent = *p; 33586470930SIngo Molnar s = rb_entry(parent, struct symbol, rb_node); 33686470930SIngo Molnar if (ip < s->start) 33786470930SIngo Molnar p = &(*p)->rb_left; 3387137ff50SDavidlohr Bueso else { 33986470930SIngo Molnar p = &(*p)->rb_right; 3407137ff50SDavidlohr Bueso leftmost = false; 3417137ff50SDavidlohr Bueso } 34286470930SIngo Molnar } 34386470930SIngo Molnar rb_link_node(&sym->rb_node, parent, p); 3447137ff50SDavidlohr Bueso rb_insert_color_cached(&sym->rb_node, symbols, leftmost); 34586470930SIngo Molnar } 34686470930SIngo Molnar 3477137ff50SDavidlohr Bueso void symbols__insert(struct rb_root_cached *symbols, struct symbol *sym) 348608c34deSArnaldo Carvalho de Melo { 349608c34deSArnaldo Carvalho de Melo __symbols__insert(symbols, sym, false); 350608c34deSArnaldo Carvalho de Melo } 351608c34deSArnaldo Carvalho de Melo 3527137ff50SDavidlohr Bueso static struct symbol *symbols__find(struct rb_root_cached *symbols, u64 ip) 35386470930SIngo Molnar { 35486470930SIngo Molnar struct rb_node *n; 35586470930SIngo Molnar 356aeafcbafSArnaldo Carvalho de Melo if (symbols == NULL) 35786470930SIngo Molnar return NULL; 35886470930SIngo Molnar 3597137ff50SDavidlohr Bueso n = symbols->rb_root.rb_node; 36086470930SIngo Molnar 36186470930SIngo Molnar while (n) { 36286470930SIngo Molnar struct symbol *s = rb_entry(n, struct symbol, rb_node); 36386470930SIngo Molnar 36486470930SIngo Molnar if (ip < s->start) 36586470930SIngo Molnar n = n->rb_left; 3669c7b37cdSChris Phlipot else if (ip > s->end || (ip == s->end && ip != s->start)) 36786470930SIngo Molnar n = n->rb_right; 36886470930SIngo Molnar else 36986470930SIngo Molnar return s; 37086470930SIngo Molnar } 37186470930SIngo Molnar 37286470930SIngo Molnar return NULL; 37386470930SIngo Molnar } 37486470930SIngo Molnar 3757137ff50SDavidlohr Bueso static struct symbol *symbols__first(struct rb_root_cached *symbols) 3768e0cf965SAdrian Hunter { 3777137ff50SDavidlohr Bueso struct rb_node *n = rb_first_cached(symbols); 3788e0cf965SAdrian Hunter 3798e0cf965SAdrian Hunter if (n) 3808e0cf965SAdrian Hunter return rb_entry(n, struct symbol, rb_node); 3818e0cf965SAdrian Hunter 3828e0cf965SAdrian Hunter return NULL; 3838e0cf965SAdrian Hunter } 3848e0cf965SAdrian Hunter 3857137ff50SDavidlohr Bueso static struct symbol *symbols__last(struct rb_root_cached *symbols) 386cd67f99fSAdrian Hunter { 3877137ff50SDavidlohr Bueso struct rb_node *n = rb_last(&symbols->rb_root); 388cd67f99fSAdrian Hunter 389cd67f99fSAdrian Hunter if (n) 390cd67f99fSAdrian Hunter return rb_entry(n, struct symbol, rb_node); 391cd67f99fSAdrian Hunter 392cd67f99fSAdrian Hunter return NULL; 393cd67f99fSAdrian Hunter } 394cd67f99fSAdrian Hunter 3959c00a81bSAdrian Hunter static struct symbol *symbols__next(struct symbol *sym) 3969c00a81bSAdrian Hunter { 3979c00a81bSAdrian Hunter struct rb_node *n = rb_next(&sym->rb_node); 3989c00a81bSAdrian Hunter 3999c00a81bSAdrian Hunter if (n) 4009c00a81bSAdrian Hunter return rb_entry(n, struct symbol, rb_node); 4019c00a81bSAdrian Hunter 4029c00a81bSAdrian Hunter return NULL; 4039c00a81bSAdrian Hunter } 4049c00a81bSAdrian Hunter 4057137ff50SDavidlohr Bueso static void symbols__insert_by_name(struct rb_root_cached *symbols, struct symbol *sym) 40679406cd7SArnaldo Carvalho de Melo { 4077137ff50SDavidlohr Bueso struct rb_node **p = &symbols->rb_root.rb_node; 40879406cd7SArnaldo Carvalho de Melo struct rb_node *parent = NULL; 40902a9d037SRabin Vincent struct symbol_name_rb_node *symn, *s; 4107137ff50SDavidlohr Bueso bool leftmost = true; 41102a9d037SRabin Vincent 41202a9d037SRabin Vincent symn = container_of(sym, struct symbol_name_rb_node, sym); 41379406cd7SArnaldo Carvalho de Melo 41479406cd7SArnaldo Carvalho de Melo while (*p != NULL) { 41579406cd7SArnaldo Carvalho de Melo parent = *p; 41679406cd7SArnaldo Carvalho de Melo s = rb_entry(parent, struct symbol_name_rb_node, rb_node); 41779406cd7SArnaldo Carvalho de Melo if (strcmp(sym->name, s->sym.name) < 0) 41879406cd7SArnaldo Carvalho de Melo p = &(*p)->rb_left; 4197137ff50SDavidlohr Bueso else { 42079406cd7SArnaldo Carvalho de Melo p = &(*p)->rb_right; 4217137ff50SDavidlohr Bueso leftmost = false; 4227137ff50SDavidlohr Bueso } 42379406cd7SArnaldo Carvalho de Melo } 42479406cd7SArnaldo Carvalho de Melo rb_link_node(&symn->rb_node, parent, p); 4257137ff50SDavidlohr Bueso rb_insert_color_cached(&symn->rb_node, symbols, leftmost); 42679406cd7SArnaldo Carvalho de Melo } 42779406cd7SArnaldo Carvalho de Melo 4287137ff50SDavidlohr Bueso static void symbols__sort_by_name(struct rb_root_cached *symbols, 4297137ff50SDavidlohr Bueso struct rb_root_cached *source) 43079406cd7SArnaldo Carvalho de Melo { 43179406cd7SArnaldo Carvalho de Melo struct rb_node *nd; 43279406cd7SArnaldo Carvalho de Melo 4337137ff50SDavidlohr Bueso for (nd = rb_first_cached(source); nd; nd = rb_next(nd)) { 43479406cd7SArnaldo Carvalho de Melo struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 435aeafcbafSArnaldo Carvalho de Melo symbols__insert_by_name(symbols, pos); 43679406cd7SArnaldo Carvalho de Melo } 43779406cd7SArnaldo Carvalho de Melo } 43879406cd7SArnaldo Carvalho de Melo 439d8040645SPaul Clarke int symbol__match_symbol_name(const char *name, const char *str, 440d8040645SPaul Clarke enum symbol_tag_include includes) 441d8040645SPaul Clarke { 442d8040645SPaul Clarke const char *versioning; 443d8040645SPaul Clarke 444d8040645SPaul Clarke if (includes == SYMBOL_TAG_INCLUDE__DEFAULT_ONLY && 445d8040645SPaul Clarke (versioning = strstr(name, "@@"))) { 446d8040645SPaul Clarke int len = strlen(str); 447d8040645SPaul Clarke 448d8040645SPaul Clarke if (len < versioning - name) 449d8040645SPaul Clarke len = versioning - name; 450d8040645SPaul Clarke 451d8040645SPaul Clarke return arch__compare_symbol_names_n(name, str, len); 452d8040645SPaul Clarke } else 453d8040645SPaul Clarke return arch__compare_symbol_names(name, str); 454d8040645SPaul Clarke } 455d8040645SPaul Clarke 4567137ff50SDavidlohr Bueso static struct symbol *symbols__find_by_name(struct rb_root_cached *symbols, 457d8040645SPaul Clarke const char *name, 458d8040645SPaul Clarke enum symbol_tag_include includes) 45979406cd7SArnaldo Carvalho de Melo { 46079406cd7SArnaldo Carvalho de Melo struct rb_node *n; 4615bcaaca3SMartin Liška struct symbol_name_rb_node *s = NULL; 46279406cd7SArnaldo Carvalho de Melo 463aeafcbafSArnaldo Carvalho de Melo if (symbols == NULL) 46479406cd7SArnaldo Carvalho de Melo return NULL; 46579406cd7SArnaldo Carvalho de Melo 4667137ff50SDavidlohr Bueso n = symbols->rb_root.rb_node; 46779406cd7SArnaldo Carvalho de Melo 46879406cd7SArnaldo Carvalho de Melo while (n) { 46979406cd7SArnaldo Carvalho de Melo int cmp; 47079406cd7SArnaldo Carvalho de Melo 47179406cd7SArnaldo Carvalho de Melo s = rb_entry(n, struct symbol_name_rb_node, rb_node); 472d8040645SPaul Clarke cmp = symbol__match_symbol_name(s->sym.name, name, includes); 47379406cd7SArnaldo Carvalho de Melo 474d8040645SPaul Clarke if (cmp > 0) 47579406cd7SArnaldo Carvalho de Melo n = n->rb_left; 476d8040645SPaul Clarke else if (cmp < 0) 47779406cd7SArnaldo Carvalho de Melo n = n->rb_right; 47879406cd7SArnaldo Carvalho de Melo else 479de480999SNamhyung Kim break; 48079406cd7SArnaldo Carvalho de Melo } 48179406cd7SArnaldo Carvalho de Melo 482de480999SNamhyung Kim if (n == NULL) 48379406cd7SArnaldo Carvalho de Melo return NULL; 484de480999SNamhyung Kim 485d8040645SPaul Clarke if (includes != SYMBOL_TAG_INCLUDE__DEFAULT_ONLY) 486de480999SNamhyung Kim /* return first symbol that has same name (if any) */ 487de480999SNamhyung Kim for (n = rb_prev(n); n; n = rb_prev(n)) { 488de480999SNamhyung Kim struct symbol_name_rb_node *tmp; 489de480999SNamhyung Kim 490de480999SNamhyung Kim tmp = rb_entry(n, struct symbol_name_rb_node, rb_node); 491031b84c4SNaveen N. Rao if (arch__compare_symbol_names(tmp->sym.name, s->sym.name)) 492de480999SNamhyung Kim break; 493de480999SNamhyung Kim 494de480999SNamhyung Kim s = tmp; 495de480999SNamhyung Kim } 496de480999SNamhyung Kim 497de480999SNamhyung Kim return &s->sym; 49879406cd7SArnaldo Carvalho de Melo } 49979406cd7SArnaldo Carvalho de Melo 500c0b4dffbSArnaldo Carvalho de Melo void dso__reset_find_symbol_cache(struct dso *dso) 501c0b4dffbSArnaldo Carvalho de Melo { 5023183f8caSArnaldo Carvalho de Melo dso->last_find_result.addr = 0; 5033183f8caSArnaldo Carvalho de Melo dso->last_find_result.symbol = NULL; 504c0b4dffbSArnaldo Carvalho de Melo } 505c0b4dffbSArnaldo Carvalho de Melo 5063183f8caSArnaldo Carvalho de Melo void dso__insert_symbol(struct dso *dso, struct symbol *sym) 507ae93a6c7SChris Phlipot { 5083183f8caSArnaldo Carvalho de Melo __symbols__insert(&dso->symbols, sym, dso->kernel); 509ae93a6c7SChris Phlipot 510ae93a6c7SChris Phlipot /* update the symbol cache if necessary */ 5113183f8caSArnaldo Carvalho de Melo if (dso->last_find_result.addr >= sym->start && 5123183f8caSArnaldo Carvalho de Melo (dso->last_find_result.addr < sym->end || 513ae93a6c7SChris Phlipot sym->start == sym->end)) { 5143183f8caSArnaldo Carvalho de Melo dso->last_find_result.symbol = sym; 515ae93a6c7SChris Phlipot } 516ae93a6c7SChris Phlipot } 517ae93a6c7SChris Phlipot 5183183f8caSArnaldo Carvalho de Melo struct symbol *dso__find_symbol(struct dso *dso, u64 addr) 519fcf1203aSArnaldo Carvalho de Melo { 5203183f8caSArnaldo Carvalho de Melo if (dso->last_find_result.addr != addr || dso->last_find_result.symbol == NULL) { 5213183f8caSArnaldo Carvalho de Melo dso->last_find_result.addr = addr; 5223183f8caSArnaldo Carvalho de Melo dso->last_find_result.symbol = symbols__find(&dso->symbols, addr); 523b685ac22SArnaldo Carvalho de Melo } 524b685ac22SArnaldo Carvalho de Melo 5253183f8caSArnaldo Carvalho de Melo return dso->last_find_result.symbol; 5268e0cf965SAdrian Hunter } 5278e0cf965SAdrian Hunter 5285cf88a63SArnaldo Carvalho de Melo struct symbol *dso__first_symbol(struct dso *dso) 5295cf88a63SArnaldo Carvalho de Melo { 5303183f8caSArnaldo Carvalho de Melo return symbols__first(&dso->symbols); 531cd67f99fSAdrian Hunter } 532cd67f99fSAdrian Hunter 5335cf88a63SArnaldo Carvalho de Melo struct symbol *dso__last_symbol(struct dso *dso) 5345cf88a63SArnaldo Carvalho de Melo { 5353183f8caSArnaldo Carvalho de Melo return symbols__last(&dso->symbols); 5365cf88a63SArnaldo Carvalho de Melo } 5375cf88a63SArnaldo Carvalho de Melo 5389c00a81bSAdrian Hunter struct symbol *dso__next_symbol(struct symbol *sym) 5399c00a81bSAdrian Hunter { 5409c00a81bSAdrian Hunter return symbols__next(sym); 5419c00a81bSAdrian Hunter } 5429c00a81bSAdrian Hunter 54318bd7264SArnaldo Carvalho de Melo struct symbol *symbol__next_by_name(struct symbol *sym) 54418bd7264SArnaldo Carvalho de Melo { 54518bd7264SArnaldo Carvalho de Melo struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym); 54618bd7264SArnaldo Carvalho de Melo struct rb_node *n = rb_next(&s->rb_node); 54718bd7264SArnaldo Carvalho de Melo 54818bd7264SArnaldo Carvalho de Melo return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL; 54918bd7264SArnaldo Carvalho de Melo } 55018bd7264SArnaldo Carvalho de Melo 55118bd7264SArnaldo Carvalho de Melo /* 552af07eeb0SArnaldo Carvalho de Melo * Returns first symbol that matched with @name. 55318bd7264SArnaldo Carvalho de Melo */ 5543183f8caSArnaldo Carvalho de Melo struct symbol *dso__find_symbol_by_name(struct dso *dso, const char *name) 55579406cd7SArnaldo Carvalho de Melo { 5563183f8caSArnaldo Carvalho de Melo struct symbol *s = symbols__find_by_name(&dso->symbol_names, name, 557d8040645SPaul Clarke SYMBOL_TAG_INCLUDE__NONE); 558d8040645SPaul Clarke if (!s) 5593183f8caSArnaldo Carvalho de Melo s = symbols__find_by_name(&dso->symbol_names, name, 560d8040645SPaul Clarke SYMBOL_TAG_INCLUDE__DEFAULT_ONLY); 561d8040645SPaul Clarke return s; 56279406cd7SArnaldo Carvalho de Melo } 56379406cd7SArnaldo Carvalho de Melo 5643183f8caSArnaldo Carvalho de Melo void dso__sort_by_name(struct dso *dso) 56579406cd7SArnaldo Carvalho de Melo { 5663183f8caSArnaldo Carvalho de Melo dso__set_sorted_by_name(dso); 5673183f8caSArnaldo Carvalho de Melo return symbols__sort_by_name(&dso->symbol_names, &dso->symbols); 56879406cd7SArnaldo Carvalho de Melo } 56979406cd7SArnaldo Carvalho de Melo 57032add10fSIan Rogers /* 57132add10fSIan Rogers * While we find nice hex chars, build a long_val. 57232add10fSIan Rogers * Return number of chars processed. 57332add10fSIan Rogers */ 57432add10fSIan Rogers static int hex2u64(const char *ptr, u64 *long_val) 57532add10fSIan Rogers { 57632add10fSIan Rogers char *p; 57732add10fSIan Rogers 57832add10fSIan Rogers *long_val = strtoull(ptr, &p, 16); 57932add10fSIan Rogers 58032add10fSIan Rogers return p - ptr; 58132add10fSIan Rogers } 58232add10fSIan Rogers 58332add10fSIan Rogers 584316d70d6SAdrian Hunter int modules__parse(const char *filename, void *arg, 585316d70d6SAdrian Hunter int (*process_module)(void *arg, const char *name, 5869ad4652bSThomas Richter u64 start, u64 size)) 587316d70d6SAdrian Hunter { 588316d70d6SAdrian Hunter char *line = NULL; 589316d70d6SAdrian Hunter size_t n; 590316d70d6SAdrian Hunter FILE *file; 591316d70d6SAdrian Hunter int err = 0; 592316d70d6SAdrian Hunter 593316d70d6SAdrian Hunter file = fopen(filename, "r"); 594316d70d6SAdrian Hunter if (file == NULL) 595316d70d6SAdrian Hunter return -1; 596316d70d6SAdrian Hunter 597316d70d6SAdrian Hunter while (1) { 598316d70d6SAdrian Hunter char name[PATH_MAX]; 5999ad4652bSThomas Richter u64 start, size; 6009ad4652bSThomas Richter char *sep, *endptr; 601316d70d6SAdrian Hunter ssize_t line_len; 602316d70d6SAdrian Hunter 603316d70d6SAdrian Hunter line_len = getline(&line, &n, file); 604316d70d6SAdrian Hunter if (line_len < 0) { 605316d70d6SAdrian Hunter if (feof(file)) 606316d70d6SAdrian Hunter break; 607316d70d6SAdrian Hunter err = -1; 608316d70d6SAdrian Hunter goto out; 609316d70d6SAdrian Hunter } 610316d70d6SAdrian Hunter 611316d70d6SAdrian Hunter if (!line) { 612316d70d6SAdrian Hunter err = -1; 613316d70d6SAdrian Hunter goto out; 614316d70d6SAdrian Hunter } 615316d70d6SAdrian Hunter 616316d70d6SAdrian Hunter line[--line_len] = '\0'; /* \n */ 617316d70d6SAdrian Hunter 618316d70d6SAdrian Hunter sep = strrchr(line, 'x'); 619316d70d6SAdrian Hunter if (sep == NULL) 620316d70d6SAdrian Hunter continue; 621316d70d6SAdrian Hunter 622316d70d6SAdrian Hunter hex2u64(sep + 1, &start); 623316d70d6SAdrian Hunter 624316d70d6SAdrian Hunter sep = strchr(line, ' '); 625316d70d6SAdrian Hunter if (sep == NULL) 626316d70d6SAdrian Hunter continue; 627316d70d6SAdrian Hunter 628316d70d6SAdrian Hunter *sep = '\0'; 629316d70d6SAdrian Hunter 630316d70d6SAdrian Hunter scnprintf(name, sizeof(name), "[%s]", line); 631316d70d6SAdrian Hunter 6329ad4652bSThomas Richter size = strtoul(sep + 1, &endptr, 0); 6339ad4652bSThomas Richter if (*endptr != ' ' && *endptr != '\t') 6349ad4652bSThomas Richter continue; 6359ad4652bSThomas Richter 6369ad4652bSThomas Richter err = process_module(arg, name, start, size); 637316d70d6SAdrian Hunter if (err) 638316d70d6SAdrian Hunter break; 639316d70d6SAdrian Hunter } 640316d70d6SAdrian Hunter out: 641316d70d6SAdrian Hunter free(line); 642316d70d6SAdrian Hunter fclose(file); 643316d70d6SAdrian Hunter return err; 644316d70d6SAdrian Hunter } 645316d70d6SAdrian Hunter 646e7110b9fSArnaldo Carvalho de Melo /* 647e7110b9fSArnaldo Carvalho de Melo * These are symbols in the kernel image, so make sure that 648e7110b9fSArnaldo Carvalho de Melo * sym is from a kernel DSO. 649e7110b9fSArnaldo Carvalho de Melo */ 650608c34deSArnaldo Carvalho de Melo static bool symbol__is_idle(const char *name) 65182d1deb0SDavid Ahern { 65282d1deb0SDavid Ahern const char * const idle_symbols[] = { 6530e71459aSKim Phillips "acpi_idle_do_entry", 6540e71459aSKim Phillips "acpi_processor_ffh_cstate_enter", 655549aff77SArnaldo Carvalho de Melo "arch_cpu_idle", 65682d1deb0SDavid Ahern "cpu_idle", 657e0336ed6SArnaldo Carvalho de Melo "cpu_startup_entry", 6580e71459aSKim Phillips "idle_cpu", 65982d1deb0SDavid Ahern "intel_idle", 66082d1deb0SDavid Ahern "default_idle", 66182d1deb0SDavid Ahern "native_safe_halt", 66282d1deb0SDavid Ahern "enter_idle", 66382d1deb0SDavid Ahern "exit_idle", 66482d1deb0SDavid Ahern "mwait_idle", 66582d1deb0SDavid Ahern "mwait_idle_with_hints", 66682d1deb0SDavid Ahern "poll_idle", 66782d1deb0SDavid Ahern "ppc64_runlatch_off", 66882d1deb0SDavid Ahern "pseries_dedicated_idle_sleep", 66919bf119cSSven Schnelle "psw_idle", 67019bf119cSSven Schnelle "psw_idle_exit", 67182d1deb0SDavid Ahern NULL 67282d1deb0SDavid Ahern }; 67382d1deb0SDavid Ahern int i; 674bc5f15beSKim Phillips static struct strlist *idle_symbols_list; 67582d1deb0SDavid Ahern 676bc5f15beSKim Phillips if (idle_symbols_list) 677bc5f15beSKim Phillips return strlist__has_entry(idle_symbols_list, name); 67882d1deb0SDavid Ahern 679bc5f15beSKim Phillips idle_symbols_list = strlist__new(NULL, NULL); 680bc5f15beSKim Phillips 681bc5f15beSKim Phillips for (i = 0; idle_symbols[i]; i++) 682bc5f15beSKim Phillips strlist__add(idle_symbols_list, idle_symbols[i]); 683bc5f15beSKim Phillips 684bc5f15beSKim Phillips return strlist__has_entry(idle_symbols_list, name); 68582d1deb0SDavid Ahern } 68682d1deb0SDavid Ahern 687682b335aSArnaldo Carvalho de Melo static int map__process_kallsym_symbol(void *arg, const char *name, 68882151520SCody P Schafer char type, u64 start) 689682b335aSArnaldo Carvalho de Melo { 690682b335aSArnaldo Carvalho de Melo struct symbol *sym; 691333cc76cSArnaldo Carvalho de Melo struct dso *dso = arg; 6927137ff50SDavidlohr Bueso struct rb_root_cached *root = &dso->symbols; 693682b335aSArnaldo Carvalho de Melo 6943183f8caSArnaldo Carvalho de Melo if (!symbol_type__filter(type)) 695682b335aSArnaldo Carvalho de Melo return 0; 696682b335aSArnaldo Carvalho de Melo 69782151520SCody P Schafer /* 69882151520SCody P Schafer * module symbols are not sorted so we add all 69982151520SCody P Schafer * symbols, setting length to 0, and rely on 70082151520SCody P Schafer * symbols__fixup_end() to fix it up. 70182151520SCody P Schafer */ 702af30bffaSArnaldo Carvalho de Melo sym = symbol__new(start, 0, kallsyms2elf_binding(type), kallsyms2elf_type(type), name); 7032e538c4aSArnaldo Carvalho de Melo if (sym == NULL) 704682b335aSArnaldo Carvalho de Melo return -ENOMEM; 70582164161SArnaldo Carvalho de Melo /* 70682164161SArnaldo Carvalho de Melo * We will pass the symbols to the filter later, in 7074e06255fSArnaldo Carvalho de Melo * map__split_kallsyms, when we have split the maps per module 70882164161SArnaldo Carvalho de Melo */ 709608c34deSArnaldo Carvalho de Melo __symbols__insert(root, sym, !strchr(name, '[')); 710a1645ce1SZhang, Yanmin 711682b335aSArnaldo Carvalho de Melo return 0; 7122e538c4aSArnaldo Carvalho de Melo } 7132e538c4aSArnaldo Carvalho de Melo 714682b335aSArnaldo Carvalho de Melo /* 715682b335aSArnaldo Carvalho de Melo * Loads the function entries in /proc/kallsyms into kernel_map->dso, 716682b335aSArnaldo Carvalho de Melo * so that we can in the next step set the symbol ->end address and then 717682b335aSArnaldo Carvalho de Melo * call kernel_maps__split_kallsyms. 718682b335aSArnaldo Carvalho de Melo */ 719333cc76cSArnaldo Carvalho de Melo static int dso__load_all_kallsyms(struct dso *dso, const char *filename) 720682b335aSArnaldo Carvalho de Melo { 721333cc76cSArnaldo Carvalho de Melo return kallsyms__parse(filename, dso, map__process_kallsym_symbol); 7222e538c4aSArnaldo Carvalho de Melo } 7232e538c4aSArnaldo Carvalho de Melo 72479b6bb73SArnaldo Carvalho de Melo static int maps__split_kallsyms_for_kcore(struct maps *kmaps, struct dso *dso) 7258e0cf965SAdrian Hunter { 7268e0cf965SAdrian Hunter struct map *curr_map; 7278e0cf965SAdrian Hunter struct symbol *pos; 728866548ddSAdrian Hunter int count = 0; 7297137ff50SDavidlohr Bueso struct rb_root_cached old_root = dso->symbols; 7307137ff50SDavidlohr Bueso struct rb_root_cached *root = &dso->symbols; 7317137ff50SDavidlohr Bueso struct rb_node *next = rb_first_cached(root); 7328e0cf965SAdrian Hunter 733ba92732eSWang Nan if (!kmaps) 734ba92732eSWang Nan return -1; 735ba92732eSWang Nan 7367137ff50SDavidlohr Bueso *root = RB_ROOT_CACHED; 737866548ddSAdrian Hunter 7388e0cf965SAdrian Hunter while (next) { 7398e0cf965SAdrian Hunter char *module; 7408e0cf965SAdrian Hunter 7418e0cf965SAdrian Hunter pos = rb_entry(next, struct symbol, rb_node); 7428e0cf965SAdrian Hunter next = rb_next(&pos->rb_node); 7438e0cf965SAdrian Hunter 7447137ff50SDavidlohr Bueso rb_erase_cached(&pos->rb_node, &old_root); 7457137ff50SDavidlohr Bueso RB_CLEAR_NODE(&pos->rb_node); 7468e0cf965SAdrian Hunter module = strchr(pos->name, '\t'); 7478e0cf965SAdrian Hunter if (module) 7488e0cf965SAdrian Hunter *module = '\0'; 7498e0cf965SAdrian Hunter 75079b6bb73SArnaldo Carvalho de Melo curr_map = maps__find(kmaps, pos->start); 7518e0cf965SAdrian Hunter 752be39db9fSArnaldo Carvalho de Melo if (!curr_map) { 7538e0cf965SAdrian Hunter symbol__delete(pos); 754866548ddSAdrian Hunter continue; 755866548ddSAdrian Hunter } 756866548ddSAdrian Hunter 7578e0cf965SAdrian Hunter pos->start -= curr_map->start - curr_map->pgoff; 758d6d45745SAdrian Hunter if (pos->end > curr_map->end) 759d6d45745SAdrian Hunter pos->end = curr_map->end; 7608e0cf965SAdrian Hunter if (pos->end) 7618e0cf965SAdrian Hunter pos->end -= curr_map->start - curr_map->pgoff; 7623183f8caSArnaldo Carvalho de Melo symbols__insert(&curr_map->dso->symbols, pos); 7638e0cf965SAdrian Hunter ++count; 7648e0cf965SAdrian Hunter } 7658e0cf965SAdrian Hunter 7668e0cf965SAdrian Hunter /* Symbols have been adjusted */ 7678e0cf965SAdrian Hunter dso->adjust_symbols = 1; 7688e0cf965SAdrian Hunter 769866548ddSAdrian Hunter return count; 7708e0cf965SAdrian Hunter } 7718e0cf965SAdrian Hunter 7722e538c4aSArnaldo Carvalho de Melo /* 7732e538c4aSArnaldo Carvalho de Melo * Split the symbols into maps, making sure there are no overlaps, i.e. the 7742e538c4aSArnaldo Carvalho de Melo * kernel range is broken in several maps, named [kernel].N, as we don't have 7752e538c4aSArnaldo Carvalho de Melo * the original ELF section names vmlinux have. 7762e538c4aSArnaldo Carvalho de Melo */ 77779b6bb73SArnaldo Carvalho de Melo static int maps__split_kallsyms(struct maps *kmaps, struct dso *dso, u64 delta, 77815e0e2d4SArnaldo Carvalho de Melo struct map *initial_map) 7792e538c4aSArnaldo Carvalho de Melo { 780ba92732eSWang Nan struct machine *machine; 78115e0e2d4SArnaldo Carvalho de Melo struct map *curr_map = initial_map; 7822e538c4aSArnaldo Carvalho de Melo struct symbol *pos; 7838a953312SArnaldo Carvalho de Melo int count = 0, moved = 0; 7847137ff50SDavidlohr Bueso struct rb_root_cached *root = &dso->symbols; 7857137ff50SDavidlohr Bueso struct rb_node *next = rb_first_cached(root); 7862e538c4aSArnaldo Carvalho de Melo int kernel_range = 0; 7874d004365SAdrian Hunter bool x86_64; 7882e538c4aSArnaldo Carvalho de Melo 789ba92732eSWang Nan if (!kmaps) 790ba92732eSWang Nan return -1; 791ba92732eSWang Nan 792ba92732eSWang Nan machine = kmaps->machine; 793ba92732eSWang Nan 7944d004365SAdrian Hunter x86_64 = machine__is(machine, "x86_64"); 7954d004365SAdrian Hunter 7962e538c4aSArnaldo Carvalho de Melo while (next) { 7972e538c4aSArnaldo Carvalho de Melo char *module; 7982e538c4aSArnaldo Carvalho de Melo 7992e538c4aSArnaldo Carvalho de Melo pos = rb_entry(next, struct symbol, rb_node); 8002e538c4aSArnaldo Carvalho de Melo next = rb_next(&pos->rb_node); 8012e538c4aSArnaldo Carvalho de Melo 8022e538c4aSArnaldo Carvalho de Melo module = strchr(pos->name, '\t'); 8032e538c4aSArnaldo Carvalho de Melo if (module) { 80475be6cf4SArnaldo Carvalho de Melo if (!symbol_conf.use_modules) 8051de8e245SArnaldo Carvalho de Melo goto discard_symbol; 8061de8e245SArnaldo Carvalho de Melo 8072e538c4aSArnaldo Carvalho de Melo *module++ = '\0'; 8082e538c4aSArnaldo Carvalho de Melo 809b7cece76SArnaldo Carvalho de Melo if (strcmp(curr_map->dso->short_name, module)) { 81015e0e2d4SArnaldo Carvalho de Melo if (curr_map != initial_map && 811*1c695c88SJiri Olsa dso->kernel == DSO_SPACE__KERNEL_GUEST && 81223346f21SArnaldo Carvalho de Melo machine__is_default_guest(machine)) { 813a1645ce1SZhang, Yanmin /* 814a1645ce1SZhang, Yanmin * We assume all symbols of a module are 815a1645ce1SZhang, Yanmin * continuous in * kallsyms, so curr_map 816a1645ce1SZhang, Yanmin * points to a module and all its 817a1645ce1SZhang, Yanmin * symbols are in its kmap. Mark it as 818a1645ce1SZhang, Yanmin * loaded. 819a1645ce1SZhang, Yanmin */ 8203183f8caSArnaldo Carvalho de Melo dso__set_loaded(curr_map->dso); 821af427bf5SArnaldo Carvalho de Melo } 822b7cece76SArnaldo Carvalho de Melo 82379b6bb73SArnaldo Carvalho de Melo curr_map = maps__find_by_name(kmaps, module); 824a1645ce1SZhang, Yanmin if (curr_map == NULL) { 8252f51903bSArnaldo Carvalho de Melo pr_debug("%s/proc/{kallsyms,modules} " 826a1645ce1SZhang, Yanmin "inconsistency while looking " 827a1645ce1SZhang, Yanmin "for \"%s\" module!\n", 82823346f21SArnaldo Carvalho de Melo machine->root_dir, module); 82915e0e2d4SArnaldo Carvalho de Melo curr_map = initial_map; 830a1645ce1SZhang, Yanmin goto discard_symbol; 831a1645ce1SZhang, Yanmin } 832a1645ce1SZhang, Yanmin 833a1645ce1SZhang, Yanmin if (curr_map->dso->loaded && 83423346f21SArnaldo Carvalho de Melo !machine__is_default_guest(machine)) 835b7cece76SArnaldo Carvalho de Melo goto discard_symbol; 836af427bf5SArnaldo Carvalho de Melo } 83786470930SIngo Molnar /* 8382e538c4aSArnaldo Carvalho de Melo * So that we look just like we get from .ko files, 83915e0e2d4SArnaldo Carvalho de Melo * i.e. not prelinked, relative to initial_map->start. 84086470930SIngo Molnar */ 8414e06255fSArnaldo Carvalho de Melo pos->start = curr_map->map_ip(curr_map, pos->start); 8424e06255fSArnaldo Carvalho de Melo pos->end = curr_map->map_ip(curr_map, pos->end); 8434d004365SAdrian Hunter } else if (x86_64 && is_entry_trampoline(pos->name)) { 8444d004365SAdrian Hunter /* 8454d004365SAdrian Hunter * These symbols are not needed anymore since the 8464d004365SAdrian Hunter * trampoline maps refer to the text section and it's 8474d004365SAdrian Hunter * symbols instead. Avoid having to deal with 8484d004365SAdrian Hunter * relocations, and the assumption that the first symbol 8494d004365SAdrian Hunter * is the start of kernel text, by simply removing the 8504d004365SAdrian Hunter * symbols at this point. 8514d004365SAdrian Hunter */ 8524d004365SAdrian Hunter goto discard_symbol; 85315e0e2d4SArnaldo Carvalho de Melo } else if (curr_map != initial_map) { 8542e538c4aSArnaldo Carvalho de Melo char dso_name[PATH_MAX]; 855aeafcbafSArnaldo Carvalho de Melo struct dso *ndso; 85686470930SIngo Molnar 857d9b62abaSAdrian Hunter if (delta) { 858d9b62abaSAdrian Hunter /* Kernel was relocated at boot time */ 859d9b62abaSAdrian Hunter pos->start -= delta; 860d9b62abaSAdrian Hunter pos->end -= delta; 861d9b62abaSAdrian Hunter } 862d9b62abaSAdrian Hunter 8638a953312SArnaldo Carvalho de Melo if (count == 0) { 86415e0e2d4SArnaldo Carvalho de Melo curr_map = initial_map; 865be39db9fSArnaldo Carvalho de Melo goto add_symbol; 8668a953312SArnaldo Carvalho de Melo } 8678a953312SArnaldo Carvalho de Melo 868*1c695c88SJiri Olsa if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 869a1645ce1SZhang, Yanmin snprintf(dso_name, sizeof(dso_name), 870a1645ce1SZhang, Yanmin "[guest.kernel].%d", 871a1645ce1SZhang, Yanmin kernel_range++); 872a1645ce1SZhang, Yanmin else 873a1645ce1SZhang, Yanmin snprintf(dso_name, sizeof(dso_name), 874a1645ce1SZhang, Yanmin "[kernel].%d", 8752e538c4aSArnaldo Carvalho de Melo kernel_range++); 87686470930SIngo Molnar 877aeafcbafSArnaldo Carvalho de Melo ndso = dso__new(dso_name); 878aeafcbafSArnaldo Carvalho de Melo if (ndso == NULL) 8792e538c4aSArnaldo Carvalho de Melo return -1; 8802e538c4aSArnaldo Carvalho de Melo 881aeafcbafSArnaldo Carvalho de Melo ndso->kernel = dso->kernel; 882a1645ce1SZhang, Yanmin 8833183f8caSArnaldo Carvalho de Melo curr_map = map__new2(pos->start, ndso); 88437fe5fcbSZhang, Yanmin if (curr_map == NULL) { 885d3a7c489SArnaldo Carvalho de Melo dso__put(ndso); 8862e538c4aSArnaldo Carvalho de Melo return -1; 8872e538c4aSArnaldo Carvalho de Melo } 8882e538c4aSArnaldo Carvalho de Melo 8894e06255fSArnaldo Carvalho de Melo curr_map->map_ip = curr_map->unmap_ip = identity__map_ip; 89079b6bb73SArnaldo Carvalho de Melo maps__insert(kmaps, curr_map); 8912e538c4aSArnaldo Carvalho de Melo ++kernel_range; 892d9b62abaSAdrian Hunter } else if (delta) { 893d9b62abaSAdrian Hunter /* Kernel was relocated at boot time */ 894d9b62abaSAdrian Hunter pos->start -= delta; 895d9b62abaSAdrian Hunter pos->end -= delta; 8962e538c4aSArnaldo Carvalho de Melo } 897be39db9fSArnaldo Carvalho de Melo add_symbol: 89815e0e2d4SArnaldo Carvalho de Melo if (curr_map != initial_map) { 8997137ff50SDavidlohr Bueso rb_erase_cached(&pos->rb_node, root); 9003183f8caSArnaldo Carvalho de Melo symbols__insert(&curr_map->dso->symbols, pos); 9018a953312SArnaldo Carvalho de Melo ++moved; 9028a953312SArnaldo Carvalho de Melo } else 9038a953312SArnaldo Carvalho de Melo ++count; 904be39db9fSArnaldo Carvalho de Melo 905be39db9fSArnaldo Carvalho de Melo continue; 906be39db9fSArnaldo Carvalho de Melo discard_symbol: 9077137ff50SDavidlohr Bueso rb_erase_cached(&pos->rb_node, root); 908be39db9fSArnaldo Carvalho de Melo symbol__delete(pos); 90986470930SIngo Molnar } 91086470930SIngo Molnar 91115e0e2d4SArnaldo Carvalho de Melo if (curr_map != initial_map && 912*1c695c88SJiri Olsa dso->kernel == DSO_SPACE__KERNEL_GUEST && 91323346f21SArnaldo Carvalho de Melo machine__is_default_guest(kmaps->machine)) { 9143183f8caSArnaldo Carvalho de Melo dso__set_loaded(curr_map->dso); 915a1645ce1SZhang, Yanmin } 916a1645ce1SZhang, Yanmin 9178a953312SArnaldo Carvalho de Melo return count + moved; 91886470930SIngo Molnar } 91986470930SIngo Molnar 9203f067dcaSArnaldo Carvalho de Melo bool symbol__restricted_filename(const char *filename, 921ec80fde7SArnaldo Carvalho de Melo const char *restricted_filename) 922ec80fde7SArnaldo Carvalho de Melo { 923ec80fde7SArnaldo Carvalho de Melo bool restricted = false; 924ec80fde7SArnaldo Carvalho de Melo 925ec80fde7SArnaldo Carvalho de Melo if (symbol_conf.kptr_restrict) { 926ec80fde7SArnaldo Carvalho de Melo char *r = realpath(filename, NULL); 927ec80fde7SArnaldo Carvalho de Melo 928ec80fde7SArnaldo Carvalho de Melo if (r != NULL) { 929ec80fde7SArnaldo Carvalho de Melo restricted = strcmp(r, restricted_filename) == 0; 930ec80fde7SArnaldo Carvalho de Melo free(r); 931ec80fde7SArnaldo Carvalho de Melo return restricted; 932ec80fde7SArnaldo Carvalho de Melo } 933ec80fde7SArnaldo Carvalho de Melo } 934ec80fde7SArnaldo Carvalho de Melo 935ec80fde7SArnaldo Carvalho de Melo return restricted; 936ec80fde7SArnaldo Carvalho de Melo } 937ec80fde7SArnaldo Carvalho de Melo 93852afdaf9SAdrian Hunter struct module_info { 93952afdaf9SAdrian Hunter struct rb_node rb_node; 94052afdaf9SAdrian Hunter char *name; 94152afdaf9SAdrian Hunter u64 start; 94252afdaf9SAdrian Hunter }; 94352afdaf9SAdrian Hunter 94452afdaf9SAdrian Hunter static void add_module(struct module_info *mi, struct rb_root *modules) 94552afdaf9SAdrian Hunter { 94652afdaf9SAdrian Hunter struct rb_node **p = &modules->rb_node; 94752afdaf9SAdrian Hunter struct rb_node *parent = NULL; 94852afdaf9SAdrian Hunter struct module_info *m; 94952afdaf9SAdrian Hunter 95052afdaf9SAdrian Hunter while (*p != NULL) { 95152afdaf9SAdrian Hunter parent = *p; 95252afdaf9SAdrian Hunter m = rb_entry(parent, struct module_info, rb_node); 95352afdaf9SAdrian Hunter if (strcmp(mi->name, m->name) < 0) 95452afdaf9SAdrian Hunter p = &(*p)->rb_left; 95552afdaf9SAdrian Hunter else 95652afdaf9SAdrian Hunter p = &(*p)->rb_right; 95752afdaf9SAdrian Hunter } 95852afdaf9SAdrian Hunter rb_link_node(&mi->rb_node, parent, p); 95952afdaf9SAdrian Hunter rb_insert_color(&mi->rb_node, modules); 96052afdaf9SAdrian Hunter } 96152afdaf9SAdrian Hunter 96252afdaf9SAdrian Hunter static void delete_modules(struct rb_root *modules) 96352afdaf9SAdrian Hunter { 96452afdaf9SAdrian Hunter struct module_info *mi; 96552afdaf9SAdrian Hunter struct rb_node *next = rb_first(modules); 96652afdaf9SAdrian Hunter 96752afdaf9SAdrian Hunter while (next) { 96852afdaf9SAdrian Hunter mi = rb_entry(next, struct module_info, rb_node); 96952afdaf9SAdrian Hunter next = rb_next(&mi->rb_node); 97052afdaf9SAdrian Hunter rb_erase(&mi->rb_node, modules); 97174cf249dSArnaldo Carvalho de Melo zfree(&mi->name); 97252afdaf9SAdrian Hunter free(mi); 97352afdaf9SAdrian Hunter } 97452afdaf9SAdrian Hunter } 97552afdaf9SAdrian Hunter 97652afdaf9SAdrian Hunter static struct module_info *find_module(const char *name, 97752afdaf9SAdrian Hunter struct rb_root *modules) 97852afdaf9SAdrian Hunter { 97952afdaf9SAdrian Hunter struct rb_node *n = modules->rb_node; 98052afdaf9SAdrian Hunter 98152afdaf9SAdrian Hunter while (n) { 98252afdaf9SAdrian Hunter struct module_info *m; 98352afdaf9SAdrian Hunter int cmp; 98452afdaf9SAdrian Hunter 98552afdaf9SAdrian Hunter m = rb_entry(n, struct module_info, rb_node); 98652afdaf9SAdrian Hunter cmp = strcmp(name, m->name); 98752afdaf9SAdrian Hunter if (cmp < 0) 98852afdaf9SAdrian Hunter n = n->rb_left; 98952afdaf9SAdrian Hunter else if (cmp > 0) 99052afdaf9SAdrian Hunter n = n->rb_right; 99152afdaf9SAdrian Hunter else 99252afdaf9SAdrian Hunter return m; 99352afdaf9SAdrian Hunter } 99452afdaf9SAdrian Hunter 99552afdaf9SAdrian Hunter return NULL; 99652afdaf9SAdrian Hunter } 99752afdaf9SAdrian Hunter 9989ad4652bSThomas Richter static int __read_proc_modules(void *arg, const char *name, u64 start, 9999ad4652bSThomas Richter u64 size __maybe_unused) 100052afdaf9SAdrian Hunter { 100152afdaf9SAdrian Hunter struct rb_root *modules = arg; 100252afdaf9SAdrian Hunter struct module_info *mi; 100352afdaf9SAdrian Hunter 100452afdaf9SAdrian Hunter mi = zalloc(sizeof(struct module_info)); 100552afdaf9SAdrian Hunter if (!mi) 100652afdaf9SAdrian Hunter return -ENOMEM; 100752afdaf9SAdrian Hunter 100852afdaf9SAdrian Hunter mi->name = strdup(name); 100952afdaf9SAdrian Hunter mi->start = start; 101052afdaf9SAdrian Hunter 101152afdaf9SAdrian Hunter if (!mi->name) { 101252afdaf9SAdrian Hunter free(mi); 101352afdaf9SAdrian Hunter return -ENOMEM; 101452afdaf9SAdrian Hunter } 101552afdaf9SAdrian Hunter 101652afdaf9SAdrian Hunter add_module(mi, modules); 101752afdaf9SAdrian Hunter 101852afdaf9SAdrian Hunter return 0; 101952afdaf9SAdrian Hunter } 102052afdaf9SAdrian Hunter 102152afdaf9SAdrian Hunter static int read_proc_modules(const char *filename, struct rb_root *modules) 102252afdaf9SAdrian Hunter { 102352afdaf9SAdrian Hunter if (symbol__restricted_filename(filename, "/proc/modules")) 102452afdaf9SAdrian Hunter return -1; 102552afdaf9SAdrian Hunter 102652afdaf9SAdrian Hunter if (modules__parse(filename, modules, __read_proc_modules)) { 102752afdaf9SAdrian Hunter delete_modules(modules); 102852afdaf9SAdrian Hunter return -1; 102952afdaf9SAdrian Hunter } 103052afdaf9SAdrian Hunter 103152afdaf9SAdrian Hunter return 0; 103252afdaf9SAdrian Hunter } 103352afdaf9SAdrian Hunter 1034fc1b691dSAdrian Hunter int compare_proc_modules(const char *from, const char *to) 1035fc1b691dSAdrian Hunter { 1036fc1b691dSAdrian Hunter struct rb_root from_modules = RB_ROOT; 1037fc1b691dSAdrian Hunter struct rb_root to_modules = RB_ROOT; 1038fc1b691dSAdrian Hunter struct rb_node *from_node, *to_node; 1039fc1b691dSAdrian Hunter struct module_info *from_m, *to_m; 1040fc1b691dSAdrian Hunter int ret = -1; 1041fc1b691dSAdrian Hunter 1042fc1b691dSAdrian Hunter if (read_proc_modules(from, &from_modules)) 1043fc1b691dSAdrian Hunter return -1; 1044fc1b691dSAdrian Hunter 1045fc1b691dSAdrian Hunter if (read_proc_modules(to, &to_modules)) 1046fc1b691dSAdrian Hunter goto out_delete_from; 1047fc1b691dSAdrian Hunter 1048fc1b691dSAdrian Hunter from_node = rb_first(&from_modules); 1049fc1b691dSAdrian Hunter to_node = rb_first(&to_modules); 1050fc1b691dSAdrian Hunter while (from_node) { 1051fc1b691dSAdrian Hunter if (!to_node) 1052fc1b691dSAdrian Hunter break; 1053fc1b691dSAdrian Hunter 1054fc1b691dSAdrian Hunter from_m = rb_entry(from_node, struct module_info, rb_node); 1055fc1b691dSAdrian Hunter to_m = rb_entry(to_node, struct module_info, rb_node); 1056fc1b691dSAdrian Hunter 1057fc1b691dSAdrian Hunter if (from_m->start != to_m->start || 1058fc1b691dSAdrian Hunter strcmp(from_m->name, to_m->name)) 1059fc1b691dSAdrian Hunter break; 1060fc1b691dSAdrian Hunter 1061fc1b691dSAdrian Hunter from_node = rb_next(from_node); 1062fc1b691dSAdrian Hunter to_node = rb_next(to_node); 1063fc1b691dSAdrian Hunter } 1064fc1b691dSAdrian Hunter 1065fc1b691dSAdrian Hunter if (!from_node && !to_node) 1066fc1b691dSAdrian Hunter ret = 0; 1067fc1b691dSAdrian Hunter 1068fc1b691dSAdrian Hunter delete_modules(&to_modules); 1069fc1b691dSAdrian Hunter out_delete_from: 1070fc1b691dSAdrian Hunter delete_modules(&from_modules); 1071fc1b691dSAdrian Hunter 1072fc1b691dSAdrian Hunter return ret; 1073fc1b691dSAdrian Hunter } 1074fc1b691dSAdrian Hunter 107579b6bb73SArnaldo Carvalho de Melo static int do_validate_kcore_modules(const char *filename, struct maps *kmaps) 107652afdaf9SAdrian Hunter { 107752afdaf9SAdrian Hunter struct rb_root modules = RB_ROOT; 107852afdaf9SAdrian Hunter struct map *old_map; 107952afdaf9SAdrian Hunter int err; 108052afdaf9SAdrian Hunter 108152afdaf9SAdrian Hunter err = read_proc_modules(filename, &modules); 108252afdaf9SAdrian Hunter if (err) 108352afdaf9SAdrian Hunter return err; 108452afdaf9SAdrian Hunter 108579b6bb73SArnaldo Carvalho de Melo maps__for_each_entry(kmaps, old_map) { 108652afdaf9SAdrian Hunter struct module_info *mi; 108752afdaf9SAdrian Hunter 10885759a682SAdrian Hunter if (!__map__is_kmodule(old_map)) { 108952afdaf9SAdrian Hunter continue; 109052afdaf9SAdrian Hunter } 109152afdaf9SAdrian Hunter 109252afdaf9SAdrian Hunter /* Module must be in memory at the same address */ 109352afdaf9SAdrian Hunter mi = find_module(old_map->dso->short_name, &modules); 109452afdaf9SAdrian Hunter if (!mi || mi->start != old_map->start) { 109552afdaf9SAdrian Hunter err = -EINVAL; 109652afdaf9SAdrian Hunter goto out; 109752afdaf9SAdrian Hunter } 109852afdaf9SAdrian Hunter } 109952afdaf9SAdrian Hunter out: 110052afdaf9SAdrian Hunter delete_modules(&modules); 110152afdaf9SAdrian Hunter return err; 110252afdaf9SAdrian Hunter } 110352afdaf9SAdrian Hunter 110452afdaf9SAdrian Hunter /* 110552afdaf9SAdrian Hunter * If kallsyms is referenced by name then we look for filename in the same 110652afdaf9SAdrian Hunter * directory. 110752afdaf9SAdrian Hunter */ 110852afdaf9SAdrian Hunter static bool filename_from_kallsyms_filename(char *filename, 110952afdaf9SAdrian Hunter const char *base_name, 111052afdaf9SAdrian Hunter const char *kallsyms_filename) 111152afdaf9SAdrian Hunter { 111252afdaf9SAdrian Hunter char *name; 111352afdaf9SAdrian Hunter 111452afdaf9SAdrian Hunter strcpy(filename, kallsyms_filename); 111552afdaf9SAdrian Hunter name = strrchr(filename, '/'); 111652afdaf9SAdrian Hunter if (!name) 111752afdaf9SAdrian Hunter return false; 111852afdaf9SAdrian Hunter 111952afdaf9SAdrian Hunter name += 1; 112052afdaf9SAdrian Hunter 112152afdaf9SAdrian Hunter if (!strcmp(name, "kallsyms")) { 112252afdaf9SAdrian Hunter strcpy(name, base_name); 112352afdaf9SAdrian Hunter return true; 112452afdaf9SAdrian Hunter } 112552afdaf9SAdrian Hunter 112652afdaf9SAdrian Hunter return false; 112752afdaf9SAdrian Hunter } 112852afdaf9SAdrian Hunter 112952afdaf9SAdrian Hunter static int validate_kcore_modules(const char *kallsyms_filename, 113052afdaf9SAdrian Hunter struct map *map) 113152afdaf9SAdrian Hunter { 113279b6bb73SArnaldo Carvalho de Melo struct maps *kmaps = map__kmaps(map); 113352afdaf9SAdrian Hunter char modules_filename[PATH_MAX]; 113452afdaf9SAdrian Hunter 1135ba92732eSWang Nan if (!kmaps) 1136ba92732eSWang Nan return -EINVAL; 1137ba92732eSWang Nan 113852afdaf9SAdrian Hunter if (!filename_from_kallsyms_filename(modules_filename, "modules", 113952afdaf9SAdrian Hunter kallsyms_filename)) 114052afdaf9SAdrian Hunter return -EINVAL; 114152afdaf9SAdrian Hunter 11425759a682SAdrian Hunter if (do_validate_kcore_modules(modules_filename, kmaps)) 114352afdaf9SAdrian Hunter return -EINVAL; 114452afdaf9SAdrian Hunter 114552afdaf9SAdrian Hunter return 0; 114652afdaf9SAdrian Hunter } 114752afdaf9SAdrian Hunter 1148a00d28cbSAdrian Hunter static int validate_kcore_addresses(const char *kallsyms_filename, 1149a00d28cbSAdrian Hunter struct map *map) 1150a00d28cbSAdrian Hunter { 1151a00d28cbSAdrian Hunter struct kmap *kmap = map__kmap(map); 1152a00d28cbSAdrian Hunter 1153ba92732eSWang Nan if (!kmap) 1154ba92732eSWang Nan return -EINVAL; 1155ba92732eSWang Nan 1156a00d28cbSAdrian Hunter if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) { 1157a00d28cbSAdrian Hunter u64 start; 1158a00d28cbSAdrian Hunter 1159b843f62aSArnaldo Carvalho de Melo if (kallsyms__get_function_start(kallsyms_filename, 1160b843f62aSArnaldo Carvalho de Melo kmap->ref_reloc_sym->name, &start)) 1161b843f62aSArnaldo Carvalho de Melo return -ENOENT; 1162a00d28cbSAdrian Hunter if (start != kmap->ref_reloc_sym->addr) 1163a00d28cbSAdrian Hunter return -EINVAL; 1164a00d28cbSAdrian Hunter } 1165a00d28cbSAdrian Hunter 1166a00d28cbSAdrian Hunter return validate_kcore_modules(kallsyms_filename, map); 1167a00d28cbSAdrian Hunter } 1168a00d28cbSAdrian Hunter 11698e0cf965SAdrian Hunter struct kcore_mapfn_data { 11708e0cf965SAdrian Hunter struct dso *dso; 11718e0cf965SAdrian Hunter struct list_head maps; 11728e0cf965SAdrian Hunter }; 11738e0cf965SAdrian Hunter 11748e0cf965SAdrian Hunter static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data) 11758e0cf965SAdrian Hunter { 11768e0cf965SAdrian Hunter struct kcore_mapfn_data *md = data; 11778e0cf965SAdrian Hunter struct map *map; 11788e0cf965SAdrian Hunter 11793183f8caSArnaldo Carvalho de Melo map = map__new2(start, md->dso); 11808e0cf965SAdrian Hunter if (map == NULL) 11818e0cf965SAdrian Hunter return -ENOMEM; 11828e0cf965SAdrian Hunter 11838e0cf965SAdrian Hunter map->end = map->start + len; 11848e0cf965SAdrian Hunter map->pgoff = pgoff; 11858e0cf965SAdrian Hunter 11868e0cf965SAdrian Hunter list_add(&map->node, &md->maps); 11878e0cf965SAdrian Hunter 11888e0cf965SAdrian Hunter return 0; 11898e0cf965SAdrian Hunter } 11908e0cf965SAdrian Hunter 1191fb5a88d4SJiri Olsa /* 119279b6bb73SArnaldo Carvalho de Melo * Merges map into maps by splitting the new map within the existing map 119379b6bb73SArnaldo Carvalho de Melo * regions. 1194fb5a88d4SJiri Olsa */ 119579b6bb73SArnaldo Carvalho de Melo int maps__merge_in(struct maps *kmaps, struct map *new_map) 1196fb5a88d4SJiri Olsa { 1197fb5a88d4SJiri Olsa struct map *old_map; 1198fb5a88d4SJiri Olsa LIST_HEAD(merged); 1199fb5a88d4SJiri Olsa 120079b6bb73SArnaldo Carvalho de Melo maps__for_each_entry(kmaps, old_map) { 1201fb5a88d4SJiri Olsa /* no overload with this one */ 1202fb5a88d4SJiri Olsa if (new_map->end < old_map->start || 1203fb5a88d4SJiri Olsa new_map->start >= old_map->end) 1204fb5a88d4SJiri Olsa continue; 1205fb5a88d4SJiri Olsa 1206fb5a88d4SJiri Olsa if (new_map->start < old_map->start) { 1207fb5a88d4SJiri Olsa /* 1208fb5a88d4SJiri Olsa * |new...... 1209fb5a88d4SJiri Olsa * |old.... 1210fb5a88d4SJiri Olsa */ 1211fb5a88d4SJiri Olsa if (new_map->end < old_map->end) { 1212fb5a88d4SJiri Olsa /* 1213fb5a88d4SJiri Olsa * |new......| -> |new..| 1214fb5a88d4SJiri Olsa * |old....| -> |old....| 1215fb5a88d4SJiri Olsa */ 1216fb5a88d4SJiri Olsa new_map->end = old_map->start; 1217fb5a88d4SJiri Olsa } else { 1218fb5a88d4SJiri Olsa /* 1219fb5a88d4SJiri Olsa * |new.............| -> |new..| |new..| 1220fb5a88d4SJiri Olsa * |old....| -> |old....| 1221fb5a88d4SJiri Olsa */ 1222fb5a88d4SJiri Olsa struct map *m = map__clone(new_map); 1223fb5a88d4SJiri Olsa 1224fb5a88d4SJiri Olsa if (!m) 1225fb5a88d4SJiri Olsa return -ENOMEM; 1226fb5a88d4SJiri Olsa 1227fb5a88d4SJiri Olsa m->end = old_map->start; 1228fb5a88d4SJiri Olsa list_add_tail(&m->node, &merged); 12290affd0e5SAdrian Hunter new_map->pgoff += old_map->end - new_map->start; 1230fb5a88d4SJiri Olsa new_map->start = old_map->end; 1231fb5a88d4SJiri Olsa } 1232fb5a88d4SJiri Olsa } else { 1233fb5a88d4SJiri Olsa /* 1234fb5a88d4SJiri Olsa * |new...... 1235fb5a88d4SJiri Olsa * |old.... 1236fb5a88d4SJiri Olsa */ 1237fb5a88d4SJiri Olsa if (new_map->end < old_map->end) { 1238fb5a88d4SJiri Olsa /* 1239fb5a88d4SJiri Olsa * |new..| -> x 1240fb5a88d4SJiri Olsa * |old.........| -> |old.........| 1241fb5a88d4SJiri Olsa */ 1242fb5a88d4SJiri Olsa map__put(new_map); 1243fb5a88d4SJiri Olsa new_map = NULL; 1244fb5a88d4SJiri Olsa break; 1245fb5a88d4SJiri Olsa } else { 1246fb5a88d4SJiri Olsa /* 1247fb5a88d4SJiri Olsa * |new......| -> |new...| 1248fb5a88d4SJiri Olsa * |old....| -> |old....| 1249fb5a88d4SJiri Olsa */ 12500affd0e5SAdrian Hunter new_map->pgoff += old_map->end - new_map->start; 1251fb5a88d4SJiri Olsa new_map->start = old_map->end; 1252fb5a88d4SJiri Olsa } 1253fb5a88d4SJiri Olsa } 1254fb5a88d4SJiri Olsa } 1255fb5a88d4SJiri Olsa 1256fb5a88d4SJiri Olsa while (!list_empty(&merged)) { 1257fb5a88d4SJiri Olsa old_map = list_entry(merged.next, struct map, node); 1258fb5a88d4SJiri Olsa list_del_init(&old_map->node); 125979b6bb73SArnaldo Carvalho de Melo maps__insert(kmaps, old_map); 1260fb5a88d4SJiri Olsa map__put(old_map); 1261fb5a88d4SJiri Olsa } 1262fb5a88d4SJiri Olsa 1263fb5a88d4SJiri Olsa if (new_map) { 126479b6bb73SArnaldo Carvalho de Melo maps__insert(kmaps, new_map); 1265fb5a88d4SJiri Olsa map__put(new_map); 1266fb5a88d4SJiri Olsa } 1267fb5a88d4SJiri Olsa return 0; 1268fb5a88d4SJiri Olsa } 1269fb5a88d4SJiri Olsa 12708e0cf965SAdrian Hunter static int dso__load_kcore(struct dso *dso, struct map *map, 12718e0cf965SAdrian Hunter const char *kallsyms_filename) 12728e0cf965SAdrian Hunter { 127379b6bb73SArnaldo Carvalho de Melo struct maps *kmaps = map__kmaps(map); 12748e0cf965SAdrian Hunter struct kcore_mapfn_data md; 127550481461SArnaldo Carvalho de Melo struct map *old_map, *new_map, *replacement_map = NULL, *next; 12761c5aae77SAdrian Hunter struct machine *machine; 12778e0cf965SAdrian Hunter bool is_64_bit; 12788e0cf965SAdrian Hunter int err, fd; 12798e0cf965SAdrian Hunter char kcore_filename[PATH_MAX]; 128056549978SAdrian Hunter u64 stext; 12818e0cf965SAdrian Hunter 1282ba92732eSWang Nan if (!kmaps) 1283ba92732eSWang Nan return -EINVAL; 1284ba92732eSWang Nan 12851c5aae77SAdrian Hunter machine = kmaps->machine; 12861c5aae77SAdrian Hunter 12878e0cf965SAdrian Hunter /* This function requires that the map is the kernel map */ 1288efdd5c6bSArnaldo Carvalho de Melo if (!__map__is_kernel(map)) 12898e0cf965SAdrian Hunter return -EINVAL; 12908e0cf965SAdrian Hunter 129152afdaf9SAdrian Hunter if (!filename_from_kallsyms_filename(kcore_filename, "kcore", 12928e0cf965SAdrian Hunter kallsyms_filename)) 12938e0cf965SAdrian Hunter return -EINVAL; 12948e0cf965SAdrian Hunter 1295a00d28cbSAdrian Hunter /* Modules and kernel must be present at their original addresses */ 1296a00d28cbSAdrian Hunter if (validate_kcore_addresses(kallsyms_filename, map)) 129752afdaf9SAdrian Hunter return -EINVAL; 129852afdaf9SAdrian Hunter 12998e0cf965SAdrian Hunter md.dso = dso; 13008e0cf965SAdrian Hunter INIT_LIST_HEAD(&md.maps); 13018e0cf965SAdrian Hunter 13028e0cf965SAdrian Hunter fd = open(kcore_filename, O_RDONLY); 130336c8bb56SLi Zhang if (fd < 0) { 1304133de940SAdrian Hunter pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n", 130536c8bb56SLi Zhang kcore_filename); 13068e0cf965SAdrian Hunter return -EINVAL; 130736c8bb56SLi Zhang } 13088e0cf965SAdrian Hunter 13098e0cf965SAdrian Hunter /* Read new maps into temporary lists */ 1310e9814df8SArnaldo Carvalho de Melo err = file__read_maps(fd, map->prot & PROT_EXEC, kcore_mapfn, &md, 13118e0cf965SAdrian Hunter &is_64_bit); 13128e0cf965SAdrian Hunter if (err) 13138e0cf965SAdrian Hunter goto out_err; 1314c6d8f2a4SAdrian Hunter dso->is_64_bit = is_64_bit; 13158e0cf965SAdrian Hunter 13168e0cf965SAdrian Hunter if (list_empty(&md.maps)) { 13178e0cf965SAdrian Hunter err = -EINVAL; 13188e0cf965SAdrian Hunter goto out_err; 13198e0cf965SAdrian Hunter } 13208e0cf965SAdrian Hunter 13218e0cf965SAdrian Hunter /* Remove old maps */ 132279b6bb73SArnaldo Carvalho de Melo maps__for_each_entry_safe(kmaps, old_map, next) { 1323fb5a88d4SJiri Olsa /* 1324fb5a88d4SJiri Olsa * We need to preserve eBPF maps even if they are 1325fb5a88d4SJiri Olsa * covered by kcore, because we need to access 1326fb5a88d4SJiri Olsa * eBPF dso for source data. 1327fb5a88d4SJiri Olsa */ 1328fb5a88d4SJiri Olsa if (old_map != map && !__map__is_bpf_prog(old_map)) 132979b6bb73SArnaldo Carvalho de Melo maps__remove(kmaps, old_map); 13308e0cf965SAdrian Hunter } 13311c5aae77SAdrian Hunter machine->trampolines_mapped = false; 13328e0cf965SAdrian Hunter 133356549978SAdrian Hunter /* Find the kernel map using the '_stext' symbol */ 133456549978SAdrian Hunter if (!kallsyms__get_function_start(kallsyms_filename, "_stext", &stext)) { 13358e0cf965SAdrian Hunter list_for_each_entry(new_map, &md.maps, node) { 133656549978SAdrian Hunter if (stext >= new_map->start && stext < new_map->end) { 13378e0cf965SAdrian Hunter replacement_map = new_map; 13388e0cf965SAdrian Hunter break; 13398e0cf965SAdrian Hunter } 13408e0cf965SAdrian Hunter } 134156549978SAdrian Hunter } 13428e0cf965SAdrian Hunter 13438e0cf965SAdrian Hunter if (!replacement_map) 13448e0cf965SAdrian Hunter replacement_map = list_entry(md.maps.next, struct map, node); 13458e0cf965SAdrian Hunter 13468e0cf965SAdrian Hunter /* Add new maps */ 13478e0cf965SAdrian Hunter while (!list_empty(&md.maps)) { 13488e0cf965SAdrian Hunter new_map = list_entry(md.maps.next, struct map, node); 1349facf3f06SArnaldo Carvalho de Melo list_del_init(&new_map->node); 13508e0cf965SAdrian Hunter if (new_map == replacement_map) { 13518e0cf965SAdrian Hunter map->start = new_map->start; 13528e0cf965SAdrian Hunter map->end = new_map->end; 13538e0cf965SAdrian Hunter map->pgoff = new_map->pgoff; 13548e0cf965SAdrian Hunter map->map_ip = new_map->map_ip; 13558e0cf965SAdrian Hunter map->unmap_ip = new_map->unmap_ip; 13568e0cf965SAdrian Hunter /* Ensure maps are correctly ordered */ 135784c2cafaSArnaldo Carvalho de Melo map__get(map); 135879b6bb73SArnaldo Carvalho de Melo maps__remove(kmaps, map); 135979b6bb73SArnaldo Carvalho de Melo maps__insert(kmaps, map); 136084c2cafaSArnaldo Carvalho de Melo map__put(map); 136184c2cafaSArnaldo Carvalho de Melo map__put(new_map); 1362fb5a88d4SJiri Olsa } else { 1363fb5a88d4SJiri Olsa /* 1364fb5a88d4SJiri Olsa * Merge kcore map into existing maps, 1365fb5a88d4SJiri Olsa * and ensure that current maps (eBPF) 1366fb5a88d4SJiri Olsa * stay intact. 1367fb5a88d4SJiri Olsa */ 136879b6bb73SArnaldo Carvalho de Melo if (maps__merge_in(kmaps, new_map)) 1369fb5a88d4SJiri Olsa goto out_err; 1370fb5a88d4SJiri Olsa } 13718e0cf965SAdrian Hunter } 13728e0cf965SAdrian Hunter 13731c5aae77SAdrian Hunter if (machine__is(machine, "x86_64")) { 13741c5aae77SAdrian Hunter u64 addr; 13751c5aae77SAdrian Hunter 13761c5aae77SAdrian Hunter /* 13771c5aae77SAdrian Hunter * If one of the corresponding symbols is there, assume the 13781c5aae77SAdrian Hunter * entry trampoline maps are too. 13791c5aae77SAdrian Hunter */ 13801c5aae77SAdrian Hunter if (!kallsyms__get_function_start(kallsyms_filename, 13811c5aae77SAdrian Hunter ENTRY_TRAMPOLINE_NAME, 13821c5aae77SAdrian Hunter &addr)) 13831c5aae77SAdrian Hunter machine->trampolines_mapped = true; 13841c5aae77SAdrian Hunter } 13851c5aae77SAdrian Hunter 13868e0cf965SAdrian Hunter /* 13878e0cf965SAdrian Hunter * Set the data type and long name so that kcore can be read via 13888e0cf965SAdrian Hunter * dso__data_read_addr(). 13898e0cf965SAdrian Hunter */ 1390*1c695c88SJiri Olsa if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 13915f70619dSArnaldo Carvalho de Melo dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE; 13928e0cf965SAdrian Hunter else 13935f70619dSArnaldo Carvalho de Melo dso->binary_type = DSO_BINARY_TYPE__KCORE; 13947e155d4dSArnaldo Carvalho de Melo dso__set_long_name(dso, strdup(kcore_filename), true); 13958e0cf965SAdrian Hunter 13968e0cf965SAdrian Hunter close(fd); 13978e0cf965SAdrian Hunter 1398e9814df8SArnaldo Carvalho de Melo if (map->prot & PROT_EXEC) 13998e0cf965SAdrian Hunter pr_debug("Using %s for kernel object code\n", kcore_filename); 14008e0cf965SAdrian Hunter else 14018e0cf965SAdrian Hunter pr_debug("Using %s for kernel data\n", kcore_filename); 14028e0cf965SAdrian Hunter 14038e0cf965SAdrian Hunter return 0; 14048e0cf965SAdrian Hunter 14058e0cf965SAdrian Hunter out_err: 14068e0cf965SAdrian Hunter while (!list_empty(&md.maps)) { 14078e0cf965SAdrian Hunter map = list_entry(md.maps.next, struct map, node); 1408facf3f06SArnaldo Carvalho de Melo list_del_init(&map->node); 140984c2cafaSArnaldo Carvalho de Melo map__put(map); 14108e0cf965SAdrian Hunter } 14118e0cf965SAdrian Hunter close(fd); 14128e0cf965SAdrian Hunter return -EINVAL; 14138e0cf965SAdrian Hunter } 14148e0cf965SAdrian Hunter 1415d9b62abaSAdrian Hunter /* 1416d9b62abaSAdrian Hunter * If the kernel is relocated at boot time, kallsyms won't match. Compute the 1417d9b62abaSAdrian Hunter * delta based on the relocation reference symbol. 1418d9b62abaSAdrian Hunter */ 1419019c6820SArnaldo Carvalho de Melo static int kallsyms__delta(struct kmap *kmap, const char *filename, u64 *delta) 1420d9b62abaSAdrian Hunter { 1421d9b62abaSAdrian Hunter u64 addr; 1422d9b62abaSAdrian Hunter 1423d9b62abaSAdrian Hunter if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name) 1424d9b62abaSAdrian Hunter return 0; 1425d9b62abaSAdrian Hunter 1426b843f62aSArnaldo Carvalho de Melo if (kallsyms__get_function_start(filename, kmap->ref_reloc_sym->name, &addr)) 1427d9b62abaSAdrian Hunter return -1; 1428d9b62abaSAdrian Hunter 1429d9b62abaSAdrian Hunter *delta = addr - kmap->ref_reloc_sym->addr; 1430d9b62abaSAdrian Hunter return 0; 1431d9b62abaSAdrian Hunter } 1432d9b62abaSAdrian Hunter 1433e02092b9SArnaldo Carvalho de Melo int __dso__load_kallsyms(struct dso *dso, const char *filename, 1434be39db9fSArnaldo Carvalho de Melo struct map *map, bool no_kcore) 14352e538c4aSArnaldo Carvalho de Melo { 1436019c6820SArnaldo Carvalho de Melo struct kmap *kmap = map__kmap(map); 1437d9b62abaSAdrian Hunter u64 delta = 0; 1438d9b62abaSAdrian Hunter 1439ec80fde7SArnaldo Carvalho de Melo if (symbol__restricted_filename(filename, "/proc/kallsyms")) 1440ec80fde7SArnaldo Carvalho de Melo return -1; 1441ec80fde7SArnaldo Carvalho de Melo 1442019c6820SArnaldo Carvalho de Melo if (!kmap || !kmap->kmaps) 1443019c6820SArnaldo Carvalho de Melo return -1; 1444019c6820SArnaldo Carvalho de Melo 1445333cc76cSArnaldo Carvalho de Melo if (dso__load_all_kallsyms(dso, filename) < 0) 14462e538c4aSArnaldo Carvalho de Melo return -1; 14472e538c4aSArnaldo Carvalho de Melo 1448019c6820SArnaldo Carvalho de Melo if (kallsyms__delta(kmap, filename, &delta)) 1449d9b62abaSAdrian Hunter return -1; 1450d9b62abaSAdrian Hunter 14513183f8caSArnaldo Carvalho de Melo symbols__fixup_end(&dso->symbols); 14523183f8caSArnaldo Carvalho de Melo symbols__fixup_duplicate(&dso->symbols); 14533f5a4272SAnton Blanchard 1454*1c695c88SJiri Olsa if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 145544f24cb3SJiri Olsa dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 1456a1645ce1SZhang, Yanmin else 145744f24cb3SJiri Olsa dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS; 14582e538c4aSArnaldo Carvalho de Melo 1459e02092b9SArnaldo Carvalho de Melo if (!no_kcore && !dso__load_kcore(dso, map, filename)) 146079b6bb73SArnaldo Carvalho de Melo return maps__split_kallsyms_for_kcore(kmap->kmaps, dso); 14618e0cf965SAdrian Hunter else 146279b6bb73SArnaldo Carvalho de Melo return maps__split_kallsyms(kmap->kmaps, dso, delta, map); 1463af427bf5SArnaldo Carvalho de Melo } 1464af427bf5SArnaldo Carvalho de Melo 1465e02092b9SArnaldo Carvalho de Melo int dso__load_kallsyms(struct dso *dso, const char *filename, 1466be39db9fSArnaldo Carvalho de Melo struct map *map) 1467e02092b9SArnaldo Carvalho de Melo { 1468be39db9fSArnaldo Carvalho de Melo return __dso__load_kallsyms(dso, filename, map, false); 1469e02092b9SArnaldo Carvalho de Melo } 1470e02092b9SArnaldo Carvalho de Melo 14713183f8caSArnaldo Carvalho de Melo static int dso__load_perf_map(const char *map_path, struct dso *dso) 147280d496beSPekka Enberg { 147380d496beSPekka Enberg char *line = NULL; 147480d496beSPekka Enberg size_t n; 147580d496beSPekka Enberg FILE *file; 147680d496beSPekka Enberg int nr_syms = 0; 147780d496beSPekka Enberg 1478bf2e710bSKrister Johansen file = fopen(map_path, "r"); 147980d496beSPekka Enberg if (file == NULL) 148080d496beSPekka Enberg goto out_failure; 148180d496beSPekka Enberg 148280d496beSPekka Enberg while (!feof(file)) { 14839cffa8d5SPaul Mackerras u64 start, size; 148480d496beSPekka Enberg struct symbol *sym; 148580d496beSPekka Enberg int line_len, len; 148680d496beSPekka Enberg 148780d496beSPekka Enberg line_len = getline(&line, &n, file); 148880d496beSPekka Enberg if (line_len < 0) 148980d496beSPekka Enberg break; 149080d496beSPekka Enberg 149180d496beSPekka Enberg if (!line) 149280d496beSPekka Enberg goto out_failure; 149380d496beSPekka Enberg 149480d496beSPekka Enberg line[--line_len] = '\0'; /* \n */ 149580d496beSPekka Enberg 149680d496beSPekka Enberg len = hex2u64(line, &start); 149780d496beSPekka Enberg 149880d496beSPekka Enberg len++; 149980d496beSPekka Enberg if (len + 2 >= line_len) 150080d496beSPekka Enberg continue; 150180d496beSPekka Enberg 150280d496beSPekka Enberg len += hex2u64(line + len, &size); 150380d496beSPekka Enberg 150480d496beSPekka Enberg len++; 150580d496beSPekka Enberg if (len + 2 >= line_len) 150680d496beSPekka Enberg continue; 150780d496beSPekka Enberg 1508af30bffaSArnaldo Carvalho de Melo sym = symbol__new(start, size, STB_GLOBAL, STT_FUNC, line + len); 150980d496beSPekka Enberg 151080d496beSPekka Enberg if (sym == NULL) 151180d496beSPekka Enberg goto out_delete_line; 151280d496beSPekka Enberg 15133183f8caSArnaldo Carvalho de Melo symbols__insert(&dso->symbols, sym); 151480d496beSPekka Enberg nr_syms++; 151580d496beSPekka Enberg } 151680d496beSPekka Enberg 151780d496beSPekka Enberg free(line); 151880d496beSPekka Enberg fclose(file); 151980d496beSPekka Enberg 152080d496beSPekka Enberg return nr_syms; 152180d496beSPekka Enberg 152280d496beSPekka Enberg out_delete_line: 152380d496beSPekka Enberg free(line); 152480d496beSPekka Enberg out_failure: 152580d496beSPekka Enberg return -1; 152680d496beSPekka Enberg } 152780d496beSPekka Enberg 15281029f9feSNamhyung Kim static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod, 15291029f9feSNamhyung Kim enum dso_binary_type type) 15301029f9feSNamhyung Kim { 15311029f9feSNamhyung Kim switch (type) { 15321029f9feSNamhyung Kim case DSO_BINARY_TYPE__JAVA_JIT: 15331029f9feSNamhyung Kim case DSO_BINARY_TYPE__DEBUGLINK: 15341029f9feSNamhyung Kim case DSO_BINARY_TYPE__SYSTEM_PATH_DSO: 15351029f9feSNamhyung Kim case DSO_BINARY_TYPE__FEDORA_DEBUGINFO: 15361029f9feSNamhyung Kim case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO: 153785afd355SAdrian Hunter case DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO: 15381029f9feSNamhyung Kim case DSO_BINARY_TYPE__BUILDID_DEBUGINFO: 15391029f9feSNamhyung Kim case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO: 1540*1c695c88SJiri Olsa return !kmod && dso->kernel == DSO_SPACE__USER; 15411029f9feSNamhyung Kim 15421029f9feSNamhyung Kim case DSO_BINARY_TYPE__KALLSYMS: 15431029f9feSNamhyung Kim case DSO_BINARY_TYPE__VMLINUX: 15441029f9feSNamhyung Kim case DSO_BINARY_TYPE__KCORE: 1545*1c695c88SJiri Olsa return dso->kernel == DSO_SPACE__KERNEL; 15461029f9feSNamhyung Kim 15471029f9feSNamhyung Kim case DSO_BINARY_TYPE__GUEST_KALLSYMS: 15481029f9feSNamhyung Kim case DSO_BINARY_TYPE__GUEST_VMLINUX: 15491029f9feSNamhyung Kim case DSO_BINARY_TYPE__GUEST_KCORE: 1550*1c695c88SJiri Olsa return dso->kernel == DSO_SPACE__KERNEL_GUEST; 15511029f9feSNamhyung Kim 15521029f9feSNamhyung Kim case DSO_BINARY_TYPE__GUEST_KMODULE: 1553c00c48fcSNamhyung Kim case DSO_BINARY_TYPE__GUEST_KMODULE_COMP: 15541029f9feSNamhyung Kim case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE: 1555c00c48fcSNamhyung Kim case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP: 15561029f9feSNamhyung Kim /* 15571029f9feSNamhyung Kim * kernel modules know their symtab type - it's set when 1558a94ab91aSArnaldo Carvalho de Melo * creating a module dso in machine__addnew_module_map(). 15591029f9feSNamhyung Kim */ 15601029f9feSNamhyung Kim return kmod && dso->symtab_type == type; 15611029f9feSNamhyung Kim 15621029f9feSNamhyung Kim case DSO_BINARY_TYPE__BUILD_ID_CACHE: 1563d2396999SKrister Johansen case DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO: 15641029f9feSNamhyung Kim return true; 15651029f9feSNamhyung Kim 15669b86d04dSSong Liu case DSO_BINARY_TYPE__BPF_PROG_INFO: 15673c29d448SJiri Olsa case DSO_BINARY_TYPE__BPF_IMAGE: 1568789e2419SAdrian Hunter case DSO_BINARY_TYPE__OOL: 15691029f9feSNamhyung Kim case DSO_BINARY_TYPE__NOT_FOUND: 15701029f9feSNamhyung Kim default: 15711029f9feSNamhyung Kim return false; 15721029f9feSNamhyung Kim } 15731029f9feSNamhyung Kim } 15741029f9feSNamhyung Kim 1575bf2e710bSKrister Johansen /* Checks for the existence of the perf-<pid>.map file in two different 1576bf2e710bSKrister Johansen * locations. First, if the process is a separate mount namespace, check in 1577bf2e710bSKrister Johansen * that namespace using the pid of the innermost pid namespace. If's not in a 1578bf2e710bSKrister Johansen * namespace, or the file can't be found there, try in the mount namespace of 1579bf2e710bSKrister Johansen * the tracing process using our view of its pid. 1580bf2e710bSKrister Johansen */ 1581bf2e710bSKrister Johansen static int dso__find_perf_map(char *filebuf, size_t bufsz, 1582bf2e710bSKrister Johansen struct nsinfo **nsip) 1583bf2e710bSKrister Johansen { 1584bf2e710bSKrister Johansen struct nscookie nsc; 1585bf2e710bSKrister Johansen struct nsinfo *nsi; 1586bf2e710bSKrister Johansen struct nsinfo *nnsi; 1587bf2e710bSKrister Johansen int rc = -1; 1588bf2e710bSKrister Johansen 1589bf2e710bSKrister Johansen nsi = *nsip; 1590bf2e710bSKrister Johansen 1591bf2e710bSKrister Johansen if (nsi->need_setns) { 1592bf2e710bSKrister Johansen snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsi->nstgid); 1593bf2e710bSKrister Johansen nsinfo__mountns_enter(nsi, &nsc); 1594bf2e710bSKrister Johansen rc = access(filebuf, R_OK); 1595bf2e710bSKrister Johansen nsinfo__mountns_exit(&nsc); 1596bf2e710bSKrister Johansen if (rc == 0) 1597bf2e710bSKrister Johansen return rc; 1598bf2e710bSKrister Johansen } 1599bf2e710bSKrister Johansen 1600bf2e710bSKrister Johansen nnsi = nsinfo__copy(nsi); 1601bf2e710bSKrister Johansen if (nnsi) { 1602bf2e710bSKrister Johansen nsinfo__put(nsi); 1603bf2e710bSKrister Johansen 1604bf2e710bSKrister Johansen nnsi->need_setns = false; 1605bf2e710bSKrister Johansen snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nnsi->tgid); 1606bf2e710bSKrister Johansen *nsip = nnsi; 1607bf2e710bSKrister Johansen rc = 0; 1608bf2e710bSKrister Johansen } 1609bf2e710bSKrister Johansen 1610bf2e710bSKrister Johansen return rc; 1611bf2e710bSKrister Johansen } 1612bf2e710bSKrister Johansen 1613be39db9fSArnaldo Carvalho de Melo int dso__load(struct dso *dso, struct map *map) 161486470930SIngo Molnar { 1615c338aee8SArnaldo Carvalho de Melo char *name; 161686470930SIngo Molnar int ret = -1; 161744f24cb3SJiri Olsa u_int i; 161893fcce96SArnaldo Carvalho de Melo struct machine *machine = NULL; 161944f24cb3SJiri Olsa char *root_dir = (char *) ""; 16203aafe5aeSCody P Schafer int ss_pos = 0; 16213aafe5aeSCody P Schafer struct symsrc ss_[2]; 16223aafe5aeSCody P Schafer struct symsrc *syms_ss = NULL, *runtime_ss = NULL; 16231029f9feSNamhyung Kim bool kmod; 1624bf2e710bSKrister Johansen bool perfmap; 16255baecbcdSDima Kogan unsigned char build_id[BUILD_ID_SIZE]; 1626843ff37bSKrister Johansen struct nscookie nsc; 1627bf2e710bSKrister Johansen char newmapname[PATH_MAX]; 1628bf2e710bSKrister Johansen const char *map_path = dso->long_name; 1629bf2e710bSKrister Johansen 1630bf2e710bSKrister Johansen perfmap = strncmp(dso->name, "/tmp/perf-", 10) == 0; 1631bf2e710bSKrister Johansen if (perfmap) { 1632bf2e710bSKrister Johansen if (dso->nsinfo && (dso__find_perf_map(newmapname, 1633bf2e710bSKrister Johansen sizeof(newmapname), &dso->nsinfo) == 0)) { 1634bf2e710bSKrister Johansen map_path = newmapname; 1635bf2e710bSKrister Johansen } 1636bf2e710bSKrister Johansen } 163786470930SIngo Molnar 1638843ff37bSKrister Johansen nsinfo__mountns_enter(dso->nsinfo, &nsc); 16394a936edcSNamhyung Kim pthread_mutex_lock(&dso->lock); 164066bd8424SArnaldo Carvalho de Melo 16414a936edcSNamhyung Kim /* check again under the dso->lock */ 16423183f8caSArnaldo Carvalho de Melo if (dso__loaded(dso)) { 16434a936edcSNamhyung Kim ret = 1; 16444a936edcSNamhyung Kim goto out; 16454a936edcSNamhyung Kim } 16464a936edcSNamhyung Kim 1647b5c09518SArnaldo Carvalho de Melo kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE || 1648b5c09518SArnaldo Carvalho de Melo dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP || 1649b5c09518SArnaldo Carvalho de Melo dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE || 1650b5c09518SArnaldo Carvalho de Melo dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP; 1651b5c09518SArnaldo Carvalho de Melo 1652b5c09518SArnaldo Carvalho de Melo if (dso->kernel && !kmod) { 1653*1c695c88SJiri Olsa if (dso->kernel == DSO_SPACE__KERNEL) 1654be39db9fSArnaldo Carvalho de Melo ret = dso__load_kernel_sym(dso, map); 1655*1c695c88SJiri Olsa else if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1656be39db9fSArnaldo Carvalho de Melo ret = dso__load_guest_kernel_sym(dso, map); 16574a936edcSNamhyung Kim 165893fcce96SArnaldo Carvalho de Melo machine = map__kmaps(map)->machine; 16594d99e413SAdrian Hunter if (machine__is(machine, "x86_64")) 16604d99e413SAdrian Hunter machine__map_x86_64_entry_trampolines(machine, dso); 16614a936edcSNamhyung Kim goto out; 16624a936edcSNamhyung Kim } 1663a1645ce1SZhang, Yanmin 1664aeafcbafSArnaldo Carvalho de Melo dso->adjust_symbols = 0; 1665f5812a7aSArnaldo Carvalho de Melo 1666bf2e710bSKrister Johansen if (perfmap) { 16673183f8caSArnaldo Carvalho de Melo ret = dso__load_perf_map(map_path, dso); 166844f24cb3SJiri Olsa dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT : 166944f24cb3SJiri Olsa DSO_BINARY_TYPE__NOT_FOUND; 16704a936edcSNamhyung Kim goto out; 167194cb9e38SArnaldo Carvalho de Melo } 167294cb9e38SArnaldo Carvalho de Melo 167344f24cb3SJiri Olsa if (machine) 167444f24cb3SJiri Olsa root_dir = machine->root_dir; 167544f24cb3SJiri Olsa 1676164c800eSDavid Ahern name = malloc(PATH_MAX); 1677164c800eSDavid Ahern if (!name) 16784a936edcSNamhyung Kim goto out; 1679164c800eSDavid Ahern 16805baecbcdSDima Kogan /* 16815baecbcdSDima Kogan * Read the build id if possible. This is required for 16825baecbcdSDima Kogan * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work 16835baecbcdSDima Kogan */ 1684ed6c166cSKan Liang if (!dso->has_build_id && 16859b200653SVictor Kamensky is_regular_file(dso->long_name)) { 16869b200653SVictor Kamensky __symbol__join_symfs(name, PATH_MAX, dso->long_name); 16879b200653SVictor Kamensky if (filename__read_build_id(name, build_id, BUILD_ID_SIZE) > 0) 16885baecbcdSDima Kogan dso__set_build_id(dso, build_id); 16899b200653SVictor Kamensky } 16905baecbcdSDima Kogan 16911029f9feSNamhyung Kim /* 16921029f9feSNamhyung Kim * Iterate over candidate debug images. 16933aafe5aeSCody P Schafer * Keep track of "interesting" ones (those which have a symtab, dynsym, 16943aafe5aeSCody P Schafer * and/or opd section) for processing. 16956da80ce8SDave Martin */ 169644f24cb3SJiri Olsa for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) { 16973aafe5aeSCody P Schafer struct symsrc *ss = &ss_[ss_pos]; 16983aafe5aeSCody P Schafer bool next_slot = false; 1699f045b8c4SKrister Johansen bool is_reg; 1700d2396999SKrister Johansen bool nsexit; 1701c3962961SJiri Olsa int sirc = -1; 170244f24cb3SJiri Olsa 1703005f9294SCody P Schafer enum dso_binary_type symtab_type = binary_type_symtab[i]; 170444f24cb3SJiri Olsa 1705d2396999SKrister Johansen nsexit = (symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE || 1706d2396999SKrister Johansen symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO); 1707d2396999SKrister Johansen 17081029f9feSNamhyung Kim if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type)) 17091029f9feSNamhyung Kim continue; 17101029f9feSNamhyung Kim 1711ee4e9625SArnaldo Carvalho de Melo if (dso__read_binary_type_filename(dso, symtab_type, 171244f24cb3SJiri Olsa root_dir, name, PATH_MAX)) 17136da80ce8SDave Martin continue; 171486470930SIngo Molnar 1715d2396999SKrister Johansen if (nsexit) 1716f045b8c4SKrister Johansen nsinfo__mountns_exit(&nsc); 171740356721SJiri Olsa 1718f045b8c4SKrister Johansen is_reg = is_regular_file(name); 1719c3962961SJiri Olsa if (is_reg) 1720f045b8c4SKrister Johansen sirc = symsrc__init(ss, dso, name, symtab_type); 1721f045b8c4SKrister Johansen 1722d2396999SKrister Johansen if (nsexit) 1723f045b8c4SKrister Johansen nsinfo__mountns_enter(dso->nsinfo, &nsc); 1724f045b8c4SKrister Johansen 1725c3962961SJiri Olsa if (!is_reg || sirc < 0) 17266da80ce8SDave Martin continue; 17276da80ce8SDave Martin 17283aafe5aeSCody P Schafer if (!syms_ss && symsrc__has_symtab(ss)) { 17293aafe5aeSCody P Schafer syms_ss = ss; 17303aafe5aeSCody P Schafer next_slot = true; 17310058aef6SAdrian Hunter if (!dso->symsrc_filename) 17320058aef6SAdrian Hunter dso->symsrc_filename = strdup(name); 1733d26cd12bSCody P Schafer } 1734d26cd12bSCody P Schafer 17353aafe5aeSCody P Schafer if (!runtime_ss && symsrc__possibly_runtime(ss)) { 17363aafe5aeSCody P Schafer runtime_ss = ss; 17373aafe5aeSCody P Schafer next_slot = true; 1738a44f605bSCody P Schafer } 173986470930SIngo Molnar 17403aafe5aeSCody P Schafer if (next_slot) { 17413aafe5aeSCody P Schafer ss_pos++; 174233ff581eSJiri Olsa 17433aafe5aeSCody P Schafer if (syms_ss && runtime_ss) 17446da80ce8SDave Martin break; 174598e9f03bSNamhyung Kim } else { 174698e9f03bSNamhyung Kim symsrc__destroy(ss); 1747a25e46c4SArnaldo Carvalho de Melo } 17483aafe5aeSCody P Schafer 17496da80ce8SDave Martin } 17506da80ce8SDave Martin 17513aafe5aeSCody P Schafer if (!runtime_ss && !syms_ss) 17523aafe5aeSCody P Schafer goto out_free; 17533aafe5aeSCody P Schafer 17543aafe5aeSCody P Schafer if (runtime_ss && !syms_ss) { 17553aafe5aeSCody P Schafer syms_ss = runtime_ss; 175660e4b10cSArnaldo Carvalho de Melo } 175760e4b10cSArnaldo Carvalho de Melo 17583aafe5aeSCody P Schafer /* We'll have to hope for the best */ 17593aafe5aeSCody P Schafer if (!runtime_ss && syms_ss) 17603aafe5aeSCody P Schafer runtime_ss = syms_ss; 17613aafe5aeSCody P Schafer 17621029f9feSNamhyung Kim if (syms_ss) 1763be39db9fSArnaldo Carvalho de Melo ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod); 17641029f9feSNamhyung Kim else 17653aafe5aeSCody P Schafer ret = -1; 17663aafe5aeSCody P Schafer 1767f47b58b7SDavid Ahern if (ret > 0) { 17683aafe5aeSCody P Schafer int nr_plt; 17693aafe5aeSCody P Schafer 17703183f8caSArnaldo Carvalho de Melo nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss); 17713aafe5aeSCody P Schafer if (nr_plt > 0) 17723aafe5aeSCody P Schafer ret += nr_plt; 17733aafe5aeSCody P Schafer } 17743aafe5aeSCody P Schafer 17753aafe5aeSCody P Schafer for (; ss_pos > 0; ss_pos--) 17763aafe5aeSCody P Schafer symsrc__destroy(&ss_[ss_pos - 1]); 17773aafe5aeSCody P Schafer out_free: 177886470930SIngo Molnar free(name); 1779aeafcbafSArnaldo Carvalho de Melo if (ret < 0 && strstr(dso->name, " (deleted)") != NULL) 17804a936edcSNamhyung Kim ret = 0; 17814a936edcSNamhyung Kim out: 17823183f8caSArnaldo Carvalho de Melo dso__set_loaded(dso); 17834a936edcSNamhyung Kim pthread_mutex_unlock(&dso->lock); 1784843ff37bSKrister Johansen nsinfo__mountns_exit(&nsc); 17854a936edcSNamhyung Kim 178686470930SIngo Molnar return ret; 178786470930SIngo Molnar } 178886470930SIngo Molnar 1789a7c2b572SArnaldo Carvalho de Melo static int map__strcmp(const void *a, const void *b) 1790a7c2b572SArnaldo Carvalho de Melo { 1791a7c2b572SArnaldo Carvalho de Melo const struct map *ma = *(const struct map **)a, *mb = *(const struct map **)b; 1792a7c2b572SArnaldo Carvalho de Melo return strcmp(ma->dso->short_name, mb->dso->short_name); 1793a7c2b572SArnaldo Carvalho de Melo } 1794a7c2b572SArnaldo Carvalho de Melo 1795a7c2b572SArnaldo Carvalho de Melo static int map__strcmp_name(const void *name, const void *b) 1796a7c2b572SArnaldo Carvalho de Melo { 1797a7c2b572SArnaldo Carvalho de Melo const struct map *map = *(const struct map **)b; 1798a7c2b572SArnaldo Carvalho de Melo return strcmp(name, map->dso->short_name); 1799a7c2b572SArnaldo Carvalho de Melo } 1800a7c2b572SArnaldo Carvalho de Melo 18019a29ceeeSArnaldo Carvalho de Melo void __maps__sort_by_name(struct maps *maps) 1802a7c2b572SArnaldo Carvalho de Melo { 18039a29ceeeSArnaldo Carvalho de Melo qsort(maps->maps_by_name, maps->nr_maps, sizeof(struct map *), map__strcmp); 1804a7c2b572SArnaldo Carvalho de Melo } 1805a7c2b572SArnaldo Carvalho de Melo 18069a29ceeeSArnaldo Carvalho de Melo static int map__groups__sort_by_name_from_rbtree(struct maps *maps) 1807a7c2b572SArnaldo Carvalho de Melo { 1808a7c2b572SArnaldo Carvalho de Melo struct map *map; 18099a29ceeeSArnaldo Carvalho de Melo struct map **maps_by_name = realloc(maps->maps_by_name, maps->nr_maps * sizeof(map)); 1810a7c2b572SArnaldo Carvalho de Melo int i = 0; 1811a7c2b572SArnaldo Carvalho de Melo 1812a7c2b572SArnaldo Carvalho de Melo if (maps_by_name == NULL) 1813a7c2b572SArnaldo Carvalho de Melo return -1; 1814a7c2b572SArnaldo Carvalho de Melo 18159a29ceeeSArnaldo Carvalho de Melo maps->maps_by_name = maps_by_name; 18169a29ceeeSArnaldo Carvalho de Melo maps->nr_maps_allocated = maps->nr_maps; 1817a7c2b572SArnaldo Carvalho de Melo 18189a29ceeeSArnaldo Carvalho de Melo maps__for_each_entry(maps, map) 1819a7c2b572SArnaldo Carvalho de Melo maps_by_name[i++] = map; 1820a7c2b572SArnaldo Carvalho de Melo 18219a29ceeeSArnaldo Carvalho de Melo __maps__sort_by_name(maps); 1822a7c2b572SArnaldo Carvalho de Melo return 0; 1823a7c2b572SArnaldo Carvalho de Melo } 1824a7c2b572SArnaldo Carvalho de Melo 18259a29ceeeSArnaldo Carvalho de Melo static struct map *__maps__find_by_name(struct maps *maps, const char *name) 1826a7c2b572SArnaldo Carvalho de Melo { 1827a7c2b572SArnaldo Carvalho de Melo struct map **mapp; 1828a7c2b572SArnaldo Carvalho de Melo 18299a29ceeeSArnaldo Carvalho de Melo if (maps->maps_by_name == NULL && 18309a29ceeeSArnaldo Carvalho de Melo map__groups__sort_by_name_from_rbtree(maps)) 1831a7c2b572SArnaldo Carvalho de Melo return NULL; 1832a7c2b572SArnaldo Carvalho de Melo 18339a29ceeeSArnaldo Carvalho de Melo mapp = bsearch(name, maps->maps_by_name, maps->nr_maps, sizeof(*mapp), map__strcmp_name); 1834a7c2b572SArnaldo Carvalho de Melo if (mapp) 1835a7c2b572SArnaldo Carvalho de Melo return *mapp; 1836a7c2b572SArnaldo Carvalho de Melo return NULL; 1837a7c2b572SArnaldo Carvalho de Melo } 1838a7c2b572SArnaldo Carvalho de Melo 18399a29ceeeSArnaldo Carvalho de Melo struct map *maps__find_by_name(struct maps *maps, const char *name) 1840439d473bSArnaldo Carvalho de Melo { 18414bb7123dSArnaldo Carvalho de Melo struct map *map; 1842439d473bSArnaldo Carvalho de Melo 18430a7c74eaSArnaldo Carvalho de Melo down_read(&maps->lock); 18446a2ffcddSArnaldo Carvalho de Melo 18459a29ceeeSArnaldo Carvalho de Melo if (maps->last_search_by_name && strcmp(maps->last_search_by_name->dso->short_name, name) == 0) { 18469a29ceeeSArnaldo Carvalho de Melo map = maps->last_search_by_name; 18476a2ffcddSArnaldo Carvalho de Melo goto out_unlock; 18481ae14516SArnaldo Carvalho de Melo } 1849a7c2b572SArnaldo Carvalho de Melo /* 18509a29ceeeSArnaldo Carvalho de Melo * If we have maps->maps_by_name, then the name isn't in the rbtree, 18519a29ceeeSArnaldo Carvalho de Melo * as maps->maps_by_name mirrors the rbtree when lookups by name are 1852a7c2b572SArnaldo Carvalho de Melo * made. 1853a7c2b572SArnaldo Carvalho de Melo */ 18549a29ceeeSArnaldo Carvalho de Melo map = __maps__find_by_name(maps, name); 18559a29ceeeSArnaldo Carvalho de Melo if (map || maps->maps_by_name != NULL) 1856a7c2b572SArnaldo Carvalho de Melo goto out_unlock; 18571ae14516SArnaldo Carvalho de Melo 1858a7c2b572SArnaldo Carvalho de Melo /* Fallback to traversing the rbtree... */ 18591ae14516SArnaldo Carvalho de Melo maps__for_each_entry(maps, map) 18601ae14516SArnaldo Carvalho de Melo if (strcmp(map->dso->short_name, name) == 0) { 18619a29ceeeSArnaldo Carvalho de Melo maps->last_search_by_name = map; 18621ae14516SArnaldo Carvalho de Melo goto out_unlock; 18631ae14516SArnaldo Carvalho de Melo } 1864439d473bSArnaldo Carvalho de Melo 18656a2ffcddSArnaldo Carvalho de Melo map = NULL; 18666a2ffcddSArnaldo Carvalho de Melo 18676a2ffcddSArnaldo Carvalho de Melo out_unlock: 18680a7c74eaSArnaldo Carvalho de Melo up_read(&maps->lock); 18696a2ffcddSArnaldo Carvalho de Melo return map; 1870439d473bSArnaldo Carvalho de Melo } 1871439d473bSArnaldo Carvalho de Melo 1872aeafcbafSArnaldo Carvalho de Melo int dso__load_vmlinux(struct dso *dso, struct map *map, 1873be39db9fSArnaldo Carvalho de Melo const char *vmlinux, bool vmlinux_allocated) 187486470930SIngo Molnar { 1875b68e2f91SCody P Schafer int err = -1; 1876b68e2f91SCody P Schafer struct symsrc ss; 1877ec5761eaSDavid Ahern char symfs_vmlinux[PATH_MAX]; 1878005f9294SCody P Schafer enum dso_binary_type symtab_type; 187986470930SIngo Molnar 18805698d2c9SNamhyung Kim if (vmlinux[0] == '/') 18815698d2c9SNamhyung Kim snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux); 18825698d2c9SNamhyung Kim else 1883972f393bSArnaldo Carvalho de Melo symbol__join_symfs(symfs_vmlinux, vmlinux); 188486470930SIngo Molnar 1885*1c695c88SJiri Olsa if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1886005f9294SCody P Schafer symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 188721ea4539SCody P Schafer else 1888005f9294SCody P Schafer symtab_type = DSO_BINARY_TYPE__VMLINUX; 188921ea4539SCody P Schafer 1890005f9294SCody P Schafer if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type)) 1891b68e2f91SCody P Schafer return -1; 1892b68e2f91SCody P Schafer 1893be39db9fSArnaldo Carvalho de Melo err = dso__load_sym(dso, map, &ss, &ss, 0); 1894b68e2f91SCody P Schafer symsrc__destroy(&ss); 189586470930SIngo Molnar 1896515850e4SCody P Schafer if (err > 0) { 1897*1c695c88SJiri Olsa if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 18985f70619dSArnaldo Carvalho de Melo dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 189939b12f78SAdrian Hunter else 19005f70619dSArnaldo Carvalho de Melo dso->binary_type = DSO_BINARY_TYPE__VMLINUX; 1901bf4414aeSArnaldo Carvalho de Melo dso__set_long_name(dso, vmlinux, vmlinux_allocated); 19023183f8caSArnaldo Carvalho de Melo dso__set_loaded(dso); 1903ec5761eaSDavid Ahern pr_debug("Using %s for symbols\n", symfs_vmlinux); 1904515850e4SCody P Schafer } 19053846df2eSArnaldo Carvalho de Melo 190686470930SIngo Molnar return err; 190786470930SIngo Molnar } 190886470930SIngo Molnar 1909be39db9fSArnaldo Carvalho de Melo int dso__load_vmlinux_path(struct dso *dso, struct map *map) 1910a19afe46SArnaldo Carvalho de Melo { 1911a19afe46SArnaldo Carvalho de Melo int i, err = 0; 191200dc8657SNamhyung Kim char *filename = NULL; 1913a19afe46SArnaldo Carvalho de Melo 1914dc38218eSArnaldo Carvalho de Melo pr_debug("Looking at the vmlinux_path (%d entries long)\n", 1915dc38218eSArnaldo Carvalho de Melo vmlinux_path__nr_entries + 1); 1916dc38218eSArnaldo Carvalho de Melo 1917dc38218eSArnaldo Carvalho de Melo for (i = 0; i < vmlinux_path__nr_entries; ++i) { 1918be39db9fSArnaldo Carvalho de Melo err = dso__load_vmlinux(dso, map, vmlinux_path[i], false); 1919dc38218eSArnaldo Carvalho de Melo if (err > 0) 1920dc38218eSArnaldo Carvalho de Melo goto out; 1921dc38218eSArnaldo Carvalho de Melo } 1922dc38218eSArnaldo Carvalho de Melo 192300dc8657SNamhyung Kim if (!symbol_conf.ignore_vmlinux_buildid) 1924d2396999SKrister Johansen filename = dso__build_id_filename(dso, NULL, 0, false); 19255ad90e4eSArnaldo Carvalho de Melo if (filename != NULL) { 1926be39db9fSArnaldo Carvalho de Melo err = dso__load_vmlinux(dso, map, filename, true); 19275230fb7dSArnaldo Carvalho de Melo if (err > 0) 19285ad90e4eSArnaldo Carvalho de Melo goto out; 19295ad90e4eSArnaldo Carvalho de Melo free(filename); 19305ad90e4eSArnaldo Carvalho de Melo } 19315ad90e4eSArnaldo Carvalho de Melo out: 1932a19afe46SArnaldo Carvalho de Melo return err; 1933a19afe46SArnaldo Carvalho de Melo } 1934a19afe46SArnaldo Carvalho de Melo 1935c48903b8SMasami Hiramatsu static bool visible_dir_filter(const char *name, struct dirent *d) 1936c48903b8SMasami Hiramatsu { 1937c48903b8SMasami Hiramatsu if (d->d_type != DT_DIR) 1938c48903b8SMasami Hiramatsu return false; 1939c48903b8SMasami Hiramatsu return lsdir_no_dot_filter(name, d); 1940c48903b8SMasami Hiramatsu } 1941c48903b8SMasami Hiramatsu 19420544d422SAdrian Hunter static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz) 19430544d422SAdrian Hunter { 19440544d422SAdrian Hunter char kallsyms_filename[PATH_MAX]; 19450544d422SAdrian Hunter int ret = -1; 1946c48903b8SMasami Hiramatsu struct strlist *dirs; 1947c48903b8SMasami Hiramatsu struct str_node *nd; 19480544d422SAdrian Hunter 1949c48903b8SMasami Hiramatsu dirs = lsdir(dir, visible_dir_filter); 1950c48903b8SMasami Hiramatsu if (!dirs) 19510544d422SAdrian Hunter return -1; 19520544d422SAdrian Hunter 1953602a1f4dSArnaldo Carvalho de Melo strlist__for_each_entry(nd, dirs) { 19540544d422SAdrian Hunter scnprintf(kallsyms_filename, sizeof(kallsyms_filename), 1955c48903b8SMasami Hiramatsu "%s/%s/kallsyms", dir, nd->s); 1956a00d28cbSAdrian Hunter if (!validate_kcore_addresses(kallsyms_filename, map)) { 19570544d422SAdrian Hunter strlcpy(dir, kallsyms_filename, dir_sz); 19580544d422SAdrian Hunter ret = 0; 19590544d422SAdrian Hunter break; 19600544d422SAdrian Hunter } 19610544d422SAdrian Hunter } 19620544d422SAdrian Hunter 1963c48903b8SMasami Hiramatsu strlist__delete(dirs); 19640544d422SAdrian Hunter 19650544d422SAdrian Hunter return ret; 19660544d422SAdrian Hunter } 19670544d422SAdrian Hunter 196811870d71SMasami Hiramatsu /* 196911870d71SMasami Hiramatsu * Use open(O_RDONLY) to check readability directly instead of access(R_OK) 197011870d71SMasami Hiramatsu * since access(R_OK) only checks with real UID/GID but open() use effective 197111870d71SMasami Hiramatsu * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO). 197211870d71SMasami Hiramatsu */ 197311870d71SMasami Hiramatsu static bool filename__readable(const char *file) 197411870d71SMasami Hiramatsu { 197511870d71SMasami Hiramatsu int fd = open(file, O_RDONLY); 197611870d71SMasami Hiramatsu if (fd < 0) 197711870d71SMasami Hiramatsu return false; 197811870d71SMasami Hiramatsu close(fd); 197911870d71SMasami Hiramatsu return true; 198011870d71SMasami Hiramatsu } 198111870d71SMasami Hiramatsu 19820544d422SAdrian Hunter static char *dso__find_kallsyms(struct dso *dso, struct map *map) 19830544d422SAdrian Hunter { 19840544d422SAdrian Hunter u8 host_build_id[BUILD_ID_SIZE]; 1985b5d8bbe8SMasami Hiramatsu char sbuild_id[SBUILD_ID_SIZE]; 19860544d422SAdrian Hunter bool is_host = false; 19870544d422SAdrian Hunter char path[PATH_MAX]; 19880544d422SAdrian Hunter 19890544d422SAdrian Hunter if (!dso->has_build_id) { 19900544d422SAdrian Hunter /* 19910544d422SAdrian Hunter * Last resort, if we don't have a build-id and couldn't find 19920544d422SAdrian Hunter * any vmlinux file, try the running kernel kallsyms table. 19930544d422SAdrian Hunter */ 19940544d422SAdrian Hunter goto proc_kallsyms; 19950544d422SAdrian Hunter } 19960544d422SAdrian Hunter 19970544d422SAdrian Hunter if (sysfs__read_build_id("/sys/kernel/notes", host_build_id, 19980544d422SAdrian Hunter sizeof(host_build_id)) == 0) 19990544d422SAdrian Hunter is_host = dso__build_id_equal(dso, host_build_id); 20000544d422SAdrian Hunter 20014e4b6c06SMasami Hiramatsu /* Try a fast path for /proc/kallsyms if possible */ 20020544d422SAdrian Hunter if (is_host) { 20030544d422SAdrian Hunter /* 200411870d71SMasami Hiramatsu * Do not check the build-id cache, unless we know we cannot use 200511870d71SMasami Hiramatsu * /proc/kcore or module maps don't match to /proc/kallsyms. 200611870d71SMasami Hiramatsu * To check readability of /proc/kcore, do not use access(R_OK) 200711870d71SMasami Hiramatsu * since /proc/kcore requires CAP_SYS_RAWIO to read and access 200811870d71SMasami Hiramatsu * can't check it. 20090544d422SAdrian Hunter */ 201011870d71SMasami Hiramatsu if (filename__readable("/proc/kcore") && 201111870d71SMasami Hiramatsu !validate_kcore_addresses("/proc/kallsyms", map)) 20120544d422SAdrian Hunter goto proc_kallsyms; 20130544d422SAdrian Hunter } 20140544d422SAdrian Hunter 20154e4b6c06SMasami Hiramatsu build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id); 20164e4b6c06SMasami Hiramatsu 2017449867e3SAdrian Hunter /* Find kallsyms in build-id cache with kcore */ 20184e4b6c06SMasami Hiramatsu scnprintf(path, sizeof(path), "%s/%s/%s", 20194e4b6c06SMasami Hiramatsu buildid_dir, DSO__NAME_KCORE, sbuild_id); 20204e4b6c06SMasami Hiramatsu 2021449867e3SAdrian Hunter if (!find_matching_kcore(map, path, sizeof(path))) 2022449867e3SAdrian Hunter return strdup(path); 2023449867e3SAdrian Hunter 20244e4b6c06SMasami Hiramatsu /* Use current /proc/kallsyms if possible */ 20254e4b6c06SMasami Hiramatsu if (is_host) { 20264e4b6c06SMasami Hiramatsu proc_kallsyms: 20274e4b6c06SMasami Hiramatsu return strdup("/proc/kallsyms"); 20284e4b6c06SMasami Hiramatsu } 20294e4b6c06SMasami Hiramatsu 20304e4b6c06SMasami Hiramatsu /* Finally, find a cache of kallsyms */ 203101412261SMasami Hiramatsu if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) { 20320544d422SAdrian Hunter pr_err("No kallsyms or vmlinux with build-id %s was found\n", 20330544d422SAdrian Hunter sbuild_id); 20340544d422SAdrian Hunter return NULL; 20350544d422SAdrian Hunter } 20360544d422SAdrian Hunter 20370544d422SAdrian Hunter return strdup(path); 20380544d422SAdrian Hunter } 20390544d422SAdrian Hunter 2040be39db9fSArnaldo Carvalho de Melo static int dso__load_kernel_sym(struct dso *dso, struct map *map) 204186470930SIngo Molnar { 2042cc612d81SArnaldo Carvalho de Melo int err; 20439e201442SArnaldo Carvalho de Melo const char *kallsyms_filename = NULL; 20449e201442SArnaldo Carvalho de Melo char *kallsyms_allocated_filename = NULL; 2045dc8d6ab2SArnaldo Carvalho de Melo /* 2046b226a5a7SDavid Ahern * Step 1: if the user specified a kallsyms or vmlinux filename, use 2047b226a5a7SDavid Ahern * it and only it, reporting errors to the user if it cannot be used. 2048dc8d6ab2SArnaldo Carvalho de Melo * 2049dc8d6ab2SArnaldo Carvalho de Melo * For instance, try to analyse an ARM perf.data file _without_ a 2050dc8d6ab2SArnaldo Carvalho de Melo * build-id, or if the user specifies the wrong path to the right 2051dc8d6ab2SArnaldo Carvalho de Melo * vmlinux file, obviously we can't fallback to another vmlinux (a 2052dc8d6ab2SArnaldo Carvalho de Melo * x86_86 one, on the machine where analysis is being performed, say), 2053dc8d6ab2SArnaldo Carvalho de Melo * or worse, /proc/kallsyms. 2054dc8d6ab2SArnaldo Carvalho de Melo * 2055dc8d6ab2SArnaldo Carvalho de Melo * If the specified file _has_ a build-id and there is a build-id 2056dc8d6ab2SArnaldo Carvalho de Melo * section in the perf.data file, we will still do the expected 2057dc8d6ab2SArnaldo Carvalho de Melo * validation in dso__load_vmlinux and will bail out if they don't 2058dc8d6ab2SArnaldo Carvalho de Melo * match. 2059dc8d6ab2SArnaldo Carvalho de Melo */ 2060b226a5a7SDavid Ahern if (symbol_conf.kallsyms_name != NULL) { 2061b226a5a7SDavid Ahern kallsyms_filename = symbol_conf.kallsyms_name; 2062b226a5a7SDavid Ahern goto do_kallsyms; 2063b226a5a7SDavid Ahern } 2064b226a5a7SDavid Ahern 2065fc2be696SWilly Tarreau if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) { 2066be39db9fSArnaldo Carvalho de Melo return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false); 2067dc8d6ab2SArnaldo Carvalho de Melo } 2068439d473bSArnaldo Carvalho de Melo 2069fc2be696SWilly Tarreau if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) { 2070be39db9fSArnaldo Carvalho de Melo err = dso__load_vmlinux_path(dso, map); 2071a19afe46SArnaldo Carvalho de Melo if (err > 0) 207239b12f78SAdrian Hunter return err; 2073cc612d81SArnaldo Carvalho de Melo } 2074cc612d81SArnaldo Carvalho de Melo 2075ec5761eaSDavid Ahern /* do not try local files if a symfs was given */ 2076ec5761eaSDavid Ahern if (symbol_conf.symfs[0] != 0) 2077ec5761eaSDavid Ahern return -1; 2078ec5761eaSDavid Ahern 20790544d422SAdrian Hunter kallsyms_allocated_filename = dso__find_kallsyms(dso, map); 20800544d422SAdrian Hunter if (!kallsyms_allocated_filename) 20818d0591f6SArnaldo Carvalho de Melo return -1; 20828d0591f6SArnaldo Carvalho de Melo 208319fc2dedSArnaldo Carvalho de Melo kallsyms_filename = kallsyms_allocated_filename; 208419fc2dedSArnaldo Carvalho de Melo 2085dc8d6ab2SArnaldo Carvalho de Melo do_kallsyms: 2086be39db9fSArnaldo Carvalho de Melo err = dso__load_kallsyms(dso, kallsyms_filename, map); 20873846df2eSArnaldo Carvalho de Melo if (err > 0) 20883846df2eSArnaldo Carvalho de Melo pr_debug("Using %s for symbols\n", kallsyms_filename); 2089dc8d6ab2SArnaldo Carvalho de Melo free(kallsyms_allocated_filename); 2090dc8d6ab2SArnaldo Carvalho de Melo 20918e0cf965SAdrian Hunter if (err > 0 && !dso__is_kcore(dso)) { 2092bdac0bcfSAdrian Hunter dso->binary_type = DSO_BINARY_TYPE__KALLSYMS; 20930a77582fSMasami Hiramatsu dso__set_long_name(dso, DSO__NAME_KALLSYMS, false); 20946a4694a4SArnaldo Carvalho de Melo map__fixup_start(map); 20956a4694a4SArnaldo Carvalho de Melo map__fixup_end(map); 2096439d473bSArnaldo Carvalho de Melo } 209794cb9e38SArnaldo Carvalho de Melo 209886470930SIngo Molnar return err; 209986470930SIngo Molnar } 210086470930SIngo Molnar 2101be39db9fSArnaldo Carvalho de Melo static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map) 2102a1645ce1SZhang, Yanmin { 2103a1645ce1SZhang, Yanmin int err; 2104a1645ce1SZhang, Yanmin const char *kallsyms_filename = NULL; 210593fcce96SArnaldo Carvalho de Melo struct machine *machine = map__kmaps(map)->machine; 2106a1645ce1SZhang, Yanmin char path[PATH_MAX]; 2107a1645ce1SZhang, Yanmin 210823346f21SArnaldo Carvalho de Melo if (machine__is_default_guest(machine)) { 2109a1645ce1SZhang, Yanmin /* 2110a1645ce1SZhang, Yanmin * if the user specified a vmlinux filename, use it and only 2111a1645ce1SZhang, Yanmin * it, reporting errors to the user if it cannot be used. 2112a1645ce1SZhang, Yanmin * Or use file guest_kallsyms inputted by user on commandline 2113a1645ce1SZhang, Yanmin */ 2114a1645ce1SZhang, Yanmin if (symbol_conf.default_guest_vmlinux_name != NULL) { 2115aeafcbafSArnaldo Carvalho de Melo err = dso__load_vmlinux(dso, map, 21165230fb7dSArnaldo Carvalho de Melo symbol_conf.default_guest_vmlinux_name, 2117be39db9fSArnaldo Carvalho de Melo false); 211839b12f78SAdrian Hunter return err; 2119a1645ce1SZhang, Yanmin } 2120a1645ce1SZhang, Yanmin 2121a1645ce1SZhang, Yanmin kallsyms_filename = symbol_conf.default_guest_kallsyms; 2122a1645ce1SZhang, Yanmin if (!kallsyms_filename) 2123a1645ce1SZhang, Yanmin return -1; 2124a1645ce1SZhang, Yanmin } else { 212523346f21SArnaldo Carvalho de Melo sprintf(path, "%s/proc/kallsyms", machine->root_dir); 2126a1645ce1SZhang, Yanmin kallsyms_filename = path; 2127a1645ce1SZhang, Yanmin } 2128a1645ce1SZhang, Yanmin 2129be39db9fSArnaldo Carvalho de Melo err = dso__load_kallsyms(dso, kallsyms_filename, map); 21308e0cf965SAdrian Hunter if (err > 0) 213139b12f78SAdrian Hunter pr_debug("Using %s for symbols\n", kallsyms_filename); 21328e0cf965SAdrian Hunter if (err > 0 && !dso__is_kcore(dso)) { 2133bdac0bcfSAdrian Hunter dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 21348c7f1bb3SJiri Olsa dso__set_long_name(dso, machine->mmap_name, false); 2135a1645ce1SZhang, Yanmin map__fixup_start(map); 2136a1645ce1SZhang, Yanmin map__fixup_end(map); 2137a1645ce1SZhang, Yanmin } 2138a1645ce1SZhang, Yanmin 2139a1645ce1SZhang, Yanmin return err; 2140a1645ce1SZhang, Yanmin } 2141cd84c2acSFrederic Weisbecker 2142cc612d81SArnaldo Carvalho de Melo static void vmlinux_path__exit(void) 21432446042cSArnaldo Carvalho de Melo { 214404662523SArnaldo Carvalho de Melo while (--vmlinux_path__nr_entries >= 0) 214504662523SArnaldo Carvalho de Melo zfree(&vmlinux_path[vmlinux_path__nr_entries]); 2146c4f03547SWang Nan vmlinux_path__nr_entries = 0; 2147cc612d81SArnaldo Carvalho de Melo 214804662523SArnaldo Carvalho de Melo zfree(&vmlinux_path); 2149cc612d81SArnaldo Carvalho de Melo } 2150cc612d81SArnaldo Carvalho de Melo 2151aac48647SEkaterina Tumanova static const char * const vmlinux_paths[] = { 2152aac48647SEkaterina Tumanova "vmlinux", 2153aac48647SEkaterina Tumanova "/boot/vmlinux" 2154aac48647SEkaterina Tumanova }; 2155aac48647SEkaterina Tumanova 2156aac48647SEkaterina Tumanova static const char * const vmlinux_paths_upd[] = { 2157aac48647SEkaterina Tumanova "/boot/vmlinux-%s", 2158aac48647SEkaterina Tumanova "/usr/lib/debug/boot/vmlinux-%s", 2159aac48647SEkaterina Tumanova "/lib/modules/%s/build/vmlinux", 2160f55ae954SEkaterina Tumanova "/usr/lib/debug/lib/modules/%s/vmlinux", 2161f55ae954SEkaterina Tumanova "/usr/lib/debug/boot/vmlinux-%s.debug" 2162aac48647SEkaterina Tumanova }; 2163aac48647SEkaterina Tumanova 2164aac48647SEkaterina Tumanova static int vmlinux_path__add(const char *new_entry) 2165aac48647SEkaterina Tumanova { 2166aac48647SEkaterina Tumanova vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry); 2167aac48647SEkaterina Tumanova if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2168aac48647SEkaterina Tumanova return -1; 2169aac48647SEkaterina Tumanova ++vmlinux_path__nr_entries; 2170aac48647SEkaterina Tumanova 2171aac48647SEkaterina Tumanova return 0; 2172aac48647SEkaterina Tumanova } 2173aac48647SEkaterina Tumanova 2174ce80d3beSKan Liang static int vmlinux_path__init(struct perf_env *env) 2175cc612d81SArnaldo Carvalho de Melo { 2176cc612d81SArnaldo Carvalho de Melo struct utsname uts; 2177cc612d81SArnaldo Carvalho de Melo char bf[PATH_MAX]; 21780a7e6d1bSNamhyung Kim char *kernel_version; 2179aac48647SEkaterina Tumanova unsigned int i; 2180cc612d81SArnaldo Carvalho de Melo 2181aac48647SEkaterina Tumanova vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) + 2182aac48647SEkaterina Tumanova ARRAY_SIZE(vmlinux_paths_upd))); 2183cc612d81SArnaldo Carvalho de Melo if (vmlinux_path == NULL) 2184cc612d81SArnaldo Carvalho de Melo return -1; 2185cc612d81SArnaldo Carvalho de Melo 2186aac48647SEkaterina Tumanova for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++) 2187aac48647SEkaterina Tumanova if (vmlinux_path__add(vmlinux_paths[i]) < 0) 2188cc612d81SArnaldo Carvalho de Melo goto out_fail; 2189ec5761eaSDavid Ahern 21900a7e6d1bSNamhyung Kim /* only try kernel version if no symfs was given */ 2191ec5761eaSDavid Ahern if (symbol_conf.symfs[0] != 0) 2192ec5761eaSDavid Ahern return 0; 2193ec5761eaSDavid Ahern 21940a7e6d1bSNamhyung Kim if (env) { 21950a7e6d1bSNamhyung Kim kernel_version = env->os_release; 21960a7e6d1bSNamhyung Kim } else { 2197ec5761eaSDavid Ahern if (uname(&uts) < 0) 2198e96c674fSNamhyung Kim goto out_fail; 2199ec5761eaSDavid Ahern 22000a7e6d1bSNamhyung Kim kernel_version = uts.release; 22010a7e6d1bSNamhyung Kim } 22020a7e6d1bSNamhyung Kim 2203aac48647SEkaterina Tumanova for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) { 2204aac48647SEkaterina Tumanova snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version); 2205aac48647SEkaterina Tumanova if (vmlinux_path__add(bf) < 0) 2206cc612d81SArnaldo Carvalho de Melo goto out_fail; 2207aac48647SEkaterina Tumanova } 2208cc612d81SArnaldo Carvalho de Melo 2209cc612d81SArnaldo Carvalho de Melo return 0; 2210cc612d81SArnaldo Carvalho de Melo 2211cc612d81SArnaldo Carvalho de Melo out_fail: 2212cc612d81SArnaldo Carvalho de Melo vmlinux_path__exit(); 2213cc612d81SArnaldo Carvalho de Melo return -1; 2214cc612d81SArnaldo Carvalho de Melo } 2215cc612d81SArnaldo Carvalho de Melo 22163bfe5f81SDavid Ahern int setup_list(struct strlist **list, const char *list_str, 2217655000e7SArnaldo Carvalho de Melo const char *list_name) 2218655000e7SArnaldo Carvalho de Melo { 2219655000e7SArnaldo Carvalho de Melo if (list_str == NULL) 2220655000e7SArnaldo Carvalho de Melo return 0; 2221655000e7SArnaldo Carvalho de Melo 22224a77e218SArnaldo Carvalho de Melo *list = strlist__new(list_str, NULL); 2223655000e7SArnaldo Carvalho de Melo if (!*list) { 2224655000e7SArnaldo Carvalho de Melo pr_err("problems parsing %s list\n", list_name); 2225655000e7SArnaldo Carvalho de Melo return -1; 2226655000e7SArnaldo Carvalho de Melo } 22270bc2f2f7SArnaldo Carvalho de Melo 22280bc2f2f7SArnaldo Carvalho de Melo symbol_conf.has_filter = true; 2229655000e7SArnaldo Carvalho de Melo return 0; 2230655000e7SArnaldo Carvalho de Melo } 2231655000e7SArnaldo Carvalho de Melo 2232e03eaa40SDavid Ahern int setup_intlist(struct intlist **list, const char *list_str, 2233e03eaa40SDavid Ahern const char *list_name) 2234e03eaa40SDavid Ahern { 2235e03eaa40SDavid Ahern if (list_str == NULL) 2236e03eaa40SDavid Ahern return 0; 2237e03eaa40SDavid Ahern 2238e03eaa40SDavid Ahern *list = intlist__new(list_str); 2239e03eaa40SDavid Ahern if (!*list) { 2240e03eaa40SDavid Ahern pr_err("problems parsing %s list\n", list_name); 2241e03eaa40SDavid Ahern return -1; 2242e03eaa40SDavid Ahern } 2243e03eaa40SDavid Ahern return 0; 2244e03eaa40SDavid Ahern } 2245e03eaa40SDavid Ahern 2246ec80fde7SArnaldo Carvalho de Melo static bool symbol__read_kptr_restrict(void) 2247ec80fde7SArnaldo Carvalho de Melo { 2248ec80fde7SArnaldo Carvalho de Melo bool value = false; 2249ec80fde7SArnaldo Carvalho de Melo FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r"); 225038272dc4SWang Nan 2251ec80fde7SArnaldo Carvalho de Melo if (fp != NULL) { 2252ec80fde7SArnaldo Carvalho de Melo char line[8]; 2253ec80fde7SArnaldo Carvalho de Melo 2254ec80fde7SArnaldo Carvalho de Melo if (fgets(line, sizeof(line), fp) != NULL) 22558859aedeSIgor Lubashev value = perf_cap__capable(CAP_SYSLOG) ? 22568859aedeSIgor Lubashev (atoi(line) >= 2) : 22578859aedeSIgor Lubashev (atoi(line) != 0); 2258ec80fde7SArnaldo Carvalho de Melo 2259ec80fde7SArnaldo Carvalho de Melo fclose(fp); 2260ec80fde7SArnaldo Carvalho de Melo } 2261ec80fde7SArnaldo Carvalho de Melo 22628859aedeSIgor Lubashev /* Per kernel/kallsyms.c: 22638859aedeSIgor Lubashev * we also restrict when perf_event_paranoid > 1 w/o CAP_SYSLOG 22648859aedeSIgor Lubashev */ 22658859aedeSIgor Lubashev if (perf_event_paranoid() > 1 && !perf_cap__capable(CAP_SYSLOG)) 22668859aedeSIgor Lubashev value = true; 22678859aedeSIgor Lubashev 2268ec80fde7SArnaldo Carvalho de Melo return value; 2269ec80fde7SArnaldo Carvalho de Melo } 2270ec80fde7SArnaldo Carvalho de Melo 2271b01141f4SArnaldo Carvalho de Melo int symbol__annotation_init(void) 2272b01141f4SArnaldo Carvalho de Melo { 22737b366142SArnaldo Carvalho de Melo if (symbol_conf.init_annotation) 22747b366142SArnaldo Carvalho de Melo return 0; 22757b366142SArnaldo Carvalho de Melo 2276b01141f4SArnaldo Carvalho de Melo if (symbol_conf.initialized) { 2277b01141f4SArnaldo Carvalho de Melo pr_err("Annotation needs to be init before symbol__init()\n"); 2278b01141f4SArnaldo Carvalho de Melo return -1; 2279b01141f4SArnaldo Carvalho de Melo } 2280b01141f4SArnaldo Carvalho de Melo 2281b01141f4SArnaldo Carvalho de Melo symbol_conf.priv_size += sizeof(struct annotation); 2282b01141f4SArnaldo Carvalho de Melo symbol_conf.init_annotation = true; 2283b01141f4SArnaldo Carvalho de Melo return 0; 2284b01141f4SArnaldo Carvalho de Melo } 2285b01141f4SArnaldo Carvalho de Melo 2286ce80d3beSKan Liang int symbol__init(struct perf_env *env) 2287cc612d81SArnaldo Carvalho de Melo { 2288ec5761eaSDavid Ahern const char *symfs; 2289ec5761eaSDavid Ahern 229085e00b55SJovi Zhang if (symbol_conf.initialized) 229185e00b55SJovi Zhang return 0; 229285e00b55SJovi Zhang 22939ac3e487SIrina Tirdea symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64)); 22944d439517SDavid S. Miller 2295166ccc9cSNamhyung Kim symbol__elf_init(); 2296166ccc9cSNamhyung Kim 229775be6cf4SArnaldo Carvalho de Melo if (symbol_conf.sort_by_name) 229875be6cf4SArnaldo Carvalho de Melo symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) - 229979406cd7SArnaldo Carvalho de Melo sizeof(struct symbol)); 2300b32d133aSArnaldo Carvalho de Melo 23010a7e6d1bSNamhyung Kim if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0) 2302cc612d81SArnaldo Carvalho de Melo return -1; 2303cc612d81SArnaldo Carvalho de Melo 2304c410a338SArnaldo Carvalho de Melo if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') { 2305c410a338SArnaldo Carvalho de Melo pr_err("'.' is the only non valid --field-separator argument\n"); 2306c410a338SArnaldo Carvalho de Melo return -1; 2307c410a338SArnaldo Carvalho de Melo } 2308c410a338SArnaldo Carvalho de Melo 2309655000e7SArnaldo Carvalho de Melo if (setup_list(&symbol_conf.dso_list, 2310655000e7SArnaldo Carvalho de Melo symbol_conf.dso_list_str, "dso") < 0) 2311655000e7SArnaldo Carvalho de Melo return -1; 2312655000e7SArnaldo Carvalho de Melo 2313655000e7SArnaldo Carvalho de Melo if (setup_list(&symbol_conf.comm_list, 2314655000e7SArnaldo Carvalho de Melo symbol_conf.comm_list_str, "comm") < 0) 2315655000e7SArnaldo Carvalho de Melo goto out_free_dso_list; 2316655000e7SArnaldo Carvalho de Melo 2317e03eaa40SDavid Ahern if (setup_intlist(&symbol_conf.pid_list, 2318e03eaa40SDavid Ahern symbol_conf.pid_list_str, "pid") < 0) 2319e03eaa40SDavid Ahern goto out_free_comm_list; 2320e03eaa40SDavid Ahern 2321e03eaa40SDavid Ahern if (setup_intlist(&symbol_conf.tid_list, 2322e03eaa40SDavid Ahern symbol_conf.tid_list_str, "tid") < 0) 2323e03eaa40SDavid Ahern goto out_free_pid_list; 2324e03eaa40SDavid Ahern 2325655000e7SArnaldo Carvalho de Melo if (setup_list(&symbol_conf.sym_list, 2326655000e7SArnaldo Carvalho de Melo symbol_conf.sym_list_str, "symbol") < 0) 2327e03eaa40SDavid Ahern goto out_free_tid_list; 2328655000e7SArnaldo Carvalho de Melo 232964eff7d9SDavid Ahern if (setup_list(&symbol_conf.bt_stop_list, 233064eff7d9SDavid Ahern symbol_conf.bt_stop_list_str, "symbol") < 0) 233164eff7d9SDavid Ahern goto out_free_sym_list; 233264eff7d9SDavid Ahern 2333ec5761eaSDavid Ahern /* 2334ec5761eaSDavid Ahern * A path to symbols of "/" is identical to "" 2335ec5761eaSDavid Ahern * reset here for simplicity. 2336ec5761eaSDavid Ahern */ 2337ec5761eaSDavid Ahern symfs = realpath(symbol_conf.symfs, NULL); 2338ec5761eaSDavid Ahern if (symfs == NULL) 2339ec5761eaSDavid Ahern symfs = symbol_conf.symfs; 2340ec5761eaSDavid Ahern if (strcmp(symfs, "/") == 0) 2341ec5761eaSDavid Ahern symbol_conf.symfs = ""; 2342ec5761eaSDavid Ahern if (symfs != symbol_conf.symfs) 2343ec5761eaSDavid Ahern free((void *)symfs); 2344ec5761eaSDavid Ahern 2345ec80fde7SArnaldo Carvalho de Melo symbol_conf.kptr_restrict = symbol__read_kptr_restrict(); 2346ec80fde7SArnaldo Carvalho de Melo 234785e00b55SJovi Zhang symbol_conf.initialized = true; 23484aa65636SArnaldo Carvalho de Melo return 0; 2349655000e7SArnaldo Carvalho de Melo 235064eff7d9SDavid Ahern out_free_sym_list: 235164eff7d9SDavid Ahern strlist__delete(symbol_conf.sym_list); 2352e03eaa40SDavid Ahern out_free_tid_list: 2353e03eaa40SDavid Ahern intlist__delete(symbol_conf.tid_list); 2354e03eaa40SDavid Ahern out_free_pid_list: 2355e03eaa40SDavid Ahern intlist__delete(symbol_conf.pid_list); 2356655000e7SArnaldo Carvalho de Melo out_free_comm_list: 2357655000e7SArnaldo Carvalho de Melo strlist__delete(symbol_conf.comm_list); 2358d74c896bSNamhyung Kim out_free_dso_list: 2359d74c896bSNamhyung Kim strlist__delete(symbol_conf.dso_list); 2360655000e7SArnaldo Carvalho de Melo return -1; 2361cc612d81SArnaldo Carvalho de Melo } 2362cc612d81SArnaldo Carvalho de Melo 2363d65a458bSArnaldo Carvalho de Melo void symbol__exit(void) 2364d65a458bSArnaldo Carvalho de Melo { 236585e00b55SJovi Zhang if (!symbol_conf.initialized) 236685e00b55SJovi Zhang return; 236764eff7d9SDavid Ahern strlist__delete(symbol_conf.bt_stop_list); 2368d65a458bSArnaldo Carvalho de Melo strlist__delete(symbol_conf.sym_list); 2369d65a458bSArnaldo Carvalho de Melo strlist__delete(symbol_conf.dso_list); 2370d65a458bSArnaldo Carvalho de Melo strlist__delete(symbol_conf.comm_list); 2371e03eaa40SDavid Ahern intlist__delete(symbol_conf.tid_list); 2372e03eaa40SDavid Ahern intlist__delete(symbol_conf.pid_list); 2373d65a458bSArnaldo Carvalho de Melo vmlinux_path__exit(); 2374d65a458bSArnaldo Carvalho de Melo symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL; 237564eff7d9SDavid Ahern symbol_conf.bt_stop_list = NULL; 237685e00b55SJovi Zhang symbol_conf.initialized = false; 2377d65a458bSArnaldo Carvalho de Melo } 2378a7066709SHe Kuang 2379a7066709SHe Kuang int symbol__config_symfs(const struct option *opt __maybe_unused, 2380a7066709SHe Kuang const char *dir, int unset __maybe_unused) 2381a7066709SHe Kuang { 2382a7066709SHe Kuang char *bf = NULL; 2383a7066709SHe Kuang int ret; 2384a7066709SHe Kuang 2385a7066709SHe Kuang symbol_conf.symfs = strdup(dir); 2386a7066709SHe Kuang if (symbol_conf.symfs == NULL) 2387a7066709SHe Kuang return -ENOMEM; 2388a7066709SHe Kuang 2389a7066709SHe Kuang /* skip the locally configured cache if a symfs is given, and 2390a7066709SHe Kuang * config buildid dir to symfs/.debug 2391a7066709SHe Kuang */ 2392a7066709SHe Kuang ret = asprintf(&bf, "%s/%s", dir, ".debug"); 2393a7066709SHe Kuang if (ret < 0) 2394a7066709SHe Kuang return -ENOMEM; 2395a7066709SHe Kuang 2396a7066709SHe Kuang set_buildid_dir(bf); 2397a7066709SHe Kuang 2398a7066709SHe Kuang free(bf); 2399a7066709SHe Kuang return 0; 2400a7066709SHe Kuang } 24019f87498fSJiri Olsa 24029f87498fSJiri Olsa struct mem_info *mem_info__get(struct mem_info *mi) 24039f87498fSJiri Olsa { 24049f87498fSJiri Olsa if (mi) 24059f87498fSJiri Olsa refcount_inc(&mi->refcnt); 24069f87498fSJiri Olsa return mi; 24079f87498fSJiri Olsa } 24089f87498fSJiri Olsa 24099f87498fSJiri Olsa void mem_info__put(struct mem_info *mi) 24109f87498fSJiri Olsa { 24119f87498fSJiri Olsa if (mi && refcount_dec_and_test(&mi->refcnt)) 24129f87498fSJiri Olsa free(mi); 24139f87498fSJiri Olsa } 24149f87498fSJiri Olsa 24159f87498fSJiri Olsa struct mem_info *mem_info__new(void) 24169f87498fSJiri Olsa { 24179f87498fSJiri Olsa struct mem_info *mi = zalloc(sizeof(*mi)); 24189f87498fSJiri Olsa 24199f87498fSJiri Olsa if (mi) 24209f87498fSJiri Olsa refcount_set(&mi->refcnt, 1); 24219f87498fSJiri Olsa return mi; 24229f87498fSJiri Olsa } 2423