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 static int __dso_id__cmp(struct dso_id *a, struct dso_id *b)
16 { 16 {
17 init_rwsem(&dsos->lock); !! 17 if (a->maj > b->maj) return -1;
>> 18 if (a->maj < b->maj) return 1;
18 19
19 dsos->cnt = 0; !! 20 if (a->min > b->min) return -1;
20 dsos->allocated = 0; !! 21 if (a->min < b->min) return 1;
21 dsos->dsos = NULL; <<
22 dsos->sorted = true; <<
23 } <<
24 22
25 static void dsos__purge(struct dsos *dsos) !! 23 if (a->ino > b->ino) return -1;
26 { !! 24 if (a->ino < b->ino) return 1;
27 down_write(&dsos->lock); <<
28 25
29 for (unsigned int i = 0; i < dsos->cnt !! 26 /*
30 struct dso *dso = dsos->dsos[i !! 27 * Synthesized MMAP events have zero ino_generation, avoid comparing
31 !! 28 * them with MMAP events with actual ino_generation.
32 dso__set_dsos(dso, NULL); !! 29 *
33 dso__put(dso); !! 30 * I found it harmful because the mismatch resulted in a new
>> 31 * dso that did not have a build ID whereas the original dso did have a
>> 32 * build ID. The build ID was essential because the object was not found
>> 33 * otherwise. - Adrian
>> 34 */
>> 35 if (a->ino_generation && b->ino_generation) {
>> 36 if (a->ino_generation > b->ino_generation) return -1;
>> 37 if (a->ino_generation < b->ino_generation) return 1;
34 } 38 }
35 39
36 zfree(&dsos->dsos); !! 40 return 0;
37 dsos->cnt = 0; <<
38 dsos->allocated = 0; <<
39 dsos->sorted = true; <<
40 <<
41 up_write(&dsos->lock); <<
42 } 41 }
43 42
44 void dsos__exit(struct dsos *dsos) !! 43 static bool dso_id__empty(struct dso_id *id)
45 { 44 {
46 dsos__purge(dsos); !! 45 if (!id)
47 exit_rwsem(&dsos->lock); !! 46 return true;
>> 47
>> 48 return !id->maj && !id->min && !id->ino && !id->ino_generation;
48 } 49 }
49 50
>> 51 static void dso__inject_id(struct dso *dso, struct dso_id *id)
>> 52 {
>> 53 dso->id.maj = id->maj;
>> 54 dso->id.min = id->min;
>> 55 dso->id.ino = id->ino;
>> 56 dso->id.ino_generation = id->ino_generation;
>> 57 }
50 58
51 static int __dsos__for_each_dso(struct dsos *d !! 59 static int dso_id__cmp(struct dso_id *a, struct dso_id *b)
52 int (*cb)(stru <<
53 void *data) <<
54 { 60 {
55 for (unsigned int i = 0; i < dsos->cnt !! 61 /*
56 struct dso *dso = dsos->dsos[i !! 62 * The second is always dso->id, so zeroes if not set, assume passing
57 int err; !! 63 * NULL for a means a zeroed id
>> 64 */
>> 65 if (dso_id__empty(a) || dso_id__empty(b))
>> 66 return 0;
58 67
59 err = cb(dso, data); !! 68 return __dso_id__cmp(a, b);
60 if (err) <<
61 return err; <<
62 } <<
63 return 0; <<
64 } 69 }
65 70
66 struct dsos__read_build_ids_cb_args { !! 71 int dso__cmp_id(struct dso *a, struct dso *b)
67 bool with_hits; !! 72 {
68 bool have_build_id; !! 73 return __dso_id__cmp(&a->id, &b->id);
69 }; !! 74 }
70 75
71 static int dsos__read_build_ids_cb(struct dso !! 76 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
72 { 77 {
73 struct dsos__read_build_ids_cb_args *a !! 78 bool have_build_id = false;
>> 79 struct dso *pos;
74 struct nscookie nsc; 80 struct nscookie nsc;
75 81
76 if (args->with_hits && !dso__hit(dso) !! 82 list_for_each_entry(pos, head, node) {
77 return 0; !! 83 if (with_hits && !pos->hit && !dso__is_vdso(pos))
78 if (dso__has_build_id(dso)) { !! 84 continue;
79 args->have_build_id = true; !! 85 if (pos->has_build_id) {
80 return 0; !! 86 have_build_id = true;
81 } !! 87 continue;
82 nsinfo__mountns_enter(dso__nsinfo(dso) !! 88 }
83 if (filename__read_build_id(dso__long_ !! 89 nsinfo__mountns_enter(pos->nsinfo, &nsc);
84 args->have_build_id = true; !! 90 if (filename__read_build_id(pos->long_name, &pos->bid) > 0) {
85 dso__set_has_build_id(dso); !! 91 have_build_id = true;
86 } else if (errno == ENOENT && dso__nsi !! 92 pos->has_build_id = true;
87 char *new_name = dso__filename !! 93 } else if (errno == ENOENT && pos->nsinfo) {
88 !! 94 char *new_name = filename_with_chroot(pos->nsinfo->pid,
89 if (new_name && filename__read !! 95 pos->long_name);
90 args->have_build_id = !! 96
91 dso__set_has_build_id( !! 97 if (new_name && filename__read_build_id(new_name,
>> 98 &pos->bid) > 0) {
>> 99 have_build_id = true;
>> 100 pos->has_build_id = true;
>> 101 }
>> 102 free(new_name);
92 } 103 }
93 free(new_name); !! 104 nsinfo__mountns_exit(&nsc);
94 } 105 }
95 nsinfo__mountns_exit(&nsc); <<
96 return 0; <<
97 } <<
98 <<
99 bool dsos__read_build_ids(struct dsos *dsos, b <<
100 { <<
101 struct dsos__read_build_ids_cb_args ar <<
102 .with_hits = with_hits, <<
103 .have_build_id = false, <<
104 }; <<
105 <<
106 dsos__for_each_dso(dsos, dsos__read_bu <<
107 return args.have_build_id; <<
108 } <<
109 106
110 static int __dso__cmp_long_name(const char *lo !! 107 return have_build_id;
111 const struct d <<
112 { <<
113 int rc = strcmp(long_name, dso__long_n <<
114 return rc ?: dso_id__cmp(id, dso__id_c <<
115 } 108 }
116 109
117 static int __dso__cmp_short_name(const char *s !! 110 static int __dso__cmp_long_name(const char *long_name, struct dso_id *id, struct dso *b)
118 const struct <<
119 { 111 {
120 int rc = strcmp(short_name, dso__short !! 112 int rc = strcmp(long_name, b->long_name);
121 return rc ?: dso_id__cmp(id, dso__id_c !! 113 return rc ?: dso_id__cmp(id, &b->id);
122 } 114 }
123 115
124 static int dsos__cmp_long_name_id_short_name(c !! 116 static int __dso__cmp_short_name(const char *short_name, struct dso_id *id, struct dso *b)
125 { 117 {
126 const struct dso *a = *((const struct !! 118 int rc = strcmp(short_name, b->short_name);
127 const struct dso *b = *((const struct !! 119 return rc ?: dso_id__cmp(id, &b->id);
128 int rc = strcmp(dso__long_name(a), dso <<
129 <<
130 if (!rc) { <<
131 rc = dso_id__cmp(dso__id_const <<
132 if (!rc) <<
133 rc = strcmp(dso__short <<
134 } <<
135 return rc; <<
136 } 120 }
137 121
138 struct dsos__key { !! 122 static int dso__cmp_short_name(struct dso *a, struct dso *b)
139 const char *long_name; <<
140 const struct dso_id *id; <<
141 }; <<
142 <<
143 static int dsos__cmp_key_long_name_id(const vo <<
144 { 123 {
145 const struct dsos__key *key = vkey; !! 124 return __dso__cmp_short_name(a->short_name, &a->id, b);
146 const struct dso *dso = *((const struc <<
147 <<
148 return __dso__cmp_long_name(key->long_ <<
149 } 125 }
150 126
151 /* 127 /*
152 * Find a matching entry and/or link current e 128 * Find a matching entry and/or link current entry to RB tree.
153 * Either one of the dso or name parameter mus 129 * Either one of the dso or name parameter must be non-NULL or the
154 * function will not work. 130 * function will not work.
155 */ 131 */
156 static struct dso *__dsos__find_by_longname_id !! 132 struct dso *__dsos__findnew_link_by_longname_id(struct rb_root *root, struct dso *dso,
157 !! 133 const char *name, struct dso_id *id)
158 <<
159 <<
160 { <<
161 struct dsos__key key = { <<
162 .long_name = name, <<
163 .id = id, <<
164 }; <<
165 struct dso **res; <<
166 <<
167 if (dsos->dsos == NULL) <<
168 return NULL; <<
169 <<
170 if (!dsos->sorted) { <<
171 if (!write_locked) { <<
172 struct dso *dso; <<
173 <<
174 up_read(&dsos->lock); <<
175 down_write(&dsos->lock <<
176 dso = __dsos__find_by_ <<
177 <<
178 up_write(&dsos->lock); <<
179 down_read(&dsos->lock) <<
180 return dso; <<
181 } <<
182 qsort(dsos->dsos, dsos->cnt, s <<
183 dsos__cmp_long_name_id_s <<
184 dsos->sorted = true; <<
185 } <<
186 <<
187 res = bsearch(&key, dsos->dsos, dsos-> <<
188 dsos__cmp_key_long_name_ <<
189 if (!res) <<
190 return NULL; <<
191 <<
192 return dso__get(*res); <<
193 } <<
194 <<
195 int __dsos__add(struct dsos *dsos, struct dso <<
196 { 134 {
197 if (dsos->cnt == dsos->allocated) { !! 135 struct rb_node **p = &root->rb_node;
198 unsigned int to_allocate = 2; !! 136 struct rb_node *parent = NULL;
199 struct dso **temp; <<
200 <<
201 if (dsos->allocated > 0) <<
202 to_allocate = dsos->al <<
203 temp = realloc(dsos->dsos, siz <<
204 if (!temp) <<
205 return -ENOMEM; <<
206 dsos->dsos = temp; <<
207 dsos->allocated = to_allocate; <<
208 } <<
209 if (!dsos->sorted) { <<
210 dsos->dsos[dsos->cnt++] = dso_ <<
211 } else { <<
212 int low = 0, high = dsos->cnt <<
213 int insert = dsos->cnt; /* Def <<
214 137
215 while (low <= high) { !! 138 if (!name)
216 int mid = low + (high !! 139 name = dso->long_name;
217 int cmp = dsos__cmp_lo !! 140 /*
218 !! 141 * Find node with the matching name
219 if (cmp < 0) { !! 142 */
220 low = mid + 1; !! 143 while (*p) {
221 } else { !! 144 struct dso *this = rb_entry(*p, struct dso, rb_node);
222 high = mid - 1 !! 145 int rc = __dso__cmp_long_name(name, id, this);
223 insert = mid; !! 146
>> 147 parent = *p;
>> 148 if (rc == 0) {
>> 149 /*
>> 150 * In case the new DSO is a duplicate of an existing
>> 151 * one, print a one-time warning & put the new entry
>> 152 * at the end of the list of duplicates.
>> 153 */
>> 154 if (!dso || (dso == this))
>> 155 return this; /* Find matching dso */
>> 156 /*
>> 157 * The core kernel DSOs may have duplicated long name.
>> 158 * In this case, the short name should be different.
>> 159 * Comparing the short names to differentiate the DSOs.
>> 160 */
>> 161 rc = dso__cmp_short_name(dso, this);
>> 162 if (rc == 0) {
>> 163 pr_err("Duplicated dso name: %s\n", name);
>> 164 return NULL;
224 } 165 }
225 } 166 }
226 memmove(&dsos->dsos[insert + 1 !! 167 if (rc < 0)
227 (dsos->cnt - insert) * !! 168 p = &parent->rb_left;
228 dsos->cnt++; !! 169 else
229 dsos->dsos[insert] = dso__get( !! 170 p = &parent->rb_right;
230 } 171 }
231 dso__set_dsos(dso, dsos); !! 172 if (dso) {
232 return 0; !! 173 /* Add new node and rebalance tree */
>> 174 rb_link_node(&dso->rb_node, parent, p);
>> 175 rb_insert_color(&dso->rb_node, root);
>> 176 dso->root = root;
>> 177 }
>> 178 return NULL;
233 } 179 }
234 180
235 int dsos__add(struct dsos *dsos, struct dso *d !! 181 void __dsos__add(struct dsos *dsos, struct dso *dso)
236 { 182 {
237 int ret; !! 183 list_add_tail(&dso->node, &dsos->head);
>> 184 __dsos__findnew_link_by_longname_id(&dsos->root, dso, NULL, &dso->id);
>> 185 /*
>> 186 * It is now in the linked list, grab a reference, then garbage collect
>> 187 * this when needing memory, by looking at LRU dso instances in the
>> 188 * list with atomic_read(&dso->refcnt) == 1, i.e. no references
>> 189 * anywhere besides the one for the list, do, under a lock for the
>> 190 * list: remove it from the list, then a dso__put(), that probably will
>> 191 * be the last and will then call dso__delete(), end of life.
>> 192 *
>> 193 * That, or at the end of the 'struct machine' lifetime, when all
>> 194 * 'struct dso' instances will be removed from the list, in
>> 195 * dsos__exit(), if they have no other reference from some other data
>> 196 * structure.
>> 197 *
>> 198 * E.g.: after processing a 'perf.data' file and storing references
>> 199 * to objects instantiated while processing events, we will have
>> 200 * references to the 'thread', 'map', 'dso' structs all from 'struct
>> 201 * hist_entry' instances, but we may not need anything not referenced,
>> 202 * so we might as well call machines__exit()/machines__delete() and
>> 203 * garbage collect it.
>> 204 */
>> 205 dso__get(dso);
>> 206 }
238 207
>> 208 void dsos__add(struct dsos *dsos, struct dso *dso)
>> 209 {
239 down_write(&dsos->lock); 210 down_write(&dsos->lock);
240 ret = __dsos__add(dsos, dso); !! 211 __dsos__add(dsos, dso);
241 up_write(&dsos->lock); 212 up_write(&dsos->lock);
242 return ret; <<
243 } 213 }
244 214
245 struct dsos__find_id_cb_args { !! 215 static struct dso *__dsos__findnew_by_longname_id(struct rb_root *root, const char *name, struct dso_id *id)
246 const char *name; !! 216 {
247 struct dso_id *id; !! 217 return __dsos__findnew_link_by_longname_id(root, NULL, name, id);
248 struct dso *res; <<
249 }; <<
250 <<
251 static int dsos__find_id_cb(struct dso *dso, v <<
252 { <<
253 struct dsos__find_id_cb_args *args = d <<
254 <<
255 if (__dso__cmp_short_name(args->name, <<
256 args->res = dso__get(dso); <<
257 return 1; <<
258 } <<
259 return 0; <<
260 <<
261 } 218 }
262 219
263 static struct dso *__dsos__find_id(struct dsos !! 220 static struct dso *__dsos__find_id(struct dsos *dsos, const char *name, struct dso_id *id, bool cmp_short)
264 bool cmp_sh <<
265 { 221 {
266 struct dso *res; !! 222 struct dso *pos;
267 223
268 if (cmp_short) { 224 if (cmp_short) {
269 struct dsos__find_id_cb_args a !! 225 list_for_each_entry(pos, &dsos->head, node)
270 .name = name, !! 226 if (__dso__cmp_short_name(name, id, pos) == 0)
271 .id = id, !! 227 return pos;
272 .res = NULL, !! 228 return NULL;
273 }; <<
274 <<
275 __dsos__for_each_dso(dsos, dso <<
276 return args.res; <<
277 } 229 }
278 res = __dsos__find_by_longname_id(dsos !! 230 return __dsos__findnew_by_longname_id(&dsos->root, name, id);
279 return res; <<
280 } 231 }
281 232
282 struct dso *dsos__find(struct dsos *dsos, cons !! 233 struct dso *__dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
283 { 234 {
284 struct dso *res; !! 235 return __dsos__find_id(dsos, name, NULL, cmp_short);
285 <<
286 down_read(&dsos->lock); <<
287 res = __dsos__find_id(dsos, name, NULL <<
288 up_read(&dsos->lock); <<
289 return res; <<
290 } 236 }
291 237
292 static void dso__set_basename(struct dso *dso) 238 static void dso__set_basename(struct dso *dso)
293 { 239 {
294 char *base, *lname; 240 char *base, *lname;
295 int tid; 241 int tid;
296 242
297 if (perf_pid_map_tid(dso__long_name(ds !! 243 if (sscanf(dso->long_name, "/tmp/perf-%d.map", &tid) == 1) {
298 if (asprintf(&base, "[JIT] tid 244 if (asprintf(&base, "[JIT] tid %d", tid) < 0)
299 return; 245 return;
300 } else { 246 } else {
301 /* 247 /*
302 * basename() may modify path bu 248 * basename() may modify path buffer, so we must pass
303 * a copy. 249 * a copy.
304 */ 250 */
305 lname = strdup(dso__long_name( !! 251 lname = strdup(dso->long_name);
306 if (!lname) 252 if (!lname)
307 return; 253 return;
308 254
309 /* 255 /*
310 * basename() may return a poi 256 * basename() may return a pointer to internal
311 * storage which is reused in 257 * storage which is reused in subsequent calls
312 * so copy the result. 258 * so copy the result.
313 */ 259 */
314 base = strdup(basename(lname)) 260 base = strdup(basename(lname));
315 261
316 free(lname); 262 free(lname);
317 263
318 if (!base) 264 if (!base)
319 return; 265 return;
320 } 266 }
321 dso__set_short_name(dso, base, true); 267 dso__set_short_name(dso, base, true);
322 } 268 }
323 269
324 static struct dso *__dsos__addnew_id(struct ds 270 static struct dso *__dsos__addnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
325 { 271 {
326 struct dso *dso = dso__new_id(name, id 272 struct dso *dso = dso__new_id(name, id);
327 273
328 if (dso != NULL) { 274 if (dso != NULL) {
329 /* <<
330 * The dsos lock is held on en <<
331 * adding it to avoid needing <<
332 * the array isn't sorted. <<
333 */ <<
334 dso__set_basename(dso); <<
335 __dsos__add(dsos, dso); 275 __dsos__add(dsos, dso);
>> 276 dso__set_basename(dso);
>> 277 /* Put dso here because __dsos_add already got it */
>> 278 dso__put(dso);
336 } 279 }
337 return dso; 280 return dso;
338 } 281 }
339 282
>> 283 struct dso *__dsos__addnew(struct dsos *dsos, const char *name)
>> 284 {
>> 285 return __dsos__addnew_id(dsos, name, NULL);
>> 286 }
>> 287
340 static struct dso *__dsos__findnew_id(struct d 288 static struct dso *__dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
341 { 289 {
342 struct dso *dso = __dsos__find_id(dsos !! 290 struct dso *dso = __dsos__find_id(dsos, name, id, false);
343 291
344 if (dso && dso_id__empty(dso__id(dso)) !! 292 if (dso && dso_id__empty(&dso->id) && !dso_id__empty(id))
345 __dso__inject_id(dso, id); !! 293 dso__inject_id(dso, id);
346 294
347 return dso ? dso : __dsos__addnew_id(d 295 return dso ? dso : __dsos__addnew_id(dsos, name, id);
348 } 296 }
349 297
350 struct dso *dsos__findnew_id(struct dsos *dsos 298 struct dso *dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
351 { 299 {
352 struct dso *dso; 300 struct dso *dso;
353 down_write(&dsos->lock); 301 down_write(&dsos->lock);
354 dso = __dsos__findnew_id(dsos, name, i !! 302 dso = dso__get(__dsos__findnew_id(dsos, name, id));
355 up_write(&dsos->lock); 303 up_write(&dsos->lock);
356 return dso; 304 return dso;
357 } 305 }
358 306
359 struct dsos__fprintf_buildid_cb_args { !! 307 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
360 FILE *fp; !! 308 bool (skip)(struct dso *dso, int parm), int parm)
361 bool (*skip)(struct dso *dso, int parm <<
362 int parm; <<
363 size_t ret; <<
364 }; <<
365 <<
366 static int dsos__fprintf_buildid_cb(struct dso <<
367 { 309 {
368 struct dsos__fprintf_buildid_cb_args * !! 310 struct dso *pos;
369 char sbuild_id[SBUILD_ID_SIZE]; !! 311 size_t ret = 0;
370 <<
371 if (args->skip && args->skip(dso, args <<
372 return 0; <<
373 build_id__sprintf(dso__bid(dso), sbuil <<
374 args->ret += fprintf(args->fp, "%-40s <<
375 return 0; <<
376 } <<
377 312
378 size_t dsos__fprintf_buildid(struct dsos *dsos !! 313 list_for_each_entry(pos, head, node) {
379 bool (*skip)(st !! 314 char sbuild_id[SBUILD_ID_SIZE];
380 { <<
381 struct dsos__fprintf_buildid_cb_args a <<
382 .fp = fp, <<
383 .skip = skip, <<
384 .parm = parm, <<
385 .ret = 0, <<
386 }; <<
387 <<
388 dsos__for_each_dso(dsos, dsos__fprintf <<
389 return args.ret; <<
390 } <<
391 <<
392 struct dsos__fprintf_cb_args { <<
393 FILE *fp; <<
394 size_t ret; <<
395 }; <<
396 <<
397 static int dsos__fprintf_cb(struct dso *dso, v <<
398 { <<
399 struct dsos__fprintf_cb_args *args = d <<
400 <<
401 args->ret += dso__fprintf(dso, args->f <<
402 return 0; <<
403 } <<
404 <<
405 size_t dsos__fprintf(struct dsos *dsos, FILE * <<
406 { <<
407 struct dsos__fprintf_cb_args args = { <<
408 .fp = fp, <<
409 .ret = 0, <<
410 }; <<
411 <<
412 dsos__for_each_dso(dsos, dsos__fprintf <<
413 return args.ret; <<
414 } <<
415 <<
416 static int dsos__hit_all_cb(struct dso *dso, v <<
417 { <<
418 dso__set_hit(dso); <<
419 return 0; <<
420 } <<
421 315
422 int dsos__hit_all(struct dsos *dsos) !! 316 if (skip && skip(pos, parm))
423 { !! 317 continue;
424 return dsos__for_each_dso(dsos, dsos__ !! 318 build_id__sprintf(&pos->bid, sbuild_id);
425 } !! 319 ret += fprintf(fp, "%-40s %s\n", sbuild_id, pos->long_name);
426 <<
427 struct dso *dsos__findnew_module_dso(struct ds <<
428 struct ma <<
429 struct km <<
430 const cha <<
431 { <<
432 struct dso *dso; <<
433 <<
434 down_write(&dsos->lock); <<
435 <<
436 dso = __dsos__find_id(dsos, m->name, N <<
437 if (dso) { <<
438 up_write(&dsos->lock); <<
439 return dso; <<
440 } <<
441 /* <<
442 * Failed to find the dso so create it <<
443 * to the array, to avoid unnecessary <<
444 * issues. <<
445 */ <<
446 dso = dso__new_id(m->name, /*id=*/NULL <<
447 if (!dso) { <<
448 up_write(&dsos->lock); <<
449 return NULL; <<
450 } 320 }
451 dso__set_basename(dso); !! 321 return ret;
452 dso__set_module_info(dso, m, machine); <<
453 dso__set_long_name(dso, strdup(filenam <<
454 dso__set_kernel(dso, DSO_SPACE__KERNEL <<
455 __dsos__add(dsos, dso); <<
456 <<
457 up_write(&dsos->lock); <<
458 return dso; <<
459 } <<
460 <<
461 static int dsos__find_kernel_dso_cb(struct dso <<
462 { <<
463 struct dso **res = data; <<
464 /* <<
465 * The cpumode passed to is_kernel_mod <<
466 * event. If we insist on passing corr <<
467 * we should record the cpumode when w <<
468 * list. <<
469 * <<
470 * However we don't really need passin <<
471 * correct cpumode must be kernel mode <<
472 * onto kernel_dsos list). <<
473 * <<
474 * Therefore, we pass PERF_RECORD_MISC <<
475 * is_kernel_module() treats it as a k <<
476 */ <<
477 if (!dso__kernel(dso) || <<
478 is_kernel_module(dso__long_name(ds <<
479 return 0; <<
480 <<
481 *res = dso__get(dso); <<
482 return 1; <<
483 } 322 }
484 323
485 struct dso *dsos__find_kernel_dso(struct dsos !! 324 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
486 { 325 {
487 struct dso *res = NULL; !! 326 struct dso *pos;
488 !! 327 size_t ret = 0;
489 dsos__for_each_dso(dsos, dsos__find_ke <<
490 return res; <<
491 } <<
492 328
493 int dsos__for_each_dso(struct dsos *dsos, int !! 329 list_for_each_entry(pos, head, node) {
494 { !! 330 ret += dso__fprintf(pos, fp);
495 int err; !! 331 }
496 332
497 down_read(&dsos->lock); !! 333 return ret;
498 err = __dsos__for_each_dso(dsos, cb, d <<
499 up_read(&dsos->lock); <<
500 return err; <<
501 } 334 }
502 335
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.