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" <<
6 #include "vdso.h" 5 #include "vdso.h"
7 #include "namespaces.h" 6 #include "namespaces.h"
8 #include <errno.h> <<
9 #include <libgen.h> 7 #include <libgen.h>
10 #include <stdlib.h> 8 #include <stdlib.h>
11 #include <string.h> 9 #include <string.h>
12 #include <symbol.h> // filename__read_build_id 10 #include <symbol.h> // filename__read_build_id
13 #include <unistd.h> <<
14 11
15 void dsos__init(struct dsos *dsos) !! 12 static int __dso_id__cmp(struct dso_id *a, struct dso_id *b)
16 { 13 {
17 init_rwsem(&dsos->lock); !! 14 if (a->maj > b->maj) return -1;
>> 15 if (a->maj < b->maj) return 1;
18 16
19 dsos->cnt = 0; !! 17 if (a->min > b->min) return -1;
20 dsos->allocated = 0; !! 18 if (a->min < b->min) return 1;
21 dsos->dsos = NULL; <<
22 dsos->sorted = true; <<
23 } <<
24 19
25 static void dsos__purge(struct dsos *dsos) !! 20 if (a->ino > b->ino) return -1;
26 { !! 21 if (a->ino < b->ino) return 1;
27 down_write(&dsos->lock); <<
28 22
29 for (unsigned int i = 0; i < dsos->cnt !! 23 if (a->ino_generation > b->ino_generation) return -1;
30 struct dso *dso = dsos->dsos[i !! 24 if (a->ino_generation < b->ino_generation) return 1;
31 25
32 dso__set_dsos(dso, NULL); !! 26 return 0;
33 dso__put(dso); <<
34 } <<
35 <<
36 zfree(&dsos->dsos); <<
37 dsos->cnt = 0; <<
38 dsos->allocated = 0; <<
39 dsos->sorted = true; <<
40 <<
41 up_write(&dsos->lock); <<
42 } 27 }
43 28
44 void dsos__exit(struct dsos *dsos) !! 29 static int dso_id__cmp(struct dso_id *a, struct dso_id *b)
45 { 30 {
46 dsos__purge(dsos); !! 31 /*
47 exit_rwsem(&dsos->lock); !! 32 * The second is always dso->id, so zeroes if not set, assume passing
48 } !! 33 * NULL for a means a zeroed id
>> 34 */
>> 35 if (a == NULL)
>> 36 return 0;
49 37
>> 38 return __dso_id__cmp(a, b);
>> 39 }
50 40
51 static int __dsos__for_each_dso(struct dsos *d !! 41 int dso__cmp_id(struct dso *a, struct dso *b)
52 int (*cb)(stru <<
53 void *data) <<
54 { 42 {
55 for (unsigned int i = 0; i < dsos->cnt !! 43 return __dso_id__cmp(&a->id, &b->id);
56 struct dso *dso = dsos->dsos[i <<
57 int err; <<
58 <<
59 err = cb(dso, data); <<
60 if (err) <<
61 return err; <<
62 } <<
63 return 0; <<
64 } 44 }
65 45
66 struct dsos__read_build_ids_cb_args { !! 46 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
67 bool with_hits; <<
68 bool have_build_id; <<
69 }; <<
70 <<
71 static int dsos__read_build_ids_cb(struct dso <<
72 { 47 {
73 struct dsos__read_build_ids_cb_args *a !! 48 bool have_build_id = false;
>> 49 struct dso *pos;
74 struct nscookie nsc; 50 struct nscookie nsc;
75 51
76 if (args->with_hits && !dso__hit(dso) !! 52 list_for_each_entry(pos, head, node) {
77 return 0; !! 53 if (with_hits && !pos->hit && !dso__is_vdso(pos))
78 if (dso__has_build_id(dso)) { !! 54 continue;
79 args->have_build_id = true; !! 55 if (pos->has_build_id) {
80 return 0; !! 56 have_build_id = true;
81 } !! 57 continue;
82 nsinfo__mountns_enter(dso__nsinfo(dso) <<
83 if (filename__read_build_id(dso__long_ <<
84 args->have_build_id = true; <<
85 dso__set_has_build_id(dso); <<
86 } else if (errno == ENOENT && dso__nsi <<
87 char *new_name = dso__filename <<
88 <<
89 if (new_name && filename__read <<
90 args->have_build_id = <<
91 dso__set_has_build_id( <<
92 } 58 }
93 free(new_name); !! 59 nsinfo__mountns_enter(pos->nsinfo, &nsc);
>> 60 if (filename__read_build_id(pos->long_name, pos->build_id,
>> 61 sizeof(pos->build_id)) > 0) {
>> 62 have_build_id = true;
>> 63 pos->has_build_id = true;
>> 64 }
>> 65 nsinfo__mountns_exit(&nsc);
94 } 66 }
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 67
110 static int __dso__cmp_long_name(const char *lo !! 68 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 } 69 }
116 70
117 static int __dso__cmp_short_name(const char *s !! 71 static int __dso__cmp_long_name(const char *long_name, struct dso_id *id, struct dso *b)
118 const struct <<
119 { 72 {
120 int rc = strcmp(short_name, dso__short !! 73 int rc = strcmp(long_name, b->long_name);
121 return rc ?: dso_id__cmp(id, dso__id_c !! 74 return rc ?: dso_id__cmp(id, &b->id);
122 } 75 }
123 76
124 static int dsos__cmp_long_name_id_short_name(c !! 77 static int __dso__cmp_short_name(const char *short_name, struct dso_id *id, struct dso *b)
125 { 78 {
126 const struct dso *a = *((const struct !! 79 int rc = strcmp(short_name, b->short_name);
127 const struct dso *b = *((const struct !! 80 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 } 81 }
137 82
138 struct dsos__key { !! 83 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 { 84 {
145 const struct dsos__key *key = vkey; !! 85 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 } 86 }
150 87
151 /* 88 /*
152 * Find a matching entry and/or link current e 89 * Find a matching entry and/or link current entry to RB tree.
153 * Either one of the dso or name parameter mus 90 * Either one of the dso or name parameter must be non-NULL or the
154 * function will not work. 91 * function will not work.
155 */ 92 */
156 static struct dso *__dsos__find_by_longname_id !! 93 struct dso *__dsos__findnew_link_by_longname_id(struct rb_root *root, struct dso *dso,
157 !! 94 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 { 95 {
197 if (dsos->cnt == dsos->allocated) { !! 96 struct rb_node **p = &root->rb_node;
198 unsigned int to_allocate = 2; !! 97 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 98
215 while (low <= high) { !! 99 if (!name)
216 int mid = low + (high !! 100 name = dso->long_name;
217 int cmp = dsos__cmp_lo !! 101 /*
218 !! 102 * Find node with the matching name
219 if (cmp < 0) { !! 103 */
220 low = mid + 1; !! 104 while (*p) {
221 } else { !! 105 struct dso *this = rb_entry(*p, struct dso, rb_node);
222 high = mid - 1 !! 106 int rc = __dso__cmp_long_name(name, id, this);
223 insert = mid; !! 107
>> 108 parent = *p;
>> 109 if (rc == 0) {
>> 110 /*
>> 111 * In case the new DSO is a duplicate of an existing
>> 112 * one, print a one-time warning & put the new entry
>> 113 * at the end of the list of duplicates.
>> 114 */
>> 115 if (!dso || (dso == this))
>> 116 return this; /* Find matching dso */
>> 117 /*
>> 118 * The core kernel DSOs may have duplicated long name.
>> 119 * In this case, the short name should be different.
>> 120 * Comparing the short names to differentiate the DSOs.
>> 121 */
>> 122 rc = dso__cmp_short_name(dso, this);
>> 123 if (rc == 0) {
>> 124 pr_err("Duplicated dso name: %s\n", name);
>> 125 return NULL;
224 } 126 }
225 } 127 }
226 memmove(&dsos->dsos[insert + 1 !! 128 if (rc < 0)
227 (dsos->cnt - insert) * !! 129 p = &parent->rb_left;
228 dsos->cnt++; !! 130 else
229 dsos->dsos[insert] = dso__get( !! 131 p = &parent->rb_right;
230 } 132 }
231 dso__set_dsos(dso, dsos); !! 133 if (dso) {
232 return 0; !! 134 /* Add new node and rebalance tree */
>> 135 rb_link_node(&dso->rb_node, parent, p);
>> 136 rb_insert_color(&dso->rb_node, root);
>> 137 dso->root = root;
>> 138 }
>> 139 return NULL;
233 } 140 }
234 141
235 int dsos__add(struct dsos *dsos, struct dso *d !! 142 void __dsos__add(struct dsos *dsos, struct dso *dso)
236 { 143 {
237 int ret; !! 144 list_add_tail(&dso->node, &dsos->head);
>> 145 __dsos__findnew_link_by_longname_id(&dsos->root, dso, NULL, &dso->id);
>> 146 /*
>> 147 * It is now in the linked list, grab a reference, then garbage collect
>> 148 * this when needing memory, by looking at LRU dso instances in the
>> 149 * list with atomic_read(&dso->refcnt) == 1, i.e. no references
>> 150 * anywhere besides the one for the list, do, under a lock for the
>> 151 * list: remove it from the list, then a dso__put(), that probably will
>> 152 * be the last and will then call dso__delete(), end of life.
>> 153 *
>> 154 * That, or at the end of the 'struct machine' lifetime, when all
>> 155 * 'struct dso' instances will be removed from the list, in
>> 156 * dsos__exit(), if they have no other reference from some other data
>> 157 * structure.
>> 158 *
>> 159 * E.g.: after processing a 'perf.data' file and storing references
>> 160 * to objects instantiated while processing events, we will have
>> 161 * references to the 'thread', 'map', 'dso' structs all from 'struct
>> 162 * hist_entry' instances, but we may not need anything not referenced,
>> 163 * so we might as well call machines__exit()/machines__delete() and
>> 164 * garbage collect it.
>> 165 */
>> 166 dso__get(dso);
>> 167 }
238 168
>> 169 void dsos__add(struct dsos *dsos, struct dso *dso)
>> 170 {
239 down_write(&dsos->lock); 171 down_write(&dsos->lock);
240 ret = __dsos__add(dsos, dso); !! 172 __dsos__add(dsos, dso);
241 up_write(&dsos->lock); 173 up_write(&dsos->lock);
242 return ret; <<
243 } 174 }
244 175
245 struct dsos__find_id_cb_args { !! 176 static struct dso *__dsos__findnew_by_longname_id(struct rb_root *root, const char *name, struct dso_id *id)
246 const char *name; !! 177 {
247 struct dso_id *id; !! 178 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 } 179 }
262 180
263 static struct dso *__dsos__find_id(struct dsos !! 181 static struct dso *__dsos__find_id(struct dsos *dsos, const char *name, struct dso_id *id, bool cmp_short)
264 bool cmp_sh <<
265 { 182 {
266 struct dso *res; !! 183 struct dso *pos;
267 184
268 if (cmp_short) { 185 if (cmp_short) {
269 struct dsos__find_id_cb_args a !! 186 list_for_each_entry(pos, &dsos->head, node)
270 .name = name, !! 187 if (__dso__cmp_short_name(name, id, pos) == 0)
271 .id = id, !! 188 return pos;
272 .res = NULL, !! 189 return NULL;
273 }; <<
274 <<
275 __dsos__for_each_dso(dsos, dso <<
276 return args.res; <<
277 } 190 }
278 res = __dsos__find_by_longname_id(dsos !! 191 return __dsos__findnew_by_longname_id(&dsos->root, name, id);
279 return res; <<
280 } 192 }
281 193
282 struct dso *dsos__find(struct dsos *dsos, cons !! 194 struct dso *__dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
283 { 195 {
284 struct dso *res; !! 196 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 } 197 }
291 198
292 static void dso__set_basename(struct dso *dso) 199 static void dso__set_basename(struct dso *dso)
293 { 200 {
294 char *base, *lname; 201 char *base, *lname;
295 int tid; 202 int tid;
296 203
297 if (perf_pid_map_tid(dso__long_name(ds !! 204 if (sscanf(dso->long_name, "/tmp/perf-%d.map", &tid) == 1) {
298 if (asprintf(&base, "[JIT] tid 205 if (asprintf(&base, "[JIT] tid %d", tid) < 0)
299 return; 206 return;
300 } else { 207 } else {
301 /* 208 /*
302 * basename() may modify path bu 209 * basename() may modify path buffer, so we must pass
303 * a copy. 210 * a copy.
304 */ 211 */
305 lname = strdup(dso__long_name( !! 212 lname = strdup(dso->long_name);
306 if (!lname) 213 if (!lname)
307 return; 214 return;
308 215
309 /* 216 /*
310 * basename() may return a poi 217 * basename() may return a pointer to internal
311 * storage which is reused in 218 * storage which is reused in subsequent calls
312 * so copy the result. 219 * so copy the result.
313 */ 220 */
314 base = strdup(basename(lname)) 221 base = strdup(basename(lname));
315 222
316 free(lname); 223 free(lname);
317 224
318 if (!base) 225 if (!base)
319 return; 226 return;
320 } 227 }
321 dso__set_short_name(dso, base, true); 228 dso__set_short_name(dso, base, true);
322 } 229 }
323 230
324 static struct dso *__dsos__addnew_id(struct ds 231 static struct dso *__dsos__addnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
325 { 232 {
326 struct dso *dso = dso__new_id(name, id 233 struct dso *dso = dso__new_id(name, id);
327 234
328 if (dso != NULL) { 235 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); 236 __dsos__add(dsos, dso);
>> 237 dso__set_basename(dso);
>> 238 /* Put dso here because __dsos_add already got it */
>> 239 dso__put(dso);
336 } 240 }
337 return dso; 241 return dso;
338 } 242 }
339 243
340 static struct dso *__dsos__findnew_id(struct d !! 244 struct dso *__dsos__addnew(struct dsos *dsos, const char *name)
341 { 245 {
342 struct dso *dso = __dsos__find_id(dsos !! 246 return __dsos__addnew_id(dsos, name, NULL);
343 !! 247 }
344 if (dso && dso_id__empty(dso__id(dso)) <<
345 __dso__inject_id(dso, id); <<
346 248
>> 249 static struct dso *__dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
>> 250 {
>> 251 struct dso *dso = __dsos__find_id(dsos, name, id, false);
347 return dso ? dso : __dsos__addnew_id(d 252 return dso ? dso : __dsos__addnew_id(dsos, name, id);
348 } 253 }
349 254
350 struct dso *dsos__findnew_id(struct dsos *dsos 255 struct dso *dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
351 { 256 {
352 struct dso *dso; 257 struct dso *dso;
353 down_write(&dsos->lock); 258 down_write(&dsos->lock);
354 dso = __dsos__findnew_id(dsos, name, i !! 259 dso = dso__get(__dsos__findnew_id(dsos, name, id));
355 up_write(&dsos->lock); 260 up_write(&dsos->lock);
356 return dso; 261 return dso;
357 } 262 }
358 263
359 struct dsos__fprintf_buildid_cb_args { !! 264 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
360 FILE *fp; !! 265 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 { <<
368 struct dsos__fprintf_buildid_cb_args * <<
369 char sbuild_id[SBUILD_ID_SIZE]; <<
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 <<
378 size_t dsos__fprintf_buildid(struct dsos *dsos <<
379 bool (*skip)(st <<
380 { 266 {
381 struct dsos__fprintf_buildid_cb_args a !! 267 struct dso *pos;
382 .fp = fp, !! 268 size_t ret = 0;
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 269
422 int dsos__hit_all(struct dsos *dsos) !! 270 list_for_each_entry(pos, head, node) {
423 { !! 271 if (skip && skip(pos, parm))
424 return dsos__for_each_dso(dsos, dsos__ !! 272 continue;
425 } !! 273 ret += dso__fprintf_buildid(pos, fp);
426 !! 274 ret += fprintf(fp, " %s\n", pos->long_name);
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 } 275 }
451 dso__set_basename(dso); !! 276 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 } 277 }
484 278
485 struct dso *dsos__find_kernel_dso(struct dsos !! 279 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
486 { 280 {
487 struct dso *res = NULL; !! 281 struct dso *pos;
488 !! 282 size_t ret = 0;
489 dsos__for_each_dso(dsos, dsos__find_ke <<
490 return res; <<
491 } <<
492 283
493 int dsos__for_each_dso(struct dsos *dsos, int !! 284 list_for_each_entry(pos, head, node) {
494 { !! 285 ret += dso__fprintf(pos, fp);
495 int err; !! 286 }
496 287
497 down_read(&dsos->lock); !! 288 return ret;
498 err = __dsos__for_each_dso(dsos, cb, d <<
499 up_read(&dsos->lock); <<
500 return err; <<
501 } 289 }
502 290
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.