9 #include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */
17 #include <linux/string.h>
21 static void __maps__insert(struct maps *maps, struct map *map);
23 const char *map_type__name[MAP__NR_TYPES] = {
24 [MAP__FUNCTION] = "Functions",
25 [MAP__VARIABLE] = "Variables",
28 static inline int is_anon_memory(const char *filename, u32 flags)
30 return flags & MAP_HUGETLB ||
31 !strcmp(filename, "//anon") ||
32 !strncmp(filename, "/dev/zero", sizeof("/dev/zero") - 1) ||
33 !strncmp(filename, "/anon_hugepage", sizeof("/anon_hugepage") - 1);
36 static inline int is_no_dso_memory(const char *filename)
38 return !strncmp(filename, "[stack", 6) ||
39 !strncmp(filename, "/SYSV",5) ||
40 !strcmp(filename, "[heap]");
43 static inline int is_android_lib(const char *filename)
45 return !strncmp(filename, "/data/app-lib", 13) ||
46 !strncmp(filename, "/system/lib", 11);
49 static inline bool replace_android_lib(const char *filename, char *newfilename)
53 size_t app_abi_length, new_length;
54 size_t lib_length = 0;
56 libname = strrchr(filename, '/');
58 lib_length = strlen(libname);
60 app_abi = getenv("APP_ABI");
64 app_abi_length = strlen(app_abi);
66 if (!strncmp(filename, "/data/app-lib", 13)) {
72 new_length = 7 + app_abi_length + lib_length;
74 apk_path = getenv("APK_PATH");
76 new_length += strlen(apk_path) + 1;
77 if (new_length > PATH_MAX)
79 snprintf(newfilename, new_length,
80 "%s/libs/%s/%s", apk_path, app_abi, libname);
82 if (new_length > PATH_MAX)
84 snprintf(newfilename, new_length,
85 "libs/%s/%s", app_abi, libname);
90 if (!strncmp(filename, "/system/lib/", 11)) {
96 ndk = getenv("NDK_ROOT");
97 app = getenv("APP_PLATFORM");
102 ndk_length = strlen(ndk);
103 app_length = strlen(app);
105 if (!(ndk_length && app_length && app_abi_length))
108 arch = !strncmp(app_abi, "arm", 3) ? "arm" :
109 !strncmp(app_abi, "mips", 4) ? "mips" :
110 !strncmp(app_abi, "x86", 3) ? "x86" : NULL;
115 new_length = 27 + ndk_length +
116 app_length + lib_length
119 if (new_length > PATH_MAX)
121 snprintf(newfilename, new_length,
122 "%s/platforms/%s/arch-%s/usr/lib/%s",
123 ndk, app, arch, libname);
130 void map__init(struct map *map, enum map_type type,
131 u64 start, u64 end, u64 pgoff, struct dso *dso)
138 map->dso = dso__get(dso);
139 map->map_ip = map__map_ip;
140 map->unmap_ip = map__unmap_ip;
141 RB_CLEAR_NODE(&map->rb_node);
143 map->erange_warned = false;
144 refcount_set(&map->refcnt, 1);
147 struct map *map__new(struct machine *machine, u64 start, u64 len,
148 u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino,
149 u64 ino_gen, u32 prot, u32 flags, char *filename,
150 enum map_type type, struct thread *thread)
152 struct map *map = malloc(sizeof(*map));
155 char newfilename[PATH_MAX];
157 int anon, no_dso, vdso, android;
159 android = is_android_lib(filename);
160 anon = is_anon_memory(filename, flags);
161 vdso = is_vdso_map(filename);
162 no_dso = is_no_dso_memory(filename);
167 map->ino_generation = ino_gen;
171 if ((anon || no_dso) && type == MAP__FUNCTION) {
172 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
173 filename = newfilename;
177 if (replace_android_lib(filename, newfilename))
178 filename = newfilename;
183 dso = machine__findnew_vdso(machine, thread);
185 dso = machine__findnew_dso(machine, filename);
190 map__init(map, type, start, start + len, pgoff, dso);
192 if (anon || no_dso) {
193 map->map_ip = map->unmap_ip = identity__map_ip;
196 * Set memory without DSO as loaded. All map__find_*
197 * functions still return NULL, and we avoid the
198 * unnecessary map__load warning.
200 if (type != MAP__FUNCTION)
201 dso__set_loaded(dso, map->type);
212 * Constructor variant for modules (where we know from /proc/modules where
213 * they are loaded) and for vmlinux, where only after we load all the
214 * symbols we'll know where it starts and ends.
216 struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
218 struct map *map = calloc(1, (sizeof(*map) +
219 (dso->kernel ? sizeof(struct kmap) : 0)));
222 * ->end will be filled after we load all the symbols
224 map__init(map, type, start, 0, 0, dso);
231 * Use this and __map__is_kmodule() for map instances that are in
232 * machine->kmaps, and thus have map->groups->machine all properly set, to
233 * disambiguate between the kernel and modules.
235 * When the need arises, introduce map__is_{kernel,kmodule)() that
236 * checks (map->groups != NULL && map->groups->machine != NULL &&
237 * map->dso->kernel) before calling __map__is_{kernel,kmodule}())
239 bool __map__is_kernel(const struct map *map)
241 return __machine__kernel_map(map->groups->machine, map->type) == map;
244 static void map__exit(struct map *map)
246 BUG_ON(!RB_EMPTY_NODE(&map->rb_node));
250 void map__delete(struct map *map)
256 void map__put(struct map *map)
258 if (map && refcount_dec_and_test(&map->refcnt))
262 void map__fixup_start(struct map *map)
264 struct rb_root *symbols = &map->dso->symbols[map->type];
265 struct rb_node *nd = rb_first(symbols);
267 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
268 map->start = sym->start;
272 void map__fixup_end(struct map *map)
274 struct rb_root *symbols = &map->dso->symbols[map->type];
275 struct rb_node *nd = rb_last(symbols);
277 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
282 #define DSO__DELETED "(deleted)"
284 int map__load(struct map *map)
286 const char *name = map->dso->long_name;
289 if (dso__loaded(map->dso, map->type))
292 nr = dso__load(map->dso, map);
294 if (map->dso->has_build_id) {
295 char sbuild_id[SBUILD_ID_SIZE];
297 build_id__sprintf(map->dso->build_id,
298 sizeof(map->dso->build_id),
300 pr_warning("%s with build id %s not found",
303 pr_warning("Failed to open %s", name);
305 pr_warning(", continuing without symbols\n");
307 } else if (nr == 0) {
308 #ifdef HAVE_LIBELF_SUPPORT
309 const size_t len = strlen(name);
310 const size_t real_len = len - sizeof(DSO__DELETED);
312 if (len > sizeof(DSO__DELETED) &&
313 strcmp(name + real_len + 1, DSO__DELETED) == 0) {
314 pr_warning("%.*s was updated (is prelink enabled?). "
315 "Restart the long running apps that use it!\n",
316 (int)real_len, name);
318 pr_warning("no symbols found in %s, maybe install "
319 "a debug package?\n", name);
328 struct symbol *map__find_symbol(struct map *map, u64 addr)
330 if (map__load(map) < 0)
333 return dso__find_symbol(map->dso, map->type, addr);
336 struct symbol *map__find_symbol_by_name(struct map *map, const char *name)
338 if (map__load(map) < 0)
341 if (!dso__sorted_by_name(map->dso, map->type))
342 dso__sort_by_name(map->dso, map->type);
344 return dso__find_symbol_by_name(map->dso, map->type, name);
347 struct map *map__clone(struct map *from)
349 struct map *map = memdup(from, sizeof(*map));
352 refcount_set(&map->refcnt, 1);
353 RB_CLEAR_NODE(&map->rb_node);
361 int map__overlap(struct map *l, struct map *r)
363 if (l->start > r->start) {
369 if (l->end > r->start)
375 size_t map__fprintf(struct map *map, FILE *fp)
377 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n",
378 map->start, map->end, map->pgoff, map->dso->name);
381 size_t map__fprintf_dsoname(struct map *map, FILE *fp)
383 const char *dsoname = "[unknown]";
385 if (map && map->dso) {
386 if (symbol_conf.show_kernel_path && map->dso->long_name)
387 dsoname = map->dso->long_name;
389 dsoname = map->dso->name;
392 return fprintf(fp, "%s", dsoname);
395 int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
401 if (map && map->dso) {
402 srcline = get_srcline(map->dso,
403 map__rip_2objdump(map, addr), NULL,
405 if (srcline != SRCLINE_UNKNOWN)
406 ret = fprintf(fp, "%s%s", prefix, srcline);
407 free_srcline(srcline);
413 * map__rip_2objdump - convert symbol start address to objdump address.
415 * @rip: symbol start address
417 * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
418 * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is
419 * relative to section start.
421 * Return: Address suitable for passing to "objdump --start-address="
423 u64 map__rip_2objdump(struct map *map, u64 rip)
425 if (!map->dso->adjust_symbols)
429 return rip - map->pgoff;
432 * kernel modules also have DSO_TYPE_USER in dso->kernel,
433 * but all kernel modules are ET_REL, so won't get here.
435 if (map->dso->kernel == DSO_TYPE_USER)
436 return rip + map->dso->text_offset;
438 return map->unmap_ip(map, rip) - map->reloc;
442 * map__objdump_2mem - convert objdump address to a memory address.
444 * @ip: objdump address
446 * Closely related to map__rip_2objdump(), this function takes an address from
447 * objdump and converts it to a memory address. Note this assumes that @map
448 * contains the address. To be sure the result is valid, check it forwards
449 * e.g. map__rip_2objdump(map->map_ip(map, map__objdump_2mem(map, ip))) == ip
451 * Return: Memory address.
453 u64 map__objdump_2mem(struct map *map, u64 ip)
455 if (!map->dso->adjust_symbols)
456 return map->unmap_ip(map, ip);
459 return map->unmap_ip(map, ip + map->pgoff);
462 * kernel modules also have DSO_TYPE_USER in dso->kernel,
463 * but all kernel modules are ET_REL, so won't get here.
465 if (map->dso->kernel == DSO_TYPE_USER)
466 return map->unmap_ip(map, ip - map->dso->text_offset);
468 return ip + map->reloc;
471 static void maps__init(struct maps *maps)
473 maps->entries = RB_ROOT;
474 pthread_rwlock_init(&maps->lock, NULL);
477 void map_groups__init(struct map_groups *mg, struct machine *machine)
480 for (i = 0; i < MAP__NR_TYPES; ++i) {
481 maps__init(&mg->maps[i]);
483 mg->machine = machine;
484 refcount_set(&mg->refcnt, 1);
487 static void __maps__purge(struct maps *maps)
489 struct rb_root *root = &maps->entries;
490 struct rb_node *next = rb_first(root);
493 struct map *pos = rb_entry(next, struct map, rb_node);
495 next = rb_next(&pos->rb_node);
496 rb_erase_init(&pos->rb_node, root);
501 static void maps__exit(struct maps *maps)
503 pthread_rwlock_wrlock(&maps->lock);
505 pthread_rwlock_unlock(&maps->lock);
508 void map_groups__exit(struct map_groups *mg)
512 for (i = 0; i < MAP__NR_TYPES; ++i)
513 maps__exit(&mg->maps[i]);
516 bool map_groups__empty(struct map_groups *mg)
520 for (i = 0; i < MAP__NR_TYPES; ++i) {
521 if (maps__first(&mg->maps[i]))
528 struct map_groups *map_groups__new(struct machine *machine)
530 struct map_groups *mg = malloc(sizeof(*mg));
533 map_groups__init(mg, machine);
538 void map_groups__delete(struct map_groups *mg)
540 map_groups__exit(mg);
544 void map_groups__put(struct map_groups *mg)
546 if (mg && refcount_dec_and_test(&mg->refcnt))
547 map_groups__delete(mg);
550 struct symbol *map_groups__find_symbol(struct map_groups *mg,
551 enum map_type type, u64 addr,
554 struct map *map = map_groups__find(mg, type, addr);
556 /* Ensure map is loaded before using map->map_ip */
557 if (map != NULL && map__load(map) >= 0) {
560 return map__find_symbol(map, map->map_ip(map, addr));
566 struct symbol *maps__find_symbol_by_name(struct maps *maps, const char *name,
572 pthread_rwlock_rdlock(&maps->lock);
574 for (nd = rb_first(&maps->entries); nd; nd = rb_next(nd)) {
575 struct map *pos = rb_entry(nd, struct map, rb_node);
577 sym = map__find_symbol_by_name(pos, name);
588 pthread_rwlock_unlock(&maps->lock);
592 struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
597 struct symbol *sym = maps__find_symbol_by_name(&mg->maps[type], name, mapp);
602 int map_groups__find_ams(struct addr_map_symbol *ams)
604 if (ams->addr < ams->map->start || ams->addr >= ams->map->end) {
605 if (ams->map->groups == NULL)
607 ams->map = map_groups__find(ams->map->groups, ams->map->type,
609 if (ams->map == NULL)
613 ams->al_addr = ams->map->map_ip(ams->map, ams->addr);
614 ams->sym = map__find_symbol(ams->map, ams->al_addr);
616 return ams->sym ? 0 : -1;
619 static size_t maps__fprintf(struct maps *maps, FILE *fp)
624 pthread_rwlock_rdlock(&maps->lock);
626 for (nd = rb_first(&maps->entries); nd; nd = rb_next(nd)) {
627 struct map *pos = rb_entry(nd, struct map, rb_node);
628 printed += fprintf(fp, "Map:");
629 printed += map__fprintf(pos, fp);
631 printed += dso__fprintf(pos->dso, pos->type, fp);
632 printed += fprintf(fp, "--\n");
636 pthread_rwlock_unlock(&maps->lock);
641 size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type,
644 size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
645 return printed += maps__fprintf(&mg->maps[type], fp);
648 size_t map_groups__fprintf(struct map_groups *mg, FILE *fp)
650 size_t printed = 0, i;
651 for (i = 0; i < MAP__NR_TYPES; ++i)
652 printed += __map_groups__fprintf_maps(mg, i, fp);
656 static void __map_groups__insert(struct map_groups *mg, struct map *map)
658 __maps__insert(&mg->maps[map->type], map);
662 static int maps__fixup_overlappings(struct maps *maps, struct map *map, FILE *fp)
664 struct rb_root *root;
665 struct rb_node *next;
668 pthread_rwlock_wrlock(&maps->lock);
670 root = &maps->entries;
671 next = rb_first(root);
674 struct map *pos = rb_entry(next, struct map, rb_node);
675 next = rb_next(&pos->rb_node);
677 if (!map__overlap(pos, map))
683 pr_warning("overlapping maps in %s "
684 "(disable tui for more info)\n",
687 fputs("overlapping maps:\n", fp);
688 map__fprintf(map, fp);
689 map__fprintf(pos, fp);
693 rb_erase_init(&pos->rb_node, root);
695 * Now check if we need to create new maps for areas not
696 * overlapped by the new map:
698 if (map->start > pos->start) {
699 struct map *before = map__clone(pos);
701 if (before == NULL) {
706 before->end = map->start;
707 __map_groups__insert(pos->groups, before);
708 if (verbose >= 2 && !use_browser)
709 map__fprintf(before, fp);
713 if (map->end < pos->end) {
714 struct map *after = map__clone(pos);
721 after->start = map->end;
722 __map_groups__insert(pos->groups, after);
723 if (verbose >= 2 && !use_browser)
724 map__fprintf(after, fp);
736 pthread_rwlock_unlock(&maps->lock);
740 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
743 return maps__fixup_overlappings(&mg->maps[map->type], map, fp);
747 * XXX This should not really _copy_ te maps, but refcount them.
749 int map_groups__clone(struct thread *thread,
750 struct map_groups *parent, enum map_type type)
752 struct map_groups *mg = thread->mg;
755 struct maps *maps = &parent->maps[type];
757 pthread_rwlock_rdlock(&maps->lock);
759 for (map = maps__first(maps); map; map = map__next(map)) {
760 struct map *new = map__clone(map);
764 err = unwind__prepare_access(thread, new, NULL);
768 map_groups__insert(mg, new);
774 pthread_rwlock_unlock(&maps->lock);
778 static void __maps__insert(struct maps *maps, struct map *map)
780 struct rb_node **p = &maps->entries.rb_node;
781 struct rb_node *parent = NULL;
782 const u64 ip = map->start;
787 m = rb_entry(parent, struct map, rb_node);
794 rb_link_node(&map->rb_node, parent, p);
795 rb_insert_color(&map->rb_node, &maps->entries);
799 void maps__insert(struct maps *maps, struct map *map)
801 pthread_rwlock_wrlock(&maps->lock);
802 __maps__insert(maps, map);
803 pthread_rwlock_unlock(&maps->lock);
806 static void __maps__remove(struct maps *maps, struct map *map)
808 rb_erase_init(&map->rb_node, &maps->entries);
812 void maps__remove(struct maps *maps, struct map *map)
814 pthread_rwlock_wrlock(&maps->lock);
815 __maps__remove(maps, map);
816 pthread_rwlock_unlock(&maps->lock);
819 struct map *maps__find(struct maps *maps, u64 ip)
821 struct rb_node **p, *parent = NULL;
824 pthread_rwlock_rdlock(&maps->lock);
826 p = &maps->entries.rb_node;
829 m = rb_entry(parent, struct map, rb_node);
832 else if (ip >= m->end)
840 pthread_rwlock_unlock(&maps->lock);
844 struct map *maps__first(struct maps *maps)
846 struct rb_node *first = rb_first(&maps->entries);
849 return rb_entry(first, struct map, rb_node);
853 struct map *map__next(struct map *map)
855 struct rb_node *next = rb_next(&map->rb_node);
858 return rb_entry(next, struct map, rb_node);
862 struct kmap *map__kmap(struct map *map)
864 if (!map->dso || !map->dso->kernel) {
865 pr_err("Internal error: map__kmap with a non-kernel map\n");
868 return (struct kmap *)(map + 1);
871 struct map_groups *map__kmaps(struct map *map)
873 struct kmap *kmap = map__kmap(map);
875 if (!kmap || !kmap->kmaps) {
876 pr_err("Internal error: map__kmaps with a non-kernel map\n");