diff options
Diffstat (limited to 'tools/perf/util/map.c')
| -rw-r--r-- | tools/perf/util/map.c | 882 |
1 files changed, 326 insertions, 556 deletions
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c index 2179b2deb730..41cdddc987ee 100644 --- a/tools/perf/util/map.c +++ b/tools/perf/util/map.c @@ -1,49 +1,25 @@ -#include "symbol.h" -#include <errno.h> +// SPDX-License-Identifier: GPL-2.0 #include <inttypes.h> #include <limits.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> -#include <stdio.h> -#include <unistd.h> +#include <linux/string.h> +#include <linux/zalloc.h> #include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */ +#include "debug.h" +#include "dso.h" #include "map.h" +#include "namespaces.h" +#include "srcline.h" +#include "symbol.h" #include "thread.h" #include "vdso.h" -#include "build-id.h" -#include "util.h" -#include "debug.h" -#include "machine.h" -#include <linux/string.h> -#include "srcline.h" -#include "unwind.h" - -static void __maps__insert(struct maps *maps, struct map *map); - -const char *map_type__name[MAP__NR_TYPES] = { - [MAP__FUNCTION] = "Functions", - [MAP__VARIABLE] = "Variables", -}; - -static inline int is_anon_memory(const char *filename, u32 flags) -{ - return flags & MAP_HUGETLB || - !strcmp(filename, "//anon") || - !strncmp(filename, "/dev/zero", sizeof("/dev/zero") - 1) || - !strncmp(filename, "/anon_hugepage", sizeof("/anon_hugepage") - 1); -} - -static inline int is_no_dso_memory(const char *filename) -{ - return !strncmp(filename, "[stack", 6) || - !strncmp(filename, "/SYSV",5) || - !strcmp(filename, "[heap]"); -} static inline int is_android_lib(const char *filename) { - return !strncmp(filename, "/data/app-lib", 13) || - !strncmp(filename, "/system/lib", 11); + return strstarts(filename, "/data/app-lib/") || + strstarts(filename, "/system/lib/"); } static inline bool replace_android_lib(const char *filename, char *newfilename) @@ -63,7 +39,7 @@ static inline bool replace_android_lib(const char *filename, char *newfilename) app_abi_length = strlen(app_abi); - if (!strncmp(filename, "/data/app-lib", 13)) { + if (strstarts(filename, "/data/app-lib/")) { char *apk_path; if (!app_abi_length) @@ -87,11 +63,10 @@ static inline bool replace_android_lib(const char *filename, char *newfilename) return true; } - if (!strncmp(filename, "/system/lib/", 11)) { + if (strstarts(filename, "/system/lib/")) { char *ndk, *app; const char *arch; - size_t ndk_length; - size_t app_length; + int ndk_length, app_length; ndk = getenv("NDK_ROOT"); app = getenv("APP_PLATFORM"); @@ -119,57 +94,56 @@ static inline bool replace_android_lib(const char *filename, char *newfilename) if (new_length > PATH_MAX) return false; snprintf(newfilename, new_length, - "%s/platforms/%s/arch-%s/usr/lib/%s", - ndk, app, arch, libname); + "%.*s/platforms/%.*s/arch-%s/usr/lib/%s", + ndk_length, ndk, app_length, app, arch, libname); return true; } return false; } -void map__init(struct map *map, enum map_type type, - u64 start, u64 end, u64 pgoff, struct dso *dso) +static void map__init(struct map *map, u64 start, u64 end, u64 pgoff, + struct dso *dso, u32 prot, u32 flags) { - map->type = type; - map->start = start; - map->end = end; - map->pgoff = pgoff; - map->reloc = 0; - map->dso = dso__get(dso); - map->map_ip = map__map_ip; - map->unmap_ip = map__unmap_ip; - RB_CLEAR_NODE(&map->rb_node); - map->groups = NULL; - map->erange_warned = false; - refcount_set(&map->refcnt, 1); + map__set_start(map, start); + map__set_end(map, end); + map__set_pgoff(map, pgoff); + assert(map__reloc(map) == 0); + map__set_dso(map, dso__get(dso)); + refcount_set(map__refcnt(map), 1); + RC_CHK_ACCESS(map)->prot = prot; + RC_CHK_ACCESS(map)->flags = flags; + map__set_mapping_type(map, MAPPING_TYPE__DSO); + assert(map__erange_warned(map) == false); + assert(map__priv(map) == false); + assert(map__hit(map) == false); } struct map *map__new(struct machine *machine, u64 start, u64 len, - u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino, - u64 ino_gen, u32 prot, u32 flags, char *filename, - enum map_type type, struct thread *thread) + u64 pgoff, const struct dso_id *id, + u32 prot, u32 flags, + char *filename, struct thread *thread) { - struct map *map = malloc(sizeof(*map)); + struct map *result; + RC_STRUCT(map) *map; + struct nsinfo *nsi = NULL; + struct nsinfo *nnsi; - if (map != NULL) { + map = zalloc(sizeof(*map)); + if (ADD_RC_CHK(result, map)) { char newfilename[PATH_MAX]; struct dso *dso; int anon, no_dso, vdso, android; android = is_android_lib(filename); - anon = is_anon_memory(filename, flags); + anon = is_anon_memory(filename) || flags & MAP_HUGETLB; vdso = is_vdso_map(filename); no_dso = is_no_dso_memory(filename); + nsi = nsinfo__get(thread__nsinfo(thread)); - map->maj = d_maj; - map->min = d_min; - map->ino = ino; - map->ino_generation = ino_gen; - map->prot = prot; - map->flags = flags; - - if ((anon || no_dso) && type == MAP__FUNCTION) { - snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid); + if ((anon || no_dso) && nsi && (prot & PROT_EXEC)) { + snprintf(newfilename, sizeof(newfilename), + "/tmp/perf-%d.map", nsinfo__pid(nsi)); filename = newfilename; } @@ -179,32 +153,63 @@ struct map *map__new(struct machine *machine, u64 start, u64 len, } if (vdso) { + /* The vdso maps are always on the host and not the + * container. Ensure that we don't use setns to look + * them up. + */ + nnsi = nsinfo__copy(nsi); + if (nnsi) { + nsinfo__put(nsi); + nsinfo__clear_need_setns(nnsi); + nsi = nnsi; + } pgoff = 0; dso = machine__findnew_vdso(machine, thread); } else - dso = machine__findnew_dso(machine, filename); + dso = machine__findnew_dso_id(machine, filename, id); if (dso == NULL) goto out_delete; - map__init(map, type, start, start + len, pgoff, dso); + assert(!dso__kernel(dso)); + map__init(result, start, start + len, pgoff, dso, prot, flags); if (anon || no_dso) { - map->map_ip = map->unmap_ip = identity__map_ip; + map->mapping_type = MAPPING_TYPE__IDENTITY; /* * Set memory without DSO as loaded. All map__find_* * functions still return NULL, and we avoid the * unnecessary map__load warning. */ - if (type != MAP__FUNCTION) - dso__set_loaded(dso, map->type); + if (!(prot & PROT_EXEC)) + dso__set_loaded(dso); + } + mutex_lock(dso__lock(dso)); + dso__set_nsinfo(dso, nsi); + mutex_unlock(dso__lock(dso)); + + if (!build_id__is_defined(&id->build_id)) { + /* + * If the mmap event had no build ID, search for an existing dso from the + * build ID header by name. Otherwise only the dso loaded at the time of + * reading the header will have the build ID set and all future mmaps will + * have it missing. + */ + struct dso *header_bid_dso = dsos__find(&machine->dsos, filename, false); + + if (header_bid_dso && dso__header_build_id(header_bid_dso)) { + dso__set_build_id(dso, dso__bid(header_bid_dso)); + dso__set_header_build_id(dso, 1); + } + dso__put(header_bid_dso); } dso__put(dso); } - return map; + return result; out_delete: - free(map); + nsinfo__put(nsi); + RC_CHK_FREE(result); return NULL; } @@ -213,69 +218,122 @@ out_delete: * they are loaded) and for vmlinux, where only after we load all the * symbols we'll know where it starts and ends. */ -struct map *map__new2(u64 start, struct dso *dso, enum map_type type) -{ - struct map *map = calloc(1, (sizeof(*map) + - (dso->kernel ? sizeof(struct kmap) : 0))); - if (map != NULL) { - /* - * ->end will be filled after we load all the symbols - */ - map__init(map, type, start, 0, 0, dso); +struct map *map__new2(u64 start, struct dso *dso) +{ + struct map *result; + RC_STRUCT(map) *map; + + map = calloc(1, sizeof(*map) + (dso__kernel(dso) ? sizeof(struct kmap) : 0)); + if (ADD_RC_CHK(result, map)) { + /* ->end will be filled after we load all the symbols. */ + map__init(result, start, /*end=*/0, /*pgoff=*/0, dso, /*prot=*/0, /*flags=*/0); } - return map; + return result; } -/* - * Use this and __map__is_kmodule() for map instances that are in - * machine->kmaps, and thus have map->groups->machine all properly set, to - * disambiguate between the kernel and modules. - * - * When the need arises, introduce map__is_{kernel,kmodule)() that - * checks (map->groups != NULL && map->groups->machine != NULL && - * map->dso->kernel) before calling __map__is_{kernel,kmodule}()) - */ bool __map__is_kernel(const struct map *map) { - return __machine__kernel_map(map->groups->machine, map->type) == map; + if (!dso__kernel(map__dso(map))) + return false; + return machine__kernel_map(maps__machine(map__kmaps((struct map *)map))) == map; +} + +bool __map__is_extra_kernel_map(const struct map *map) +{ + struct kmap *kmap = __map__kmap((struct map *)map); + + return kmap && kmap->name[0]; +} + +bool __map__is_bpf_prog(const struct map *map) +{ + const char *name; + struct dso *dso = map__dso(map); + + if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_PROG_INFO) + return true; + + /* + * If PERF_RECORD_BPF_EVENT is not included, the dso will not have + * type of DSO_BINARY_TYPE__BPF_PROG_INFO. In such cases, we can + * guess the type based on name. + */ + name = dso__short_name(dso); + return name && (strstr(name, "bpf_prog_") == name); +} + +bool __map__is_bpf_image(const struct map *map) +{ + const char *name; + struct dso *dso = map__dso(map); + + if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_IMAGE) + return true; + + /* + * If PERF_RECORD_KSYMBOL is not included, the dso will not have + * type of DSO_BINARY_TYPE__BPF_IMAGE. In such cases, we can + * guess the type based on name. + */ + name = dso__short_name(dso); + return name && is_bpf_image(name); +} + +bool __map__is_ool(const struct map *map) +{ + const struct dso *dso = map__dso(map); + + return dso && dso__binary_type(dso) == DSO_BINARY_TYPE__OOL; +} + +bool map__has_symbols(const struct map *map) +{ + return dso__has_symbols(map__dso(map)); } static void map__exit(struct map *map) { - BUG_ON(!RB_EMPTY_NODE(&map->rb_node)); - dso__zput(map->dso); + BUG_ON(refcount_read(map__refcnt(map)) != 0); + dso__zput(RC_CHK_ACCESS(map)->dso); } void map__delete(struct map *map) { map__exit(map); - free(map); + RC_CHK_FREE(map); } void map__put(struct map *map) { - if (map && refcount_dec_and_test(&map->refcnt)) + if (map && refcount_dec_and_test(map__refcnt(map))) map__delete(map); + else + RC_CHK_PUT(map); } void map__fixup_start(struct map *map) { - struct rb_root *symbols = &map->dso->symbols[map->type]; - struct rb_node *nd = rb_first(symbols); + struct dso *dso = map__dso(map); + struct rb_root_cached *symbols = dso__symbols(dso); + struct rb_node *nd = rb_first_cached(symbols); + if (nd != NULL) { struct symbol *sym = rb_entry(nd, struct symbol, rb_node); - map->start = sym->start; + + map__set_start(map, sym->start); } } void map__fixup_end(struct map *map) { - struct rb_root *symbols = &map->dso->symbols[map->type]; - struct rb_node *nd = rb_last(symbols); + struct dso *dso = map__dso(map); + struct rb_root_cached *symbols = dso__symbols(dso); + struct rb_node *nd = rb_last(&symbols->rb_root); + if (nd != NULL) { struct symbol *sym = rb_entry(nd, struct symbol, rb_node); - map->end = sym->end; + map__set_end(map, sym->end); } } @@ -283,26 +341,24 @@ void map__fixup_end(struct map *map) int map__load(struct map *map) { - const char *name = map->dso->long_name; + struct dso *dso = map__dso(map); + const char *name = dso__long_name(dso); int nr; - if (dso__loaded(map->dso, map->type)) + if (dso__loaded(dso)) return 0; - nr = dso__load(map->dso, map); + nr = dso__load(dso, map); if (nr < 0) { - if (map->dso->has_build_id) { + if (dso__has_build_id(dso)) { char sbuild_id[SBUILD_ID_SIZE]; - build_id__sprintf(map->dso->build_id, - sizeof(map->dso->build_id), - sbuild_id); - pr_warning("%s with build id %s not found", - name, sbuild_id); + build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id)); + pr_debug("%s with build id %s not found", name, sbuild_id); } else - pr_warning("Failed to open %s", name); + pr_debug("Failed to open %s", name); - pr_warning(", continuing without symbols\n"); + pr_debug(", continuing without symbols\n"); return -1; } else if (nr == 0) { #ifdef HAVE_LIBELF_SUPPORT @@ -311,12 +367,11 @@ int map__load(struct map *map) if (len > sizeof(DSO__DELETED) && strcmp(name + real_len + 1, DSO__DELETED) == 0) { - pr_warning("%.*s was updated (is prelink enabled?). " + pr_debug("%.*s was updated (is prelink enabled?). " "Restart the long running apps that use it!\n", (int)real_len, name); } else { - pr_warning("no symbols found in %s, maybe install " - "a debug package?\n", name); + pr_debug("no symbols found in %s, maybe install a debug package?\n", name); } #endif return -1; @@ -330,85 +385,136 @@ struct symbol *map__find_symbol(struct map *map, u64 addr) if (map__load(map) < 0) return NULL; - return dso__find_symbol(map->dso, map->type, addr); + return dso__find_symbol(map__dso(map), addr); } -struct symbol *map__find_symbol_by_name(struct map *map, const char *name) +struct symbol *map__find_symbol_by_name_idx(struct map *map, const char *name, size_t *idx) { + struct dso *dso; + if (map__load(map) < 0) return NULL; - if (!dso__sorted_by_name(map->dso, map->type)) - dso__sort_by_name(map->dso, map->type); + dso = map__dso(map); + dso__sort_by_name(dso); + + return dso__find_symbol_by_name(dso, name, idx); +} + +struct symbol *map__find_symbol_by_name(struct map *map, const char *name) +{ + size_t idx; - return dso__find_symbol_by_name(map->dso, map->type, name); + return map__find_symbol_by_name_idx(map, name, &idx); } struct map *map__clone(struct map *from) { - struct map *map = memdup(from, sizeof(*map)); + struct map *result; + RC_STRUCT(map) *map; + size_t size = sizeof(RC_STRUCT(map)); + struct dso *dso = map__dso(from); + + if (dso && dso__kernel(dso)) + size += sizeof(struct kmap); - if (map != NULL) { + map = memdup(RC_CHK_ACCESS(from), size); + if (ADD_RC_CHK(result, map)) { refcount_set(&map->refcnt, 1); - RB_CLEAR_NODE(&map->rb_node); - dso__get(map->dso); - map->groups = NULL; + map->dso = dso__get(dso); } - return map; + return result; } -int map__overlap(struct map *l, struct map *r) +size_t map__fprintf(struct map *map, FILE *fp) { - if (l->start > r->start) { - struct map *t = l; - l = r; - r = t; - } + const struct dso *dso = map__dso(map); - if (l->end > r->start) - return 1; - - return 0; + return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n", + map__start(map), map__end(map), map__pgoff(map), dso__name(dso)); } -size_t map__fprintf(struct map *map, FILE *fp) +static bool prefer_dso_long_name(const struct dso *dso, bool print_off) { - return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n", - map->start, map->end, map->pgoff, map->dso->name); + return dso__long_name(dso) && + (symbol_conf.show_kernel_path || + (print_off && (dso__name(dso)[0] == '[' || dso__is_kcore(dso)))); } -size_t map__fprintf_dsoname(struct map *map, FILE *fp) +static size_t __map__fprintf_dsoname(struct map *map, bool print_off, FILE *fp) { + char buf[symbol_conf.pad_output_len_dso + 1]; const char *dsoname = "[unknown]"; + const struct dso *dso = map ? map__dso(map) : NULL; - if (map && map->dso) { - if (symbol_conf.show_kernel_path && map->dso->long_name) - dsoname = map->dso->long_name; + if (dso) { + if (prefer_dso_long_name(dso, print_off)) + dsoname = dso__long_name(dso); else - dsoname = map->dso->name; + dsoname = dso__name(dso); + } + + if (symbol_conf.pad_output_len_dso) { + scnprintf_pad(buf, symbol_conf.pad_output_len_dso, "%s", dsoname); + dsoname = buf; } return fprintf(fp, "%s", dsoname); } +size_t map__fprintf_dsoname(struct map *map, FILE *fp) +{ + return __map__fprintf_dsoname(map, false, fp); +} + +size_t map__fprintf_dsoname_dsoff(struct map *map, bool print_off, u64 addr, FILE *fp) +{ + const struct dso *dso = map ? map__dso(map) : NULL; + int printed = 0; + + if (print_off && (!dso || !dso__is_object_file(dso))) + print_off = false; + printed += fprintf(fp, " ("); + printed += __map__fprintf_dsoname(map, print_off, fp); + if (print_off) + printed += fprintf(fp, "+0x%" PRIx64, addr); + printed += fprintf(fp, ")"); + + return printed; +} + +char *map__srcline(struct map *map, u64 addr, struct symbol *sym) +{ + if (map == NULL) + return SRCLINE_UNKNOWN; + + return get_srcline(map__dso(map), map__rip_2objdump(map, addr), sym, true, true, addr); +} + int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix, FILE *fp) { - char *srcline; + const struct dso *dso = map ? map__dso(map) : NULL; int ret = 0; - if (map && map->dso) { - srcline = get_srcline(map->dso, - map__rip_2objdump(map, addr), NULL, - true, true); + if (dso) { + char *srcline = map__srcline(map, addr, NULL); if (srcline != SRCLINE_UNKNOWN) ret = fprintf(fp, "%s%s", prefix, srcline); - free_srcline(srcline); + zfree_srcline(&srcline); } return ret; } +void srccode_state_free(struct srccode_state *state) +{ + zfree(&state->srcfile); + state->line = 0; +} + +static const struct kmap *__map__const_kmap(const struct map *map); + /** * map__rip_2objdump - convert symbol start address to objdump address. * @map: memory map @@ -420,22 +526,37 @@ int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix, * * Return: Address suitable for passing to "objdump --start-address=" */ -u64 map__rip_2objdump(struct map *map, u64 rip) +u64 map__rip_2objdump(const struct map *map, u64 rip) { - if (!map->dso->adjust_symbols) - return rip; - - if (map->dso->rel) - return rip - map->pgoff; + const struct kmap *kmap = __map__const_kmap(map); + const struct dso *dso = map__dso(map); /* - * kernel modules also have DSO_TYPE_USER in dso->kernel, - * but all kernel modules are ET_REL, so won't get here. + * vmlinux does not have program headers for PTI entry trampolines and + * kcore may not either. However the trampoline object code is on the + * main kernel map, so just use that instead. */ - if (map->dso->kernel == DSO_TYPE_USER) - return rip + map->dso->text_offset; + if (kmap && is_entry_trampoline(kmap->name) && kmap->kmaps) { + struct machine *machine = maps__machine(kmap->kmaps); + + if (machine) { + struct map *kernel_map = machine__kernel_map(machine); + + if (kernel_map) + map = kernel_map; + } + } + + if (!dso__adjust_symbols(dso)) + return rip; - return map->unmap_ip(map, rip) - map->reloc; + if (dso__rel(dso)) + return rip - map__pgoff(map); + + if (dso__kernel(dso) == DSO_SPACE__USER) + return rip + dso__text_offset(dso); + + return map__unmap_ip(map, rip) - map__reloc(map); } /** @@ -446,429 +567,78 @@ u64 map__rip_2objdump(struct map *map, u64 rip) * Closely related to map__rip_2objdump(), this function takes an address from * objdump and converts it to a memory address. Note this assumes that @map * contains the address. To be sure the result is valid, check it forwards - * e.g. map__rip_2objdump(map->map_ip(map, map__objdump_2mem(map, ip))) == ip + * e.g. map__rip_2objdump(map__map_ip(map, map__objdump_2mem(map, ip))) == ip * * Return: Memory address. */ -u64 map__objdump_2mem(struct map *map, u64 ip) +u64 map__objdump_2mem(const struct map *map, u64 ip) { - if (!map->dso->adjust_symbols) - return map->unmap_ip(map, ip); + const struct dso *dso = map__dso(map); - if (map->dso->rel) - return map->unmap_ip(map, ip + map->pgoff); + if (!dso__adjust_symbols(dso)) + return map__unmap_ip(map, ip); - /* - * kernel modules also have DSO_TYPE_USER in dso->kernel, - * but all kernel modules are ET_REL, so won't get here. - */ - if (map->dso->kernel == DSO_TYPE_USER) - return map->unmap_ip(map, ip - map->dso->text_offset); + if (dso__rel(dso)) + return map__unmap_ip(map, ip + map__pgoff(map)); - return ip + map->reloc; -} + if (dso__kernel(dso) == DSO_SPACE__USER) + return map__unmap_ip(map, ip - dso__text_offset(dso)); -static void maps__init(struct maps *maps) -{ - maps->entries = RB_ROOT; - pthread_rwlock_init(&maps->lock, NULL); + return ip + map__reloc(map); } -void map_groups__init(struct map_groups *mg, struct machine *machine) +/* convert objdump address to relative address. (To be removed) */ +u64 map__objdump_2rip(const struct map *map, u64 ip) { - int i; - for (i = 0; i < MAP__NR_TYPES; ++i) { - maps__init(&mg->maps[i]); - } - mg->machine = machine; - refcount_set(&mg->refcnt, 1); -} + const struct dso *dso = map__dso(map); -static void __maps__purge(struct maps *maps) -{ - struct rb_root *root = &maps->entries; - struct rb_node *next = rb_first(root); + if (!dso__adjust_symbols(dso)) + return ip; - while (next) { - struct map *pos = rb_entry(next, struct map, rb_node); + if (dso__rel(dso)) + return ip + map__pgoff(map); - next = rb_next(&pos->rb_node); - rb_erase_init(&pos->rb_node, root); - map__put(pos); - } -} + if (dso__kernel(dso) == DSO_SPACE__USER) + return ip - dso__text_offset(dso); -static void maps__exit(struct maps *maps) -{ - pthread_rwlock_wrlock(&maps->lock); - __maps__purge(maps); - pthread_rwlock_unlock(&maps->lock); + return map__map_ip(map, ip + map__reloc(map)); } -void map_groups__exit(struct map_groups *mg) +bool map__contains_symbol(const struct map *map, const struct symbol *sym) { - int i; - - for (i = 0; i < MAP__NR_TYPES; ++i) - maps__exit(&mg->maps[i]); -} - -bool map_groups__empty(struct map_groups *mg) -{ - int i; - - for (i = 0; i < MAP__NR_TYPES; ++i) { - if (maps__first(&mg->maps[i])) - return false; - } + u64 ip = map__unmap_ip(map, sym->start); - return true; + return ip >= map__start(map) && ip < map__end(map); } -struct map_groups *map_groups__new(struct machine *machine) +struct kmap *__map__kmap(struct map *map) { - struct map_groups *mg = malloc(sizeof(*mg)); + const struct dso *dso = map__dso(map); - if (mg != NULL) - map_groups__init(mg, machine); - - return mg; -} - -void map_groups__delete(struct map_groups *mg) -{ - map_groups__exit(mg); - free(mg); -} - -void map_groups__put(struct map_groups *mg) -{ - if (mg && refcount_dec_and_test(&mg->refcnt)) - map_groups__delete(mg); -} - -struct symbol *map_groups__find_symbol(struct map_groups *mg, - enum map_type type, u64 addr, - struct map **mapp) -{ - struct map *map = map_groups__find(mg, type, addr); - - /* Ensure map is loaded before using map->map_ip */ - if (map != NULL && map__load(map) >= 0) { - if (mapp != NULL) - *mapp = map; - return map__find_symbol(map, map->map_ip(map, addr)); - } - - return NULL; -} - -struct symbol *maps__find_symbol_by_name(struct maps *maps, const char *name, - struct map **mapp) -{ - struct symbol *sym; - struct rb_node *nd; - - pthread_rwlock_rdlock(&maps->lock); - - for (nd = rb_first(&maps->entries); nd; nd = rb_next(nd)) { - struct map *pos = rb_entry(nd, struct map, rb_node); - - sym = map__find_symbol_by_name(pos, name); - - if (sym == NULL) - continue; - if (mapp != NULL) - *mapp = pos; - goto out; - } - - sym = NULL; -out: - pthread_rwlock_unlock(&maps->lock); - return sym; -} - -struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg, - enum map_type type, - const char *name, - struct map **mapp) -{ - struct symbol *sym = maps__find_symbol_by_name(&mg->maps[type], name, mapp); - - return sym; -} - -int map_groups__find_ams(struct addr_map_symbol *ams) -{ - if (ams->addr < ams->map->start || ams->addr >= ams->map->end) { - if (ams->map->groups == NULL) - return -1; - ams->map = map_groups__find(ams->map->groups, ams->map->type, - ams->addr); - if (ams->map == NULL) - return -1; - } - - ams->al_addr = ams->map->map_ip(ams->map, ams->addr); - ams->sym = map__find_symbol(ams->map, ams->al_addr); - - return ams->sym ? 0 : -1; -} - -static size_t maps__fprintf(struct maps *maps, FILE *fp) -{ - size_t printed = 0; - struct rb_node *nd; - - pthread_rwlock_rdlock(&maps->lock); - - for (nd = rb_first(&maps->entries); nd; nd = rb_next(nd)) { - struct map *pos = rb_entry(nd, struct map, rb_node); - printed += fprintf(fp, "Map:"); - printed += map__fprintf(pos, fp); - if (verbose > 2) { - printed += dso__fprintf(pos->dso, pos->type, fp); - printed += fprintf(fp, "--\n"); - } - } - - pthread_rwlock_unlock(&maps->lock); - - return printed; -} - -size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type, - FILE *fp) -{ - size_t printed = fprintf(fp, "%s:\n", map_type__name[type]); - return printed += maps__fprintf(&mg->maps[type], fp); -} - -size_t map_groups__fprintf(struct map_groups *mg, FILE *fp) -{ - size_t printed = 0, i; - for (i = 0; i < MAP__NR_TYPES; ++i) - printed += __map_groups__fprintf_maps(mg, i, fp); - return printed; -} - -static void __map_groups__insert(struct map_groups *mg, struct map *map) -{ - __maps__insert(&mg->maps[map->type], map); - map->groups = mg; -} - -static int maps__fixup_overlappings(struct maps *maps, struct map *map, FILE *fp) -{ - struct rb_root *root; - struct rb_node *next; - int err = 0; - - pthread_rwlock_wrlock(&maps->lock); - - root = &maps->entries; - next = rb_first(root); - - while (next) { - struct map *pos = rb_entry(next, struct map, rb_node); - next = rb_next(&pos->rb_node); - - if (!map__overlap(pos, map)) - continue; - - if (verbose >= 2) { - - if (use_browser) { - pr_warning("overlapping maps in %s " - "(disable tui for more info)\n", - map->dso->name); - } else { - fputs("overlapping maps:\n", fp); - map__fprintf(map, fp); - map__fprintf(pos, fp); - } - } - - rb_erase_init(&pos->rb_node, root); - /* - * Now check if we need to create new maps for areas not - * overlapped by the new map: - */ - if (map->start > pos->start) { - struct map *before = map__clone(pos); - - if (before == NULL) { - err = -ENOMEM; - goto put_map; - } - - before->end = map->start; - __map_groups__insert(pos->groups, before); - if (verbose >= 2 && !use_browser) - map__fprintf(before, fp); - map__put(before); - } - - if (map->end < pos->end) { - struct map *after = map__clone(pos); - - if (after == NULL) { - err = -ENOMEM; - goto put_map; - } - - after->start = map->end; - __map_groups__insert(pos->groups, after); - if (verbose >= 2 && !use_browser) - map__fprintf(after, fp); - map__put(after); - } -put_map: - map__put(pos); - - if (err) - goto out; - } - - err = 0; -out: - pthread_rwlock_unlock(&maps->lock); - return err; -} - -int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map, - FILE *fp) -{ - return maps__fixup_overlappings(&mg->maps[map->type], map, fp); -} - -/* - * XXX This should not really _copy_ te maps, but refcount them. - */ -int map_groups__clone(struct thread *thread, - struct map_groups *parent, enum map_type type) -{ - struct map_groups *mg = thread->mg; - int err = -ENOMEM; - struct map *map; - struct maps *maps = &parent->maps[type]; - - pthread_rwlock_rdlock(&maps->lock); - - for (map = maps__first(maps); map; map = map__next(map)) { - struct map *new = map__clone(map); - if (new == NULL) - goto out_unlock; - - err = unwind__prepare_access(thread, new, NULL); - if (err) - goto out_unlock; - - map_groups__insert(mg, new); - map__put(new); - } - - err = 0; -out_unlock: - pthread_rwlock_unlock(&maps->lock); - return err; -} - -static void __maps__insert(struct maps *maps, struct map *map) -{ - struct rb_node **p = &maps->entries.rb_node; - struct rb_node *parent = NULL; - const u64 ip = map->start; - struct map *m; - - while (*p != NULL) { - parent = *p; - m = rb_entry(parent, struct map, rb_node); - if (ip < m->start) - p = &(*p)->rb_left; - else - p = &(*p)->rb_right; - } - - rb_link_node(&map->rb_node, parent, p); - rb_insert_color(&map->rb_node, &maps->entries); - map__get(map); -} - -void maps__insert(struct maps *maps, struct map *map) -{ - pthread_rwlock_wrlock(&maps->lock); - __maps__insert(maps, map); - pthread_rwlock_unlock(&maps->lock); -} - -static void __maps__remove(struct maps *maps, struct map *map) -{ - rb_erase_init(&map->rb_node, &maps->entries); - map__put(map); -} - -void maps__remove(struct maps *maps, struct map *map) -{ - pthread_rwlock_wrlock(&maps->lock); - __maps__remove(maps, map); - pthread_rwlock_unlock(&maps->lock); -} - -struct map *maps__find(struct maps *maps, u64 ip) -{ - struct rb_node **p, *parent = NULL; - struct map *m; - - pthread_rwlock_rdlock(&maps->lock); - - p = &maps->entries.rb_node; - while (*p != NULL) { - parent = *p; - m = rb_entry(parent, struct map, rb_node); - if (ip < m->start) - p = &(*p)->rb_left; - else if (ip >= m->end) - p = &(*p)->rb_right; - else - goto out; - } - - m = NULL; -out: - pthread_rwlock_unlock(&maps->lock); - return m; -} - -struct map *maps__first(struct maps *maps) -{ - struct rb_node *first = rb_first(&maps->entries); - - if (first) - return rb_entry(first, struct map, rb_node); - return NULL; + if (!dso || !dso__kernel(dso)) + return NULL; + return (struct kmap *)(&RC_CHK_ACCESS(map)[1]); } -struct map *map__next(struct map *map) +static const struct kmap *__map__const_kmap(const struct map *map) { - struct rb_node *next = rb_next(&map->rb_node); + const struct dso *dso = map__dso(map); - if (next) - return rb_entry(next, struct map, rb_node); - return NULL; + if (!dso || !dso__kernel(dso)) + return NULL; + return (struct kmap *)(&RC_CHK_ACCESS(map)[1]); } struct kmap *map__kmap(struct map *map) { - if (!map->dso || !map->dso->kernel) { + struct kmap *kmap = __map__kmap(map); + + if (!kmap) pr_err("Internal error: map__kmap with a non-kernel map\n"); - return NULL; - } - return (struct kmap *)(map + 1); + return kmap; } -struct map_groups *map__kmaps(struct map *map) +struct maps *map__kmaps(struct map *map) { struct kmap *kmap = map__kmap(map); |