1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * build-id.c
4  *
5  * build-id support
6  *
7  * Copyright (C) 2009, 2010 Red Hat Inc.
8  * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
9  */
10 #include "util.h" // lsdir(), mkdir_p(), rm_rf()
11 #include <dirent.h>
12 #include <errno.h>
13 #include <stdio.h>
14 #include <sys/stat.h>
15 #include <sys/types.h>
16 #include "util/copyfile.h"
17 #include "dso.h"
18 #include "build-id.h"
19 #include "event.h"
20 #include "namespaces.h"
21 #include "map.h"
22 #include "symbol.h"
23 #include "thread.h"
24 #include <linux/kernel.h>
25 #include "debug.h"
26 #include "session.h"
27 #include "tool.h"
28 #include "header.h"
29 #include "vdso.h"
30 #include "path.h"
31 #include "probe-file.h"
32 #include "strlist.h"
33 
34 #ifdef HAVE_DEBUGINFOD_SUPPORT
35 #include <elfutils/debuginfod.h>
36 #endif
37 
38 #include <linux/ctype.h>
39 #include <linux/zalloc.h>
40 #include <linux/string.h>
41 #include <asm/bug.h>
42 
43 static bool no_buildid_cache;
44 
build_id__mark_dso_hit(struct perf_tool * tool __maybe_unused,union perf_event * event,struct perf_sample * sample,struct evsel * evsel __maybe_unused,struct machine * machine)45 int build_id__mark_dso_hit(struct perf_tool *tool __maybe_unused,
46 			   union perf_event *event,
47 			   struct perf_sample *sample,
48 			   struct evsel *evsel __maybe_unused,
49 			   struct machine *machine)
50 {
51 	struct addr_location al;
52 	struct thread *thread = machine__findnew_thread(machine, sample->pid,
53 							sample->tid);
54 
55 	if (thread == NULL) {
56 		pr_err("problem processing %d event, skipping it.\n",
57 			event->header.type);
58 		return -1;
59 	}
60 
61 	if (thread__find_map(thread, sample->cpumode, sample->ip, &al))
62 		al.map->dso->hit = 1;
63 
64 	thread__put(thread);
65 	return 0;
66 }
67 
perf_event__exit_del_thread(struct perf_tool * tool __maybe_unused,union perf_event * event,struct perf_sample * sample __maybe_unused,struct machine * machine)68 static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
69 				       union perf_event *event,
70 				       struct perf_sample *sample
71 				       __maybe_unused,
72 				       struct machine *machine)
73 {
74 	struct thread *thread = machine__findnew_thread(machine,
75 							event->fork.pid,
76 							event->fork.tid);
77 
78 	dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
79 		    event->fork.ppid, event->fork.ptid);
80 
81 	if (thread) {
82 		machine__remove_thread(machine, thread);
83 		thread__put(thread);
84 	}
85 
86 	return 0;
87 }
88 
89 struct perf_tool build_id__mark_dso_hit_ops = {
90 	.sample	= build_id__mark_dso_hit,
91 	.mmap	= perf_event__process_mmap,
92 	.mmap2	= perf_event__process_mmap2,
93 	.fork	= perf_event__process_fork,
94 	.exit	= perf_event__exit_del_thread,
95 	.attr		 = perf_event__process_attr,
96 	.build_id	 = perf_event__process_build_id,
97 	.ordered_events	 = true,
98 };
99 
build_id__sprintf(const struct build_id * build_id,char * bf)100 int build_id__sprintf(const struct build_id *build_id, char *bf)
101 {
102 	char *bid = bf;
103 	const u8 *raw = build_id->data;
104 	size_t i;
105 
106 	bf[0] = 0x0;
107 
108 	for (i = 0; i < build_id->size; ++i) {
109 		sprintf(bid, "%02x", *raw);
110 		++raw;
111 		bid += 2;
112 	}
113 
114 	return (bid - bf) + 1;
115 }
116 
sysfs__sprintf_build_id(const char * root_dir,char * sbuild_id)117 int sysfs__sprintf_build_id(const char *root_dir, char *sbuild_id)
118 {
119 	char notes[PATH_MAX];
120 	struct build_id bid;
121 	int ret;
122 
123 	if (!root_dir)
124 		root_dir = "";
125 
126 	scnprintf(notes, sizeof(notes), "%s/sys/kernel/notes", root_dir);
127 
128 	ret = sysfs__read_build_id(notes, &bid);
129 	if (ret < 0)
130 		return ret;
131 
132 	return build_id__sprintf(&bid, sbuild_id);
133 }
134 
filename__sprintf_build_id(const char * pathname,char * sbuild_id)135 int filename__sprintf_build_id(const char *pathname, char *sbuild_id)
136 {
137 	struct build_id bid;
138 	int ret;
139 
140 	ret = filename__read_build_id(pathname, &bid);
141 	if (ret < 0)
142 		return ret;
143 
144 	return build_id__sprintf(&bid, sbuild_id);
145 }
146 
147 /* asnprintf consolidates asprintf and snprintf */
asnprintf(char ** strp,size_t size,const char * fmt,...)148 static int asnprintf(char **strp, size_t size, const char *fmt, ...)
149 {
150 	va_list ap;
151 	int ret;
152 
153 	if (!strp)
154 		return -EINVAL;
155 
156 	va_start(ap, fmt);
157 	if (*strp)
158 		ret = vsnprintf(*strp, size, fmt, ap);
159 	else
160 		ret = vasprintf(strp, fmt, ap);
161 	va_end(ap);
162 
163 	return ret;
164 }
165 
build_id_cache__kallsyms_path(const char * sbuild_id,char * bf,size_t size)166 char *build_id_cache__kallsyms_path(const char *sbuild_id, char *bf,
167 				    size_t size)
168 {
169 	bool retry_old = true;
170 
171 	snprintf(bf, size, "%s/%s/%s/kallsyms",
172 		 buildid_dir, DSO__NAME_KALLSYMS, sbuild_id);
173 retry:
174 	if (!access(bf, F_OK))
175 		return bf;
176 	if (retry_old) {
177 		/* Try old style kallsyms cache */
178 		snprintf(bf, size, "%s/%s/%s",
179 			 buildid_dir, DSO__NAME_KALLSYMS, sbuild_id);
180 		retry_old = false;
181 		goto retry;
182 	}
183 
184 	return NULL;
185 }
186 
build_id_cache__linkname(const char * sbuild_id,char * bf,size_t size)187 char *build_id_cache__linkname(const char *sbuild_id, char *bf, size_t size)
188 {
189 	char *tmp = bf;
190 	int ret = asnprintf(&bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
191 			    sbuild_id, sbuild_id + 2);
192 	if (ret < 0 || (tmp && size < (unsigned int)ret))
193 		return NULL;
194 	return bf;
195 }
196 
197 /* The caller is responsible to free the returned buffer. */
build_id_cache__origname(const char * sbuild_id)198 char *build_id_cache__origname(const char *sbuild_id)
199 {
200 	char *linkname;
201 	char buf[PATH_MAX];
202 	char *ret = NULL, *p;
203 	size_t offs = 5;	/* == strlen("../..") */
204 	ssize_t len;
205 
206 	linkname = build_id_cache__linkname(sbuild_id, NULL, 0);
207 	if (!linkname)
208 		return NULL;
209 
210 	len = readlink(linkname, buf, sizeof(buf) - 1);
211 	if (len <= 0)
212 		goto out;
213 	buf[len] = '\0';
214 
215 	/* The link should be "../..<origpath>/<sbuild_id>" */
216 	p = strrchr(buf, '/');	/* Cut off the "/<sbuild_id>" */
217 	if (p && (p > buf + offs)) {
218 		*p = '\0';
219 		if (buf[offs + 1] == '[')
220 			offs++;	/*
221 				 * This is a DSO name, like [kernel.kallsyms].
222 				 * Skip the first '/', since this is not the
223 				 * cache of a regular file.
224 				 */
225 		ret = strdup(buf + offs);	/* Skip "../..[/]" */
226 	}
227 out:
228 	free(linkname);
229 	return ret;
230 }
231 
232 /* Check if the given build_id cache is valid on current running system */
build_id_cache__valid_id(char * sbuild_id)233 static bool build_id_cache__valid_id(char *sbuild_id)
234 {
235 	char real_sbuild_id[SBUILD_ID_SIZE] = "";
236 	char *pathname;
237 	int ret = 0;
238 	bool result = false;
239 
240 	pathname = build_id_cache__origname(sbuild_id);
241 	if (!pathname)
242 		return false;
243 
244 	if (!strcmp(pathname, DSO__NAME_KALLSYMS))
245 		ret = sysfs__sprintf_build_id("/", real_sbuild_id);
246 	else if (pathname[0] == '/')
247 		ret = filename__sprintf_build_id(pathname, real_sbuild_id);
248 	else
249 		ret = -EINVAL;	/* Should we support other special DSO cache? */
250 	if (ret >= 0)
251 		result = (strcmp(sbuild_id, real_sbuild_id) == 0);
252 	free(pathname);
253 
254 	return result;
255 }
256 
build_id_cache__basename(bool is_kallsyms,bool is_vdso,bool is_debug)257 static const char *build_id_cache__basename(bool is_kallsyms, bool is_vdso,
258 					    bool is_debug)
259 {
260 	return is_kallsyms ? "kallsyms" : (is_vdso ? "vdso" : (is_debug ?
261 	    "debug" : "elf"));
262 }
263 
__dso__build_id_filename(const struct dso * dso,char * bf,size_t size,bool is_debug,bool is_kallsyms)264 char *__dso__build_id_filename(const struct dso *dso, char *bf, size_t size,
265 			       bool is_debug, bool is_kallsyms)
266 {
267 	bool is_vdso = dso__is_vdso((struct dso *)dso);
268 	char sbuild_id[SBUILD_ID_SIZE];
269 	char *linkname;
270 	bool alloc = (bf == NULL);
271 	int ret;
272 
273 	if (!dso->has_build_id)
274 		return NULL;
275 
276 	build_id__sprintf(&dso->bid, sbuild_id);
277 	linkname = build_id_cache__linkname(sbuild_id, NULL, 0);
278 	if (!linkname)
279 		return NULL;
280 
281 	/* Check if old style build_id cache */
282 	if (is_regular_file(linkname))
283 		ret = asnprintf(&bf, size, "%s", linkname);
284 	else
285 		ret = asnprintf(&bf, size, "%s/%s", linkname,
286 			 build_id_cache__basename(is_kallsyms, is_vdso,
287 						  is_debug));
288 	if (ret < 0 || (!alloc && size < (unsigned int)ret))
289 		bf = NULL;
290 	free(linkname);
291 
292 	return bf;
293 }
294 
dso__build_id_filename(const struct dso * dso,char * bf,size_t size,bool is_debug)295 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size,
296 			     bool is_debug)
297 {
298 	bool is_kallsyms = dso__is_kallsyms((struct dso *)dso);
299 
300 	return __dso__build_id_filename(dso, bf, size, is_debug, is_kallsyms);
301 }
302 
303 #define dsos__for_each_with_build_id(pos, head)	\
304 	list_for_each_entry(pos, head, node)	\
305 		if (!pos->has_build_id)		\
306 			continue;		\
307 		else
308 
write_buildid(const char * name,size_t name_len,struct build_id * bid,pid_t pid,u16 misc,struct feat_fd * fd)309 static int write_buildid(const char *name, size_t name_len, struct build_id *bid,
310 			 pid_t pid, u16 misc, struct feat_fd *fd)
311 {
312 	int err;
313 	struct perf_record_header_build_id b;
314 	size_t len;
315 
316 	len = name_len + 1;
317 	len = PERF_ALIGN(len, NAME_ALIGN);
318 
319 	memset(&b, 0, sizeof(b));
320 	memcpy(&b.data, bid->data, bid->size);
321 	b.size = (u8) bid->size;
322 	misc |= PERF_RECORD_MISC_BUILD_ID_SIZE;
323 	b.pid = pid;
324 	b.header.misc = misc;
325 	b.header.size = sizeof(b) + len;
326 
327 	err = do_write(fd, &b, sizeof(b));
328 	if (err < 0)
329 		return err;
330 
331 	return write_padded(fd, name, name_len + 1, len);
332 }
333 
machine__write_buildid_table(struct machine * machine,struct feat_fd * fd)334 static int machine__write_buildid_table(struct machine *machine,
335 					struct feat_fd *fd)
336 {
337 	int err = 0;
338 	struct dso *pos;
339 	u16 kmisc = PERF_RECORD_MISC_KERNEL,
340 	    umisc = PERF_RECORD_MISC_USER;
341 
342 	if (!machine__is_host(machine)) {
343 		kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
344 		umisc = PERF_RECORD_MISC_GUEST_USER;
345 	}
346 
347 	dsos__for_each_with_build_id(pos, &machine->dsos.head) {
348 		const char *name;
349 		size_t name_len;
350 		bool in_kernel = false;
351 
352 		if (!pos->hit && !dso__is_vdso(pos))
353 			continue;
354 
355 		if (dso__is_vdso(pos)) {
356 			name = pos->short_name;
357 			name_len = pos->short_name_len;
358 		} else if (dso__is_kcore(pos)) {
359 			name = machine->mmap_name;
360 			name_len = strlen(name);
361 		} else {
362 			name = pos->long_name;
363 			name_len = pos->long_name_len;
364 		}
365 
366 		in_kernel = pos->kernel ||
367 				is_kernel_module(name,
368 					PERF_RECORD_MISC_CPUMODE_UNKNOWN);
369 		err = write_buildid(name, name_len, &pos->bid, machine->pid,
370 				    in_kernel ? kmisc : umisc, fd);
371 		if (err)
372 			break;
373 	}
374 
375 	return err;
376 }
377 
perf_session__write_buildid_table(struct perf_session * session,struct feat_fd * fd)378 int perf_session__write_buildid_table(struct perf_session *session,
379 				      struct feat_fd *fd)
380 {
381 	struct rb_node *nd;
382 	int err = machine__write_buildid_table(&session->machines.host, fd);
383 
384 	if (err)
385 		return err;
386 
387 	for (nd = rb_first_cached(&session->machines.guests); nd;
388 	     nd = rb_next(nd)) {
389 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
390 		err = machine__write_buildid_table(pos, fd);
391 		if (err)
392 			break;
393 	}
394 	return err;
395 }
396 
__dsos__hit_all(struct list_head * head)397 static int __dsos__hit_all(struct list_head *head)
398 {
399 	struct dso *pos;
400 
401 	list_for_each_entry(pos, head, node)
402 		pos->hit = true;
403 
404 	return 0;
405 }
406 
machine__hit_all_dsos(struct machine * machine)407 static int machine__hit_all_dsos(struct machine *machine)
408 {
409 	return __dsos__hit_all(&machine->dsos.head);
410 }
411 
dsos__hit_all(struct perf_session * session)412 int dsos__hit_all(struct perf_session *session)
413 {
414 	struct rb_node *nd;
415 	int err;
416 
417 	err = machine__hit_all_dsos(&session->machines.host);
418 	if (err)
419 		return err;
420 
421 	for (nd = rb_first_cached(&session->machines.guests); nd;
422 	     nd = rb_next(nd)) {
423 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
424 
425 		err = machine__hit_all_dsos(pos);
426 		if (err)
427 			return err;
428 	}
429 
430 	return 0;
431 }
432 
disable_buildid_cache(void)433 void disable_buildid_cache(void)
434 {
435 	no_buildid_cache = true;
436 }
437 
lsdir_bid_head_filter(const char * name __maybe_unused,struct dirent * d)438 static bool lsdir_bid_head_filter(const char *name __maybe_unused,
439 				  struct dirent *d)
440 {
441 	return (strlen(d->d_name) == 2) &&
442 		isxdigit(d->d_name[0]) && isxdigit(d->d_name[1]);
443 }
444 
lsdir_bid_tail_filter(const char * name __maybe_unused,struct dirent * d)445 static bool lsdir_bid_tail_filter(const char *name __maybe_unused,
446 				  struct dirent *d)
447 {
448 	int i = 0;
449 	while (isxdigit(d->d_name[i]) && i < SBUILD_ID_SIZE - 3)
450 		i++;
451 	return (i >= SBUILD_ID_MIN_SIZE - 3) && (i <= SBUILD_ID_SIZE - 3) &&
452 		(d->d_name[i] == '\0');
453 }
454 
build_id_cache__list_all(bool validonly)455 struct strlist *build_id_cache__list_all(bool validonly)
456 {
457 	struct strlist *toplist, *linklist = NULL, *bidlist;
458 	struct str_node *nd, *nd2;
459 	char *topdir, *linkdir = NULL;
460 	char sbuild_id[SBUILD_ID_SIZE];
461 
462 	/* for filename__ functions */
463 	if (validonly)
464 		symbol__init(NULL);
465 
466 	/* Open the top-level directory */
467 	if (asprintf(&topdir, "%s/.build-id/", buildid_dir) < 0)
468 		return NULL;
469 
470 	bidlist = strlist__new(NULL, NULL);
471 	if (!bidlist)
472 		goto out;
473 
474 	toplist = lsdir(topdir, lsdir_bid_head_filter);
475 	if (!toplist) {
476 		pr_debug("Error in lsdir(%s): %d\n", topdir, errno);
477 		/* If there is no buildid cache, return an empty list */
478 		if (errno == ENOENT)
479 			goto out;
480 		goto err_out;
481 	}
482 
483 	strlist__for_each_entry(nd, toplist) {
484 		if (asprintf(&linkdir, "%s/%s", topdir, nd->s) < 0)
485 			goto err_out;
486 		/* Open the lower-level directory */
487 		linklist = lsdir(linkdir, lsdir_bid_tail_filter);
488 		if (!linklist) {
489 			pr_debug("Error in lsdir(%s): %d\n", linkdir, errno);
490 			goto err_out;
491 		}
492 		strlist__for_each_entry(nd2, linklist) {
493 			if (snprintf(sbuild_id, SBUILD_ID_SIZE, "%s%s",
494 				     nd->s, nd2->s) > SBUILD_ID_SIZE - 1)
495 				goto err_out;
496 			if (validonly && !build_id_cache__valid_id(sbuild_id))
497 				continue;
498 			if (strlist__add(bidlist, sbuild_id) < 0)
499 				goto err_out;
500 		}
501 		strlist__delete(linklist);
502 		zfree(&linkdir);
503 	}
504 
505 out_free:
506 	strlist__delete(toplist);
507 out:
508 	free(topdir);
509 
510 	return bidlist;
511 
512 err_out:
513 	strlist__delete(linklist);
514 	zfree(&linkdir);
515 	strlist__delete(bidlist);
516 	bidlist = NULL;
517 	goto out_free;
518 }
519 
str_is_build_id(const char * maybe_sbuild_id,size_t len)520 static bool str_is_build_id(const char *maybe_sbuild_id, size_t len)
521 {
522 	size_t i;
523 
524 	for (i = 0; i < len; i++) {
525 		if (!isxdigit(maybe_sbuild_id[i]))
526 			return false;
527 	}
528 	return true;
529 }
530 
531 /* Return the valid complete build-id */
build_id_cache__complement(const char * incomplete_sbuild_id)532 char *build_id_cache__complement(const char *incomplete_sbuild_id)
533 {
534 	struct strlist *bidlist;
535 	struct str_node *nd, *cand = NULL;
536 	char *sbuild_id = NULL;
537 	size_t len = strlen(incomplete_sbuild_id);
538 
539 	if (len >= SBUILD_ID_SIZE ||
540 	    !str_is_build_id(incomplete_sbuild_id, len))
541 		return NULL;
542 
543 	bidlist = build_id_cache__list_all(true);
544 	if (!bidlist)
545 		return NULL;
546 
547 	strlist__for_each_entry(nd, bidlist) {
548 		if (strncmp(nd->s, incomplete_sbuild_id, len) != 0)
549 			continue;
550 		if (cand) {	/* Error: There are more than 2 candidates. */
551 			cand = NULL;
552 			break;
553 		}
554 		cand = nd;
555 	}
556 	if (cand)
557 		sbuild_id = strdup(cand->s);
558 	strlist__delete(bidlist);
559 
560 	return sbuild_id;
561 }
562 
build_id_cache__cachedir(const char * sbuild_id,const char * name,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso)563 char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
564 			       struct nsinfo *nsi, bool is_kallsyms,
565 			       bool is_vdso)
566 {
567 	char *realname = (char *)name, *filename;
568 	bool slash = is_kallsyms || is_vdso;
569 
570 	if (!slash) {
571 		realname = nsinfo__realpath(name, nsi);
572 		if (!realname)
573 			return NULL;
574 	}
575 
576 	if (asprintf(&filename, "%s%s%s%s%s", buildid_dir, slash ? "/" : "",
577 		     is_vdso ? DSO__NAME_VDSO : realname,
578 		     sbuild_id ? "/" : "", sbuild_id ?: "") < 0)
579 		filename = NULL;
580 
581 	if (!slash)
582 		free(realname);
583 
584 	return filename;
585 }
586 
build_id_cache__list_build_ids(const char * pathname,struct nsinfo * nsi,struct strlist ** result)587 int build_id_cache__list_build_ids(const char *pathname, struct nsinfo *nsi,
588 				   struct strlist **result)
589 {
590 	char *dir_name;
591 	int ret = 0;
592 
593 	dir_name = build_id_cache__cachedir(NULL, pathname, nsi, false, false);
594 	if (!dir_name)
595 		return -ENOMEM;
596 
597 	*result = lsdir(dir_name, lsdir_no_dot_filter);
598 	if (!*result)
599 		ret = -errno;
600 	free(dir_name);
601 
602 	return ret;
603 }
604 
605 #if defined(HAVE_LIBELF_SUPPORT) && defined(HAVE_GELF_GETNOTE_SUPPORT)
build_id_cache__add_sdt_cache(const char * sbuild_id,const char * realname,struct nsinfo * nsi)606 static int build_id_cache__add_sdt_cache(const char *sbuild_id,
607 					  const char *realname,
608 					  struct nsinfo *nsi)
609 {
610 	struct probe_cache *cache;
611 	int ret;
612 	struct nscookie nsc;
613 
614 	cache = probe_cache__new(sbuild_id, nsi);
615 	if (!cache)
616 		return -1;
617 
618 	nsinfo__mountns_enter(nsi, &nsc);
619 	ret = probe_cache__scan_sdt(cache, realname);
620 	nsinfo__mountns_exit(&nsc);
621 	if (ret >= 0) {
622 		pr_debug4("Found %d SDTs in %s\n", ret, realname);
623 		if (probe_cache__commit(cache) < 0)
624 			ret = -1;
625 	}
626 	probe_cache__delete(cache);
627 	return ret;
628 }
629 #else
630 #define build_id_cache__add_sdt_cache(sbuild_id, realname, nsi) (0)
631 #endif
632 
build_id_cache__find_debug(const char * sbuild_id,struct nsinfo * nsi)633 static char *build_id_cache__find_debug(const char *sbuild_id,
634 					struct nsinfo *nsi)
635 {
636 	char *realname = NULL;
637 	char *debugfile;
638 	struct nscookie nsc;
639 	size_t len = 0;
640 
641 	debugfile = calloc(1, PATH_MAX);
642 	if (!debugfile)
643 		goto out;
644 
645 	len = __symbol__join_symfs(debugfile, PATH_MAX,
646 				   "/usr/lib/debug/.build-id/");
647 	snprintf(debugfile + len, PATH_MAX - len, "%.2s/%s.debug", sbuild_id,
648 		 sbuild_id + 2);
649 
650 	nsinfo__mountns_enter(nsi, &nsc);
651 	realname = realpath(debugfile, NULL);
652 	if (realname && access(realname, R_OK))
653 		zfree(&realname);
654 	nsinfo__mountns_exit(&nsc);
655 
656 #ifdef HAVE_DEBUGINFOD_SUPPORT
657         if (realname == NULL) {
658                 debuginfod_client* c = debuginfod_begin();
659                 if (c != NULL) {
660                         int fd = debuginfod_find_debuginfo(c,
661                                                            (const unsigned char*)sbuild_id, 0,
662                                                            &realname);
663                         if (fd >= 0)
664                                 close(fd); /* retaining reference by realname */
665                         debuginfod_end(c);
666                 }
667         }
668 #endif
669 
670 out:
671 	free(debugfile);
672 	return realname;
673 }
674 
675 int
build_id_cache__add(const char * sbuild_id,const char * name,const char * realname,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso)676 build_id_cache__add(const char *sbuild_id, const char *name, const char *realname,
677 		    struct nsinfo *nsi, bool is_kallsyms, bool is_vdso)
678 {
679 	const size_t size = PATH_MAX;
680 	char *filename = NULL, *dir_name = NULL, *linkname = zalloc(size), *tmp;
681 	char *debugfile = NULL;
682 	int err = -1;
683 
684 	dir_name = build_id_cache__cachedir(sbuild_id, name, nsi, is_kallsyms,
685 					    is_vdso);
686 	if (!dir_name)
687 		goto out_free;
688 
689 	/* Remove old style build-id cache */
690 	if (is_regular_file(dir_name))
691 		if (unlink(dir_name))
692 			goto out_free;
693 
694 	if (mkdir_p(dir_name, 0755))
695 		goto out_free;
696 
697 	/* Save the allocated buildid dirname */
698 	if (asprintf(&filename, "%s/%s", dir_name,
699 		     build_id_cache__basename(is_kallsyms, is_vdso,
700 		     false)) < 0) {
701 		filename = NULL;
702 		goto out_free;
703 	}
704 
705 	if (access(filename, F_OK)) {
706 		if (is_kallsyms) {
707 			if (copyfile("/proc/kallsyms", filename))
708 				goto out_free;
709 		} else if (nsi && nsinfo__need_setns(nsi)) {
710 			if (copyfile_ns(name, filename, nsi))
711 				goto out_free;
712 		} else if (link(realname, filename) && errno != EEXIST &&
713 				copyfile(name, filename))
714 			goto out_free;
715 	}
716 
717 	/* Some binaries are stripped, but have .debug files with their symbol
718 	 * table.  Check to see if we can locate one of those, since the elf
719 	 * file itself may not be very useful to users of our tools without a
720 	 * symtab.
721 	 */
722 	if (!is_kallsyms && !is_vdso &&
723 	    strncmp(".ko", name + strlen(name) - 3, 3)) {
724 		debugfile = build_id_cache__find_debug(sbuild_id, nsi);
725 		if (debugfile) {
726 			zfree(&filename);
727 			if (asprintf(&filename, "%s/%s", dir_name,
728 			    build_id_cache__basename(false, false, true)) < 0) {
729 				filename = NULL;
730 				goto out_free;
731 			}
732 			if (access(filename, F_OK)) {
733 				if (nsi && nsinfo__need_setns(nsi)) {
734 					if (copyfile_ns(debugfile, filename,
735 							nsi))
736 						goto out_free;
737 				} else if (link(debugfile, filename) &&
738 						errno != EEXIST &&
739 						copyfile(debugfile, filename))
740 					goto out_free;
741 			}
742 		}
743 	}
744 
745 	if (!build_id_cache__linkname(sbuild_id, linkname, size))
746 		goto out_free;
747 	tmp = strrchr(linkname, '/');
748 	*tmp = '\0';
749 
750 	if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
751 		goto out_free;
752 
753 	*tmp = '/';
754 	tmp = dir_name + strlen(buildid_dir) - 5;
755 	memcpy(tmp, "../..", 5);
756 
757 	if (symlink(tmp, linkname) == 0) {
758 		err = 0;
759 	} else if (errno == EEXIST) {
760 		char path[PATH_MAX];
761 		ssize_t len;
762 
763 		len = readlink(linkname, path, sizeof(path) - 1);
764 		if (len <= 0) {
765 			pr_err("Can't read link: %s\n", linkname);
766 			goto out_free;
767 		}
768 		path[len] = '\0';
769 
770 		if (strcmp(tmp, path)) {
771 			pr_debug("build <%s> already linked to %s\n",
772 				 sbuild_id, linkname);
773 		}
774 		err = 0;
775 	}
776 
777 	/* Update SDT cache : error is just warned */
778 	if (realname &&
779 	    build_id_cache__add_sdt_cache(sbuild_id, realname, nsi) < 0)
780 		pr_debug4("Failed to update/scan SDT cache for %s\n", realname);
781 
782 out_free:
783 	free(filename);
784 	free(debugfile);
785 	free(dir_name);
786 	free(linkname);
787 	return err;
788 }
789 
build_id_cache__add_s(const char * sbuild_id,const char * name,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso)790 int build_id_cache__add_s(const char *sbuild_id, const char *name,
791 			  struct nsinfo *nsi, bool is_kallsyms, bool is_vdso)
792 {
793 	char *realname = NULL;
794 	int err = -1;
795 
796 	if (!is_kallsyms) {
797 		if (!is_vdso)
798 			realname = nsinfo__realpath(name, nsi);
799 		else
800 			realname = realpath(name, NULL);
801 		if (!realname)
802 			goto out_free;
803 	}
804 
805 	err = build_id_cache__add(sbuild_id, name, realname, nsi, is_kallsyms, is_vdso);
806 
807 out_free:
808 	if (!is_kallsyms)
809 		free(realname);
810 	return err;
811 }
812 
build_id_cache__add_b(const struct build_id * bid,const char * name,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso)813 static int build_id_cache__add_b(const struct build_id *bid,
814 				 const char *name, struct nsinfo *nsi,
815 				 bool is_kallsyms, bool is_vdso)
816 {
817 	char sbuild_id[SBUILD_ID_SIZE];
818 
819 	build_id__sprintf(bid, sbuild_id);
820 
821 	return build_id_cache__add_s(sbuild_id, name, nsi, is_kallsyms,
822 				     is_vdso);
823 }
824 
build_id_cache__cached(const char * sbuild_id)825 bool build_id_cache__cached(const char *sbuild_id)
826 {
827 	bool ret = false;
828 	char *filename = build_id_cache__linkname(sbuild_id, NULL, 0);
829 
830 	if (filename && !access(filename, F_OK))
831 		ret = true;
832 	free(filename);
833 
834 	return ret;
835 }
836 
build_id_cache__remove_s(const char * sbuild_id)837 int build_id_cache__remove_s(const char *sbuild_id)
838 {
839 	const size_t size = PATH_MAX;
840 	char *filename = zalloc(size),
841 	     *linkname = zalloc(size), *tmp;
842 	int err = -1;
843 
844 	if (filename == NULL || linkname == NULL)
845 		goto out_free;
846 
847 	if (!build_id_cache__linkname(sbuild_id, linkname, size))
848 		goto out_free;
849 
850 	if (access(linkname, F_OK))
851 		goto out_free;
852 
853 	if (readlink(linkname, filename, size - 1) < 0)
854 		goto out_free;
855 
856 	if (unlink(linkname))
857 		goto out_free;
858 
859 	/*
860 	 * Since the link is relative, we must make it absolute:
861 	 */
862 	tmp = strrchr(linkname, '/') + 1;
863 	snprintf(tmp, size - (tmp - linkname), "%s", filename);
864 
865 	if (rm_rf(linkname))
866 		goto out_free;
867 
868 	err = 0;
869 out_free:
870 	free(filename);
871 	free(linkname);
872 	return err;
873 }
874 
filename__read_build_id_ns(const char * filename,struct build_id * bid,struct nsinfo * nsi)875 static int filename__read_build_id_ns(const char *filename,
876 				      struct build_id *bid,
877 				      struct nsinfo *nsi)
878 {
879 	struct nscookie nsc;
880 	int ret;
881 
882 	nsinfo__mountns_enter(nsi, &nsc);
883 	ret = filename__read_build_id(filename, bid);
884 	nsinfo__mountns_exit(&nsc);
885 
886 	return ret;
887 }
888 
dso__build_id_mismatch(struct dso * dso,const char * name)889 static bool dso__build_id_mismatch(struct dso *dso, const char *name)
890 {
891 	struct build_id bid;
892 
893 	if (filename__read_build_id_ns(name, &bid, dso->nsinfo) < 0)
894 		return false;
895 
896 	return !dso__build_id_equal(dso, &bid);
897 }
898 
dso__cache_build_id(struct dso * dso,struct machine * machine,void * priv __maybe_unused)899 static int dso__cache_build_id(struct dso *dso, struct machine *machine,
900 			       void *priv __maybe_unused)
901 {
902 	bool is_kallsyms = dso__is_kallsyms(dso);
903 	bool is_vdso = dso__is_vdso(dso);
904 	const char *name = dso->long_name;
905 
906 	if (!dso->has_build_id)
907 		return 0;
908 
909 	if (dso__is_kcore(dso)) {
910 		is_kallsyms = true;
911 		name = machine->mmap_name;
912 	}
913 
914 	if (!is_kallsyms && dso__build_id_mismatch(dso, name))
915 		return 0;
916 
917 	return build_id_cache__add_b(&dso->bid, name, dso->nsinfo,
918 				     is_kallsyms, is_vdso);
919 }
920 
921 static int
machines__for_each_dso(struct machines * machines,machine__dso_t fn,void * priv)922 machines__for_each_dso(struct machines *machines, machine__dso_t fn, void *priv)
923 {
924 	int ret = machine__for_each_dso(&machines->host, fn, priv);
925 	struct rb_node *nd;
926 
927 	for (nd = rb_first_cached(&machines->guests); nd;
928 	     nd = rb_next(nd)) {
929 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
930 
931 		ret |= machine__for_each_dso(pos, fn, priv);
932 	}
933 	return ret ? -1 : 0;
934 }
935 
__perf_session__cache_build_ids(struct perf_session * session,machine__dso_t fn,void * priv)936 int __perf_session__cache_build_ids(struct perf_session *session,
937 				    machine__dso_t fn, void *priv)
938 {
939 	if (no_buildid_cache)
940 		return 0;
941 
942 	if (mkdir(buildid_dir, 0755) != 0 && errno != EEXIST)
943 		return -1;
944 
945 	return machines__for_each_dso(&session->machines, fn, priv) ?  -1 : 0;
946 }
947 
perf_session__cache_build_ids(struct perf_session * session)948 int perf_session__cache_build_ids(struct perf_session *session)
949 {
950 	return __perf_session__cache_build_ids(session, dso__cache_build_id, NULL);
951 }
952 
machine__read_build_ids(struct machine * machine,bool with_hits)953 static bool machine__read_build_ids(struct machine *machine, bool with_hits)
954 {
955 	return __dsos__read_build_ids(&machine->dsos.head, with_hits);
956 }
957 
perf_session__read_build_ids(struct perf_session * session,bool with_hits)958 bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
959 {
960 	struct rb_node *nd;
961 	bool ret = machine__read_build_ids(&session->machines.host, with_hits);
962 
963 	for (nd = rb_first_cached(&session->machines.guests); nd;
964 	     nd = rb_next(nd)) {
965 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
966 		ret |= machine__read_build_ids(pos, with_hits);
967 	}
968 
969 	return ret;
970 }
971 
build_id__init(struct build_id * bid,const u8 * data,size_t size)972 void build_id__init(struct build_id *bid, const u8 *data, size_t size)
973 {
974 	WARN_ON(size > BUILD_ID_SIZE);
975 	memcpy(bid->data, data, size);
976 	bid->size = size;
977 }
978 
build_id__is_defined(const struct build_id * bid)979 bool build_id__is_defined(const struct build_id *bid)
980 {
981 	return bid && bid->size ? !!memchr_inv(bid->data, 0, bid->size) : false;
982 }
983