Branch data Line data Source code
1 : : /*
2 : : * kobject.c - library routines for handling generic kernel objects
3 : : *
4 : : * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org>
5 : : * Copyright (c) 2006-2007 Greg Kroah-Hartman <greg@kroah.com>
6 : : * Copyright (c) 2006-2007 Novell Inc.
7 : : *
8 : : * This file is released under the GPLv2.
9 : : *
10 : : *
11 : : * Please see the file Documentation/kobject.txt for critical information
12 : : * about using the kobject interface.
13 : : */
14 : :
15 : : #include <linux/kobject.h>
16 : : #include <linux/kobj_completion.h>
17 : : #include <linux/string.h>
18 : : #include <linux/export.h>
19 : : #include <linux/stat.h>
20 : : #include <linux/slab.h>
21 : :
22 : : /**
23 : : * kobject_namespace - return @kobj's namespace tag
24 : : * @kobj: kobject in question
25 : : *
26 : : * Returns namespace tag of @kobj if its parent has namespace ops enabled
27 : : * and thus @kobj should have a namespace tag associated with it. Returns
28 : : * %NULL otherwise.
29 : : */
30 : 0 : const void *kobject_namespace(struct kobject *kobj)
31 : : {
32 : : const struct kobj_ns_type_operations *ns_ops = kobj_ns_ops(kobj);
33 : :
34 [ - + ][ # # ]: 112 : if (!ns_ops || ns_ops->type == KOBJ_NS_TYPE_NONE)
35 : : return NULL;
36 : :
37 : 0 : return kobj->ktype->namespace(kobj);
38 : : }
39 : :
40 : : /*
41 : : * populate_dir - populate directory with attributes.
42 : : * @kobj: object we're working on.
43 : : *
44 : : * Most subsystems have a set of default attributes that are associated
45 : : * with an object that registers with them. This is a helper called during
46 : : * object registration that loops through the default attributes of the
47 : : * subsystem and creates attributes files for them in sysfs.
48 : : */
49 : 0 : static int populate_dir(struct kobject *kobj)
50 : : {
51 : : struct kobj_type *t = get_ktype(kobj);
52 : : struct attribute *attr;
53 : : int error = 0;
54 : : int i;
55 : :
56 [ + - ][ - + ]: 112 : if (t && t->default_attrs) {
57 [ # # ]: 0 : for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
58 : : error = sysfs_create_file(kobj, attr);
59 [ # # ]: 0 : if (error)
60 : : break;
61 : : }
62 : : }
63 : 0 : return error;
64 : : }
65 : :
66 : 0 : static int create_dir(struct kobject *kobj)
67 : : {
68 : : int error;
69 : :
70 : 112 : error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj));
71 [ + - ]: 112 : if (!error) {
72 : 112 : error = populate_dir(kobj);
73 [ - + ]: 112 : if (error)
74 : 0 : sysfs_remove_dir(kobj);
75 : : }
76 : :
77 : : /*
78 : : * @kobj->sd may be deleted by an ancestor going away. Hold an
79 : : * extra reference so that it stays until @kobj is gone.
80 : : */
81 : 112 : sysfs_get(kobj->sd);
82 : :
83 : 112 : return error;
84 : : }
85 : :
86 : 113 : static int get_kobj_path_length(struct kobject *kobj)
87 : : {
88 : : int length = 1;
89 : 458 : struct kobject *parent = kobj;
90 : :
91 : : /* walk up the ancestors until we hit the one pointing to the
92 : : * root.
93 : : * Add 1 to strlen for leading '/' of each level.
94 : : */
95 : : do {
96 [ + ]: 458 : if (kobject_name(parent) == NULL)
97 : : return 0;
98 : 458 : length += strlen(kobject_name(parent)) + 1;
99 : 458 : parent = parent->parent;
100 [ + + ]: 458 : } while (parent);
101 : : return length;
102 : : }
103 : :
104 : 0 : static void fill_kobj_path(struct kobject *kobj, char *path, int length)
105 : : {
106 : 458 : struct kobject *parent;
107 : :
108 : 113 : --length;
109 [ + + ]: 571 : for (parent = kobj; parent; parent = parent->parent) {
110 : 458 : int cur = strlen(kobject_name(parent));
111 : : /* back up enough to print this name with '/' */
112 : 458 : length -= cur;
113 : 458 : strncpy(path + length, kobject_name(parent), cur);
114 : 458 : *(path + --length) = '/';
115 : : }
116 : :
117 : : pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
118 : : kobj, __func__, path);
119 : 113 : }
120 : :
121 : : /**
122 : : * kobject_get_path - generate and return the path associated with a given kobj and kset pair.
123 : : *
124 : : * @kobj: kobject in question, with which to build the path
125 : : * @gfp_mask: the allocation type used to allocate the path
126 : : *
127 : : * The result must be freed by the caller with kfree().
128 : : */
129 : 0 : char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
130 : : {
131 : : char *path;
132 : : int len;
133 : :
134 : 113 : len = get_kobj_path_length(kobj);
135 [ + - ]: 113 : if (len == 0)
136 : : return NULL;
137 : 113 : path = kzalloc(len, gfp_mask);
138 [ + - ]: 113 : if (!path)
139 : : return NULL;
140 : 113 : fill_kobj_path(kobj, path, len);
141 : :
142 : 113 : return path;
143 : : }
144 : : EXPORT_SYMBOL_GPL(kobject_get_path);
145 : :
146 : : /* add the kobject to its kset's list */
147 : 0 : static void kobj_kset_join(struct kobject *kobj)
148 : : {
149 [ + - ]: 112 : if (!kobj->kset)
150 : 112 : return;
151 : :
152 : : kset_get(kobj->kset);
153 : 112 : spin_lock(&kobj->kset->list_lock);
154 : 112 : list_add_tail(&kobj->entry, &kobj->kset->list);
155 : 112 : spin_unlock(&kobj->kset->list_lock);
156 : : }
157 : :
158 : : /* remove the kobject from its kset's list */
159 : 0 : static void kobj_kset_leave(struct kobject *kobj)
160 : : {
161 [ # # ]: 0 : if (!kobj->kset)
162 : 0 : return;
163 : :
164 : : spin_lock(&kobj->kset->list_lock);
165 : 0 : list_del_init(&kobj->entry);
166 : 0 : spin_unlock(&kobj->kset->list_lock);
167 : 0 : kset_put(kobj->kset);
168 : : }
169 : :
170 : : static void kobject_init_internal(struct kobject *kobj)
171 : : {
172 [ # # ][ # # ]: 224 : if (!kobj)
[ + - ]
173 : : return;
174 : : kref_init(&kobj->kref);
175 : 112 : INIT_LIST_HEAD(&kobj->entry);
176 : 112 : kobj->state_in_sysfs = 0;
177 : 112 : kobj->state_add_uevent_sent = 0;
178 : 112 : kobj->state_remove_uevent_sent = 0;
179 : 112 : kobj->state_initialized = 1;
180 : : }
181 : :
182 : :
183 : 0 : static int kobject_add_internal(struct kobject *kobj)
184 : : {
185 : : int error = 0;
186 : 0 : struct kobject *parent;
187 : :
188 [ + - ]: 112 : if (!kobj)
189 : : return -ENOENT;
190 : :
191 [ + - ][ - + ]: 112 : if (!kobj->name || !kobj->name[0]) {
192 : 0 : WARN(1, "kobject: (%p): attempted to be registered with empty "
193 : : "name!\n", kobj);
194 : 0 : return -EINVAL;
195 : : }
196 : :
197 : 112 : parent = kobject_get(kobj->parent);
198 : :
199 : : /* join kset if set, use it as parent if we do not already have one */
200 [ + - ]: 112 : if (kobj->kset) {
201 [ - + ]: 112 : if (!parent)
202 : 0 : parent = kobject_get(&kobj->kset->kobj);
203 : 112 : kobj_kset_join(kobj);
204 : 112 : kobj->parent = parent;
205 : : }
206 : :
207 : : pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
208 : : kobject_name(kobj), kobj, __func__,
209 : : parent ? kobject_name(parent) : "<NULL>",
210 : : kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
211 : :
212 : 112 : error = create_dir(kobj);
213 [ - + ]: 224 : if (error) {
214 : 0 : kobj_kset_leave(kobj);
215 : 0 : kobject_put(parent);
216 : 0 : kobj->parent = NULL;
217 : :
218 : : /* be noisy on error issues */
219 [ # # ]: 0 : if (error == -EEXIST)
220 : 0 : WARN(1, "%s failed for %s with "
221 : : "-EEXIST, don't try to register things with "
222 : : "the same name in the same directory.\n",
223 : : __func__, kobject_name(kobj));
224 : : else
225 [ # # ]: 0 : WARN(1, "%s failed for %s (error: %d parent: %s)\n",
226 : : __func__, kobject_name(kobj), error,
227 : : parent ? kobject_name(parent) : "'none'");
228 : : } else
229 : 112 : kobj->state_in_sysfs = 1;
230 : :
231 : 112 : return error;
232 : : }
233 : :
234 : : /**
235 : : * kobject_set_name_vargs - Set the name of an kobject
236 : : * @kobj: struct kobject to set the name of
237 : : * @fmt: format string used to build the name
238 : : * @vargs: vargs to format the string.
239 : : */
240 : 0 : int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
241 : : va_list vargs)
242 : : {
243 : 224 : const char *old_name = kobj->name;
244 : : char *s;
245 : :
246 [ + + ][ - + ]: 224 : if (kobj->name && !fmt)
247 : : return 0;
248 : :
249 : 112 : kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
250 [ + - ]: 112 : if (!kobj->name)
251 : : return -ENOMEM;
252 : :
253 : : /* ewww... some of these buggers have '/' in the name ... */
254 [ - + ]: 112 : while ((s = strchr(kobj->name, '/')))
255 : 0 : s[0] = '!';
256 : :
257 : 112 : kfree(old_name);
258 : 112 : return 0;
259 : : }
260 : :
261 : : /**
262 : : * kobject_set_name - Set the name of a kobject
263 : : * @kobj: struct kobject to set the name of
264 : : * @fmt: format string used to build the name
265 : : *
266 : : * This sets the name of the kobject. If you have already added the
267 : : * kobject to the system, you must call kobject_rename() in order to
268 : : * change the name of the kobject.
269 : : */
270 : 0 : int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
271 : : {
272 : : va_list vargs;
273 : : int retval;
274 : :
275 : 0 : va_start(vargs, fmt);
276 : 0 : retval = kobject_set_name_vargs(kobj, fmt, vargs);
277 : 0 : va_end(vargs);
278 : :
279 : 0 : return retval;
280 : : }
281 : : EXPORT_SYMBOL(kobject_set_name);
282 : :
283 : : /**
284 : : * kobject_init - initialize a kobject structure
285 : : * @kobj: pointer to the kobject to initialize
286 : : * @ktype: pointer to the ktype for this kobject.
287 : : *
288 : : * This function will properly initialize a kobject such that it can then
289 : : * be passed to the kobject_add() call.
290 : : *
291 : : * After this function is called, the kobject MUST be cleaned up by a call
292 : : * to kobject_put(), not by a call to kfree directly to ensure that all of
293 : : * the memory is cleaned up properly.
294 : : */
295 : 0 : void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
296 : : {
297 : : char *err_str;
298 : :
299 [ + - ]: 112 : if (!kobj) {
300 : : err_str = "invalid kobject pointer!";
301 : : goto error;
302 : : }
303 [ + - ]: 112 : if (!ktype) {
304 : : err_str = "must have a ktype to be initialized properly!\n";
305 : : goto error;
306 : : }
307 [ - + ]: 112 : if (kobj->state_initialized) {
308 : : /* do not error out as sometimes we can recover */
309 : 0 : printk(KERN_ERR "kobject (%p): tried to init an initialized "
310 : : "object, something is seriously wrong.\n", kobj);
311 : 0 : dump_stack();
312 : : }
313 : :
314 : : kobject_init_internal(kobj);
315 : 112 : kobj->ktype = ktype;
316 : 112 : return;
317 : :
318 : : error:
319 : 0 : printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
320 : 0 : dump_stack();
321 : : }
322 : : EXPORT_SYMBOL(kobject_init);
323 : :
324 : 0 : static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
325 : : const char *fmt, va_list vargs)
326 : : {
327 : : int retval;
328 : :
329 : 112 : retval = kobject_set_name_vargs(kobj, fmt, vargs);
330 [ - + ]: 112 : if (retval) {
331 : 0 : printk(KERN_ERR "kobject: can not set name properly!\n");
332 : 0 : return retval;
333 : : }
334 : 112 : kobj->parent = parent;
335 : 112 : return kobject_add_internal(kobj);
336 : : }
337 : :
338 : : /**
339 : : * kobject_add - the main kobject add function
340 : : * @kobj: the kobject to add
341 : : * @parent: pointer to the parent of the kobject.
342 : : * @fmt: format to name the kobject with.
343 : : *
344 : : * The kobject name is set and added to the kobject hierarchy in this
345 : : * function.
346 : : *
347 : : * If @parent is set, then the parent of the @kobj will be set to it.
348 : : * If @parent is NULL, then the parent of the @kobj will be set to the
349 : : * kobject associted with the kset assigned to this kobject. If no kset
350 : : * is assigned to the kobject, then the kobject will be located in the
351 : : * root of the sysfs tree.
352 : : *
353 : : * If this function returns an error, kobject_put() must be called to
354 : : * properly clean up the memory associated with the object.
355 : : * Under no instance should the kobject that is passed to this function
356 : : * be directly freed with a call to kfree(), that can leak memory.
357 : : *
358 : : * Note, no "add" uevent will be created with this call, the caller should set
359 : : * up all of the necessary sysfs files for the object and then call
360 : : * kobject_uevent() with the UEVENT_ADD parameter to ensure that
361 : : * userspace is properly notified of this kobject's creation.
362 : : */
363 : 0 : int kobject_add(struct kobject *kobj, struct kobject *parent,
364 : : const char *fmt, ...)
365 : : {
366 : : va_list args;
367 : : int retval;
368 : :
369 [ + - ]: 112 : if (!kobj)
370 : : return -EINVAL;
371 : :
372 [ - + ]: 112 : if (!kobj->state_initialized) {
373 : 0 : printk(KERN_ERR "kobject '%s' (%p): tried to add an "
374 : : "uninitialized object, something is seriously wrong.\n",
375 : : kobject_name(kobj), kobj);
376 : 0 : dump_stack();
377 : 0 : return -EINVAL;
378 : : }
379 : 112 : va_start(args, fmt);
380 : 112 : retval = kobject_add_varg(kobj, parent, fmt, args);
381 : 112 : va_end(args);
382 : :
383 : 112 : return retval;
384 : : }
385 : : EXPORT_SYMBOL(kobject_add);
386 : :
387 : : /**
388 : : * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
389 : : * @kobj: pointer to the kobject to initialize
390 : : * @ktype: pointer to the ktype for this kobject.
391 : : * @parent: pointer to the parent of this kobject.
392 : : * @fmt: the name of the kobject.
393 : : *
394 : : * This function combines the call to kobject_init() and
395 : : * kobject_add(). The same type of error handling after a call to
396 : : * kobject_add() and kobject lifetime rules are the same here.
397 : : */
398 : 0 : int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
399 : : struct kobject *parent, const char *fmt, ...)
400 : : {
401 : : va_list args;
402 : : int retval;
403 : :
404 : 0 : kobject_init(kobj, ktype);
405 : :
406 : 0 : va_start(args, fmt);
407 : 0 : retval = kobject_add_varg(kobj, parent, fmt, args);
408 : 0 : va_end(args);
409 : :
410 : 0 : return retval;
411 : : }
412 : : EXPORT_SYMBOL_GPL(kobject_init_and_add);
413 : :
414 : : /**
415 : : * kobject_rename - change the name of an object
416 : : * @kobj: object in question.
417 : : * @new_name: object's new name
418 : : *
419 : : * It is the responsibility of the caller to provide mutual
420 : : * exclusion between two different calls of kobject_rename
421 : : * on the same kobject and to ensure that new_name is valid and
422 : : * won't conflict with other kobjects.
423 : : */
424 : 0 : int kobject_rename(struct kobject *kobj, const char *new_name)
425 : : {
426 : : int error = 0;
427 : : const char *devpath = NULL;
428 : : const char *dup_name = NULL, *name;
429 : : char *devpath_string = NULL;
430 : : char *envp[2];
431 : :
432 : 0 : kobj = kobject_get(kobj);
433 [ # # ]: 0 : if (!kobj)
434 : : return -EINVAL;
435 [ # # ]: 0 : if (!kobj->parent)
436 : : return -EINVAL;
437 : :
438 : 0 : devpath = kobject_get_path(kobj, GFP_KERNEL);
439 [ # # ]: 0 : if (!devpath) {
440 : : error = -ENOMEM;
441 : : goto out;
442 : : }
443 [ # # ]: 0 : devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
444 [ # # ]: 0 : if (!devpath_string) {
445 : : error = -ENOMEM;
446 : : goto out;
447 : : }
448 : 0 : sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
449 : 0 : envp[0] = devpath_string;
450 : 0 : envp[1] = NULL;
451 : :
452 : 0 : name = dup_name = kstrdup(new_name, GFP_KERNEL);
453 [ # # ]: 0 : if (!name) {
454 : : error = -ENOMEM;
455 : : goto out;
456 : : }
457 : :
458 : 0 : error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
459 [ # # ]: 0 : if (error)
460 : : goto out;
461 : :
462 : : /* Install the new kobject name */
463 : 0 : dup_name = kobj->name;
464 : 0 : kobj->name = name;
465 : :
466 : : /* This function is mostly/only used for network interface.
467 : : * Some hotplug package track interfaces by their name and
468 : : * therefore want to know when the name is changed by the user. */
469 : 0 : kobject_uevent_env(kobj, KOBJ_MOVE, envp);
470 : :
471 : : out:
472 : 0 : kfree(dup_name);
473 : 0 : kfree(devpath_string);
474 : 0 : kfree(devpath);
475 : 0 : kobject_put(kobj);
476 : :
477 : 0 : return error;
478 : : }
479 : : EXPORT_SYMBOL_GPL(kobject_rename);
480 : :
481 : : /**
482 : : * kobject_move - move object to another parent
483 : : * @kobj: object in question.
484 : : * @new_parent: object's new parent (can be NULL)
485 : : */
486 : 0 : int kobject_move(struct kobject *kobj, struct kobject *new_parent)
487 : : {
488 : : int error;
489 : : struct kobject *old_parent;
490 : : const char *devpath = NULL;
491 : : char *devpath_string = NULL;
492 : : char *envp[2];
493 : :
494 : 0 : kobj = kobject_get(kobj);
495 [ # # ]: 0 : if (!kobj)
496 : : return -EINVAL;
497 : 0 : new_parent = kobject_get(new_parent);
498 [ # # ]: 0 : if (!new_parent) {
499 [ # # ]: 0 : if (kobj->kset)
500 : 0 : new_parent = kobject_get(&kobj->kset->kobj);
501 : : }
502 : :
503 : : /* old object path */
504 : 0 : devpath = kobject_get_path(kobj, GFP_KERNEL);
505 [ # # ]: 0 : if (!devpath) {
506 : : error = -ENOMEM;
507 : : goto out;
508 : : }
509 : 0 : devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
510 [ # # ]: 0 : if (!devpath_string) {
511 : : error = -ENOMEM;
512 : : goto out;
513 : : }
514 : 0 : sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
515 : 0 : envp[0] = devpath_string;
516 : 0 : envp[1] = NULL;
517 : 0 : error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj));
518 [ # # ]: 0 : if (error)
519 : : goto out;
520 : 0 : old_parent = kobj->parent;
521 : 0 : kobj->parent = new_parent;
522 : : new_parent = NULL;
523 : 0 : kobject_put(old_parent);
524 : 0 : kobject_uevent_env(kobj, KOBJ_MOVE, envp);
525 : : out:
526 : 0 : kobject_put(new_parent);
527 : 0 : kobject_put(kobj);
528 : 0 : kfree(devpath_string);
529 : 0 : kfree(devpath);
530 : 0 : return error;
531 : : }
532 : :
533 : : /**
534 : : * kobject_del - unlink kobject from hierarchy.
535 : : * @kobj: object.
536 : : */
537 : 0 : void kobject_del(struct kobject *kobj)
538 : : {
539 : : struct sysfs_dirent *sd;
540 : :
541 [ # # ]: 0 : if (!kobj)
542 : 0 : return;
543 : :
544 : 0 : sd = kobj->sd;
545 : 0 : sysfs_remove_dir(kobj);
546 : 0 : sysfs_put(sd);
547 : :
548 : 0 : kobj->state_in_sysfs = 0;
549 : 0 : kobj_kset_leave(kobj);
550 : 0 : kobject_put(kobj->parent);
551 : 0 : kobj->parent = NULL;
552 : : }
553 : :
554 : : /**
555 : : * kobject_get - increment refcount for object.
556 : : * @kobj: object.
557 : : */
558 : 0 : struct kobject *kobject_get(struct kobject *kobj)
559 : : {
560 [ + + ]: 1917836 : if (kobj)
561 : : kref_get(&kobj->kref);
562 : 1917842 : return kobj;
563 : : }
564 : :
565 : 0 : static struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
566 : : {
567 [ # # ]: 0 : if (!kref_get_unless_zero(&kobj->kref))
568 : : kobj = NULL;
569 : 0 : return kobj;
570 : : }
571 : :
572 : : /*
573 : : * kobject_cleanup - free kobject resources.
574 : : * @kobj: object to cleanup
575 : : */
576 : 0 : static void kobject_cleanup(struct kobject *kobj)
577 : : {
578 : : struct kobj_type *t = get_ktype(kobj);
579 : 0 : const char *name = kobj->name;
580 : :
581 : : pr_debug("kobject: '%s' (%p): %s, parent %p\n",
582 : : kobject_name(kobj), kobj, __func__, kobj->parent);
583 : :
584 : : if (t && !t->release)
585 : : pr_debug("kobject: '%s' (%p): does not have a release() "
586 : : "function, it is broken and must be fixed.\n",
587 : : kobject_name(kobj), kobj);
588 : :
589 : : /* send "remove" if the caller did not do it but sent "add" */
590 [ # # ]: 0 : if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
591 : : pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
592 : : kobject_name(kobj), kobj);
593 : 0 : kobject_uevent(kobj, KOBJ_REMOVE);
594 : : }
595 : :
596 : : /* remove from sysfs if the caller did not do it */
597 [ # # ]: 0 : if (kobj->state_in_sysfs) {
598 : : pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
599 : : kobject_name(kobj), kobj);
600 : 0 : kobject_del(kobj);
601 : : }
602 : :
603 [ # # ][ # # ]: 0 : if (t && t->release) {
604 : : pr_debug("kobject: '%s' (%p): calling ktype release\n",
605 : : kobject_name(kobj), kobj);
606 : 0 : t->release(kobj);
607 : : }
608 : :
609 : : /* free name if we allocated it */
610 [ # # ]: 0 : if (name) {
611 : : pr_debug("kobject: '%s': free name\n", name);
612 : 0 : kfree(name);
613 : : }
614 : 0 : }
615 : :
616 : : #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
617 : : static void kobject_delayed_cleanup(struct work_struct *work)
618 : : {
619 : : kobject_cleanup(container_of(to_delayed_work(work),
620 : : struct kobject, release));
621 : : }
622 : : #endif
623 : :
624 : 0 : static void kobject_release(struct kref *kref)
625 : : {
626 : 0 : struct kobject *kobj = container_of(kref, struct kobject, kref);
627 : : #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
628 : : pr_info("kobject: '%s' (%p): %s, parent %p (delayed)\n",
629 : : kobject_name(kobj), kobj, __func__, kobj->parent);
630 : : INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
631 : : schedule_delayed_work(&kobj->release, HZ);
632 : : #else
633 : 0 : kobject_cleanup(kobj);
634 : : #endif
635 : 0 : }
636 : :
637 : : /**
638 : : * kobject_put - decrement refcount for object.
639 : : * @kobj: object.
640 : : *
641 : : * Decrement the refcount, and if 0, call kobject_cleanup().
642 : : */
643 : 0 : void kobject_put(struct kobject *kobj)
644 : : {
645 [ + + ]: 1917395 : if (kobj) {
646 [ - + ]: 1917388 : if (!kobj->state_initialized)
647 : 0 : WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
648 : : "initialized, yet kobject_put() is being "
649 : : "called.\n", kobject_name(kobj), kobj);
650 : 1917388 : kref_put(&kobj->kref, kobject_release);
651 : : }
652 : 4 : }
653 : :
654 : 0 : static void dynamic_kobj_release(struct kobject *kobj)
655 : : {
656 : : pr_debug("kobject: (%p): %s\n", kobj, __func__);
657 : 0 : kfree(kobj);
658 : 0 : }
659 : :
660 : : static struct kobj_type dynamic_kobj_ktype = {
661 : : .release = dynamic_kobj_release,
662 : : .sysfs_ops = &kobj_sysfs_ops,
663 : : };
664 : :
665 : : /**
666 : : * kobject_create - create a struct kobject dynamically
667 : : *
668 : : * This function creates a kobject structure dynamically and sets it up
669 : : * to be a "dynamic" kobject with a default release function set up.
670 : : *
671 : : * If the kobject was not able to be created, NULL will be returned.
672 : : * The kobject structure returned from here must be cleaned up with a
673 : : * call to kobject_put() and not kfree(), as kobject_init() has
674 : : * already been called on this structure.
675 : : */
676 : 0 : struct kobject *kobject_create(void)
677 : : {
678 : : struct kobject *kobj;
679 : :
680 : : kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
681 [ # # ]: 0 : if (!kobj)
682 : : return NULL;
683 : :
684 : 0 : kobject_init(kobj, &dynamic_kobj_ktype);
685 : 0 : return kobj;
686 : : }
687 : :
688 : : /**
689 : : * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
690 : : *
691 : : * @name: the name for the kobject
692 : : * @parent: the parent kobject of this kobject, if any.
693 : : *
694 : : * This function creates a kobject structure dynamically and registers it
695 : : * with sysfs. When you are finished with this structure, call
696 : : * kobject_put() and the structure will be dynamically freed when
697 : : * it is no longer being used.
698 : : *
699 : : * If the kobject was not able to be created, NULL will be returned.
700 : : */
701 : 0 : struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
702 : : {
703 : : struct kobject *kobj;
704 : : int retval;
705 : :
706 : 0 : kobj = kobject_create();
707 [ # # ]: 0 : if (!kobj)
708 : : return NULL;
709 : :
710 : 0 : retval = kobject_add(kobj, parent, "%s", name);
711 [ # # ]: 0 : if (retval) {
712 : 0 : printk(KERN_WARNING "%s: kobject_add error: %d\n",
713 : : __func__, retval);
714 : 0 : kobject_put(kobj);
715 : : kobj = NULL;
716 : : }
717 : 0 : return kobj;
718 : : }
719 : : EXPORT_SYMBOL_GPL(kobject_create_and_add);
720 : :
721 : : /**
722 : : * kset_init - initialize a kset for use
723 : : * @k: kset
724 : : */
725 : 0 : void kset_init(struct kset *k)
726 : : {
727 : 0 : kobject_init_internal(&k->kobj);
728 : 0 : INIT_LIST_HEAD(&k->list);
729 : 0 : spin_lock_init(&k->list_lock);
730 : 0 : }
731 : :
732 : : /* default kobject attribute operations */
733 : 0 : static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
734 : : char *buf)
735 : : {
736 : : struct kobj_attribute *kattr;
737 : : ssize_t ret = -EIO;
738 : :
739 : : kattr = container_of(attr, struct kobj_attribute, attr);
740 [ # # ]: 0 : if (kattr->show)
741 : 0 : ret = kattr->show(kobj, kattr, buf);
742 : 0 : return ret;
743 : : }
744 : :
745 : 0 : static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
746 : : const char *buf, size_t count)
747 : : {
748 : : struct kobj_attribute *kattr;
749 : : ssize_t ret = -EIO;
750 : :
751 : : kattr = container_of(attr, struct kobj_attribute, attr);
752 [ # # ]: 0 : if (kattr->store)
753 : 0 : ret = kattr->store(kobj, kattr, buf, count);
754 : 0 : return ret;
755 : : }
756 : :
757 : : const struct sysfs_ops kobj_sysfs_ops = {
758 : : .show = kobj_attr_show,
759 : : .store = kobj_attr_store,
760 : : };
761 : :
762 : : /**
763 : : * kobj_completion_init - initialize a kobj_completion object.
764 : : * @kc: kobj_completion
765 : : * @ktype: type of kobject to initialize
766 : : *
767 : : * kobj_completion structures can be embedded within structures with different
768 : : * lifetime rules. During the release of the enclosing object, we can
769 : : * wait on the release of the kobject so that we don't free it while it's
770 : : * still busy.
771 : : */
772 : 0 : void kobj_completion_init(struct kobj_completion *kc, struct kobj_type *ktype)
773 : : {
774 : : init_completion(&kc->kc_unregister);
775 : 0 : kobject_init(&kc->kc_kobj, ktype);
776 : 0 : }
777 : : EXPORT_SYMBOL_GPL(kobj_completion_init);
778 : :
779 : : /**
780 : : * kobj_completion_release - release a kobj_completion object
781 : : * @kobj: kobject embedded in kobj_completion
782 : : *
783 : : * Used with kobject_release to notify waiters that the kobject has been
784 : : * released.
785 : : */
786 : 0 : void kobj_completion_release(struct kobject *kobj)
787 : : {
788 : : struct kobj_completion *kc = kobj_to_kobj_completion(kobj);
789 : 0 : complete(&kc->kc_unregister);
790 : 0 : }
791 : : EXPORT_SYMBOL_GPL(kobj_completion_release);
792 : :
793 : : /**
794 : : * kobj_completion_del_and_wait - release the kobject and wait for it
795 : : * @kc: kobj_completion object to release
796 : : *
797 : : * Delete the kobject from sysfs and drop the reference count. Then wait
798 : : * until any other outstanding references are also dropped. This routine
799 : : * is only necessary once other references may have been taken on the
800 : : * kobject. Typically this happens when the kobject has been published
801 : : * to sysfs via kobject_add.
802 : : */
803 : 0 : void kobj_completion_del_and_wait(struct kobj_completion *kc)
804 : : {
805 : 0 : kobject_del(&kc->kc_kobj);
806 : 0 : kobject_put(&kc->kc_kobj);
807 : 0 : wait_for_completion(&kc->kc_unregister);
808 : 0 : }
809 : : EXPORT_SYMBOL_GPL(kobj_completion_del_and_wait);
810 : :
811 : : /**
812 : : * kset_register - initialize and add a kset.
813 : : * @k: kset.
814 : : */
815 : 0 : int kset_register(struct kset *k)
816 : : {
817 : : int err;
818 : :
819 [ # # ]: 0 : if (!k)
820 : : return -EINVAL;
821 : :
822 : : kset_init(k);
823 : 0 : err = kobject_add_internal(&k->kobj);
824 [ # # ]: 0 : if (err)
825 : : return err;
826 : 0 : kobject_uevent(&k->kobj, KOBJ_ADD);
827 : 0 : return 0;
828 : : }
829 : :
830 : : /**
831 : : * kset_unregister - remove a kset.
832 : : * @k: kset.
833 : : */
834 : 0 : void kset_unregister(struct kset *k)
835 : : {
836 [ # # ]: 0 : if (!k)
837 : 0 : return;
838 : 0 : kobject_put(&k->kobj);
839 : : }
840 : :
841 : : /**
842 : : * kset_find_obj - search for object in kset.
843 : : * @kset: kset we're looking in.
844 : : * @name: object's name.
845 : : *
846 : : * Lock kset via @kset->subsys, and iterate over @kset->list,
847 : : * looking for a matching kobject. If matching object is found
848 : : * take a reference and return the object.
849 : : */
850 : 0 : struct kobject *kset_find_obj(struct kset *kset, const char *name)
851 : : {
852 : 0 : struct kobject *k;
853 : : struct kobject *ret = NULL;
854 : :
855 : : spin_lock(&kset->list_lock);
856 : :
857 [ # # ]: 0 : list_for_each_entry(k, &kset->list, entry) {
858 [ # # ][ # # ]: 0 : if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
859 : 0 : ret = kobject_get_unless_zero(k);
860 : 0 : break;
861 : : }
862 : : }
863 : :
864 : : spin_unlock(&kset->list_lock);
865 : 0 : return ret;
866 : : }
867 : :
868 : 0 : static void kset_release(struct kobject *kobj)
869 : : {
870 : 0 : struct kset *kset = container_of(kobj, struct kset, kobj);
871 : : pr_debug("kobject: '%s' (%p): %s\n",
872 : : kobject_name(kobj), kobj, __func__);
873 : 0 : kfree(kset);
874 : 0 : }
875 : :
876 : : static struct kobj_type kset_ktype = {
877 : : .sysfs_ops = &kobj_sysfs_ops,
878 : : .release = kset_release,
879 : : };
880 : :
881 : : /**
882 : : * kset_create - create a struct kset dynamically
883 : : *
884 : : * @name: the name for the kset
885 : : * @uevent_ops: a struct kset_uevent_ops for the kset
886 : : * @parent_kobj: the parent kobject of this kset, if any.
887 : : *
888 : : * This function creates a kset structure dynamically. This structure can
889 : : * then be registered with the system and show up in sysfs with a call to
890 : : * kset_register(). When you are finished with this structure, if
891 : : * kset_register() has been called, call kset_unregister() and the
892 : : * structure will be dynamically freed when it is no longer being used.
893 : : *
894 : : * If the kset was not able to be created, NULL will be returned.
895 : : */
896 : 0 : static struct kset *kset_create(const char *name,
897 : : const struct kset_uevent_ops *uevent_ops,
898 : : struct kobject *parent_kobj)
899 : : {
900 : : struct kset *kset;
901 : : int retval;
902 : :
903 : : kset = kzalloc(sizeof(*kset), GFP_KERNEL);
904 [ # # ]: 0 : if (!kset)
905 : : return NULL;
906 : 0 : retval = kobject_set_name(&kset->kobj, "%s", name);
907 [ # # ]: 0 : if (retval) {
908 : 0 : kfree(kset);
909 : 0 : return NULL;
910 : : }
911 : 0 : kset->uevent_ops = uevent_ops;
912 : 0 : kset->kobj.parent = parent_kobj;
913 : :
914 : : /*
915 : : * The kobject of this kset will have a type of kset_ktype and belong to
916 : : * no kset itself. That way we can properly free it when it is
917 : : * finished being used.
918 : : */
919 : 0 : kset->kobj.ktype = &kset_ktype;
920 : 0 : kset->kobj.kset = NULL;
921 : :
922 : 0 : return kset;
923 : : }
924 : :
925 : : /**
926 : : * kset_create_and_add - create a struct kset dynamically and add it to sysfs
927 : : *
928 : : * @name: the name for the kset
929 : : * @uevent_ops: a struct kset_uevent_ops for the kset
930 : : * @parent_kobj: the parent kobject of this kset, if any.
931 : : *
932 : : * This function creates a kset structure dynamically and registers it
933 : : * with sysfs. When you are finished with this structure, call
934 : : * kset_unregister() and the structure will be dynamically freed when it
935 : : * is no longer being used.
936 : : *
937 : : * If the kset was not able to be created, NULL will be returned.
938 : : */
939 : 0 : struct kset *kset_create_and_add(const char *name,
940 : : const struct kset_uevent_ops *uevent_ops,
941 : : struct kobject *parent_kobj)
942 : : {
943 : : struct kset *kset;
944 : : int error;
945 : :
946 : 0 : kset = kset_create(name, uevent_ops, parent_kobj);
947 [ # # ]: 0 : if (!kset)
948 : : return NULL;
949 : 0 : error = kset_register(kset);
950 [ # # ]: 0 : if (error) {
951 : 0 : kfree(kset);
952 : 0 : return NULL;
953 : : }
954 : : return kset;
955 : : }
956 : : EXPORT_SYMBOL_GPL(kset_create_and_add);
957 : :
958 : :
959 : : static DEFINE_SPINLOCK(kobj_ns_type_lock);
960 : : static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
961 : :
962 : 0 : int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
963 : : {
964 : 0 : enum kobj_ns_type type = ops->type;
965 : : int error;
966 : :
967 : : spin_lock(&kobj_ns_type_lock);
968 : :
969 : : error = -EINVAL;
970 [ # # ]: 0 : if (type >= KOBJ_NS_TYPES)
971 : : goto out;
972 : :
973 : : error = -EINVAL;
974 [ # # ]: 0 : if (type <= KOBJ_NS_TYPE_NONE)
975 : : goto out;
976 : :
977 : : error = -EBUSY;
978 [ # # ]: 0 : if (kobj_ns_ops_tbl[type])
979 : : goto out;
980 : :
981 : : error = 0;
982 : 0 : kobj_ns_ops_tbl[type] = ops;
983 : :
984 : : out:
985 : : spin_unlock(&kobj_ns_type_lock);
986 : 0 : return error;
987 : : }
988 : :
989 : 0 : int kobj_ns_type_registered(enum kobj_ns_type type)
990 : : {
991 : : int registered = 0;
992 : :
993 : : spin_lock(&kobj_ns_type_lock);
994 [ # # ]: 0 : if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
995 : 0 : registered = kobj_ns_ops_tbl[type] != NULL;
996 : : spin_unlock(&kobj_ns_type_lock);
997 : :
998 : 0 : return registered;
999 : : }
1000 : :
1001 : 0 : const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
1002 : : {
1003 : : const struct kobj_ns_type_operations *ops = NULL;
1004 : :
1005 [ + - ][ + - ]: 448 : if (parent && parent->ktype->child_ns_type)
[ + - ][ - + ]
[ + - ][ + - ]
1006 : 336 : ops = parent->ktype->child_ns_type(parent);
1007 : :
1008 : 0 : return ops;
1009 : : }
1010 : :
1011 : 0 : const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
1012 : : {
1013 : 336 : return kobj_child_ns_ops(kobj->parent);
1014 : : }
1015 : :
1016 : 0 : bool kobj_ns_current_may_mount(enum kobj_ns_type type)
1017 : : {
1018 : : bool may_mount = true;
1019 : :
1020 : : spin_lock(&kobj_ns_type_lock);
1021 [ # # ][ # # ]: 0 : if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1022 : 0 : kobj_ns_ops_tbl[type])
1023 : 0 : may_mount = kobj_ns_ops_tbl[type]->current_may_mount();
1024 : : spin_unlock(&kobj_ns_type_lock);
1025 : :
1026 : 0 : return may_mount;
1027 : : }
1028 : :
1029 : 0 : void *kobj_ns_grab_current(enum kobj_ns_type type)
1030 : : {
1031 : : void *ns = NULL;
1032 : :
1033 : : spin_lock(&kobj_ns_type_lock);
1034 [ # # ][ # # ]: 0 : if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1035 : 0 : kobj_ns_ops_tbl[type])
1036 : 0 : ns = kobj_ns_ops_tbl[type]->grab_current_ns();
1037 : : spin_unlock(&kobj_ns_type_lock);
1038 : :
1039 : 0 : return ns;
1040 : : }
1041 : :
1042 : 0 : const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
1043 : : {
1044 : : const void *ns = NULL;
1045 : :
1046 : : spin_lock(&kobj_ns_type_lock);
1047 [ # # ][ # # ]: 0 : if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1048 : 0 : kobj_ns_ops_tbl[type])
1049 : 0 : ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
1050 : : spin_unlock(&kobj_ns_type_lock);
1051 : :
1052 : 0 : return ns;
1053 : : }
1054 : :
1055 : 0 : const void *kobj_ns_initial(enum kobj_ns_type type)
1056 : : {
1057 : : const void *ns = NULL;
1058 : :
1059 : : spin_lock(&kobj_ns_type_lock);
1060 [ # # ][ # # ]: 0 : if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1061 : 0 : kobj_ns_ops_tbl[type])
1062 : 0 : ns = kobj_ns_ops_tbl[type]->initial_ns();
1063 : : spin_unlock(&kobj_ns_type_lock);
1064 : :
1065 : 0 : return ns;
1066 : : }
1067 : :
1068 : 0 : void kobj_ns_drop(enum kobj_ns_type type, void *ns)
1069 : : {
1070 : : spin_lock(&kobj_ns_type_lock);
1071 [ # # ][ # # ]: 0 : if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
1072 [ # # ]: 0 : kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
1073 : 0 : kobj_ns_ops_tbl[type]->drop_ns(ns);
1074 : : spin_unlock(&kobj_ns_type_lock);
1075 : 0 : }
1076 : :
1077 : : EXPORT_SYMBOL(kobject_get);
1078 : : EXPORT_SYMBOL(kobject_put);
1079 : : EXPORT_SYMBOL(kobject_del);
1080 : :
1081 : : EXPORT_SYMBOL(kset_register);
1082 : : EXPORT_SYMBOL(kset_unregister);
|
