1 // SPDX-License-Identifier: GPL-2.0
2 #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 
is_android_lib(const char * filename)19 static inline int is_android_lib(const char *filename)
20 {
21 	return strstarts(filename, "/data/app-lib/") ||
22 	       strstarts(filename, "/system/lib/");
23 }
24 
replace_android_lib(const char * filename,char * newfilename)25 static 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_length
92 			   + 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 
map__init(struct map * map,u64 start,u64 end,u64 pgoff,struct dso * dso)105 void map__init(struct map *map, u64 start, u64 end, u64 pgoff, struct dso *dso)
106 {
107 	map->start    = start;
108 	map->end      = end;
109 	map->pgoff    = pgoff;
110 	map->reloc    = 0;
111 	map->dso      = dso__get(dso);
112 	map->map_ip   = map__map_ip;
113 	map->unmap_ip = map__unmap_ip;
114 	RB_CLEAR_NODE(&map->rb_node);
115 	map->erange_warned = false;
116 	refcount_set(&map->refcnt, 1);
117 }
118 
map__new(struct machine * machine,u64 start,u64 len,u64 pgoff,struct dso_id * id,u32 prot,u32 flags,struct build_id * bid,char * filename,struct thread * thread)119 struct map *map__new(struct machine *machine, u64 start, u64 len,
120 		     u64 pgoff, struct dso_id *id,
121 		     u32 prot, u32 flags, struct build_id *bid,
122 		     char *filename, struct thread *thread)
123 {
124 	struct map *map = malloc(sizeof(*map));
125 	struct nsinfo *nsi = NULL;
126 	struct nsinfo *nnsi;
127 
128 	if (map != NULL) {
129 		char newfilename[PATH_MAX];
130 		struct dso *dso, *header_bid_dso;
131 		int anon, no_dso, vdso, android;
132 
133 		android = is_android_lib(filename);
134 		anon = is_anon_memory(filename) || flags & MAP_HUGETLB;
135 		vdso = is_vdso_map(filename);
136 		no_dso = is_no_dso_memory(filename);
137 		map->prot = prot;
138 		map->flags = flags;
139 		nsi = nsinfo__get(thread->nsinfo);
140 
141 		if ((anon || no_dso) && nsi && (prot & PROT_EXEC)) {
142 			snprintf(newfilename, sizeof(newfilename),
143 				 "/tmp/perf-%d.map", nsinfo__pid(nsi));
144 			filename = newfilename;
145 		}
146 
147 		if (android) {
148 			if (replace_android_lib(filename, newfilename))
149 				filename = newfilename;
150 		}
151 
152 		if (vdso) {
153 			/* The vdso maps are always on the host and not the
154 			 * container.  Ensure that we don't use setns to look
155 			 * them up.
156 			 */
157 			nnsi = nsinfo__copy(nsi);
158 			if (nnsi) {
159 				nsinfo__put(nsi);
160 				nsinfo__clear_need_setns(nnsi);
161 				nsi = nnsi;
162 			}
163 			pgoff = 0;
164 			dso = machine__findnew_vdso(machine, thread);
165 		} else
166 			dso = machine__findnew_dso_id(machine, filename, id);
167 
168 		if (dso == NULL)
169 			goto out_delete;
170 
171 		map__init(map, start, start + len, pgoff, dso);
172 
173 		if (anon || no_dso) {
174 			map->map_ip = map->unmap_ip = identity__map_ip;
175 
176 			/*
177 			 * Set memory without DSO as loaded. All map__find_*
178 			 * functions still return NULL, and we avoid the
179 			 * unnecessary map__load warning.
180 			 */
181 			if (!(prot & PROT_EXEC))
182 				dso__set_loaded(dso);
183 		}
184 		dso->nsinfo = nsi;
185 
186 		if (build_id__is_defined(bid)) {
187 			dso__set_build_id(dso, bid);
188 		} else {
189 			/*
190 			 * If the mmap event had no build ID, search for an existing dso from the
191 			 * build ID header by name. Otherwise only the dso loaded at the time of
192 			 * reading the header will have the build ID set and all future mmaps will
193 			 * have it missing.
194 			 */
195 			down_read(&machine->dsos.lock);
196 			header_bid_dso = __dsos__find(&machine->dsos, filename, false);
197 			up_read(&machine->dsos.lock);
198 			if (header_bid_dso && header_bid_dso->header_build_id) {
199 				dso__set_build_id(dso, &header_bid_dso->bid);
200 				dso->header_build_id = 1;
201 			}
202 		}
203 		dso__put(dso);
204 	}
205 	return map;
206 out_delete:
207 	nsinfo__put(nsi);
208 	free(map);
209 	return NULL;
210 }
211 
212 /*
213  * Constructor variant for modules (where we know from /proc/modules where
214  * they are loaded) and for vmlinux, where only after we load all the
215  * symbols we'll know where it starts and ends.
216  */
map__new2(u64 start,struct dso * dso)217 struct map *map__new2(u64 start, struct dso *dso)
218 {
219 	struct map *map = calloc(1, (sizeof(*map) +
220 				     (dso->kernel ? sizeof(struct kmap) : 0)));
221 	if (map != NULL) {
222 		/*
223 		 * ->end will be filled after we load all the symbols
224 		 */
225 		map__init(map, start, 0, 0, dso);
226 	}
227 
228 	return map;
229 }
230 
__map__is_kernel(const struct map * map)231 bool __map__is_kernel(const struct map *map)
232 {
233 	if (!map->dso->kernel)
234 		return false;
235 	return machine__kernel_map(map__kmaps((struct map *)map)->machine) == map;
236 }
237 
__map__is_extra_kernel_map(const struct map * map)238 bool __map__is_extra_kernel_map(const struct map *map)
239 {
240 	struct kmap *kmap = __map__kmap((struct map *)map);
241 
242 	return kmap && kmap->name[0];
243 }
244 
__map__is_bpf_prog(const struct map * map)245 bool __map__is_bpf_prog(const struct map *map)
246 {
247 	const char *name;
248 
249 	if (map->dso->binary_type == DSO_BINARY_TYPE__BPF_PROG_INFO)
250 		return true;
251 
252 	/*
253 	 * If PERF_RECORD_BPF_EVENT is not included, the dso will not have
254 	 * type of DSO_BINARY_TYPE__BPF_PROG_INFO. In such cases, we can
255 	 * guess the type based on name.
256 	 */
257 	name = map->dso->short_name;
258 	return name && (strstr(name, "bpf_prog_") == name);
259 }
260 
__map__is_bpf_image(const struct map * map)261 bool __map__is_bpf_image(const struct map *map)
262 {
263 	const char *name;
264 
265 	if (map->dso->binary_type == DSO_BINARY_TYPE__BPF_IMAGE)
266 		return true;
267 
268 	/*
269 	 * If PERF_RECORD_KSYMBOL is not included, the dso will not have
270 	 * type of DSO_BINARY_TYPE__BPF_IMAGE. In such cases, we can
271 	 * guess the type based on name.
272 	 */
273 	name = map->dso->short_name;
274 	return name && is_bpf_image(name);
275 }
276 
__map__is_ool(const struct map * map)277 bool __map__is_ool(const struct map *map)
278 {
279 	return map->dso && map->dso->binary_type == DSO_BINARY_TYPE__OOL;
280 }
281 
map__has_symbols(const struct map * map)282 bool map__has_symbols(const struct map *map)
283 {
284 	return dso__has_symbols(map->dso);
285 }
286 
map__exit(struct map * map)287 static void map__exit(struct map *map)
288 {
289 	BUG_ON(refcount_read(&map->refcnt) != 0);
290 	dso__zput(map->dso);
291 }
292 
map__delete(struct map * map)293 void map__delete(struct map *map)
294 {
295 	map__exit(map);
296 	free(map);
297 }
298 
map__put(struct map * map)299 void map__put(struct map *map)
300 {
301 	if (map && refcount_dec_and_test(&map->refcnt))
302 		map__delete(map);
303 }
304 
map__fixup_start(struct map * map)305 void map__fixup_start(struct map *map)
306 {
307 	struct rb_root_cached *symbols = &map->dso->symbols;
308 	struct rb_node *nd = rb_first_cached(symbols);
309 	if (nd != NULL) {
310 		struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
311 		map->start = sym->start;
312 	}
313 }
314 
map__fixup_end(struct map * map)315 void map__fixup_end(struct map *map)
316 {
317 	struct rb_root_cached *symbols = &map->dso->symbols;
318 	struct rb_node *nd = rb_last(&symbols->rb_root);
319 	if (nd != NULL) {
320 		struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
321 		map->end = sym->end;
322 	}
323 }
324 
325 #define DSO__DELETED "(deleted)"
326 
map__load(struct map * map)327 int map__load(struct map *map)
328 {
329 	const char *name = map->dso->long_name;
330 	int nr;
331 
332 	if (dso__loaded(map->dso))
333 		return 0;
334 
335 	nr = dso__load(map->dso, map);
336 	if (nr < 0) {
337 		if (map->dso->has_build_id) {
338 			char sbuild_id[SBUILD_ID_SIZE];
339 
340 			build_id__sprintf(&map->dso->bid, sbuild_id);
341 			pr_debug("%s with build id %s not found", name, sbuild_id);
342 		} else
343 			pr_debug("Failed to open %s", name);
344 
345 		pr_debug(", continuing without symbols\n");
346 		return -1;
347 	} else if (nr == 0) {
348 #ifdef HAVE_LIBELF_SUPPORT
349 		const size_t len = strlen(name);
350 		const size_t real_len = len - sizeof(DSO__DELETED);
351 
352 		if (len > sizeof(DSO__DELETED) &&
353 		    strcmp(name + real_len + 1, DSO__DELETED) == 0) {
354 			pr_debug("%.*s was updated (is prelink enabled?). "
355 				"Restart the long running apps that use it!\n",
356 				   (int)real_len, name);
357 		} else {
358 			pr_debug("no symbols found in %s, maybe install a debug package?\n", name);
359 		}
360 #endif
361 		return -1;
362 	}
363 
364 	return 0;
365 }
366 
map__find_symbol(struct map * map,u64 addr)367 struct symbol *map__find_symbol(struct map *map, u64 addr)
368 {
369 	if (map__load(map) < 0)
370 		return NULL;
371 
372 	return dso__find_symbol(map->dso, addr);
373 }
374 
map__find_symbol_by_name(struct map * map,const char * name)375 struct symbol *map__find_symbol_by_name(struct map *map, const char *name)
376 {
377 	if (map__load(map) < 0)
378 		return NULL;
379 
380 	if (!dso__sorted_by_name(map->dso))
381 		dso__sort_by_name(map->dso);
382 
383 	return dso__find_symbol_by_name(map->dso, name);
384 }
385 
map__clone(struct map * from)386 struct map *map__clone(struct map *from)
387 {
388 	size_t size = sizeof(struct map);
389 	struct map *map;
390 
391 	if (from->dso && from->dso->kernel)
392 		size += sizeof(struct kmap);
393 
394 	map = memdup(from, size);
395 	if (map != NULL) {
396 		refcount_set(&map->refcnt, 1);
397 		RB_CLEAR_NODE(&map->rb_node);
398 		dso__get(map->dso);
399 	}
400 
401 	return map;
402 }
403 
map__fprintf(struct map * map,FILE * fp)404 size_t map__fprintf(struct map *map, FILE *fp)
405 {
406 	return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n",
407 		       map->start, map->end, map->pgoff, map->dso->name);
408 }
409 
map__fprintf_dsoname(struct map * map,FILE * fp)410 size_t map__fprintf_dsoname(struct map *map, FILE *fp)
411 {
412 	char buf[symbol_conf.pad_output_len_dso + 1];
413 	const char *dsoname = "[unknown]";
414 
415 	if (map && map->dso) {
416 		if (symbol_conf.show_kernel_path && map->dso->long_name)
417 			dsoname = map->dso->long_name;
418 		else
419 			dsoname = map->dso->name;
420 	}
421 
422 	if (symbol_conf.pad_output_len_dso) {
423 		scnprintf_pad(buf, symbol_conf.pad_output_len_dso, "%s", dsoname);
424 		dsoname = buf;
425 	}
426 
427 	return fprintf(fp, "%s", dsoname);
428 }
429 
map__srcline(struct map * map,u64 addr,struct symbol * sym)430 char *map__srcline(struct map *map, u64 addr, struct symbol *sym)
431 {
432 	if (map == NULL)
433 		return SRCLINE_UNKNOWN;
434 	return get_srcline(map->dso, map__rip_2objdump(map, addr), sym, true, true, addr);
435 }
436 
map__fprintf_srcline(struct map * map,u64 addr,const char * prefix,FILE * fp)437 int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
438 			 FILE *fp)
439 {
440 	int ret = 0;
441 
442 	if (map && map->dso) {
443 		char *srcline = map__srcline(map, addr, NULL);
444 		if (strncmp(srcline, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)
445 			ret = fprintf(fp, "%s%s", prefix, srcline);
446 		free_srcline(srcline);
447 	}
448 	return ret;
449 }
450 
srccode_state_free(struct srccode_state * state)451 void srccode_state_free(struct srccode_state *state)
452 {
453 	zfree(&state->srcfile);
454 	state->line = 0;
455 }
456 
457 /**
458  * map__rip_2objdump - convert symbol start address to objdump address.
459  * @map: memory map
460  * @rip: symbol start address
461  *
462  * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
463  * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is
464  * relative to section start.
465  *
466  * Return: Address suitable for passing to "objdump --start-address="
467  */
map__rip_2objdump(struct map * map,u64 rip)468 u64 map__rip_2objdump(struct map *map, u64 rip)
469 {
470 	struct kmap *kmap = __map__kmap(map);
471 
472 	/*
473 	 * vmlinux does not have program headers for PTI entry trampolines and
474 	 * kcore may not either. However the trampoline object code is on the
475 	 * main kernel map, so just use that instead.
476 	 */
477 	if (kmap && is_entry_trampoline(kmap->name) && kmap->kmaps && kmap->kmaps->machine) {
478 		struct map *kernel_map = machine__kernel_map(kmap->kmaps->machine);
479 
480 		if (kernel_map)
481 			map = kernel_map;
482 	}
483 
484 	if (!map->dso->adjust_symbols)
485 		return rip;
486 
487 	if (map->dso->rel)
488 		return rip - map->pgoff;
489 
490 	/*
491 	 * kernel modules also have DSO_TYPE_USER in dso->kernel,
492 	 * but all kernel modules are ET_REL, so won't get here.
493 	 */
494 	if (map->dso->kernel == DSO_SPACE__USER)
495 		return rip + map->dso->text_offset;
496 
497 	return map->unmap_ip(map, rip) - map->reloc;
498 }
499 
500 /**
501  * map__objdump_2mem - convert objdump address to a memory address.
502  * @map: memory map
503  * @ip: objdump address
504  *
505  * Closely related to map__rip_2objdump(), this function takes an address from
506  * objdump and converts it to a memory address.  Note this assumes that @map
507  * contains the address.  To be sure the result is valid, check it forwards
508  * e.g. map__rip_2objdump(map->map_ip(map, map__objdump_2mem(map, ip))) == ip
509  *
510  * Return: Memory address.
511  */
map__objdump_2mem(struct map * map,u64 ip)512 u64 map__objdump_2mem(struct map *map, u64 ip)
513 {
514 	if (!map->dso->adjust_symbols)
515 		return map->unmap_ip(map, ip);
516 
517 	if (map->dso->rel)
518 		return map->unmap_ip(map, ip + map->pgoff);
519 
520 	/*
521 	 * kernel modules also have DSO_TYPE_USER in dso->kernel,
522 	 * but all kernel modules are ET_REL, so won't get here.
523 	 */
524 	if (map->dso->kernel == DSO_SPACE__USER)
525 		return map->unmap_ip(map, ip - map->dso->text_offset);
526 
527 	return ip + map->reloc;
528 }
529 
map__contains_symbol(const struct map * map,const struct symbol * sym)530 bool map__contains_symbol(const struct map *map, const struct symbol *sym)
531 {
532 	u64 ip = map->unmap_ip(map, sym->start);
533 
534 	return ip >= map->start && ip < map->end;
535 }
536 
__map__next(struct map * map)537 static struct map *__map__next(struct map *map)
538 {
539 	struct rb_node *next = rb_next(&map->rb_node);
540 
541 	if (next)
542 		return rb_entry(next, struct map, rb_node);
543 	return NULL;
544 }
545 
map__next(struct map * map)546 struct map *map__next(struct map *map)
547 {
548 	return map ? __map__next(map) : NULL;
549 }
550 
__map__kmap(struct map * map)551 struct kmap *__map__kmap(struct map *map)
552 {
553 	if (!map->dso || !map->dso->kernel)
554 		return NULL;
555 	return (struct kmap *)(map + 1);
556 }
557 
map__kmap(struct map * map)558 struct kmap *map__kmap(struct map *map)
559 {
560 	struct kmap *kmap = __map__kmap(map);
561 
562 	if (!kmap)
563 		pr_err("Internal error: map__kmap with a non-kernel map\n");
564 	return kmap;
565 }
566 
map__kmaps(struct map * map)567 struct maps *map__kmaps(struct map *map)
568 {
569 	struct kmap *kmap = map__kmap(map);
570 
571 	if (!kmap || !kmap->kmaps) {
572 		pr_err("Internal error: map__kmaps with a non-kernel map\n");
573 		return NULL;
574 	}
575 	return kmap->kmaps;
576 }
577 
map__map_ip(const struct map * map,u64 ip)578 u64 map__map_ip(const struct map *map, u64 ip)
579 {
580 	return ip - map->start + map->pgoff;
581 }
582 
map__unmap_ip(const struct map * map,u64 ip)583 u64 map__unmap_ip(const struct map *map, u64 ip)
584 {
585 	return ip + map->start - map->pgoff;
586 }
587 
identity__map_ip(const struct map * map __maybe_unused,u64 ip)588 u64 identity__map_ip(const struct map *map __maybe_unused, u64 ip)
589 {
590 	return ip;
591 }
592