15 const char *map_type__name
[MAP__NR_TYPES
] = {
16 [MAP__FUNCTION
] = "Functions",
17 [MAP__VARIABLE
] = "Variables",
20 static inline int is_anon_memory(const char *filename
)
22 return strcmp(filename
, "//anon") == 0;
25 static inline int is_no_dso_memory(const char *filename
)
27 return !strncmp(filename
, "[stack", 6) ||
28 !strcmp(filename
, "[heap]");
31 void map__init(struct map
*self
, enum map_type type
,
32 u64 start
, u64 end
, u64 pgoff
, struct dso
*dso
)
39 self
->map_ip
= map__map_ip
;
40 self
->unmap_ip
= map__unmap_ip
;
41 RB_CLEAR_NODE(&self
->rb_node
);
43 self
->referenced
= false;
44 self
->erange_warned
= false;
47 struct map
*map__new(struct list_head
*dsos__list
, u64 start
, u64 len
,
48 u64 pgoff
, u32 pid
, char *filename
,
51 struct map
*self
= malloc(sizeof(*self
));
54 char newfilename
[PATH_MAX
];
56 int anon
, no_dso
, vdso
;
58 anon
= is_anon_memory(filename
);
59 vdso
= is_vdso_map(filename
);
60 no_dso
= is_no_dso_memory(filename
);
63 snprintf(newfilename
, sizeof(newfilename
), "/tmp/perf-%d.map", pid
);
64 filename
= newfilename
;
69 dso
= vdso__dso_findnew(dsos__list
);
71 dso
= __dsos__findnew(dsos__list
, filename
);
76 map__init(self
, type
, start
, start
+ len
, pgoff
, dso
);
79 self
->map_ip
= self
->unmap_ip
= identity__map_ip
;
82 * Set memory without DSO as loaded. All map__find_*
83 * functions still return NULL, and we avoid the
84 * unnecessary map__load warning.
87 dso__set_loaded(dso
, self
->type
);
97 * Constructor variant for modules (where we know from /proc/modules where
98 * they are loaded) and for vmlinux, where only after we load all the
99 * symbols we'll know where it starts and ends.
101 struct map
*map__new2(u64 start
, struct dso
*dso
, enum map_type type
)
103 struct map
*map
= calloc(1, (sizeof(*map
) +
104 (dso
->kernel
? sizeof(struct kmap
) : 0)));
107 * ->end will be filled after we load all the symbols
109 map__init(map
, type
, start
, 0, 0, dso
);
115 void map__delete(struct map
*self
)
120 void map__fixup_start(struct map
*self
)
122 struct rb_root
*symbols
= &self
->dso
->symbols
[self
->type
];
123 struct rb_node
*nd
= rb_first(symbols
);
125 struct symbol
*sym
= rb_entry(nd
, struct symbol
, rb_node
);
126 self
->start
= sym
->start
;
130 void map__fixup_end(struct map
*self
)
132 struct rb_root
*symbols
= &self
->dso
->symbols
[self
->type
];
133 struct rb_node
*nd
= rb_last(symbols
);
135 struct symbol
*sym
= rb_entry(nd
, struct symbol
, rb_node
);
136 self
->end
= sym
->end
;
140 #define DSO__DELETED "(deleted)"
142 int map__load(struct map
*self
, symbol_filter_t filter
)
144 const char *name
= self
->dso
->long_name
;
147 if (dso__loaded(self
->dso
, self
->type
))
150 nr
= dso__load(self
->dso
, self
, filter
);
152 if (self
->dso
->has_build_id
) {
153 char sbuild_id
[BUILD_ID_SIZE
* 2 + 1];
155 build_id__sprintf(self
->dso
->build_id
,
156 sizeof(self
->dso
->build_id
),
158 pr_warning("%s with build id %s not found",
161 pr_warning("Failed to open %s", name
);
163 pr_warning(", continuing without symbols\n");
165 } else if (nr
== 0) {
166 #ifdef LIBELF_SUPPORT
167 const size_t len
= strlen(name
);
168 const size_t real_len
= len
- sizeof(DSO__DELETED
);
170 if (len
> sizeof(DSO__DELETED
) &&
171 strcmp(name
+ real_len
+ 1, DSO__DELETED
) == 0) {
172 pr_warning("%.*s was updated (is prelink enabled?). "
173 "Restart the long running apps that use it!\n",
174 (int)real_len
, name
);
176 pr_warning("no symbols found in %s, maybe install "
177 "a debug package?\n", name
);
183 * Only applies to the kernel, as its symtabs aren't relative like the
186 if (self
->dso
->kernel
)
187 map__reloc_vmlinux(self
);
192 struct symbol
*map__find_symbol(struct map
*self
, u64 addr
,
193 symbol_filter_t filter
)
195 if (map__load(self
, filter
) < 0)
198 return dso__find_symbol(self
->dso
, self
->type
, addr
);
201 struct symbol
*map__find_symbol_by_name(struct map
*self
, const char *name
,
202 symbol_filter_t filter
)
204 if (map__load(self
, filter
) < 0)
207 if (!dso__sorted_by_name(self
->dso
, self
->type
))
208 dso__sort_by_name(self
->dso
, self
->type
);
210 return dso__find_symbol_by_name(self
->dso
, self
->type
, name
);
213 struct map
*map__clone(struct map
*self
)
215 struct map
*map
= malloc(sizeof(*self
));
220 memcpy(map
, self
, sizeof(*self
));
225 int map__overlap(struct map
*l
, struct map
*r
)
227 if (l
->start
> r
->start
) {
233 if (l
->end
> r
->start
)
239 size_t map__fprintf(struct map
*self
, FILE *fp
)
241 return fprintf(fp
, " %" PRIx64
"-%" PRIx64
" %" PRIx64
" %s\n",
242 self
->start
, self
->end
, self
->pgoff
, self
->dso
->name
);
245 size_t map__fprintf_dsoname(struct map
*map
, FILE *fp
)
247 const char *dsoname
= "[unknown]";
249 if (map
&& map
->dso
&& (map
->dso
->name
|| map
->dso
->long_name
)) {
250 if (symbol_conf
.show_kernel_path
&& map
->dso
->long_name
)
251 dsoname
= map
->dso
->long_name
;
252 else if (map
->dso
->name
)
253 dsoname
= map
->dso
->name
;
256 return fprintf(fp
, "%s", dsoname
);
260 * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
261 * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
263 u64
map__rip_2objdump(struct map
*map
, u64 rip
)
265 u64 addr
= map
->dso
->adjust_symbols
?
266 map
->unmap_ip(map
, rip
) : /* RIP -> IP */
271 void map_groups__init(struct map_groups
*mg
)
274 for (i
= 0; i
< MAP__NR_TYPES
; ++i
) {
275 mg
->maps
[i
] = RB_ROOT
;
276 INIT_LIST_HEAD(&mg
->removed_maps
[i
]);
281 static void maps__delete(struct rb_root
*maps
)
283 struct rb_node
*next
= rb_first(maps
);
286 struct map
*pos
= rb_entry(next
, struct map
, rb_node
);
288 next
= rb_next(&pos
->rb_node
);
289 rb_erase(&pos
->rb_node
, maps
);
294 static void maps__delete_removed(struct list_head
*maps
)
298 list_for_each_entry_safe(pos
, n
, maps
, node
) {
299 list_del(&pos
->node
);
304 void map_groups__exit(struct map_groups
*mg
)
308 for (i
= 0; i
< MAP__NR_TYPES
; ++i
) {
309 maps__delete(&mg
->maps
[i
]);
310 maps__delete_removed(&mg
->removed_maps
[i
]);
314 void map_groups__flush(struct map_groups
*mg
)
318 for (type
= 0; type
< MAP__NR_TYPES
; type
++) {
319 struct rb_root
*root
= &mg
->maps
[type
];
320 struct rb_node
*next
= rb_first(root
);
323 struct map
*pos
= rb_entry(next
, struct map
, rb_node
);
324 next
= rb_next(&pos
->rb_node
);
325 rb_erase(&pos
->rb_node
, root
);
327 * We may have references to this map, for
328 * instance in some hist_entry instances, so
329 * just move them to a separate list.
331 list_add_tail(&pos
->node
, &mg
->removed_maps
[pos
->type
]);
336 struct symbol
*map_groups__find_symbol(struct map_groups
*mg
,
337 enum map_type type
, u64 addr
,
339 symbol_filter_t filter
)
341 struct map
*map
= map_groups__find(mg
, type
, addr
);
346 return map__find_symbol(map
, map
->map_ip(map
, addr
), filter
);
352 struct symbol
*map_groups__find_symbol_by_name(struct map_groups
*mg
,
356 symbol_filter_t filter
)
360 for (nd
= rb_first(&mg
->maps
[type
]); nd
; nd
= rb_next(nd
)) {
361 struct map
*pos
= rb_entry(nd
, struct map
, rb_node
);
362 struct symbol
*sym
= map__find_symbol_by_name(pos
, name
, filter
);
374 size_t __map_groups__fprintf_maps(struct map_groups
*mg
,
375 enum map_type type
, int verbose
, FILE *fp
)
377 size_t printed
= fprintf(fp
, "%s:\n", map_type__name
[type
]);
380 for (nd
= rb_first(&mg
->maps
[type
]); nd
; nd
= rb_next(nd
)) {
381 struct map
*pos
= rb_entry(nd
, struct map
, rb_node
);
382 printed
+= fprintf(fp
, "Map:");
383 printed
+= map__fprintf(pos
, fp
);
385 printed
+= dso__fprintf(pos
->dso
, type
, fp
);
386 printed
+= fprintf(fp
, "--\n");
393 size_t map_groups__fprintf_maps(struct map_groups
*mg
, int verbose
, FILE *fp
)
395 size_t printed
= 0, i
;
396 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
397 printed
+= __map_groups__fprintf_maps(mg
, i
, verbose
, fp
);
401 static size_t __map_groups__fprintf_removed_maps(struct map_groups
*mg
,
403 int verbose
, FILE *fp
)
408 list_for_each_entry(pos
, &mg
->removed_maps
[type
], node
) {
409 printed
+= fprintf(fp
, "Map:");
410 printed
+= map__fprintf(pos
, fp
);
412 printed
+= dso__fprintf(pos
->dso
, type
, fp
);
413 printed
+= fprintf(fp
, "--\n");
419 static size_t map_groups__fprintf_removed_maps(struct map_groups
*mg
,
420 int verbose
, FILE *fp
)
422 size_t printed
= 0, i
;
423 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
424 printed
+= __map_groups__fprintf_removed_maps(mg
, i
, verbose
, fp
);
428 size_t map_groups__fprintf(struct map_groups
*mg
, int verbose
, FILE *fp
)
430 size_t printed
= map_groups__fprintf_maps(mg
, verbose
, fp
);
431 printed
+= fprintf(fp
, "Removed maps:\n");
432 return printed
+ map_groups__fprintf_removed_maps(mg
, verbose
, fp
);
435 int map_groups__fixup_overlappings(struct map_groups
*mg
, struct map
*map
,
436 int verbose
, FILE *fp
)
438 struct rb_root
*root
= &mg
->maps
[map
->type
];
439 struct rb_node
*next
= rb_first(root
);
443 struct map
*pos
= rb_entry(next
, struct map
, rb_node
);
444 next
= rb_next(&pos
->rb_node
);
446 if (!map__overlap(pos
, map
))
450 fputs("overlapping maps:\n", fp
);
451 map__fprintf(map
, fp
);
452 map__fprintf(pos
, fp
);
455 rb_erase(&pos
->rb_node
, root
);
457 * Now check if we need to create new maps for areas not
458 * overlapped by the new map:
460 if (map
->start
> pos
->start
) {
461 struct map
*before
= map__clone(pos
);
463 if (before
== NULL
) {
468 before
->end
= map
->start
- 1;
469 map_groups__insert(mg
, before
);
471 map__fprintf(before
, fp
);
474 if (map
->end
< pos
->end
) {
475 struct map
*after
= map__clone(pos
);
482 after
->start
= map
->end
+ 1;
483 map_groups__insert(mg
, after
);
485 map__fprintf(after
, fp
);
489 * If we have references, just move them to a separate list.
492 list_add_tail(&pos
->node
, &mg
->removed_maps
[map
->type
]);
504 * XXX This should not really _copy_ te maps, but refcount them.
506 int map_groups__clone(struct map_groups
*mg
,
507 struct map_groups
*parent
, enum map_type type
)
510 for (nd
= rb_first(&parent
->maps
[type
]); nd
; nd
= rb_next(nd
)) {
511 struct map
*map
= rb_entry(nd
, struct map
, rb_node
);
512 struct map
*new = map__clone(map
);
515 map_groups__insert(mg
, new);
520 static u64
map__reloc_map_ip(struct map
*map
, u64 ip
)
522 return ip
+ (s64
)map
->pgoff
;
525 static u64
map__reloc_unmap_ip(struct map
*map
, u64 ip
)
527 return ip
- (s64
)map
->pgoff
;
530 void map__reloc_vmlinux(struct map
*self
)
532 struct kmap
*kmap
= map__kmap(self
);
535 if (!kmap
->ref_reloc_sym
|| !kmap
->ref_reloc_sym
->unrelocated_addr
)
538 reloc
= (kmap
->ref_reloc_sym
->unrelocated_addr
-
539 kmap
->ref_reloc_sym
->addr
);
544 self
->map_ip
= map__reloc_map_ip
;
545 self
->unmap_ip
= map__reloc_unmap_ip
;
549 void maps__insert(struct rb_root
*maps
, struct map
*map
)
551 struct rb_node
**p
= &maps
->rb_node
;
552 struct rb_node
*parent
= NULL
;
553 const u64 ip
= map
->start
;
558 m
= rb_entry(parent
, struct map
, rb_node
);
565 rb_link_node(&map
->rb_node
, parent
, p
);
566 rb_insert_color(&map
->rb_node
, maps
);
569 void maps__remove(struct rb_root
*self
, struct map
*map
)
571 rb_erase(&map
->rb_node
, self
);
574 struct map
*maps__find(struct rb_root
*maps
, u64 ip
)
576 struct rb_node
**p
= &maps
->rb_node
;
577 struct rb_node
*parent
= NULL
;
582 m
= rb_entry(parent
, struct map
, rb_node
);
585 else if (ip
> m
->end
)