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