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
 12bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 13{
 14	bool have_build_id = false;
 15	struct dso *pos;
 16	struct nscookie nsc;
 17
 18	list_for_each_entry(pos, head, node) {
 19		if (with_hits && !pos->hit && !dso__is_vdso(pos))
 20			continue;
 21		if (pos->has_build_id) {
 22			have_build_id = true;
 23			continue;
 24		}
 25		nsinfo__mountns_enter(pos->nsinfo, &nsc);
 26		if (filename__read_build_id(pos->long_name, pos->build_id,
 27					    sizeof(pos->build_id)) > 0) {
 28			have_build_id	  = true;
 29			pos->has_build_id = true;
 30		}
 31		nsinfo__mountns_exit(&nsc);
 32	}
 33
 34	return have_build_id;
 35}
 36
 37/*
 38 * Find a matching entry and/or link current entry to RB tree.
 39 * Either one of the dso or name parameter must be non-NULL or the
 40 * function will not work.
 41 */
 42struct dso *__dsos__findnew_link_by_longname(struct rb_root *root, struct dso *dso, const char *name)
 43{
 44	struct rb_node **p = &root->rb_node;
 45	struct rb_node  *parent = NULL;
 46
 47	if (!name)
 48		name = dso->long_name;
 49	/*
 50	 * Find node with the matching name
 51	 */
 52	while (*p) {
 53		struct dso *this = rb_entry(*p, struct dso, rb_node);
 54		int rc = strcmp(name, this->long_name);
 55
 56		parent = *p;
 57		if (rc == 0) {
 58			/*
 59			 * In case the new DSO is a duplicate of an existing
 60			 * one, print a one-time warning & put the new entry
 61			 * at the end of the list of duplicates.
 62			 */
 63			if (!dso || (dso == this))
 64				return this;	/* Find matching dso */
 65			/*
 66			 * The core kernel DSOs may have duplicated long name.
 67			 * In this case, the short name should be different.
 68			 * Comparing the short names to differentiate the DSOs.
 69			 */
 70			rc = strcmp(dso->short_name, this->short_name);
 71			if (rc == 0) {
 72				pr_err("Duplicated dso name: %s\n", name);
 73				return NULL;
 74			}
 75		}
 76		if (rc < 0)
 77			p = &parent->rb_left;
 78		else
 79			p = &parent->rb_right;
 80	}
 81	if (dso) {
 82		/* Add new node and rebalance tree */
 83		rb_link_node(&dso->rb_node, parent, p);
 84		rb_insert_color(&dso->rb_node, root);
 85		dso->root = root;
 86	}
 87	return NULL;
 88}
 89
 90void __dsos__add(struct dsos *dsos, struct dso *dso)
 91{
 92	list_add_tail(&dso->node, &dsos->head);
 93	__dsos__findnew_link_by_longname(&dsos->root, dso, NULL);
 94	/*
 95	 * It is now in the linked list, grab a reference, then garbage collect
 96	 * this when needing memory, by looking at LRU dso instances in the
 97	 * list with atomic_read(&dso->refcnt) == 1, i.e. no references
 98	 * anywhere besides the one for the list, do, under a lock for the
 99	 * list: remove it from the list, then a dso__put(), that probably will
100	 * be the last and will then call dso__delete(), end of life.
101	 *
102	 * That, or at the end of the 'struct machine' lifetime, when all
103	 * 'struct dso' instances will be removed from the list, in
104	 * dsos__exit(), if they have no other reference from some other data
105	 * structure.
106	 *
107	 * E.g.: after processing a 'perf.data' file and storing references
108	 * to objects instantiated while processing events, we will have
109	 * references to the 'thread', 'map', 'dso' structs all from 'struct
110	 * hist_entry' instances, but we may not need anything not referenced,
111	 * so we might as well call machines__exit()/machines__delete() and
112	 * garbage collect it.
113	 */
114	dso__get(dso);
115}
116
117void dsos__add(struct dsos *dsos, struct dso *dso)
118{
119	down_write(&dsos->lock);
120	__dsos__add(dsos, dso);
121	up_write(&dsos->lock);
122}
123
124struct dso *__dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
125{
126	struct dso *pos;
127
128	if (cmp_short) {
129		list_for_each_entry(pos, &dsos->head, node)
130			if (strcmp(pos->short_name, name) == 0)
131				return pos;
132		return NULL;
133	}
134	return __dsos__findnew_by_longname(&dsos->root, name);
135}
136
137struct dso *dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
138{
139	struct dso *dso;
140	down_read(&dsos->lock);
141	dso = __dsos__find(dsos, name, cmp_short);
142	up_read(&dsos->lock);
143	return dso;
144}
145
146static void dso__set_basename(struct dso *dso)
147{
148	char *base, *lname;
149	int tid;
150
151	if (sscanf(dso->long_name, "/tmp/perf-%d.map", &tid) == 1) {
152		if (asprintf(&base, "[JIT] tid %d", tid) < 0)
153			return;
154	} else {
155	      /*
156	       * basename() may modify path buffer, so we must pass
157               * a copy.
158               */
159		lname = strdup(dso->long_name);
160		if (!lname)
161			return;
162
163		/*
164		 * basename() may return a pointer to internal
165		 * storage which is reused in subsequent calls
166		 * so copy the result.
167		 */
168		base = strdup(basename(lname));
169
170		free(lname);
171
172		if (!base)
173			return;
174	}
175	dso__set_short_name(dso, base, true);
176}
177
178struct dso *__dsos__addnew(struct dsos *dsos, const char *name)
179{
180	struct dso *dso = dso__new(name);
181
182	if (dso != NULL) {
183		__dsos__add(dsos, dso);
184		dso__set_basename(dso);
185		/* Put dso here because __dsos_add already got it */
186		dso__put(dso);
187	}
188	return dso;
189}
190
191struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
192{
193	struct dso *dso = __dsos__find(dsos, name, false);
194
195	return dso ? dso : __dsos__addnew(dsos, name);
196}
197
198struct dso *dsos__findnew(struct dsos *dsos, const char *name)
199{
200	struct dso *dso;
201	down_write(&dsos->lock);
202	dso = dso__get(__dsos__findnew(dsos, name));
203	up_write(&dsos->lock);
204	return dso;
205}
206
207size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
208			       bool (skip)(struct dso *dso, int parm), int parm)
209{
210	struct dso *pos;
211	size_t ret = 0;
212
213	list_for_each_entry(pos, head, node) {
214		if (skip && skip(pos, parm))
215			continue;
216		ret += dso__fprintf_buildid(pos, fp);
217		ret += fprintf(fp, " %s\n", pos->long_name);
218	}
219	return ret;
220}
221
222size_t __dsos__fprintf(struct list_head *head, FILE *fp)
223{
224	struct dso *pos;
225	size_t ret = 0;
226
227	list_for_each_entry(pos, head, node) {
228		ret += dso__fprintf(pos, fp);
229	}
230
231	return ret;
232}