1// SPDX-License-Identifier: GPL-2.0
  2#include "debug.h"
  3#include "dsos.h"
  4#include "dso.h"
  5#include "vdso.h"
  6#include "namespaces.h"
  7#include <libgen.h>
  8#include <stdlib.h>
  9#include <string.h>
 10#include <symbol.h> // filename__read_build_id
 11
 12static int __dso_id__cmp(struct dso_id *a, struct dso_id *b)
 13{
 14	if (a->maj > b->maj) return -1;
 15	if (a->maj < b->maj) return 1;
 16
 17	if (a->min > b->min) return -1;
 18	if (a->min < b->min) return 1;
 19
 20	if (a->ino > b->ino) return -1;
 21	if (a->ino < b->ino) return 1;
 22
 23	if (a->ino_generation > b->ino_generation) return -1;
 24	if (a->ino_generation < b->ino_generation) return 1;
 25
 26	return 0;
 27}
 28
 29static bool dso_id__empty(struct dso_id *id)
 30{
 31	if (!id)
 32		return true;
 33
 34	return !id->maj && !id->min && !id->ino && !id->ino_generation;
 35}
 36
 37static void dso__inject_id(struct dso *dso, struct dso_id *id)
 38{
 39	dso->id.maj = id->maj;
 40	dso->id.min = id->min;
 41	dso->id.ino = id->ino;
 42	dso->id.ino_generation = id->ino_generation;
 43}
 44
 45static int dso_id__cmp(struct dso_id *a, struct dso_id *b)
 46{
 47	/*
 48	 * The second is always dso->id, so zeroes if not set, assume passing
 49	 * NULL for a means a zeroed id
 50	 */
 51	if (dso_id__empty(a) || dso_id__empty(b))
 52		return 0;
 53
 54	return __dso_id__cmp(a, b);
 55}
 56
 57int dso__cmp_id(struct dso *a, struct dso *b)
 58{
 59	return __dso_id__cmp(&a->id, &b->id);
 60}
 61
 62bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 63{
 64	bool have_build_id = false;
 65	struct dso *pos;
 66	struct nscookie nsc;
 67
 68	list_for_each_entry(pos, head, node) {
 69		if (with_hits && !pos->hit && !dso__is_vdso(pos))
 70			continue;
 71		if (pos->has_build_id) {
 72			have_build_id = true;
 73			continue;
 74		}
 75		nsinfo__mountns_enter(pos->nsinfo, &nsc);
 76		if (filename__read_build_id(pos->long_name, &pos->bid) > 0) {
 77			have_build_id	  = true;
 78			pos->has_build_id = true;
 79		}
 80		nsinfo__mountns_exit(&nsc);
 81	}
 82
 83	return have_build_id;
 84}
 85
 86static int __dso__cmp_long_name(const char *long_name, struct dso_id *id, struct dso *b)
 87{
 88	int rc = strcmp(long_name, b->long_name);
 89	return rc ?: dso_id__cmp(id, &b->id);
 90}
 91
 92static int __dso__cmp_short_name(const char *short_name, struct dso_id *id, struct dso *b)
 93{
 94	int rc = strcmp(short_name, b->short_name);
 95	return rc ?: dso_id__cmp(id, &b->id);
 96}
 97
 98static int dso__cmp_short_name(struct dso *a, struct dso *b)
 99{
100	return __dso__cmp_short_name(a->short_name, &a->id, b);
101}
102
103/*
104 * Find a matching entry and/or link current entry to RB tree.
105 * Either one of the dso or name parameter must be non-NULL or the
106 * function will not work.
107 */
108struct dso *__dsos__findnew_link_by_longname_id(struct rb_root *root, struct dso *dso,
109						const char *name, struct dso_id *id)
110{
111	struct rb_node **p = &root->rb_node;
112	struct rb_node  *parent = NULL;
113
114	if (!name)
115		name = dso->long_name;
116	/*
117	 * Find node with the matching name
118	 */
119	while (*p) {
120		struct dso *this = rb_entry(*p, struct dso, rb_node);
121		int rc = __dso__cmp_long_name(name, id, this);
122
123		parent = *p;
124		if (rc == 0) {
125			/*
126			 * In case the new DSO is a duplicate of an existing
127			 * one, print a one-time warning & put the new entry
128			 * at the end of the list of duplicates.
129			 */
130			if (!dso || (dso == this))
131				return this;	/* Find matching dso */
132			/*
133			 * The core kernel DSOs may have duplicated long name.
134			 * In this case, the short name should be different.
135			 * Comparing the short names to differentiate the DSOs.
136			 */
137			rc = dso__cmp_short_name(dso, this);
138			if (rc == 0) {
139				pr_err("Duplicated dso name: %s\n", name);
140				return NULL;
141			}
142		}
143		if (rc < 0)
144			p = &parent->rb_left;
145		else
146			p = &parent->rb_right;
147	}
148	if (dso) {
149		/* Add new node and rebalance tree */
150		rb_link_node(&dso->rb_node, parent, p);
151		rb_insert_color(&dso->rb_node, root);
152		dso->root = root;
153	}
154	return NULL;
155}
156
157void __dsos__add(struct dsos *dsos, struct dso *dso)
158{
159	list_add_tail(&dso->node, &dsos->head);
160	__dsos__findnew_link_by_longname_id(&dsos->root, dso, NULL, &dso->id);
161	/*
162	 * It is now in the linked list, grab a reference, then garbage collect
163	 * this when needing memory, by looking at LRU dso instances in the
164	 * list with atomic_read(&dso->refcnt) == 1, i.e. no references
165	 * anywhere besides the one for the list, do, under a lock for the
166	 * list: remove it from the list, then a dso__put(), that probably will
167	 * be the last and will then call dso__delete(), end of life.
168	 *
169	 * That, or at the end of the 'struct machine' lifetime, when all
170	 * 'struct dso' instances will be removed from the list, in
171	 * dsos__exit(), if they have no other reference from some other data
172	 * structure.
173	 *
174	 * E.g.: after processing a 'perf.data' file and storing references
175	 * to objects instantiated while processing events, we will have
176	 * references to the 'thread', 'map', 'dso' structs all from 'struct
177	 * hist_entry' instances, but we may not need anything not referenced,
178	 * so we might as well call machines__exit()/machines__delete() and
179	 * garbage collect it.
180	 */
181	dso__get(dso);
182}
183
184void dsos__add(struct dsos *dsos, struct dso *dso)
185{
186	down_write(&dsos->lock);
187	__dsos__add(dsos, dso);
188	up_write(&dsos->lock);
189}
190
191static struct dso *__dsos__findnew_by_longname_id(struct rb_root *root, const char *name, struct dso_id *id)
192{
193	return __dsos__findnew_link_by_longname_id(root, NULL, name, id);
194}
195
196static struct dso *__dsos__find_id(struct dsos *dsos, const char *name, struct dso_id *id, bool cmp_short)
197{
198	struct dso *pos;
199
200	if (cmp_short) {
201		list_for_each_entry(pos, &dsos->head, node)
202			if (__dso__cmp_short_name(name, id, pos) == 0)
203				return pos;
204		return NULL;
205	}
206	return __dsos__findnew_by_longname_id(&dsos->root, name, id);
207}
208
209struct dso *__dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
210{
211	return __dsos__find_id(dsos, name, NULL, cmp_short);
212}
213
214static void dso__set_basename(struct dso *dso)
215{
216	char *base, *lname;
217	int tid;
218
219	if (sscanf(dso->long_name, "/tmp/perf-%d.map", &tid) == 1) {
220		if (asprintf(&base, "[JIT] tid %d", tid) < 0)
221			return;
222	} else {
223	      /*
224	       * basename() may modify path buffer, so we must pass
225               * a copy.
226               */
227		lname = strdup(dso->long_name);
228		if (!lname)
229			return;
230
231		/*
232		 * basename() may return a pointer to internal
233		 * storage which is reused in subsequent calls
234		 * so copy the result.
235		 */
236		base = strdup(basename(lname));
237
238		free(lname);
239
240		if (!base)
241			return;
242	}
243	dso__set_short_name(dso, base, true);
244}
245
246static struct dso *__dsos__addnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
247{
248	struct dso *dso = dso__new_id(name, id);
249
250	if (dso != NULL) {
251		__dsos__add(dsos, dso);
252		dso__set_basename(dso);
253		/* Put dso here because __dsos_add already got it */
254		dso__put(dso);
255	}
256	return dso;
257}
258
259struct dso *__dsos__addnew(struct dsos *dsos, const char *name)
260{
261	return __dsos__addnew_id(dsos, name, NULL);
262}
263
264static struct dso *__dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
265{
266	struct dso *dso = __dsos__find_id(dsos, name, id, false);
267
268	if (dso && dso_id__empty(&dso->id) && !dso_id__empty(id))
269		dso__inject_id(dso, id);
270
271	return dso ? dso : __dsos__addnew_id(dsos, name, id);
272}
273
274struct dso *dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
275{
276	struct dso *dso;
277	down_write(&dsos->lock);
278	dso = dso__get(__dsos__findnew_id(dsos, name, id));
279	up_write(&dsos->lock);
280	return dso;
281}
282
283size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
284			       bool (skip)(struct dso *dso, int parm), int parm)
285{
286	struct dso *pos;
287	size_t ret = 0;
288
289	list_for_each_entry(pos, head, node) {
290		char sbuild_id[SBUILD_ID_SIZE];
291
292		if (skip && skip(pos, parm))
293			continue;
294		build_id__sprintf(&pos->bid, sbuild_id);
295		ret += fprintf(fp, "%-40s %s\n", sbuild_id, pos->long_name);
296	}
297	return ret;
298}
299
300size_t __dsos__fprintf(struct list_head *head, FILE *fp)
301{
302	struct dso *pos;
303	size_t ret = 0;
304
305	list_for_each_entry(pos, head, node) {
306		ret += dso__fprintf(pos, fp);
307	}
308
309	return ret;
310}