1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 #include "debug.h" 2 #include "debug.h"
3 #include "dsos.h" 3 #include "dsos.h"
4 #include "dso.h" 4 #include "dso.h"
5 #include "util.h" 5 #include "util.h"
6 #include "vdso.h" 6 #include "vdso.h"
7 #include "namespaces.h" 7 #include "namespaces.h"
8 #include <errno.h> 8 #include <errno.h>
9 #include <libgen.h> 9 #include <libgen.h>
10 #include <stdlib.h> 10 #include <stdlib.h>
11 #include <string.h> 11 #include <string.h>
12 #include <symbol.h> // filename__read_build_id 12 #include <symbol.h> // filename__read_build_id
13 #include <unistd.h> 13 #include <unistd.h>
14 14
15 void dsos__init(struct dsos *dsos) 15 void dsos__init(struct dsos *dsos)
16 { 16 {
17 init_rwsem(&dsos->lock); 17 init_rwsem(&dsos->lock);
18 18
19 dsos->cnt = 0; 19 dsos->cnt = 0;
20 dsos->allocated = 0; 20 dsos->allocated = 0;
21 dsos->dsos = NULL; 21 dsos->dsos = NULL;
22 dsos->sorted = true; 22 dsos->sorted = true;
23 } 23 }
24 24
25 static void dsos__purge(struct dsos *dsos) 25 static void dsos__purge(struct dsos *dsos)
26 { 26 {
27 down_write(&dsos->lock); 27 down_write(&dsos->lock);
28 28
29 for (unsigned int i = 0; i < dsos->cnt 29 for (unsigned int i = 0; i < dsos->cnt; i++) {
30 struct dso *dso = dsos->dsos[i 30 struct dso *dso = dsos->dsos[i];
31 31
32 dso__set_dsos(dso, NULL); 32 dso__set_dsos(dso, NULL);
33 dso__put(dso); 33 dso__put(dso);
34 } 34 }
35 35
36 zfree(&dsos->dsos); 36 zfree(&dsos->dsos);
37 dsos->cnt = 0; 37 dsos->cnt = 0;
38 dsos->allocated = 0; 38 dsos->allocated = 0;
39 dsos->sorted = true; 39 dsos->sorted = true;
40 40
41 up_write(&dsos->lock); 41 up_write(&dsos->lock);
42 } 42 }
43 43
44 void dsos__exit(struct dsos *dsos) 44 void dsos__exit(struct dsos *dsos)
45 { 45 {
46 dsos__purge(dsos); 46 dsos__purge(dsos);
47 exit_rwsem(&dsos->lock); 47 exit_rwsem(&dsos->lock);
48 } 48 }
49 49
50 50
51 static int __dsos__for_each_dso(struct dsos *d 51 static int __dsos__for_each_dso(struct dsos *dsos,
52 int (*cb)(stru 52 int (*cb)(struct dso *dso, void *data),
53 void *data) 53 void *data)
54 { 54 {
55 for (unsigned int i = 0; i < dsos->cnt 55 for (unsigned int i = 0; i < dsos->cnt; i++) {
56 struct dso *dso = dsos->dsos[i 56 struct dso *dso = dsos->dsos[i];
57 int err; 57 int err;
58 58
59 err = cb(dso, data); 59 err = cb(dso, data);
60 if (err) 60 if (err)
61 return err; 61 return err;
62 } 62 }
63 return 0; 63 return 0;
64 } 64 }
65 65
66 struct dsos__read_build_ids_cb_args { 66 struct dsos__read_build_ids_cb_args {
67 bool with_hits; 67 bool with_hits;
68 bool have_build_id; 68 bool have_build_id;
69 }; 69 };
70 70
71 static int dsos__read_build_ids_cb(struct dso 71 static int dsos__read_build_ids_cb(struct dso *dso, void *data)
72 { 72 {
73 struct dsos__read_build_ids_cb_args *a 73 struct dsos__read_build_ids_cb_args *args = data;
74 struct nscookie nsc; 74 struct nscookie nsc;
75 75
76 if (args->with_hits && !dso__hit(dso) 76 if (args->with_hits && !dso__hit(dso) && !dso__is_vdso(dso))
77 return 0; 77 return 0;
78 if (dso__has_build_id(dso)) { 78 if (dso__has_build_id(dso)) {
79 args->have_build_id = true; 79 args->have_build_id = true;
80 return 0; 80 return 0;
81 } 81 }
82 nsinfo__mountns_enter(dso__nsinfo(dso) 82 nsinfo__mountns_enter(dso__nsinfo(dso), &nsc);
83 if (filename__read_build_id(dso__long_ 83 if (filename__read_build_id(dso__long_name(dso), dso__bid(dso)) > 0) {
84 args->have_build_id = true; 84 args->have_build_id = true;
85 dso__set_has_build_id(dso); 85 dso__set_has_build_id(dso);
86 } else if (errno == ENOENT && dso__nsi 86 } else if (errno == ENOENT && dso__nsinfo(dso)) {
87 char *new_name = dso__filename 87 char *new_name = dso__filename_with_chroot(dso, dso__long_name(dso));
88 88
89 if (new_name && filename__read 89 if (new_name && filename__read_build_id(new_name, dso__bid(dso)) > 0) {
90 args->have_build_id = 90 args->have_build_id = true;
91 dso__set_has_build_id( 91 dso__set_has_build_id(dso);
92 } 92 }
93 free(new_name); 93 free(new_name);
94 } 94 }
95 nsinfo__mountns_exit(&nsc); 95 nsinfo__mountns_exit(&nsc);
96 return 0; 96 return 0;
97 } 97 }
98 98
99 bool dsos__read_build_ids(struct dsos *dsos, b 99 bool dsos__read_build_ids(struct dsos *dsos, bool with_hits)
100 { 100 {
101 struct dsos__read_build_ids_cb_args ar 101 struct dsos__read_build_ids_cb_args args = {
102 .with_hits = with_hits, 102 .with_hits = with_hits,
103 .have_build_id = false, 103 .have_build_id = false,
104 }; 104 };
105 105
106 dsos__for_each_dso(dsos, dsos__read_bu 106 dsos__for_each_dso(dsos, dsos__read_build_ids_cb, &args);
107 return args.have_build_id; 107 return args.have_build_id;
108 } 108 }
109 109
110 static int __dso__cmp_long_name(const char *lo 110 static int __dso__cmp_long_name(const char *long_name, const struct dso_id *id,
111 const struct d 111 const struct dso *b)
112 { 112 {
113 int rc = strcmp(long_name, dso__long_n 113 int rc = strcmp(long_name, dso__long_name(b));
114 return rc ?: dso_id__cmp(id, dso__id_c 114 return rc ?: dso_id__cmp(id, dso__id_const(b));
115 } 115 }
116 116
117 static int __dso__cmp_short_name(const char *s 117 static int __dso__cmp_short_name(const char *short_name, const struct dso_id *id,
118 const struct 118 const struct dso *b)
119 { 119 {
120 int rc = strcmp(short_name, dso__short 120 int rc = strcmp(short_name, dso__short_name(b));
121 return rc ?: dso_id__cmp(id, dso__id_c 121 return rc ?: dso_id__cmp(id, dso__id_const(b));
122 } 122 }
123 123
124 static int dsos__cmp_long_name_id_short_name(c 124 static int dsos__cmp_long_name_id_short_name(const void *va, const void *vb)
125 { 125 {
126 const struct dso *a = *((const struct 126 const struct dso *a = *((const struct dso **)va);
127 const struct dso *b = *((const struct 127 const struct dso *b = *((const struct dso **)vb);
128 int rc = strcmp(dso__long_name(a), dso 128 int rc = strcmp(dso__long_name(a), dso__long_name(b));
129 129
130 if (!rc) { 130 if (!rc) {
131 rc = dso_id__cmp(dso__id_const 131 rc = dso_id__cmp(dso__id_const(a), dso__id_const(b));
132 if (!rc) 132 if (!rc)
133 rc = strcmp(dso__short 133 rc = strcmp(dso__short_name(a), dso__short_name(b));
134 } 134 }
135 return rc; 135 return rc;
136 } 136 }
137 137
138 struct dsos__key { 138 struct dsos__key {
139 const char *long_name; 139 const char *long_name;
140 const struct dso_id *id; 140 const struct dso_id *id;
141 }; 141 };
142 142
143 static int dsos__cmp_key_long_name_id(const vo 143 static int dsos__cmp_key_long_name_id(const void *vkey, const void *vdso)
144 { 144 {
145 const struct dsos__key *key = vkey; 145 const struct dsos__key *key = vkey;
146 const struct dso *dso = *((const struc 146 const struct dso *dso = *((const struct dso **)vdso);
147 147
148 return __dso__cmp_long_name(key->long_ 148 return __dso__cmp_long_name(key->long_name, key->id, dso);
149 } 149 }
150 150
151 /* 151 /*
152 * Find a matching entry and/or link current e 152 * Find a matching entry and/or link current entry to RB tree.
153 * Either one of the dso or name parameter mus 153 * Either one of the dso or name parameter must be non-NULL or the
154 * function will not work. 154 * function will not work.
155 */ 155 */
156 static struct dso *__dsos__find_by_longname_id 156 static struct dso *__dsos__find_by_longname_id(struct dsos *dsos,
157 157 const char *name,
158 158 struct dso_id *id,
159 159 bool write_locked)
160 { 160 {
161 struct dsos__key key = { 161 struct dsos__key key = {
162 .long_name = name, 162 .long_name = name,
163 .id = id, 163 .id = id,
164 }; 164 };
165 struct dso **res; 165 struct dso **res;
166 166
167 if (dsos->dsos == NULL) 167 if (dsos->dsos == NULL)
168 return NULL; 168 return NULL;
169 169
170 if (!dsos->sorted) { 170 if (!dsos->sorted) {
171 if (!write_locked) { 171 if (!write_locked) {
172 struct dso *dso; 172 struct dso *dso;
173 173
174 up_read(&dsos->lock); 174 up_read(&dsos->lock);
175 down_write(&dsos->lock 175 down_write(&dsos->lock);
176 dso = __dsos__find_by_ 176 dso = __dsos__find_by_longname_id(dsos, name, id,
177 177 /*write_locked=*/true);
178 up_write(&dsos->lock); 178 up_write(&dsos->lock);
179 down_read(&dsos->lock) 179 down_read(&dsos->lock);
180 return dso; 180 return dso;
181 } 181 }
182 qsort(dsos->dsos, dsos->cnt, s 182 qsort(dsos->dsos, dsos->cnt, sizeof(struct dso *),
183 dsos__cmp_long_name_id_s 183 dsos__cmp_long_name_id_short_name);
184 dsos->sorted = true; 184 dsos->sorted = true;
185 } 185 }
186 186
187 res = bsearch(&key, dsos->dsos, dsos-> 187 res = bsearch(&key, dsos->dsos, dsos->cnt, sizeof(struct dso *),
188 dsos__cmp_key_long_name_ 188 dsos__cmp_key_long_name_id);
189 if (!res) 189 if (!res)
190 return NULL; 190 return NULL;
191 191
192 return dso__get(*res); 192 return dso__get(*res);
193 } 193 }
194 194
195 int __dsos__add(struct dsos *dsos, struct dso 195 int __dsos__add(struct dsos *dsos, struct dso *dso)
196 { 196 {
197 if (dsos->cnt == dsos->allocated) { 197 if (dsos->cnt == dsos->allocated) {
198 unsigned int to_allocate = 2; 198 unsigned int to_allocate = 2;
199 struct dso **temp; 199 struct dso **temp;
200 200
201 if (dsos->allocated > 0) 201 if (dsos->allocated > 0)
202 to_allocate = dsos->al 202 to_allocate = dsos->allocated * 2;
203 temp = realloc(dsos->dsos, siz 203 temp = realloc(dsos->dsos, sizeof(struct dso *) * to_allocate);
204 if (!temp) 204 if (!temp)
205 return -ENOMEM; 205 return -ENOMEM;
206 dsos->dsos = temp; 206 dsos->dsos = temp;
207 dsos->allocated = to_allocate; 207 dsos->allocated = to_allocate;
208 } 208 }
209 if (!dsos->sorted) { 209 if (!dsos->sorted) {
210 dsos->dsos[dsos->cnt++] = dso_ 210 dsos->dsos[dsos->cnt++] = dso__get(dso);
211 } else { 211 } else {
212 int low = 0, high = dsos->cnt 212 int low = 0, high = dsos->cnt - 1;
213 int insert = dsos->cnt; /* Def 213 int insert = dsos->cnt; /* Default to inserting at the end. */
214 214
215 while (low <= high) { 215 while (low <= high) {
216 int mid = low + (high 216 int mid = low + (high - low) / 2;
217 int cmp = dsos__cmp_lo 217 int cmp = dsos__cmp_long_name_id_short_name(&dsos->dsos[mid], &dso);
218 218
219 if (cmp < 0) { 219 if (cmp < 0) {
220 low = mid + 1; 220 low = mid + 1;
221 } else { 221 } else {
222 high = mid - 1 222 high = mid - 1;
223 insert = mid; 223 insert = mid;
224 } 224 }
225 } 225 }
226 memmove(&dsos->dsos[insert + 1 226 memmove(&dsos->dsos[insert + 1], &dsos->dsos[insert],
227 (dsos->cnt - insert) * 227 (dsos->cnt - insert) * sizeof(struct dso *));
228 dsos->cnt++; 228 dsos->cnt++;
229 dsos->dsos[insert] = dso__get( 229 dsos->dsos[insert] = dso__get(dso);
230 } 230 }
231 dso__set_dsos(dso, dsos); 231 dso__set_dsos(dso, dsos);
232 return 0; 232 return 0;
233 } 233 }
234 234
235 int dsos__add(struct dsos *dsos, struct dso *d 235 int dsos__add(struct dsos *dsos, struct dso *dso)
236 { 236 {
237 int ret; 237 int ret;
238 238
239 down_write(&dsos->lock); 239 down_write(&dsos->lock);
240 ret = __dsos__add(dsos, dso); 240 ret = __dsos__add(dsos, dso);
241 up_write(&dsos->lock); 241 up_write(&dsos->lock);
242 return ret; 242 return ret;
243 } 243 }
244 244
245 struct dsos__find_id_cb_args { 245 struct dsos__find_id_cb_args {
246 const char *name; 246 const char *name;
247 struct dso_id *id; 247 struct dso_id *id;
248 struct dso *res; 248 struct dso *res;
249 }; 249 };
250 250
251 static int dsos__find_id_cb(struct dso *dso, v 251 static int dsos__find_id_cb(struct dso *dso, void *data)
252 { 252 {
253 struct dsos__find_id_cb_args *args = d 253 struct dsos__find_id_cb_args *args = data;
254 254
255 if (__dso__cmp_short_name(args->name, 255 if (__dso__cmp_short_name(args->name, args->id, dso) == 0) {
256 args->res = dso__get(dso); 256 args->res = dso__get(dso);
257 return 1; 257 return 1;
258 } 258 }
259 return 0; 259 return 0;
260 260
261 } 261 }
262 262
263 static struct dso *__dsos__find_id(struct dsos 263 static struct dso *__dsos__find_id(struct dsos *dsos, const char *name, struct dso_id *id,
264 bool cmp_sh 264 bool cmp_short, bool write_locked)
265 { 265 {
266 struct dso *res; 266 struct dso *res;
267 267
268 if (cmp_short) { 268 if (cmp_short) {
269 struct dsos__find_id_cb_args a 269 struct dsos__find_id_cb_args args = {
270 .name = name, 270 .name = name,
271 .id = id, 271 .id = id,
272 .res = NULL, 272 .res = NULL,
273 }; 273 };
274 274
275 __dsos__for_each_dso(dsos, dso 275 __dsos__for_each_dso(dsos, dsos__find_id_cb, &args);
276 return args.res; 276 return args.res;
277 } 277 }
278 res = __dsos__find_by_longname_id(dsos 278 res = __dsos__find_by_longname_id(dsos, name, id, write_locked);
279 return res; 279 return res;
280 } 280 }
281 281
282 struct dso *dsos__find(struct dsos *dsos, cons 282 struct dso *dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
283 { 283 {
284 struct dso *res; 284 struct dso *res;
285 285
286 down_read(&dsos->lock); 286 down_read(&dsos->lock);
287 res = __dsos__find_id(dsos, name, NULL 287 res = __dsos__find_id(dsos, name, NULL, cmp_short, /*write_locked=*/false);
288 up_read(&dsos->lock); 288 up_read(&dsos->lock);
289 return res; 289 return res;
290 } 290 }
291 291
292 static void dso__set_basename(struct dso *dso) 292 static void dso__set_basename(struct dso *dso)
293 { 293 {
294 char *base, *lname; 294 char *base, *lname;
295 int tid; 295 int tid;
296 296
297 if (perf_pid_map_tid(dso__long_name(ds 297 if (perf_pid_map_tid(dso__long_name(dso), &tid)) {
298 if (asprintf(&base, "[JIT] tid 298 if (asprintf(&base, "[JIT] tid %d", tid) < 0)
299 return; 299 return;
300 } else { 300 } else {
301 /* 301 /*
302 * basename() may modify path bu 302 * basename() may modify path buffer, so we must pass
303 * a copy. 303 * a copy.
304 */ 304 */
305 lname = strdup(dso__long_name( 305 lname = strdup(dso__long_name(dso));
306 if (!lname) 306 if (!lname)
307 return; 307 return;
308 308
309 /* 309 /*
310 * basename() may return a poi 310 * basename() may return a pointer to internal
311 * storage which is reused in 311 * storage which is reused in subsequent calls
312 * so copy the result. 312 * so copy the result.
313 */ 313 */
314 base = strdup(basename(lname)) 314 base = strdup(basename(lname));
315 315
316 free(lname); 316 free(lname);
317 317
318 if (!base) 318 if (!base)
319 return; 319 return;
320 } 320 }
321 dso__set_short_name(dso, base, true); 321 dso__set_short_name(dso, base, true);
322 } 322 }
323 323
324 static struct dso *__dsos__addnew_id(struct ds 324 static struct dso *__dsos__addnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
325 { 325 {
326 struct dso *dso = dso__new_id(name, id 326 struct dso *dso = dso__new_id(name, id);
327 327
328 if (dso != NULL) { 328 if (dso != NULL) {
329 /* 329 /*
330 * The dsos lock is held on en 330 * The dsos lock is held on entry, so rename the dso before
331 * adding it to avoid needing 331 * adding it to avoid needing to take the dsos lock again to say
332 * the array isn't sorted. 332 * the array isn't sorted.
333 */ 333 */
334 dso__set_basename(dso); 334 dso__set_basename(dso);
335 __dsos__add(dsos, dso); 335 __dsos__add(dsos, dso);
336 } 336 }
337 return dso; 337 return dso;
338 } 338 }
339 339
340 static struct dso *__dsos__findnew_id(struct d 340 static struct dso *__dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
341 { 341 {
342 struct dso *dso = __dsos__find_id(dsos 342 struct dso *dso = __dsos__find_id(dsos, name, id, false, /*write_locked=*/true);
343 343
344 if (dso && dso_id__empty(dso__id(dso)) 344 if (dso && dso_id__empty(dso__id(dso)) && !dso_id__empty(id))
345 __dso__inject_id(dso, id); 345 __dso__inject_id(dso, id);
346 346
347 return dso ? dso : __dsos__addnew_id(d 347 return dso ? dso : __dsos__addnew_id(dsos, name, id);
348 } 348 }
349 349
350 struct dso *dsos__findnew_id(struct dsos *dsos 350 struct dso *dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
351 { 351 {
352 struct dso *dso; 352 struct dso *dso;
353 down_write(&dsos->lock); 353 down_write(&dsos->lock);
354 dso = __dsos__findnew_id(dsos, name, i 354 dso = __dsos__findnew_id(dsos, name, id);
355 up_write(&dsos->lock); 355 up_write(&dsos->lock);
356 return dso; 356 return dso;
357 } 357 }
358 358
359 struct dsos__fprintf_buildid_cb_args { 359 struct dsos__fprintf_buildid_cb_args {
360 FILE *fp; 360 FILE *fp;
361 bool (*skip)(struct dso *dso, int parm 361 bool (*skip)(struct dso *dso, int parm);
362 int parm; 362 int parm;
363 size_t ret; 363 size_t ret;
364 }; 364 };
365 365
366 static int dsos__fprintf_buildid_cb(struct dso 366 static int dsos__fprintf_buildid_cb(struct dso *dso, void *data)
367 { 367 {
368 struct dsos__fprintf_buildid_cb_args * 368 struct dsos__fprintf_buildid_cb_args *args = data;
369 char sbuild_id[SBUILD_ID_SIZE]; 369 char sbuild_id[SBUILD_ID_SIZE];
370 370
371 if (args->skip && args->skip(dso, args 371 if (args->skip && args->skip(dso, args->parm))
372 return 0; 372 return 0;
373 build_id__sprintf(dso__bid(dso), sbuil 373 build_id__sprintf(dso__bid(dso), sbuild_id);
374 args->ret += fprintf(args->fp, "%-40s 374 args->ret += fprintf(args->fp, "%-40s %s\n", sbuild_id, dso__long_name(dso));
375 return 0; 375 return 0;
376 } 376 }
377 377
378 size_t dsos__fprintf_buildid(struct dsos *dsos 378 size_t dsos__fprintf_buildid(struct dsos *dsos, FILE *fp,
379 bool (*skip)(st 379 bool (*skip)(struct dso *dso, int parm), int parm)
380 { 380 {
381 struct dsos__fprintf_buildid_cb_args a 381 struct dsos__fprintf_buildid_cb_args args = {
382 .fp = fp, 382 .fp = fp,
383 .skip = skip, 383 .skip = skip,
384 .parm = parm, 384 .parm = parm,
385 .ret = 0, 385 .ret = 0,
386 }; 386 };
387 387
388 dsos__for_each_dso(dsos, dsos__fprintf 388 dsos__for_each_dso(dsos, dsos__fprintf_buildid_cb, &args);
389 return args.ret; 389 return args.ret;
390 } 390 }
391 391
392 struct dsos__fprintf_cb_args { 392 struct dsos__fprintf_cb_args {
393 FILE *fp; 393 FILE *fp;
394 size_t ret; 394 size_t ret;
395 }; 395 };
396 396
397 static int dsos__fprintf_cb(struct dso *dso, v 397 static int dsos__fprintf_cb(struct dso *dso, void *data)
398 { 398 {
399 struct dsos__fprintf_cb_args *args = d 399 struct dsos__fprintf_cb_args *args = data;
400 400
401 args->ret += dso__fprintf(dso, args->f 401 args->ret += dso__fprintf(dso, args->fp);
402 return 0; 402 return 0;
403 } 403 }
404 404
405 size_t dsos__fprintf(struct dsos *dsos, FILE * 405 size_t dsos__fprintf(struct dsos *dsos, FILE *fp)
406 { 406 {
407 struct dsos__fprintf_cb_args args = { 407 struct dsos__fprintf_cb_args args = {
408 .fp = fp, 408 .fp = fp,
409 .ret = 0, 409 .ret = 0,
410 }; 410 };
411 411
412 dsos__for_each_dso(dsos, dsos__fprintf 412 dsos__for_each_dso(dsos, dsos__fprintf_cb, &args);
413 return args.ret; 413 return args.ret;
414 } 414 }
415 415
416 static int dsos__hit_all_cb(struct dso *dso, v 416 static int dsos__hit_all_cb(struct dso *dso, void *data __maybe_unused)
417 { 417 {
418 dso__set_hit(dso); 418 dso__set_hit(dso);
419 return 0; 419 return 0;
420 } 420 }
421 421
422 int dsos__hit_all(struct dsos *dsos) 422 int dsos__hit_all(struct dsos *dsos)
423 { 423 {
424 return dsos__for_each_dso(dsos, dsos__ 424 return dsos__for_each_dso(dsos, dsos__hit_all_cb, NULL);
425 } 425 }
426 426
427 struct dso *dsos__findnew_module_dso(struct ds 427 struct dso *dsos__findnew_module_dso(struct dsos *dsos,
428 struct ma 428 struct machine *machine,
429 struct km 429 struct kmod_path *m,
430 const cha 430 const char *filename)
431 { 431 {
432 struct dso *dso; 432 struct dso *dso;
433 433
434 down_write(&dsos->lock); 434 down_write(&dsos->lock);
435 435
436 dso = __dsos__find_id(dsos, m->name, N 436 dso = __dsos__find_id(dsos, m->name, NULL, /*cmp_short=*/true, /*write_locked=*/true);
437 if (dso) { 437 if (dso) {
438 up_write(&dsos->lock); 438 up_write(&dsos->lock);
439 return dso; 439 return dso;
440 } 440 }
441 /* 441 /*
442 * Failed to find the dso so create it 442 * Failed to find the dso so create it. Change the name before adding it
443 * to the array, to avoid unnecessary 443 * to the array, to avoid unnecessary sorts and potential locking
444 * issues. 444 * issues.
445 */ 445 */
446 dso = dso__new_id(m->name, /*id=*/NULL 446 dso = dso__new_id(m->name, /*id=*/NULL);
447 if (!dso) { 447 if (!dso) {
448 up_write(&dsos->lock); 448 up_write(&dsos->lock);
449 return NULL; 449 return NULL;
450 } 450 }
451 dso__set_basename(dso); 451 dso__set_basename(dso);
452 dso__set_module_info(dso, m, machine); 452 dso__set_module_info(dso, m, machine);
453 dso__set_long_name(dso, strdup(filenam 453 dso__set_long_name(dso, strdup(filename), true);
454 dso__set_kernel(dso, DSO_SPACE__KERNEL 454 dso__set_kernel(dso, DSO_SPACE__KERNEL);
455 __dsos__add(dsos, dso); 455 __dsos__add(dsos, dso);
456 456
457 up_write(&dsos->lock); 457 up_write(&dsos->lock);
458 return dso; 458 return dso;
459 } 459 }
460 460
461 static int dsos__find_kernel_dso_cb(struct dso 461 static int dsos__find_kernel_dso_cb(struct dso *dso, void *data)
462 { 462 {
463 struct dso **res = data; 463 struct dso **res = data;
464 /* 464 /*
465 * The cpumode passed to is_kernel_mod 465 * The cpumode passed to is_kernel_module is not the cpumode of *this*
466 * event. If we insist on passing corr 466 * event. If we insist on passing correct cpumode to is_kernel_module,
467 * we should record the cpumode when w 467 * we should record the cpumode when we adding this dso to the linked
468 * list. 468 * list.
469 * 469 *
470 * However we don't really need passin 470 * However we don't really need passing correct cpumode. We know the
471 * correct cpumode must be kernel mode 471 * correct cpumode must be kernel mode (if not, we should not link it
472 * onto kernel_dsos list). 472 * onto kernel_dsos list).
473 * 473 *
474 * Therefore, we pass PERF_RECORD_MISC 474 * Therefore, we pass PERF_RECORD_MISC_CPUMODE_UNKNOWN.
475 * is_kernel_module() treats it as a k 475 * is_kernel_module() treats it as a kernel cpumode.
476 */ 476 */
477 if (!dso__kernel(dso) || 477 if (!dso__kernel(dso) ||
478 is_kernel_module(dso__long_name(ds 478 is_kernel_module(dso__long_name(dso), PERF_RECORD_MISC_CPUMODE_UNKNOWN))
479 return 0; 479 return 0;
480 480
481 *res = dso__get(dso); 481 *res = dso__get(dso);
482 return 1; 482 return 1;
483 } 483 }
484 484
485 struct dso *dsos__find_kernel_dso(struct dsos 485 struct dso *dsos__find_kernel_dso(struct dsos *dsos)
486 { 486 {
487 struct dso *res = NULL; 487 struct dso *res = NULL;
488 488
489 dsos__for_each_dso(dsos, dsos__find_ke 489 dsos__for_each_dso(dsos, dsos__find_kernel_dso_cb, &res);
490 return res; 490 return res;
491 } 491 }
492 492
493 int dsos__for_each_dso(struct dsos *dsos, int 493 int dsos__for_each_dso(struct dsos *dsos, int (*cb)(struct dso *dso, void *data), void *data)
494 { 494 {
495 int err; 495 int err;
496 496
497 down_read(&dsos->lock); 497 down_read(&dsos->lock);
498 err = __dsos__for_each_dso(dsos, cb, d 498 err = __dsos__for_each_dso(dsos, cb, data);
499 up_read(&dsos->lock); 499 up_read(&dsos->lock);
500 return err; 500 return err;
501 } 501 }
502 502
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.