641 lines · c
1// SPDX-License-Identifier: GPL-2.02#include <inttypes.h>3#include <limits.h>4#include <stdio.h>5#include <stdlib.h>6#include <string.h>7#include <linux/string.h>8#include <linux/zalloc.h>9#include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */10#include "debug.h"11#include "dso.h"12#include "map.h"13#include "namespaces.h"14#include "srcline.h"15#include "symbol.h"16#include "thread.h"17#include "vdso.h"18 19static inline int is_android_lib(const char *filename)20{21 return strstarts(filename, "/data/app-lib/") ||22 strstarts(filename, "/system/lib/");23}24 25static inline bool replace_android_lib(const char *filename, char *newfilename)26{27 const char *libname;28 char *app_abi;29 size_t app_abi_length, new_length;30 size_t lib_length = 0;31 32 libname = strrchr(filename, '/');33 if (libname)34 lib_length = strlen(libname);35 36 app_abi = getenv("APP_ABI");37 if (!app_abi)38 return false;39 40 app_abi_length = strlen(app_abi);41 42 if (strstarts(filename, "/data/app-lib/")) {43 char *apk_path;44 45 if (!app_abi_length)46 return false;47 48 new_length = 7 + app_abi_length + lib_length;49 50 apk_path = getenv("APK_PATH");51 if (apk_path) {52 new_length += strlen(apk_path) + 1;53 if (new_length > PATH_MAX)54 return false;55 snprintf(newfilename, new_length,56 "%s/libs/%s/%s", apk_path, app_abi, libname);57 } else {58 if (new_length > PATH_MAX)59 return false;60 snprintf(newfilename, new_length,61 "libs/%s/%s", app_abi, libname);62 }63 return true;64 }65 66 if (strstarts(filename, "/system/lib/")) {67 char *ndk, *app;68 const char *arch;69 int ndk_length, app_length;70 71 ndk = getenv("NDK_ROOT");72 app = getenv("APP_PLATFORM");73 74 if (!(ndk && app))75 return false;76 77 ndk_length = strlen(ndk);78 app_length = strlen(app);79 80 if (!(ndk_length && app_length && app_abi_length))81 return false;82 83 arch = !strncmp(app_abi, "arm", 3) ? "arm" :84 !strncmp(app_abi, "mips", 4) ? "mips" :85 !strncmp(app_abi, "x86", 3) ? "x86" : NULL;86 87 if (!arch)88 return false;89 90 new_length = 27 + ndk_length +91 app_length + lib_length92 + strlen(arch);93 94 if (new_length > PATH_MAX)95 return false;96 snprintf(newfilename, new_length,97 "%.*s/platforms/%.*s/arch-%s/usr/lib/%s",98 ndk_length, ndk, app_length, app, arch, libname);99 100 return true;101 }102 return false;103}104 105static void map__init(struct map *map, u64 start, u64 end, u64 pgoff,106 struct dso *dso, u32 prot, u32 flags)107{108 map__set_start(map, start);109 map__set_end(map, end);110 map__set_pgoff(map, pgoff);111 assert(map__reloc(map) == 0);112 map__set_dso(map, dso__get(dso));113 refcount_set(map__refcnt(map), 1);114 RC_CHK_ACCESS(map)->prot = prot;115 RC_CHK_ACCESS(map)->flags = flags;116 map__set_mapping_type(map, MAPPING_TYPE__DSO);117 assert(map__erange_warned(map) == false);118 assert(map__priv(map) == false);119 assert(map__hit(map) == false);120}121 122struct map *map__new(struct machine *machine, u64 start, u64 len,123 u64 pgoff, struct dso_id *id,124 u32 prot, u32 flags, struct build_id *bid,125 char *filename, struct thread *thread)126{127 struct map *result;128 RC_STRUCT(map) *map;129 struct nsinfo *nsi = NULL;130 struct nsinfo *nnsi;131 132 map = zalloc(sizeof(*map));133 if (ADD_RC_CHK(result, map)) {134 char newfilename[PATH_MAX];135 struct dso *dso, *header_bid_dso;136 int anon, no_dso, vdso, android;137 138 android = is_android_lib(filename);139 anon = is_anon_memory(filename) || flags & MAP_HUGETLB;140 vdso = is_vdso_map(filename);141 no_dso = is_no_dso_memory(filename);142 nsi = nsinfo__get(thread__nsinfo(thread));143 144 if ((anon || no_dso) && nsi && (prot & PROT_EXEC)) {145 snprintf(newfilename, sizeof(newfilename),146 "/tmp/perf-%d.map", nsinfo__pid(nsi));147 filename = newfilename;148 }149 150 if (android) {151 if (replace_android_lib(filename, newfilename))152 filename = newfilename;153 }154 155 if (vdso) {156 /* The vdso maps are always on the host and not the157 * container. Ensure that we don't use setns to look158 * them up.159 */160 nnsi = nsinfo__copy(nsi);161 if (nnsi) {162 nsinfo__put(nsi);163 nsinfo__clear_need_setns(nnsi);164 nsi = nnsi;165 }166 pgoff = 0;167 dso = machine__findnew_vdso(machine, thread);168 } else169 dso = machine__findnew_dso_id(machine, filename, id);170 171 if (dso == NULL)172 goto out_delete;173 174 assert(!dso__kernel(dso));175 map__init(result, start, start + len, pgoff, dso, prot, flags);176 177 if (anon || no_dso) {178 map->mapping_type = MAPPING_TYPE__IDENTITY;179 180 /*181 * Set memory without DSO as loaded. All map__find_*182 * functions still return NULL, and we avoid the183 * unnecessary map__load warning.184 */185 if (!(prot & PROT_EXEC))186 dso__set_loaded(dso);187 }188 mutex_lock(dso__lock(dso));189 dso__set_nsinfo(dso, nsi);190 mutex_unlock(dso__lock(dso));191 192 if (build_id__is_defined(bid)) {193 dso__set_build_id(dso, bid);194 } else {195 /*196 * If the mmap event had no build ID, search for an existing dso from the197 * build ID header by name. Otherwise only the dso loaded at the time of198 * reading the header will have the build ID set and all future mmaps will199 * have it missing.200 */201 header_bid_dso = dsos__find(&machine->dsos, filename, false);202 if (header_bid_dso && dso__header_build_id(header_bid_dso)) {203 dso__set_build_id(dso, dso__bid(header_bid_dso));204 dso__set_header_build_id(dso, 1);205 }206 dso__put(header_bid_dso);207 }208 dso__put(dso);209 }210 return result;211out_delete:212 nsinfo__put(nsi);213 RC_CHK_FREE(result);214 return NULL;215}216 217/*218 * Constructor variant for modules (where we know from /proc/modules where219 * they are loaded) and for vmlinux, where only after we load all the220 * symbols we'll know where it starts and ends.221 */222struct map *map__new2(u64 start, struct dso *dso)223{224 struct map *result;225 RC_STRUCT(map) *map;226 227 map = calloc(1, sizeof(*map) + (dso__kernel(dso) ? sizeof(struct kmap) : 0));228 if (ADD_RC_CHK(result, map)) {229 /* ->end will be filled after we load all the symbols. */230 map__init(result, start, /*end=*/0, /*pgoff=*/0, dso, /*prot=*/0, /*flags=*/0);231 }232 233 return result;234}235 236bool __map__is_kernel(const struct map *map)237{238 if (!dso__kernel(map__dso(map)))239 return false;240 return machine__kernel_map(maps__machine(map__kmaps((struct map *)map))) == map;241}242 243bool __map__is_extra_kernel_map(const struct map *map)244{245 struct kmap *kmap = __map__kmap((struct map *)map);246 247 return kmap && kmap->name[0];248}249 250bool __map__is_bpf_prog(const struct map *map)251{252 const char *name;253 struct dso *dso = map__dso(map);254 255 if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_PROG_INFO)256 return true;257 258 /*259 * If PERF_RECORD_BPF_EVENT is not included, the dso will not have260 * type of DSO_BINARY_TYPE__BPF_PROG_INFO. In such cases, we can261 * guess the type based on name.262 */263 name = dso__short_name(dso);264 return name && (strstr(name, "bpf_prog_") == name);265}266 267bool __map__is_bpf_image(const struct map *map)268{269 const char *name;270 struct dso *dso = map__dso(map);271 272 if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_IMAGE)273 return true;274 275 /*276 * If PERF_RECORD_KSYMBOL is not included, the dso will not have277 * type of DSO_BINARY_TYPE__BPF_IMAGE. In such cases, we can278 * guess the type based on name.279 */280 name = dso__short_name(dso);281 return name && is_bpf_image(name);282}283 284bool __map__is_ool(const struct map *map)285{286 const struct dso *dso = map__dso(map);287 288 return dso && dso__binary_type(dso) == DSO_BINARY_TYPE__OOL;289}290 291bool map__has_symbols(const struct map *map)292{293 return dso__has_symbols(map__dso(map));294}295 296static void map__exit(struct map *map)297{298 BUG_ON(refcount_read(map__refcnt(map)) != 0);299 dso__zput(RC_CHK_ACCESS(map)->dso);300}301 302void map__delete(struct map *map)303{304 map__exit(map);305 RC_CHK_FREE(map);306}307 308void map__put(struct map *map)309{310 if (map && refcount_dec_and_test(map__refcnt(map)))311 map__delete(map);312 else313 RC_CHK_PUT(map);314}315 316void map__fixup_start(struct map *map)317{318 struct dso *dso = map__dso(map);319 struct rb_root_cached *symbols = dso__symbols(dso);320 struct rb_node *nd = rb_first_cached(symbols);321 322 if (nd != NULL) {323 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);324 325 map__set_start(map, sym->start);326 }327}328 329void map__fixup_end(struct map *map)330{331 struct dso *dso = map__dso(map);332 struct rb_root_cached *symbols = dso__symbols(dso);333 struct rb_node *nd = rb_last(&symbols->rb_root);334 335 if (nd != NULL) {336 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);337 map__set_end(map, sym->end);338 }339}340 341#define DSO__DELETED "(deleted)"342 343int map__load(struct map *map)344{345 struct dso *dso = map__dso(map);346 const char *name = dso__long_name(dso);347 int nr;348 349 if (dso__loaded(dso))350 return 0;351 352 nr = dso__load(dso, map);353 if (nr < 0) {354 if (dso__has_build_id(dso)) {355 char sbuild_id[SBUILD_ID_SIZE];356 357 build_id__sprintf(dso__bid(dso), sbuild_id);358 pr_debug("%s with build id %s not found", name, sbuild_id);359 } else360 pr_debug("Failed to open %s", name);361 362 pr_debug(", continuing without symbols\n");363 return -1;364 } else if (nr == 0) {365#ifdef HAVE_LIBELF_SUPPORT366 const size_t len = strlen(name);367 const size_t real_len = len - sizeof(DSO__DELETED);368 369 if (len > sizeof(DSO__DELETED) &&370 strcmp(name + real_len + 1, DSO__DELETED) == 0) {371 pr_debug("%.*s was updated (is prelink enabled?). "372 "Restart the long running apps that use it!\n",373 (int)real_len, name);374 } else {375 pr_debug("no symbols found in %s, maybe install a debug package?\n", name);376 }377#endif378 return -1;379 }380 381 return 0;382}383 384struct symbol *map__find_symbol(struct map *map, u64 addr)385{386 if (map__load(map) < 0)387 return NULL;388 389 return dso__find_symbol(map__dso(map), addr);390}391 392struct symbol *map__find_symbol_by_name_idx(struct map *map, const char *name, size_t *idx)393{394 struct dso *dso;395 396 if (map__load(map) < 0)397 return NULL;398 399 dso = map__dso(map);400 dso__sort_by_name(dso);401 402 return dso__find_symbol_by_name(dso, name, idx);403}404 405struct symbol *map__find_symbol_by_name(struct map *map, const char *name)406{407 size_t idx;408 409 return map__find_symbol_by_name_idx(map, name, &idx);410}411 412struct map *map__clone(struct map *from)413{414 struct map *result;415 RC_STRUCT(map) *map;416 size_t size = sizeof(RC_STRUCT(map));417 struct dso *dso = map__dso(from);418 419 if (dso && dso__kernel(dso))420 size += sizeof(struct kmap);421 422 map = memdup(RC_CHK_ACCESS(from), size);423 if (ADD_RC_CHK(result, map)) {424 refcount_set(&map->refcnt, 1);425 map->dso = dso__get(dso);426 }427 428 return result;429}430 431size_t map__fprintf(struct map *map, FILE *fp)432{433 const struct dso *dso = map__dso(map);434 435 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n",436 map__start(map), map__end(map), map__pgoff(map), dso__name(dso));437}438 439static bool prefer_dso_long_name(const struct dso *dso, bool print_off)440{441 return dso__long_name(dso) &&442 (symbol_conf.show_kernel_path ||443 (print_off && (dso__name(dso)[0] == '[' || dso__is_kcore(dso))));444}445 446static size_t __map__fprintf_dsoname(struct map *map, bool print_off, FILE *fp)447{448 char buf[symbol_conf.pad_output_len_dso + 1];449 const char *dsoname = "[unknown]";450 const struct dso *dso = map ? map__dso(map) : NULL;451 452 if (dso) {453 if (prefer_dso_long_name(dso, print_off))454 dsoname = dso__long_name(dso);455 else456 dsoname = dso__name(dso);457 }458 459 if (symbol_conf.pad_output_len_dso) {460 scnprintf_pad(buf, symbol_conf.pad_output_len_dso, "%s", dsoname);461 dsoname = buf;462 }463 464 return fprintf(fp, "%s", dsoname);465}466 467size_t map__fprintf_dsoname(struct map *map, FILE *fp)468{469 return __map__fprintf_dsoname(map, false, fp);470}471 472size_t map__fprintf_dsoname_dsoff(struct map *map, bool print_off, u64 addr, FILE *fp)473{474 const struct dso *dso = map ? map__dso(map) : NULL;475 int printed = 0;476 477 if (print_off && (!dso || !dso__is_object_file(dso)))478 print_off = false;479 printed += fprintf(fp, " (");480 printed += __map__fprintf_dsoname(map, print_off, fp);481 if (print_off)482 printed += fprintf(fp, "+0x%" PRIx64, addr);483 printed += fprintf(fp, ")");484 485 return printed;486}487 488char *map__srcline(struct map *map, u64 addr, struct symbol *sym)489{490 if (map == NULL)491 return SRCLINE_UNKNOWN;492 493 return get_srcline(map__dso(map), map__rip_2objdump(map, addr), sym, true, true, addr);494}495 496int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,497 FILE *fp)498{499 const struct dso *dso = map ? map__dso(map) : NULL;500 int ret = 0;501 502 if (dso) {503 char *srcline = map__srcline(map, addr, NULL);504 if (srcline != SRCLINE_UNKNOWN)505 ret = fprintf(fp, "%s%s", prefix, srcline);506 zfree_srcline(&srcline);507 }508 return ret;509}510 511void srccode_state_free(struct srccode_state *state)512{513 zfree(&state->srcfile);514 state->line = 0;515}516 517/**518 * map__rip_2objdump - convert symbol start address to objdump address.519 * @map: memory map520 * @rip: symbol start address521 *522 * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.523 * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is524 * relative to section start.525 *526 * Return: Address suitable for passing to "objdump --start-address="527 */528u64 map__rip_2objdump(struct map *map, u64 rip)529{530 struct kmap *kmap = __map__kmap(map);531 const struct dso *dso = map__dso(map);532 533 /*534 * vmlinux does not have program headers for PTI entry trampolines and535 * kcore may not either. However the trampoline object code is on the536 * main kernel map, so just use that instead.537 */538 if (kmap && is_entry_trampoline(kmap->name) && kmap->kmaps) {539 struct machine *machine = maps__machine(kmap->kmaps);540 541 if (machine) {542 struct map *kernel_map = machine__kernel_map(machine);543 544 if (kernel_map)545 map = kernel_map;546 }547 }548 549 if (!dso__adjust_symbols(dso))550 return rip;551 552 if (dso__rel(dso))553 return rip - map__pgoff(map);554 555 if (dso__kernel(dso) == DSO_SPACE__USER)556 return rip + dso__text_offset(dso);557 558 return map__unmap_ip(map, rip) - map__reloc(map);559}560 561/**562 * map__objdump_2mem - convert objdump address to a memory address.563 * @map: memory map564 * @ip: objdump address565 *566 * Closely related to map__rip_2objdump(), this function takes an address from567 * objdump and converts it to a memory address. Note this assumes that @map568 * contains the address. To be sure the result is valid, check it forwards569 * e.g. map__rip_2objdump(map__map_ip(map, map__objdump_2mem(map, ip))) == ip570 *571 * Return: Memory address.572 */573u64 map__objdump_2mem(struct map *map, u64 ip)574{575 const struct dso *dso = map__dso(map);576 577 if (!dso__adjust_symbols(dso))578 return map__unmap_ip(map, ip);579 580 if (dso__rel(dso))581 return map__unmap_ip(map, ip + map__pgoff(map));582 583 if (dso__kernel(dso) == DSO_SPACE__USER)584 return map__unmap_ip(map, ip - dso__text_offset(dso));585 586 return ip + map__reloc(map);587}588 589/* convert objdump address to relative address. (To be removed) */590u64 map__objdump_2rip(struct map *map, u64 ip)591{592 const struct dso *dso = map__dso(map);593 594 if (!dso__adjust_symbols(dso))595 return ip;596 597 if (dso__rel(dso))598 return ip + map__pgoff(map);599 600 if (dso__kernel(dso) == DSO_SPACE__USER)601 return ip - dso__text_offset(dso);602 603 return map__map_ip(map, ip + map__reloc(map));604}605 606bool map__contains_symbol(const struct map *map, const struct symbol *sym)607{608 u64 ip = map__unmap_ip(map, sym->start);609 610 return ip >= map__start(map) && ip < map__end(map);611}612 613struct kmap *__map__kmap(struct map *map)614{615 const struct dso *dso = map__dso(map);616 617 if (!dso || !dso__kernel(dso))618 return NULL;619 return (struct kmap *)(&RC_CHK_ACCESS(map)[1]);620}621 622struct kmap *map__kmap(struct map *map)623{624 struct kmap *kmap = __map__kmap(map);625 626 if (!kmap)627 pr_err("Internal error: map__kmap with a non-kernel map\n");628 return kmap;629}630 631struct maps *map__kmaps(struct map *map)632{633 struct kmap *kmap = map__kmap(map);634 635 if (!kmap || !kmap->kmaps) {636 pr_err("Internal error: map__kmaps with a non-kernel map\n");637 return NULL;638 }639 return kmap->kmaps;640}641