Loading...
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}
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}