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