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 
write_buildid(const char * name,size_t name_len,struct build_id * bid,pid_t pid,u16 misc,struct feat_fd * fd)303 static int write_buildid(const char *name, size_t name_len, struct build_id *bid,
304 			 pid_t pid, u16 misc, struct feat_fd *fd)
305 {
306 	int err;
307 	struct perf_record_header_build_id b;
308 	size_t len;
309 
310 	len = name_len + 1;
311 	len = PERF_ALIGN(len, NAME_ALIGN);
312 
313 	memset(&b, 0, sizeof(b));
314 	memcpy(&b.data, bid->data, bid->size);
315 	b.size = (u8) bid->size;
316 	misc |= PERF_RECORD_MISC_BUILD_ID_SIZE;
317 	b.pid = pid;
318 	b.header.misc = misc;
319 	b.header.size = sizeof(b) + len;
320 
321 	err = do_write(fd, &b, sizeof(b));
322 	if (err < 0)
323 		return err;
324 
325 	return write_padded(fd, name, name_len + 1, len);
326 }
327 
machine__write_buildid_table(struct machine * machine,struct feat_fd * fd)328 static int machine__write_buildid_table(struct machine *machine,
329 					struct feat_fd *fd)
330 {
331 	int err = 0;
332 	struct dso *pos;
333 	u16 kmisc = PERF_RECORD_MISC_KERNEL,
334 	    umisc = PERF_RECORD_MISC_USER;
335 
336 	if (!machine__is_host(machine)) {
337 		kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
338 		umisc = PERF_RECORD_MISC_GUEST_USER;
339 	}
340 
341 	dsos__for_each_with_build_id(pos, &machine->dsos.head) {
342 		const char *name;
343 		size_t name_len;
344 		bool in_kernel = false;
345 
346 		if (!pos->hit && !dso__is_vdso(pos))
347 			continue;
348 
349 		if (dso__is_vdso(pos)) {
350 			name = pos->short_name;
351 			name_len = pos->short_name_len;
352 		} else if (dso__is_kcore(pos)) {
353 			name = machine->mmap_name;
354 			name_len = strlen(name);
355 		} else {
356 			name = pos->long_name;
357 			name_len = pos->long_name_len;
358 		}
359 
360 		in_kernel = pos->kernel ||
361 				is_kernel_module(name,
362 					PERF_RECORD_MISC_CPUMODE_UNKNOWN);
363 		err = write_buildid(name, name_len, &pos->bid, machine->pid,
364 				    in_kernel ? kmisc : umisc, fd);
365 		if (err)
366 			break;
367 	}
368 
369 	return err;
370 }
371 
perf_session__write_buildid_table(struct perf_session * session,struct feat_fd * fd)372 int perf_session__write_buildid_table(struct perf_session *session,
373 				      struct feat_fd *fd)
374 {
375 	struct rb_node *nd;
376 	int err = machine__write_buildid_table(&session->machines.host, fd);
377 
378 	if (err)
379 		return err;
380 
381 	for (nd = rb_first_cached(&session->machines.guests); nd;
382 	     nd = rb_next(nd)) {
383 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
384 		err = machine__write_buildid_table(pos, fd);
385 		if (err)
386 			break;
387 	}
388 	return err;
389 }
390 
__dsos__hit_all(struct list_head * head)391 static int __dsos__hit_all(struct list_head *head)
392 {
393 	struct dso *pos;
394 
395 	list_for_each_entry(pos, head, node)
396 		pos->hit = true;
397 
398 	return 0;
399 }
400 
machine__hit_all_dsos(struct machine * machine)401 static int machine__hit_all_dsos(struct machine *machine)
402 {
403 	return __dsos__hit_all(&machine->dsos.head);
404 }
405 
dsos__hit_all(struct perf_session * session)406 int dsos__hit_all(struct perf_session *session)
407 {
408 	struct rb_node *nd;
409 	int err;
410 
411 	err = machine__hit_all_dsos(&session->machines.host);
412 	if (err)
413 		return err;
414 
415 	for (nd = rb_first_cached(&session->machines.guests); nd;
416 	     nd = rb_next(nd)) {
417 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
418 
419 		err = machine__hit_all_dsos(pos);
420 		if (err)
421 			return err;
422 	}
423 
424 	return 0;
425 }
426 
disable_buildid_cache(void)427 void disable_buildid_cache(void)
428 {
429 	no_buildid_cache = true;
430 }
431 
lsdir_bid_head_filter(const char * name __maybe_unused,struct dirent * d)432 static bool lsdir_bid_head_filter(const char *name __maybe_unused,
433 				  struct dirent *d)
434 {
435 	return (strlen(d->d_name) == 2) &&
436 		isxdigit(d->d_name[0]) && isxdigit(d->d_name[1]);
437 }
438 
lsdir_bid_tail_filter(const char * name __maybe_unused,struct dirent * d)439 static bool lsdir_bid_tail_filter(const char *name __maybe_unused,
440 				  struct dirent *d)
441 {
442 	int i = 0;
443 	while (isxdigit(d->d_name[i]) && i < SBUILD_ID_SIZE - 3)
444 		i++;
445 	return (i >= SBUILD_ID_MIN_SIZE - 3) && (i <= SBUILD_ID_SIZE - 3) &&
446 		(d->d_name[i] == '\0');
447 }
448 
build_id_cache__list_all(bool validonly)449 struct strlist *build_id_cache__list_all(bool validonly)
450 {
451 	struct strlist *toplist, *linklist = NULL, *bidlist;
452 	struct str_node *nd, *nd2;
453 	char *topdir, *linkdir = NULL;
454 	char sbuild_id[SBUILD_ID_SIZE];
455 
456 	/* for filename__ functions */
457 	if (validonly)
458 		symbol__init(NULL);
459 
460 	/* Open the top-level directory */
461 	if (asprintf(&topdir, "%s/.build-id/", buildid_dir) < 0)
462 		return NULL;
463 
464 	bidlist = strlist__new(NULL, NULL);
465 	if (!bidlist)
466 		goto out;
467 
468 	toplist = lsdir(topdir, lsdir_bid_head_filter);
469 	if (!toplist) {
470 		pr_debug("Error in lsdir(%s): %d\n", topdir, errno);
471 		/* If there is no buildid cache, return an empty list */
472 		if (errno == ENOENT)
473 			goto out;
474 		goto err_out;
475 	}
476 
477 	strlist__for_each_entry(nd, toplist) {
478 		if (asprintf(&linkdir, "%s/%s", topdir, nd->s) < 0)
479 			goto err_out;
480 		/* Open the lower-level directory */
481 		linklist = lsdir(linkdir, lsdir_bid_tail_filter);
482 		if (!linklist) {
483 			pr_debug("Error in lsdir(%s): %d\n", linkdir, errno);
484 			goto err_out;
485 		}
486 		strlist__for_each_entry(nd2, linklist) {
487 			if (snprintf(sbuild_id, SBUILD_ID_SIZE, "%s%s",
488 				     nd->s, nd2->s) > SBUILD_ID_SIZE - 1)
489 				goto err_out;
490 			if (validonly && !build_id_cache__valid_id(sbuild_id))
491 				continue;
492 			if (strlist__add(bidlist, sbuild_id) < 0)
493 				goto err_out;
494 		}
495 		strlist__delete(linklist);
496 		zfree(&linkdir);
497 	}
498 
499 out_free:
500 	strlist__delete(toplist);
501 out:
502 	free(topdir);
503 
504 	return bidlist;
505 
506 err_out:
507 	strlist__delete(linklist);
508 	zfree(&linkdir);
509 	strlist__delete(bidlist);
510 	bidlist = NULL;
511 	goto out_free;
512 }
513 
str_is_build_id(const char * maybe_sbuild_id,size_t len)514 static bool str_is_build_id(const char *maybe_sbuild_id, size_t len)
515 {
516 	size_t i;
517 
518 	for (i = 0; i < len; i++) {
519 		if (!isxdigit(maybe_sbuild_id[i]))
520 			return false;
521 	}
522 	return true;
523 }
524 
525 /* Return the valid complete build-id */
build_id_cache__complement(const char * incomplete_sbuild_id)526 char *build_id_cache__complement(const char *incomplete_sbuild_id)
527 {
528 	struct strlist *bidlist;
529 	struct str_node *nd, *cand = NULL;
530 	char *sbuild_id = NULL;
531 	size_t len = strlen(incomplete_sbuild_id);
532 
533 	if (len >= SBUILD_ID_SIZE ||
534 	    !str_is_build_id(incomplete_sbuild_id, len))
535 		return NULL;
536 
537 	bidlist = build_id_cache__list_all(true);
538 	if (!bidlist)
539 		return NULL;
540 
541 	strlist__for_each_entry(nd, bidlist) {
542 		if (strncmp(nd->s, incomplete_sbuild_id, len) != 0)
543 			continue;
544 		if (cand) {	/* Error: There are more than 2 candidates. */
545 			cand = NULL;
546 			break;
547 		}
548 		cand = nd;
549 	}
550 	if (cand)
551 		sbuild_id = strdup(cand->s);
552 	strlist__delete(bidlist);
553 
554 	return sbuild_id;
555 }
556 
build_id_cache__cachedir(const char * sbuild_id,const char * name,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso)557 char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
558 			       struct nsinfo *nsi, bool is_kallsyms,
559 			       bool is_vdso)
560 {
561 	char *realname = (char *)name, *filename;
562 	bool slash = is_kallsyms || is_vdso;
563 
564 	if (!slash)
565 		realname = nsinfo__realpath(name, nsi);
566 
567 	if (asprintf(&filename, "%s%s%s%s%s", buildid_dir, slash ? "/" : "",
568 		     is_vdso ? DSO__NAME_VDSO : (realname ? realname : name),
569 		     sbuild_id ? "/" : "", sbuild_id ?: "") < 0)
570 		filename = NULL;
571 
572 	if (!slash)
573 		free(realname);
574 
575 	return filename;
576 }
577 
build_id_cache__list_build_ids(const char * pathname,struct nsinfo * nsi,struct strlist ** result)578 int build_id_cache__list_build_ids(const char *pathname, struct nsinfo *nsi,
579 				   struct strlist **result)
580 {
581 	char *dir_name;
582 	int ret = 0;
583 
584 	dir_name = build_id_cache__cachedir(NULL, pathname, nsi, false, false);
585 	if (!dir_name)
586 		return -ENOMEM;
587 
588 	*result = lsdir(dir_name, lsdir_no_dot_filter);
589 	if (!*result)
590 		ret = -errno;
591 	free(dir_name);
592 
593 	return ret;
594 }
595 
596 #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)597 static int build_id_cache__add_sdt_cache(const char *sbuild_id,
598 					  const char *realname,
599 					  struct nsinfo *nsi)
600 {
601 	struct probe_cache *cache;
602 	int ret;
603 	struct nscookie nsc;
604 
605 	cache = probe_cache__new(sbuild_id, nsi);
606 	if (!cache)
607 		return -1;
608 
609 	nsinfo__mountns_enter(nsi, &nsc);
610 	ret = probe_cache__scan_sdt(cache, realname);
611 	nsinfo__mountns_exit(&nsc);
612 	if (ret >= 0) {
613 		pr_debug4("Found %d SDTs in %s\n", ret, realname);
614 		if (probe_cache__commit(cache) < 0)
615 			ret = -1;
616 	}
617 	probe_cache__delete(cache);
618 	return ret;
619 }
620 #else
621 #define build_id_cache__add_sdt_cache(sbuild_id, realname, nsi) (0)
622 #endif
623 
build_id_cache__find_debug(const char * sbuild_id,struct nsinfo * nsi,const char * root_dir)624 static char *build_id_cache__find_debug(const char *sbuild_id,
625 					struct nsinfo *nsi,
626 					const char *root_dir)
627 {
628 	const char *dirname = "/usr/lib/debug/.build-id/";
629 	char *realname = NULL;
630 	char dirbuf[PATH_MAX];
631 	char *debugfile;
632 	struct nscookie nsc;
633 	size_t len = 0;
634 
635 	debugfile = calloc(1, PATH_MAX);
636 	if (!debugfile)
637 		goto out;
638 
639 	if (root_dir) {
640 		path__join(dirbuf, PATH_MAX, root_dir, dirname);
641 		dirname = dirbuf;
642 	}
643 
644 	len = __symbol__join_symfs(debugfile, PATH_MAX, dirname);
645 	snprintf(debugfile + len, PATH_MAX - len, "%.2s/%s.debug", sbuild_id,
646 		 sbuild_id + 2);
647 
648 	nsinfo__mountns_enter(nsi, &nsc);
649 	realname = realpath(debugfile, NULL);
650 	if (realname && access(realname, R_OK))
651 		zfree(&realname);
652 	nsinfo__mountns_exit(&nsc);
653 
654 #ifdef HAVE_DEBUGINFOD_SUPPORT
655 	if (realname == NULL) {
656 		debuginfod_client* c;
657 
658 		pr_debug("Downloading debug info with build id %s\n", sbuild_id);
659 
660 		c = debuginfod_begin();
661 		if (c != NULL) {
662 			int fd = debuginfod_find_debuginfo(c,
663 					(const unsigned char*)sbuild_id, 0,
664 					&realname);
665 			if (fd >= 0)
666 				close(fd); /* retaining reference by realname */
667 			debuginfod_end(c);
668 		}
669 	}
670 #endif
671 
672 out:
673 	free(debugfile);
674 	return realname;
675 }
676 
677 int
build_id_cache__add(const char * sbuild_id,const char * name,const char * realname,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso,const char * proper_name,const char * root_dir)678 build_id_cache__add(const char *sbuild_id, const char *name, const char *realname,
679 		    struct nsinfo *nsi, bool is_kallsyms, bool is_vdso,
680 		    const char *proper_name, const char *root_dir)
681 {
682 	const size_t size = PATH_MAX;
683 	char *filename = NULL, *dir_name = NULL, *linkname = zalloc(size), *tmp;
684 	char *debugfile = NULL;
685 	int err = -1;
686 
687 	if (!proper_name)
688 		proper_name = name;
689 
690 	dir_name = build_id_cache__cachedir(sbuild_id, proper_name, nsi, is_kallsyms,
691 					    is_vdso);
692 	if (!dir_name)
693 		goto out_free;
694 
695 	/* Remove old style build-id cache */
696 	if (is_regular_file(dir_name))
697 		if (unlink(dir_name))
698 			goto out_free;
699 
700 	if (mkdir_p(dir_name, 0755))
701 		goto out_free;
702 
703 	/* Save the allocated buildid dirname */
704 	if (asprintf(&filename, "%s/%s", dir_name,
705 		     build_id_cache__basename(is_kallsyms, is_vdso,
706 		     false)) < 0) {
707 		filename = NULL;
708 		goto out_free;
709 	}
710 
711 	if (access(filename, F_OK)) {
712 		if (is_kallsyms) {
713 			if (copyfile("/proc/kallsyms", filename))
714 				goto out_free;
715 		} else if (nsi && nsinfo__need_setns(nsi)) {
716 			if (copyfile_ns(name, filename, nsi))
717 				goto out_free;
718 		} else if (link(realname, filename) && errno != EEXIST &&
719 				copyfile(name, filename))
720 			goto out_free;
721 	}
722 
723 	/* Some binaries are stripped, but have .debug files with their symbol
724 	 * table.  Check to see if we can locate one of those, since the elf
725 	 * file itself may not be very useful to users of our tools without a
726 	 * symtab.
727 	 */
728 	if (!is_kallsyms && !is_vdso &&
729 	    strncmp(".ko", name + strlen(name) - 3, 3)) {
730 		debugfile = build_id_cache__find_debug(sbuild_id, nsi, root_dir);
731 		if (debugfile) {
732 			zfree(&filename);
733 			if (asprintf(&filename, "%s/%s", dir_name,
734 			    build_id_cache__basename(false, false, true)) < 0) {
735 				filename = NULL;
736 				goto out_free;
737 			}
738 			if (access(filename, F_OK)) {
739 				if (nsi && nsinfo__need_setns(nsi)) {
740 					if (copyfile_ns(debugfile, filename,
741 							nsi))
742 						goto out_free;
743 				} else if (link(debugfile, filename) &&
744 						errno != EEXIST &&
745 						copyfile(debugfile, filename))
746 					goto out_free;
747 			}
748 		}
749 	}
750 
751 	if (!build_id_cache__linkname(sbuild_id, linkname, size))
752 		goto out_free;
753 	tmp = strrchr(linkname, '/');
754 	*tmp = '\0';
755 
756 	if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
757 		goto out_free;
758 
759 	*tmp = '/';
760 	tmp = dir_name + strlen(buildid_dir) - 5;
761 	memcpy(tmp, "../..", 5);
762 
763 	if (symlink(tmp, linkname) == 0) {
764 		err = 0;
765 	} else if (errno == EEXIST) {
766 		char path[PATH_MAX];
767 		ssize_t len;
768 
769 		len = readlink(linkname, path, sizeof(path) - 1);
770 		if (len <= 0) {
771 			pr_err("Can't read link: %s\n", linkname);
772 			goto out_free;
773 		}
774 		path[len] = '\0';
775 
776 		if (strcmp(tmp, path)) {
777 			pr_debug("build <%s> already linked to %s\n",
778 				 sbuild_id, linkname);
779 		}
780 		err = 0;
781 	}
782 
783 	/* Update SDT cache : error is just warned */
784 	if (realname &&
785 	    build_id_cache__add_sdt_cache(sbuild_id, realname, nsi) < 0)
786 		pr_debug4("Failed to update/scan SDT cache for %s\n", realname);
787 
788 out_free:
789 	free(filename);
790 	free(debugfile);
791 	free(dir_name);
792 	free(linkname);
793 	return err;
794 }
795 
__build_id_cache__add_s(const char * sbuild_id,const char * name,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso,const char * proper_name,const char * root_dir)796 int __build_id_cache__add_s(const char *sbuild_id, const char *name,
797 			    struct nsinfo *nsi, bool is_kallsyms, bool is_vdso,
798 			    const char *proper_name, const char *root_dir)
799 {
800 	char *realname = NULL;
801 	int err = -1;
802 
803 	if (!is_kallsyms) {
804 		if (!is_vdso)
805 			realname = nsinfo__realpath(name, nsi);
806 		else
807 			realname = realpath(name, NULL);
808 		if (!realname)
809 			goto out_free;
810 	}
811 
812 	err = build_id_cache__add(sbuild_id, name, realname, nsi,
813 				  is_kallsyms, is_vdso, proper_name, root_dir);
814 out_free:
815 	if (!is_kallsyms)
816 		free(realname);
817 	return err;
818 }
819 
build_id_cache__add_b(const struct build_id * bid,const char * name,struct nsinfo * nsi,bool is_kallsyms,bool is_vdso,const char * proper_name,const char * root_dir)820 static int build_id_cache__add_b(const struct build_id *bid,
821 				 const char *name, struct nsinfo *nsi,
822 				 bool is_kallsyms, bool is_vdso,
823 				 const char *proper_name,
824 				 const char *root_dir)
825 {
826 	char sbuild_id[SBUILD_ID_SIZE];
827 
828 	build_id__sprintf(bid, sbuild_id);
829 
830 	return __build_id_cache__add_s(sbuild_id, name, nsi, is_kallsyms,
831 				       is_vdso, proper_name, root_dir);
832 }
833 
build_id_cache__cached(const char * sbuild_id)834 bool build_id_cache__cached(const char *sbuild_id)
835 {
836 	bool ret = false;
837 	char *filename = build_id_cache__linkname(sbuild_id, NULL, 0);
838 
839 	if (filename && !access(filename, F_OK))
840 		ret = true;
841 	free(filename);
842 
843 	return ret;
844 }
845 
build_id_cache__remove_s(const char * sbuild_id)846 int build_id_cache__remove_s(const char *sbuild_id)
847 {
848 	const size_t size = PATH_MAX;
849 	char *filename = zalloc(size),
850 	     *linkname = zalloc(size), *tmp;
851 	int err = -1;
852 
853 	if (filename == NULL || linkname == NULL)
854 		goto out_free;
855 
856 	if (!build_id_cache__linkname(sbuild_id, linkname, size))
857 		goto out_free;
858 
859 	if (access(linkname, F_OK))
860 		goto out_free;
861 
862 	if (readlink(linkname, filename, size - 1) < 0)
863 		goto out_free;
864 
865 	if (unlink(linkname))
866 		goto out_free;
867 
868 	/*
869 	 * Since the link is relative, we must make it absolute:
870 	 */
871 	tmp = strrchr(linkname, '/') + 1;
872 	snprintf(tmp, size - (tmp - linkname), "%s", filename);
873 
874 	if (rm_rf(linkname))
875 		goto out_free;
876 
877 	err = 0;
878 out_free:
879 	free(filename);
880 	free(linkname);
881 	return err;
882 }
883 
filename__read_build_id_ns(const char * filename,struct build_id * bid,struct nsinfo * nsi)884 static int filename__read_build_id_ns(const char *filename,
885 				      struct build_id *bid,
886 				      struct nsinfo *nsi)
887 {
888 	struct nscookie nsc;
889 	int ret;
890 
891 	nsinfo__mountns_enter(nsi, &nsc);
892 	ret = filename__read_build_id(filename, bid);
893 	nsinfo__mountns_exit(&nsc);
894 
895 	return ret;
896 }
897 
dso__build_id_mismatch(struct dso * dso,const char * name)898 static bool dso__build_id_mismatch(struct dso *dso, const char *name)
899 {
900 	struct build_id bid;
901 	bool ret = false;
902 
903 	mutex_lock(&dso->lock);
904 	if (filename__read_build_id_ns(name, &bid, dso->nsinfo) >= 0)
905 		ret = !dso__build_id_equal(dso, &bid);
906 
907 	mutex_unlock(&dso->lock);
908 
909 	return ret;
910 }
911 
dso__cache_build_id(struct dso * dso,struct machine * machine,void * priv __maybe_unused)912 static int dso__cache_build_id(struct dso *dso, struct machine *machine,
913 			       void *priv __maybe_unused)
914 {
915 	bool is_kallsyms = dso__is_kallsyms(dso);
916 	bool is_vdso = dso__is_vdso(dso);
917 	const char *name = dso->long_name;
918 	const char *proper_name = NULL;
919 	const char *root_dir = NULL;
920 	char *allocated_name = NULL;
921 	int ret = 0;
922 
923 	if (!dso->has_build_id)
924 		return 0;
925 
926 	if (dso__is_kcore(dso)) {
927 		is_kallsyms = true;
928 		name = machine->mmap_name;
929 	}
930 
931 	if (!machine__is_host(machine)) {
932 		if (*machine->root_dir) {
933 			root_dir = machine->root_dir;
934 			ret = asprintf(&allocated_name, "%s/%s", root_dir, name);
935 			if (ret < 0)
936 				return ret;
937 			proper_name = name;
938 			name = allocated_name;
939 		} else if (is_kallsyms) {
940 			/* Cannot get guest kallsyms */
941 			return 0;
942 		}
943 	}
944 
945 	if (!is_kallsyms && dso__build_id_mismatch(dso, name))
946 		goto out_free;
947 
948 	mutex_lock(&dso->lock);
949 	ret = build_id_cache__add_b(&dso->bid, name, dso->nsinfo,
950 				    is_kallsyms, is_vdso, proper_name, root_dir);
951 	mutex_unlock(&dso->lock);
952 out_free:
953 	free(allocated_name);
954 	return ret;
955 }
956 
957 static int
machines__for_each_dso(struct machines * machines,machine__dso_t fn,void * priv)958 machines__for_each_dso(struct machines *machines, machine__dso_t fn, void *priv)
959 {
960 	int ret = machine__for_each_dso(&machines->host, fn, priv);
961 	struct rb_node *nd;
962 
963 	for (nd = rb_first_cached(&machines->guests); nd;
964 	     nd = rb_next(nd)) {
965 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
966 
967 		ret |= machine__for_each_dso(pos, fn, priv);
968 	}
969 	return ret ? -1 : 0;
970 }
971 
__perf_session__cache_build_ids(struct perf_session * session,machine__dso_t fn,void * priv)972 int __perf_session__cache_build_ids(struct perf_session *session,
973 				    machine__dso_t fn, void *priv)
974 {
975 	if (no_buildid_cache)
976 		return 0;
977 
978 	if (mkdir(buildid_dir, 0755) != 0 && errno != EEXIST)
979 		return -1;
980 
981 	return machines__for_each_dso(&session->machines, fn, priv) ?  -1 : 0;
982 }
983 
perf_session__cache_build_ids(struct perf_session * session)984 int perf_session__cache_build_ids(struct perf_session *session)
985 {
986 	return __perf_session__cache_build_ids(session, dso__cache_build_id, NULL);
987 }
988 
machine__read_build_ids(struct machine * machine,bool with_hits)989 static bool machine__read_build_ids(struct machine *machine, bool with_hits)
990 {
991 	return __dsos__read_build_ids(&machine->dsos.head, with_hits);
992 }
993 
perf_session__read_build_ids(struct perf_session * session,bool with_hits)994 bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
995 {
996 	struct rb_node *nd;
997 	bool ret = machine__read_build_ids(&session->machines.host, with_hits);
998 
999 	for (nd = rb_first_cached(&session->machines.guests); nd;
1000 	     nd = rb_next(nd)) {
1001 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
1002 		ret |= machine__read_build_ids(pos, with_hits);
1003 	}
1004 
1005 	return ret;
1006 }
1007 
build_id__init(struct build_id * bid,const u8 * data,size_t size)1008 void build_id__init(struct build_id *bid, const u8 *data, size_t size)
1009 {
1010 	WARN_ON(size > BUILD_ID_SIZE);
1011 	memcpy(bid->data, data, size);
1012 	bid->size = size;
1013 }
1014 
build_id__is_defined(const struct build_id * bid)1015 bool build_id__is_defined(const struct build_id *bid)
1016 {
1017 	return bid && bid->size ? !!memchr_inv(bid->data, 0, bid->size) : false;
1018 }
1019