17 #include <linux/string.h>
19 static void __maps__insert(struct maps
*maps
, struct map
*map
);
21 const char *map_type__name
[MAP__NR_TYPES
] = {
22 [MAP__FUNCTION
] = "Functions",
23 [MAP__VARIABLE
] = "Variables",
26 static inline int is_anon_memory(const char *filename
)
28 return !strcmp(filename
, "//anon") ||
29 !strcmp(filename
, "/dev/zero (deleted)") ||
30 !strcmp(filename
, "/anon_hugepage (deleted)");
33 static inline int is_no_dso_memory(const char *filename
)
35 return !strncmp(filename
, "[stack", 6) ||
36 !strncmp(filename
, "/SYSV",5) ||
37 !strcmp(filename
, "[heap]");
40 static inline int is_android_lib(const char *filename
)
42 return !strncmp(filename
, "/data/app-lib", 13) ||
43 !strncmp(filename
, "/system/lib", 11);
46 static inline bool replace_android_lib(const char *filename
, char *newfilename
)
50 size_t app_abi_length
, new_length
;
51 size_t lib_length
= 0;
53 libname
= strrchr(filename
, '/');
55 lib_length
= strlen(libname
);
57 app_abi
= getenv("APP_ABI");
61 app_abi_length
= strlen(app_abi
);
63 if (!strncmp(filename
, "/data/app-lib", 13)) {
69 new_length
= 7 + app_abi_length
+ lib_length
;
71 apk_path
= getenv("APK_PATH");
73 new_length
+= strlen(apk_path
) + 1;
74 if (new_length
> PATH_MAX
)
76 snprintf(newfilename
, new_length
,
77 "%s/libs/%s/%s", apk_path
, app_abi
, libname
);
79 if (new_length
> PATH_MAX
)
81 snprintf(newfilename
, new_length
,
82 "libs/%s/%s", app_abi
, libname
);
87 if (!strncmp(filename
, "/system/lib/", 11)) {
93 ndk
= getenv("NDK_ROOT");
94 app
= getenv("APP_PLATFORM");
99 ndk_length
= strlen(ndk
);
100 app_length
= strlen(app
);
102 if (!(ndk_length
&& app_length
&& app_abi_length
))
105 arch
= !strncmp(app_abi
, "arm", 3) ? "arm" :
106 !strncmp(app_abi
, "mips", 4) ? "mips" :
107 !strncmp(app_abi
, "x86", 3) ? "x86" : NULL
;
112 new_length
= 27 + ndk_length
+
113 app_length
+ lib_length
116 if (new_length
> PATH_MAX
)
118 snprintf(newfilename
, new_length
,
119 "%s/platforms/%s/arch-%s/usr/lib/%s",
120 ndk
, app
, arch
, libname
);
127 void map__init(struct map
*map
, enum map_type type
,
128 u64 start
, u64 end
, u64 pgoff
, struct dso
*dso
)
135 map
->dso
= dso__get(dso
);
136 map
->map_ip
= map__map_ip
;
137 map
->unmap_ip
= map__unmap_ip
;
138 RB_CLEAR_NODE(&map
->rb_node
);
140 map
->erange_warned
= false;
141 atomic_set(&map
->refcnt
, 1);
144 struct map
*map__new(struct machine
*machine
, u64 start
, u64 len
,
145 u64 pgoff
, u32 pid
, u32 d_maj
, u32 d_min
, u64 ino
,
146 u64 ino_gen
, u32 prot
, u32 flags
, char *filename
,
147 enum map_type type
, struct thread
*thread
)
149 struct map
*map
= malloc(sizeof(*map
));
152 char newfilename
[PATH_MAX
];
154 int anon
, no_dso
, vdso
, android
;
156 android
= is_android_lib(filename
);
157 anon
= is_anon_memory(filename
);
158 vdso
= is_vdso_map(filename
);
159 no_dso
= is_no_dso_memory(filename
);
164 map
->ino_generation
= ino_gen
;
168 if ((anon
|| no_dso
) && type
== MAP__FUNCTION
) {
169 snprintf(newfilename
, sizeof(newfilename
), "/tmp/perf-%d.map", pid
);
170 filename
= newfilename
;
174 if (replace_android_lib(filename
, newfilename
))
175 filename
= newfilename
;
180 dso
= machine__findnew_vdso(machine
, thread
);
182 dso
= machine__findnew_dso(machine
, filename
);
187 map__init(map
, type
, start
, start
+ len
, pgoff
, dso
);
189 if (anon
|| no_dso
) {
190 map
->map_ip
= map
->unmap_ip
= identity__map_ip
;
193 * Set memory without DSO as loaded. All map__find_*
194 * functions still return NULL, and we avoid the
195 * unnecessary map__load warning.
197 if (type
!= MAP__FUNCTION
)
198 dso__set_loaded(dso
, map
->type
);
209 * Constructor variant for modules (where we know from /proc/modules where
210 * they are loaded) and for vmlinux, where only after we load all the
211 * symbols we'll know where it starts and ends.
213 struct map
*map__new2(u64 start
, struct dso
*dso
, enum map_type type
)
215 struct map
*map
= calloc(1, (sizeof(*map
) +
216 (dso
->kernel
? sizeof(struct kmap
) : 0)));
219 * ->end will be filled after we load all the symbols
221 map__init(map
, type
, start
, 0, 0, dso
);
227 static void map__exit(struct map
*map
)
229 BUG_ON(!RB_EMPTY_NODE(&map
->rb_node
));
233 void map__delete(struct map
*map
)
239 void map__put(struct map
*map
)
241 if (map
&& atomic_dec_and_test(&map
->refcnt
))
245 void map__fixup_start(struct map
*map
)
247 struct rb_root
*symbols
= &map
->dso
->symbols
[map
->type
];
248 struct rb_node
*nd
= rb_first(symbols
);
250 struct symbol
*sym
= rb_entry(nd
, struct symbol
, rb_node
);
251 map
->start
= sym
->start
;
255 void map__fixup_end(struct map
*map
)
257 struct rb_root
*symbols
= &map
->dso
->symbols
[map
->type
];
258 struct rb_node
*nd
= rb_last(symbols
);
260 struct symbol
*sym
= rb_entry(nd
, struct symbol
, rb_node
);
265 #define DSO__DELETED "(deleted)"
267 int map__load(struct map
*map
, symbol_filter_t filter
)
269 const char *name
= map
->dso
->long_name
;
272 if (dso__loaded(map
->dso
, map
->type
))
275 nr
= dso__load(map
->dso
, map
, filter
);
277 if (map
->dso
->has_build_id
) {
278 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
280 build_id__sprintf(map
->dso
->build_id
,
281 sizeof(map
->dso
->build_id
),
283 pr_warning("%s with build id %s not found",
286 pr_warning("Failed to open %s", name
);
288 pr_warning(", continuing without symbols\n");
290 } else if (nr
== 0) {
291 #ifdef HAVE_LIBELF_SUPPORT
292 const size_t len
= strlen(name
);
293 const size_t real_len
= len
- sizeof(DSO__DELETED
);
295 if (len
> sizeof(DSO__DELETED
) &&
296 strcmp(name
+ real_len
+ 1, DSO__DELETED
) == 0) {
297 pr_warning("%.*s was updated (is prelink enabled?). "
298 "Restart the long running apps that use it!\n",
299 (int)real_len
, name
);
301 pr_warning("no symbols found in %s, maybe install "
302 "a debug package?\n", name
);
311 int __weak
arch__compare_symbol_names(const char *namea
, const char *nameb
)
313 return strcmp(namea
, nameb
);
316 struct symbol
*map__find_symbol(struct map
*map
, u64 addr
,
317 symbol_filter_t filter
)
319 if (map__load(map
, filter
) < 0)
322 return dso__find_symbol(map
->dso
, map
->type
, addr
);
325 struct symbol
*map__find_symbol_by_name(struct map
*map
, const char *name
,
326 symbol_filter_t filter
)
328 if (map__load(map
, filter
) < 0)
331 if (!dso__sorted_by_name(map
->dso
, map
->type
))
332 dso__sort_by_name(map
->dso
, map
->type
);
334 return dso__find_symbol_by_name(map
->dso
, map
->type
, name
);
337 struct map
*map__clone(struct map
*map
)
339 return memdup(map
, sizeof(*map
));
342 int map__overlap(struct map
*l
, struct map
*r
)
344 if (l
->start
> r
->start
) {
350 if (l
->end
> r
->start
)
356 size_t map__fprintf(struct map
*map
, FILE *fp
)
358 return fprintf(fp
, " %" PRIx64
"-%" PRIx64
" %" PRIx64
" %s\n",
359 map
->start
, map
->end
, map
->pgoff
, map
->dso
->name
);
362 size_t map__fprintf_dsoname(struct map
*map
, FILE *fp
)
364 const char *dsoname
= "[unknown]";
366 if (map
&& map
->dso
&& (map
->dso
->name
|| map
->dso
->long_name
)) {
367 if (symbol_conf
.show_kernel_path
&& map
->dso
->long_name
)
368 dsoname
= map
->dso
->long_name
;
369 else if (map
->dso
->name
)
370 dsoname
= map
->dso
->name
;
373 return fprintf(fp
, "%s", dsoname
);
376 int map__fprintf_srcline(struct map
*map
, u64 addr
, const char *prefix
,
382 if (map
&& map
->dso
) {
383 srcline
= get_srcline(map
->dso
,
384 map__rip_2objdump(map
, addr
), NULL
, true);
385 if (srcline
!= SRCLINE_UNKNOWN
)
386 ret
= fprintf(fp
, "%s%s", prefix
, srcline
);
387 free_srcline(srcline
);
393 * map__rip_2objdump - convert symbol start address to objdump address.
395 * @rip: symbol start address
397 * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
398 * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is
399 * relative to section start.
401 * Return: Address suitable for passing to "objdump --start-address="
403 u64
map__rip_2objdump(struct map
*map
, u64 rip
)
405 if (!map
->dso
->adjust_symbols
)
409 return rip
- map
->pgoff
;
411 return map
->unmap_ip(map
, rip
) - map
->reloc
;
415 * map__objdump_2mem - convert objdump address to a memory address.
417 * @ip: objdump address
419 * Closely related to map__rip_2objdump(), this function takes an address from
420 * objdump and converts it to a memory address. Note this assumes that @map
421 * contains the address. To be sure the result is valid, check it forwards
422 * e.g. map__rip_2objdump(map->map_ip(map, map__objdump_2mem(map, ip))) == ip
424 * Return: Memory address.
426 u64
map__objdump_2mem(struct map
*map
, u64 ip
)
428 if (!map
->dso
->adjust_symbols
)
429 return map
->unmap_ip(map
, ip
);
432 return map
->unmap_ip(map
, ip
+ map
->pgoff
);
434 return ip
+ map
->reloc
;
437 static void maps__init(struct maps
*maps
)
439 maps
->entries
= RB_ROOT
;
440 pthread_rwlock_init(&maps
->lock
, NULL
);
443 void map_groups__init(struct map_groups
*mg
, struct machine
*machine
)
446 for (i
= 0; i
< MAP__NR_TYPES
; ++i
) {
447 maps__init(&mg
->maps
[i
]);
449 mg
->machine
= machine
;
450 atomic_set(&mg
->refcnt
, 1);
453 static void __maps__purge(struct maps
*maps
)
455 struct rb_root
*root
= &maps
->entries
;
456 struct rb_node
*next
= rb_first(root
);
459 struct map
*pos
= rb_entry(next
, struct map
, rb_node
);
461 next
= rb_next(&pos
->rb_node
);
462 rb_erase_init(&pos
->rb_node
, root
);
467 static void maps__exit(struct maps
*maps
)
469 pthread_rwlock_wrlock(&maps
->lock
);
471 pthread_rwlock_unlock(&maps
->lock
);
474 void map_groups__exit(struct map_groups
*mg
)
478 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
479 maps__exit(&mg
->maps
[i
]);
482 bool map_groups__empty(struct map_groups
*mg
)
486 for (i
= 0; i
< MAP__NR_TYPES
; ++i
) {
487 if (maps__first(&mg
->maps
[i
]))
494 struct map_groups
*map_groups__new(struct machine
*machine
)
496 struct map_groups
*mg
= malloc(sizeof(*mg
));
499 map_groups__init(mg
, machine
);
504 void map_groups__delete(struct map_groups
*mg
)
506 map_groups__exit(mg
);
510 void map_groups__put(struct map_groups
*mg
)
512 if (mg
&& atomic_dec_and_test(&mg
->refcnt
))
513 map_groups__delete(mg
);
516 struct symbol
*map_groups__find_symbol(struct map_groups
*mg
,
517 enum map_type type
, u64 addr
,
519 symbol_filter_t filter
)
521 struct map
*map
= map_groups__find(mg
, type
, addr
);
523 /* Ensure map is loaded before using map->map_ip */
524 if (map
!= NULL
&& map__load(map
, filter
) >= 0) {
527 return map__find_symbol(map
, map
->map_ip(map
, addr
), filter
);
533 struct symbol
*map_groups__find_symbol_by_name(struct map_groups
*mg
,
537 symbol_filter_t filter
)
539 struct maps
*maps
= &mg
->maps
[type
];
543 pthread_rwlock_rdlock(&maps
->lock
);
545 for (nd
= rb_first(&maps
->entries
); nd
; nd
= rb_next(nd
)) {
546 struct map
*pos
= rb_entry(nd
, struct map
, rb_node
);
548 sym
= map__find_symbol_by_name(pos
, name
, filter
);
559 pthread_rwlock_unlock(&maps
->lock
);
563 int map_groups__find_ams(struct addr_map_symbol
*ams
, symbol_filter_t filter
)
565 if (ams
->addr
< ams
->map
->start
|| ams
->addr
>= ams
->map
->end
) {
566 if (ams
->map
->groups
== NULL
)
568 ams
->map
= map_groups__find(ams
->map
->groups
, ams
->map
->type
,
570 if (ams
->map
== NULL
)
574 ams
->al_addr
= ams
->map
->map_ip(ams
->map
, ams
->addr
);
575 ams
->sym
= map__find_symbol(ams
->map
, ams
->al_addr
, filter
);
577 return ams
->sym
? 0 : -1;
580 static size_t maps__fprintf(struct maps
*maps
, FILE *fp
)
585 pthread_rwlock_rdlock(&maps
->lock
);
587 for (nd
= rb_first(&maps
->entries
); nd
; nd
= rb_next(nd
)) {
588 struct map
*pos
= rb_entry(nd
, struct map
, rb_node
);
589 printed
+= fprintf(fp
, "Map:");
590 printed
+= map__fprintf(pos
, fp
);
592 printed
+= dso__fprintf(pos
->dso
, pos
->type
, fp
);
593 printed
+= fprintf(fp
, "--\n");
597 pthread_rwlock_unlock(&maps
->lock
);
602 size_t __map_groups__fprintf_maps(struct map_groups
*mg
, enum map_type type
,
605 size_t printed
= fprintf(fp
, "%s:\n", map_type__name
[type
]);
606 return printed
+= maps__fprintf(&mg
->maps
[type
], fp
);
609 size_t map_groups__fprintf(struct map_groups
*mg
, FILE *fp
)
611 size_t printed
= 0, i
;
612 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
613 printed
+= __map_groups__fprintf_maps(mg
, i
, fp
);
617 static int maps__fixup_overlappings(struct maps
*maps
, struct map
*map
, FILE *fp
)
619 struct rb_root
*root
;
620 struct rb_node
*next
;
623 pthread_rwlock_wrlock(&maps
->lock
);
625 root
= &maps
->entries
;
626 next
= rb_first(root
);
629 struct map
*pos
= rb_entry(next
, struct map
, rb_node
);
630 next
= rb_next(&pos
->rb_node
);
632 if (!map__overlap(pos
, map
))
636 fputs("overlapping maps:\n", fp
);
637 map__fprintf(map
, fp
);
638 map__fprintf(pos
, fp
);
641 rb_erase_init(&pos
->rb_node
, root
);
643 * Now check if we need to create new maps for areas not
644 * overlapped by the new map:
646 if (map
->start
> pos
->start
) {
647 struct map
*before
= map__clone(pos
);
649 if (before
== NULL
) {
654 before
->end
= map
->start
;
655 __maps__insert(maps
, before
);
657 map__fprintf(before
, fp
);
660 if (map
->end
< pos
->end
) {
661 struct map
*after
= map__clone(pos
);
668 after
->start
= map
->end
;
669 __maps__insert(maps
, after
);
671 map__fprintf(after
, fp
);
682 pthread_rwlock_unlock(&maps
->lock
);
686 int map_groups__fixup_overlappings(struct map_groups
*mg
, struct map
*map
,
689 return maps__fixup_overlappings(&mg
->maps
[map
->type
], map
, fp
);
693 * XXX This should not really _copy_ te maps, but refcount them.
695 int map_groups__clone(struct map_groups
*mg
,
696 struct map_groups
*parent
, enum map_type type
)
700 struct maps
*maps
= &parent
->maps
[type
];
702 pthread_rwlock_rdlock(&maps
->lock
);
704 for (map
= maps__first(maps
); map
; map
= map__next(map
)) {
705 struct map
*new = map__clone(map
);
708 map_groups__insert(mg
, new);
713 pthread_rwlock_unlock(&maps
->lock
);
717 static void __maps__insert(struct maps
*maps
, struct map
*map
)
719 struct rb_node
**p
= &maps
->entries
.rb_node
;
720 struct rb_node
*parent
= NULL
;
721 const u64 ip
= map
->start
;
726 m
= rb_entry(parent
, struct map
, rb_node
);
733 rb_link_node(&map
->rb_node
, parent
, p
);
734 rb_insert_color(&map
->rb_node
, &maps
->entries
);
738 void maps__insert(struct maps
*maps
, struct map
*map
)
740 pthread_rwlock_wrlock(&maps
->lock
);
741 __maps__insert(maps
, map
);
742 pthread_rwlock_unlock(&maps
->lock
);
745 static void __maps__remove(struct maps
*maps
, struct map
*map
)
747 rb_erase_init(&map
->rb_node
, &maps
->entries
);
751 void maps__remove(struct maps
*maps
, struct map
*map
)
753 pthread_rwlock_wrlock(&maps
->lock
);
754 __maps__remove(maps
, map
);
755 pthread_rwlock_unlock(&maps
->lock
);
758 struct map
*maps__find(struct maps
*maps
, u64 ip
)
760 struct rb_node
**p
, *parent
= NULL
;
763 pthread_rwlock_rdlock(&maps
->lock
);
765 p
= &maps
->entries
.rb_node
;
768 m
= rb_entry(parent
, struct map
, rb_node
);
771 else if (ip
>= m
->end
)
779 pthread_rwlock_unlock(&maps
->lock
);
783 struct map
*maps__first(struct maps
*maps
)
785 struct rb_node
*first
= rb_first(&maps
->entries
);
788 return rb_entry(first
, struct map
, rb_node
);
792 struct map
*map__next(struct map
*map
)
794 struct rb_node
*next
= rb_next(&map
->rb_node
);
797 return rb_entry(next
, struct map
, rb_node
);
801 struct kmap
*map__kmap(struct map
*map
)
803 if (!map
->dso
|| !map
->dso
->kernel
) {
804 pr_err("Internal error: map__kmap with a non-kernel map\n");
807 return (struct kmap
*)(map
+ 1);
810 struct map_groups
*map__kmaps(struct map
*map
)
812 struct kmap
*kmap
= map__kmap(map
);
814 if (!kmap
|| !kmap
->kmaps
) {
815 pr_err("Internal error: map__kmaps with a non-kernel map\n");
This page took 0.051219 seconds and 5 git commands to generate.