1 // SPDX-License-Identifier: GPL-2.0
3 * kobject.c - library routines for handling generic kernel objects
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.
9 * Please see the file Documentation/core-api/kobject.rst for critical information
10 * about using the kobject interface.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
23 * kobject_namespace() - Return @kobj's namespace tag.
24 * @kobj: kobject in question
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
30 const void *kobject_namespace(const struct kobject
*kobj
)
32 const struct kobj_ns_type_operations
*ns_ops
= kobj_ns_ops(kobj
);
34 if (!ns_ops
|| ns_ops
->type
== KOBJ_NS_TYPE_NONE
)
37 return kobj
->ktype
->namespace(kobj
);
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
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.
50 void kobject_get_ownership(const struct kobject
*kobj
, kuid_t
*uid
, kgid_t
*gid
)
52 *uid
= GLOBAL_ROOT_UID
;
53 *gid
= GLOBAL_ROOT_GID
;
55 if (kobj
->ktype
->get_ownership
)
56 kobj
->ktype
->get_ownership(kobj
, uid
, gid
);
59 static bool kobj_ns_type_is_valid(enum kobj_ns_type type
)
61 if ((type
<= KOBJ_NS_TYPE_NONE
) || (type
>= KOBJ_NS_TYPES
))
67 static int create_dir(struct kobject
*kobj
)
69 const struct kobj_type
*ktype
= get_ktype(kobj
);
70 const struct kobj_ns_type_operations
*ops
;
73 error
= sysfs_create_dir_ns(kobj
, kobject_namespace(kobj
));
77 error
= sysfs_create_groups(kobj
, ktype
->default_groups
);
79 sysfs_remove_dir(kobj
);
84 * @kobj->sd may be deleted by an ancestor going away. Hold an
85 * extra reference so that it stays until @kobj is gone.
90 * If @kobj has ns_ops, its children need to be filtered based on
91 * their namespace tags. Enable namespace support on @kobj->sd.
93 ops
= kobj_child_ns_ops(kobj
);
95 BUG_ON(!kobj_ns_type_is_valid(ops
->type
));
96 BUG_ON(!kobj_ns_type_registered(ops
->type
));
98 sysfs_enable_ns(kobj
->sd
);
104 static int get_kobj_path_length(const struct kobject
*kobj
)
107 const struct kobject
*parent
= kobj
;
109 /* walk up the ancestors until we hit the one pointing to the
111 * Add 1 to strlen for leading '/' of each level.
114 if (kobject_name(parent
) == NULL
)
116 length
+= strlen(kobject_name(parent
)) + 1;
117 parent
= parent
->parent
;
122 static int fill_kobj_path(const struct kobject
*kobj
, char *path
, int length
)
124 const struct kobject
*parent
;
127 for (parent
= kobj
; parent
; parent
= parent
->parent
) {
128 int cur
= strlen(kobject_name(parent
));
129 /* back up enough to print this name with '/' */
133 memcpy(path
+ length
, kobject_name(parent
), cur
);
134 *(path
+ --length
) = '/';
137 pr_debug("'%s' (%p): %s: path = '%s'\n", kobject_name(kobj
),
138 kobj
, __func__
, path
);
144 * kobject_get_path() - Allocate memory and fill in the path for @kobj.
145 * @kobj: kobject in question, with which to build the path
146 * @gfp_mask: the allocation type used to allocate the path
148 * Return: The newly allocated memory, caller must free with kfree().
150 char *kobject_get_path(const struct kobject
*kobj
, gfp_t gfp_mask
)
156 len
= get_kobj_path_length(kobj
);
159 path
= kzalloc(len
, gfp_mask
);
162 if (fill_kobj_path(kobj
, path
, len
)) {
169 EXPORT_SYMBOL_GPL(kobject_get_path
);
171 /* add the kobject to its kset's list */
172 static void kobj_kset_join(struct kobject
*kobj
)
177 kset_get(kobj
->kset
);
178 spin_lock(&kobj
->kset
->list_lock
);
179 list_add_tail(&kobj
->entry
, &kobj
->kset
->list
);
180 spin_unlock(&kobj
->kset
->list_lock
);
183 /* remove the kobject from its kset's list */
184 static void kobj_kset_leave(struct kobject
*kobj
)
189 spin_lock(&kobj
->kset
->list_lock
);
190 list_del_init(&kobj
->entry
);
191 spin_unlock(&kobj
->kset
->list_lock
);
192 kset_put(kobj
->kset
);
195 static void kobject_init_internal(struct kobject
*kobj
)
199 kref_init(&kobj
->kref
);
200 INIT_LIST_HEAD(&kobj
->entry
);
201 kobj
->state_in_sysfs
= 0;
202 kobj
->state_add_uevent_sent
= 0;
203 kobj
->state_remove_uevent_sent
= 0;
204 kobj
->state_initialized
= 1;
208 static int kobject_add_internal(struct kobject
*kobj
)
211 struct kobject
*parent
;
216 if (!kobj
->name
|| !kobj
->name
[0]) {
218 "kobject: (%p): attempted to be registered with empty name!\n",
223 parent
= kobject_get(kobj
->parent
);
225 /* join kset if set, use it as parent if we do not already have one */
228 parent
= kobject_get(&kobj
->kset
->kobj
);
229 kobj_kset_join(kobj
);
230 kobj
->parent
= parent
;
233 pr_debug("'%s' (%p): %s: parent: '%s', set: '%s'\n",
234 kobject_name(kobj
), kobj
, __func__
,
235 parent
? kobject_name(parent
) : "<NULL>",
236 kobj
->kset
? kobject_name(&kobj
->kset
->kobj
) : "<NULL>");
238 error
= create_dir(kobj
);
240 kobj_kset_leave(kobj
);
244 /* be noisy on error issues */
245 if (error
== -EEXIST
)
246 pr_err("%s failed for %s with -EEXIST, don't try to register things with the same name in the same directory.\n",
247 __func__
, kobject_name(kobj
));
249 pr_err("%s failed for %s (error: %d parent: %s)\n",
250 __func__
, kobject_name(kobj
), error
,
251 parent
? kobject_name(parent
) : "'none'");
253 kobj
->state_in_sysfs
= 1;
259 * kobject_set_name_vargs() - Set the name of a kobject.
260 * @kobj: struct kobject to set the name of
261 * @fmt: format string used to build the name
262 * @vargs: vargs to format the string.
264 int kobject_set_name_vargs(struct kobject
*kobj
, const char *fmt
,
269 if (kobj
->name
&& !fmt
)
272 s
= kvasprintf_const(GFP_KERNEL
, fmt
, vargs
);
277 * ewww... some of these buggers have '/' in the name ... If
278 * that's the case, we need to make sure we have an actual
279 * allocated copy to modify, since kvasprintf_const may have
280 * returned something from .rodata.
282 if (strchr(s
, '/')) {
285 t
= kstrdup(s
, GFP_KERNEL
);
289 s
= strreplace(t
, '/', '!');
291 kfree_const(kobj
->name
);
298 * kobject_set_name() - Set the name of a kobject.
299 * @kobj: struct kobject to set the name of
300 * @fmt: format string used to build the name
302 * This sets the name of the kobject. If you have already added the
303 * kobject to the system, you must call kobject_rename() in order to
304 * change the name of the kobject.
306 int kobject_set_name(struct kobject
*kobj
, const char *fmt
, ...)
311 va_start(vargs
, fmt
);
312 retval
= kobject_set_name_vargs(kobj
, fmt
, vargs
);
317 EXPORT_SYMBOL(kobject_set_name
);
320 * kobject_init() - Initialize a kobject structure.
321 * @kobj: pointer to the kobject to initialize
322 * @ktype: pointer to the ktype for this kobject.
324 * This function will properly initialize a kobject such that it can then
325 * be passed to the kobject_add() call.
327 * After this function is called, the kobject MUST be cleaned up by a call
328 * to kobject_put(), not by a call to kfree directly to ensure that all of
329 * the memory is cleaned up properly.
331 void kobject_init(struct kobject
*kobj
, const struct kobj_type
*ktype
)
336 err_str
= "invalid kobject pointer!";
340 err_str
= "must have a ktype to be initialized properly!\n";
343 if (kobj
->state_initialized
) {
344 /* do not error out as sometimes we can recover */
345 pr_err("kobject (%p): tried to init an initialized object, something is seriously wrong.\n",
347 dump_stack_lvl(KERN_ERR
);
350 kobject_init_internal(kobj
);
355 pr_err("kobject (%p): %s\n", kobj
, err_str
);
356 dump_stack_lvl(KERN_ERR
);
358 EXPORT_SYMBOL(kobject_init
);
360 static __printf(3, 0) int kobject_add_varg(struct kobject
*kobj
,
361 struct kobject
*parent
,
362 const char *fmt
, va_list vargs
)
366 retval
= kobject_set_name_vargs(kobj
, fmt
, vargs
);
368 pr_err("can not set name properly!\n");
371 kobj
->parent
= parent
;
372 return kobject_add_internal(kobj
);
376 * kobject_add() - The main kobject add function.
377 * @kobj: the kobject to add
378 * @parent: pointer to the parent of the kobject.
379 * @fmt: format to name the kobject with.
381 * The kobject name is set and added to the kobject hierarchy in this
384 * If @parent is set, then the parent of the @kobj will be set to it.
385 * If @parent is NULL, then the parent of the @kobj will be set to the
386 * kobject associated with the kset assigned to this kobject. If no kset
387 * is assigned to the kobject, then the kobject will be located in the
388 * root of the sysfs tree.
390 * Note, no "add" uevent will be created with this call, the caller should set
391 * up all of the necessary sysfs files for the object and then call
392 * kobject_uevent() with the UEVENT_ADD parameter to ensure that
393 * userspace is properly notified of this kobject's creation.
395 * Return: If this function returns an error, kobject_put() must be
396 * called to properly clean up the memory associated with the
397 * object. Under no instance should the kobject that is passed
398 * to this function be directly freed with a call to kfree(),
399 * that can leak memory.
401 * If this function returns success, kobject_put() must also be called
402 * in order to properly clean up the memory associated with the object.
404 * In short, once this function is called, kobject_put() MUST be called
405 * when the use of the object is finished in order to properly free
408 int kobject_add(struct kobject
*kobj
, struct kobject
*parent
,
409 const char *fmt
, ...)
417 if (!kobj
->state_initialized
) {
418 pr_err("kobject '%s' (%p): tried to add an uninitialized object, something is seriously wrong.\n",
419 kobject_name(kobj
), kobj
);
420 dump_stack_lvl(KERN_ERR
);
424 retval
= kobject_add_varg(kobj
, parent
, fmt
, args
);
429 EXPORT_SYMBOL(kobject_add
);
432 * kobject_init_and_add() - Initialize a kobject structure and add it to
433 * the kobject hierarchy.
434 * @kobj: pointer to the kobject to initialize
435 * @ktype: pointer to the ktype for this kobject.
436 * @parent: pointer to the parent of this kobject.
437 * @fmt: the name of the kobject.
439 * This function combines the call to kobject_init() and kobject_add().
441 * If this function returns an error, kobject_put() must be called to
442 * properly clean up the memory associated with the object. This is the
443 * same type of error handling after a call to kobject_add() and kobject
444 * lifetime rules are the same here.
446 int kobject_init_and_add(struct kobject
*kobj
, const struct kobj_type
*ktype
,
447 struct kobject
*parent
, const char *fmt
, ...)
452 kobject_init(kobj
, ktype
);
455 retval
= kobject_add_varg(kobj
, parent
, fmt
, args
);
460 EXPORT_SYMBOL_GPL(kobject_init_and_add
);
463 * kobject_rename() - Change the name of an object.
464 * @kobj: object in question.
465 * @new_name: object's new name
467 * It is the responsibility of the caller to provide mutual
468 * exclusion between two different calls of kobject_rename
469 * on the same kobject and to ensure that new_name is valid and
470 * won't conflict with other kobjects.
472 int kobject_rename(struct kobject
*kobj
, const char *new_name
)
475 const char *devpath
= NULL
;
476 const char *dup_name
= NULL
, *name
;
477 char *devpath_string
= NULL
;
480 kobj
= kobject_get(kobj
);
488 devpath
= kobject_get_path(kobj
, GFP_KERNEL
);
493 devpath_string
= kmalloc(strlen(devpath
) + 15, GFP_KERNEL
);
494 if (!devpath_string
) {
498 sprintf(devpath_string
, "DEVPATH_OLD=%s", devpath
);
499 envp
[0] = devpath_string
;
502 name
= dup_name
= kstrdup_const(new_name
, GFP_KERNEL
);
508 error
= sysfs_rename_dir_ns(kobj
, new_name
, kobject_namespace(kobj
));
512 /* Install the new kobject name */
513 dup_name
= kobj
->name
;
516 /* This function is mostly/only used for network interface.
517 * Some hotplug package track interfaces by their name and
518 * therefore want to know when the name is changed by the user. */
519 kobject_uevent_env(kobj
, KOBJ_MOVE
, envp
);
522 kfree_const(dup_name
);
523 kfree(devpath_string
);
529 EXPORT_SYMBOL_GPL(kobject_rename
);
532 * kobject_move() - Move object to another parent.
533 * @kobj: object in question.
534 * @new_parent: object's new parent (can be NULL)
536 int kobject_move(struct kobject
*kobj
, struct kobject
*new_parent
)
539 struct kobject
*old_parent
;
540 const char *devpath
= NULL
;
541 char *devpath_string
= NULL
;
544 kobj
= kobject_get(kobj
);
547 new_parent
= kobject_get(new_parent
);
550 new_parent
= kobject_get(&kobj
->kset
->kobj
);
553 /* old object path */
554 devpath
= kobject_get_path(kobj
, GFP_KERNEL
);
559 devpath_string
= kmalloc(strlen(devpath
) + 15, GFP_KERNEL
);
560 if (!devpath_string
) {
564 sprintf(devpath_string
, "DEVPATH_OLD=%s", devpath
);
565 envp
[0] = devpath_string
;
567 error
= sysfs_move_dir_ns(kobj
, new_parent
, kobject_namespace(kobj
));
570 old_parent
= kobj
->parent
;
571 kobj
->parent
= new_parent
;
573 kobject_put(old_parent
);
574 kobject_uevent_env(kobj
, KOBJ_MOVE
, envp
);
576 kobject_put(new_parent
);
578 kfree(devpath_string
);
582 EXPORT_SYMBOL_GPL(kobject_move
);
584 static void __kobject_del(struct kobject
*kobj
)
586 struct kernfs_node
*sd
;
587 const struct kobj_type
*ktype
;
590 ktype
= get_ktype(kobj
);
592 sysfs_remove_groups(kobj
, ktype
->default_groups
);
594 /* send "remove" if the caller did not do it but sent "add" */
595 if (kobj
->state_add_uevent_sent
&& !kobj
->state_remove_uevent_sent
) {
596 pr_debug("'%s' (%p): auto cleanup 'remove' event\n",
597 kobject_name(kobj
), kobj
);
598 kobject_uevent(kobj
, KOBJ_REMOVE
);
601 sysfs_remove_dir(kobj
);
604 kobj
->state_in_sysfs
= 0;
605 kobj_kset_leave(kobj
);
610 * kobject_del() - Unlink kobject from hierarchy.
613 * This is the function that should be called to delete an object
614 * successfully added via kobject_add().
616 void kobject_del(struct kobject
*kobj
)
618 struct kobject
*parent
;
623 parent
= kobj
->parent
;
627 EXPORT_SYMBOL(kobject_del
);
630 * kobject_get() - Increment refcount for object.
633 struct kobject
*kobject_get(struct kobject
*kobj
)
636 if (!kobj
->state_initialized
)
638 "kobject: '%s' (%p): is not initialized, yet kobject_get() is being called.\n",
639 kobject_name(kobj
), kobj
);
640 kref_get(&kobj
->kref
);
644 EXPORT_SYMBOL(kobject_get
);
646 struct kobject
* __must_check
kobject_get_unless_zero(struct kobject
*kobj
)
650 if (!kref_get_unless_zero(&kobj
->kref
))
654 EXPORT_SYMBOL(kobject_get_unless_zero
);
657 * kobject_cleanup - free kobject resources.
658 * @kobj: object to cleanup
660 static void kobject_cleanup(struct kobject
*kobj
)
662 struct kobject
*parent
= kobj
->parent
;
663 const struct kobj_type
*t
= get_ktype(kobj
);
664 const char *name
= kobj
->name
;
666 pr_debug("'%s' (%p): %s, parent %p\n",
667 kobject_name(kobj
), kobj
, __func__
, kobj
->parent
);
669 /* remove from sysfs if the caller did not do it */
670 if (kobj
->state_in_sysfs
) {
671 pr_debug("'%s' (%p): auto cleanup kobject_del\n",
672 kobject_name(kobj
), kobj
);
675 /* avoid dropping the parent reference unnecessarily */
680 pr_debug("'%s' (%p): calling ktype release\n",
681 kobject_name(kobj
), kobj
);
684 pr_debug("'%s' (%p): does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kobject.rst.\n",
685 kobject_name(kobj
), kobj
);
688 /* free name if we allocated it */
690 pr_debug("'%s': free name\n", name
);
697 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
698 static void kobject_delayed_cleanup(struct work_struct
*work
)
700 kobject_cleanup(container_of(to_delayed_work(work
),
701 struct kobject
, release
));
705 static void kobject_release(struct kref
*kref
)
707 struct kobject
*kobj
= container_of(kref
, struct kobject
, kref
);
708 #ifdef CONFIG_DEBUG_KOBJECT_RELEASE
709 unsigned long delay
= HZ
+ HZ
* get_random_u32_below(4);
710 pr_info("'%s' (%p): %s, parent %p (delayed %ld)\n",
711 kobject_name(kobj
), kobj
, __func__
, kobj
->parent
, delay
);
712 INIT_DELAYED_WORK(&kobj
->release
, kobject_delayed_cleanup
);
714 schedule_delayed_work(&kobj
->release
, delay
);
716 kobject_cleanup(kobj
);
721 * kobject_put() - Decrement refcount for object.
724 * Decrement the refcount, and if 0, call kobject_cleanup().
726 void kobject_put(struct kobject
*kobj
)
729 if (!kobj
->state_initialized
)
731 "kobject: '%s' (%p): is not initialized, yet kobject_put() is being called.\n",
732 kobject_name(kobj
), kobj
);
733 kref_put(&kobj
->kref
, kobject_release
);
736 EXPORT_SYMBOL(kobject_put
);
738 static void dynamic_kobj_release(struct kobject
*kobj
)
740 pr_debug("(%p): %s\n", kobj
, __func__
);
744 static const struct kobj_type dynamic_kobj_ktype
= {
745 .release
= dynamic_kobj_release
,
746 .sysfs_ops
= &kobj_sysfs_ops
,
750 * kobject_create() - Create a struct kobject dynamically.
752 * This function creates a kobject structure dynamically and sets it up
753 * to be a "dynamic" kobject with a default release function set up.
755 * If the kobject was not able to be created, NULL will be returned.
756 * The kobject structure returned from here must be cleaned up with a
757 * call to kobject_put() and not kfree(), as kobject_init() has
758 * already been called on this structure.
760 static struct kobject
*kobject_create(void)
762 struct kobject
*kobj
;
764 kobj
= kzalloc(sizeof(*kobj
), GFP_KERNEL
);
768 kobject_init(kobj
, &dynamic_kobj_ktype
);
773 * kobject_create_and_add() - Create a struct kobject dynamically and
774 * register it with sysfs.
775 * @name: the name for the kobject
776 * @parent: the parent kobject of this kobject, if any.
778 * This function creates a kobject structure dynamically and registers it
779 * with sysfs. When you are finished with this structure, call
780 * kobject_put() and the structure will be dynamically freed when
781 * it is no longer being used.
783 * If the kobject was not able to be created, NULL will be returned.
785 struct kobject
*kobject_create_and_add(const char *name
, struct kobject
*parent
)
787 struct kobject
*kobj
;
790 kobj
= kobject_create();
794 retval
= kobject_add(kobj
, parent
, "%s", name
);
796 pr_warn("%s: kobject_add error: %d\n", __func__
, retval
);
802 EXPORT_SYMBOL_GPL(kobject_create_and_add
);
805 * kset_init() - Initialize a kset for use.
808 void kset_init(struct kset
*k
)
810 kobject_init_internal(&k
->kobj
);
811 INIT_LIST_HEAD(&k
->list
);
812 spin_lock_init(&k
->list_lock
);
815 /* default kobject attribute operations */
816 static ssize_t
kobj_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
819 struct kobj_attribute
*kattr
;
822 kattr
= container_of(attr
, struct kobj_attribute
, attr
);
824 ret
= kattr
->show(kobj
, kattr
, buf
);
828 static ssize_t
kobj_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
829 const char *buf
, size_t count
)
831 struct kobj_attribute
*kattr
;
834 kattr
= container_of(attr
, struct kobj_attribute
, attr
);
836 ret
= kattr
->store(kobj
, kattr
, buf
, count
);
840 const struct sysfs_ops kobj_sysfs_ops
= {
841 .show
= kobj_attr_show
,
842 .store
= kobj_attr_store
,
844 EXPORT_SYMBOL_GPL(kobj_sysfs_ops
);
847 * kset_register() - Initialize and add a kset.
850 * NOTE: On error, the kset.kobj.name allocated by() kobj_set_name()
851 * is freed, it can not be used any more.
853 int kset_register(struct kset
*k
)
860 if (!k
->kobj
.ktype
) {
861 pr_err("must have a ktype to be initialized properly!\n");
866 err
= kobject_add_internal(&k
->kobj
);
868 kfree_const(k
->kobj
.name
);
869 /* Set it to NULL to avoid accessing bad pointer in callers. */
873 kobject_uevent(&k
->kobj
, KOBJ_ADD
);
876 EXPORT_SYMBOL(kset_register
);
879 * kset_unregister() - Remove a kset.
882 void kset_unregister(struct kset
*k
)
886 kobject_del(&k
->kobj
);
887 kobject_put(&k
->kobj
);
889 EXPORT_SYMBOL(kset_unregister
);
892 * kset_find_obj() - Search for object in kset.
893 * @kset: kset we're looking in.
894 * @name: object's name.
896 * Lock kset via @kset->subsys, and iterate over @kset->list,
897 * looking for a matching kobject. If matching object is found
898 * take a reference and return the object.
900 struct kobject
*kset_find_obj(struct kset
*kset
, const char *name
)
903 struct kobject
*ret
= NULL
;
905 spin_lock(&kset
->list_lock
);
907 list_for_each_entry(k
, &kset
->list
, entry
) {
908 if (kobject_name(k
) && !strcmp(kobject_name(k
), name
)) {
909 ret
= kobject_get_unless_zero(k
);
914 spin_unlock(&kset
->list_lock
);
917 EXPORT_SYMBOL_GPL(kset_find_obj
);
919 static void kset_release(struct kobject
*kobj
)
921 struct kset
*kset
= container_of(kobj
, struct kset
, kobj
);
922 pr_debug("'%s' (%p): %s\n",
923 kobject_name(kobj
), kobj
, __func__
);
927 static void kset_get_ownership(const struct kobject
*kobj
, kuid_t
*uid
, kgid_t
*gid
)
930 kobject_get_ownership(kobj
->parent
, uid
, gid
);
933 static const struct kobj_type kset_ktype
= {
934 .sysfs_ops
= &kobj_sysfs_ops
,
935 .release
= kset_release
,
936 .get_ownership
= kset_get_ownership
,
940 * kset_create() - Create a struct kset dynamically.
942 * @name: the name for the kset
943 * @uevent_ops: a struct kset_uevent_ops for the kset
944 * @parent_kobj: the parent kobject of this kset, if any.
946 * This function creates a kset structure dynamically. This structure can
947 * then be registered with the system and show up in sysfs with a call to
948 * kset_register(). When you are finished with this structure, if
949 * kset_register() has been called, call kset_unregister() and the
950 * structure will be dynamically freed when it is no longer being used.
952 * If the kset was not able to be created, NULL will be returned.
954 static struct kset
*kset_create(const char *name
,
955 const struct kset_uevent_ops
*uevent_ops
,
956 struct kobject
*parent_kobj
)
961 kset
= kzalloc(sizeof(*kset
), GFP_KERNEL
);
964 retval
= kobject_set_name(&kset
->kobj
, "%s", name
);
969 kset
->uevent_ops
= uevent_ops
;
970 kset
->kobj
.parent
= parent_kobj
;
973 * The kobject of this kset will have a type of kset_ktype and belong to
974 * no kset itself. That way we can properly free it when it is
975 * finished being used.
977 kset
->kobj
.ktype
= &kset_ktype
;
978 kset
->kobj
.kset
= NULL
;
984 * kset_create_and_add() - Create a struct kset dynamically and add it to sysfs.
986 * @name: the name for the kset
987 * @uevent_ops: a struct kset_uevent_ops for the kset
988 * @parent_kobj: the parent kobject of this kset, if any.
990 * This function creates a kset structure dynamically and registers it
991 * with sysfs. When you are finished with this structure, call
992 * kset_unregister() and the structure will be dynamically freed when it
993 * is no longer being used.
995 * If the kset was not able to be created, NULL will be returned.
997 struct kset
*kset_create_and_add(const char *name
,
998 const struct kset_uevent_ops
*uevent_ops
,
999 struct kobject
*parent_kobj
)
1004 kset
= kset_create(name
, uevent_ops
, parent_kobj
);
1007 error
= kset_register(kset
);
1014 EXPORT_SYMBOL_GPL(kset_create_and_add
);
1017 static DEFINE_SPINLOCK(kobj_ns_type_lock
);
1018 static const struct kobj_ns_type_operations
*kobj_ns_ops_tbl
[KOBJ_NS_TYPES
];
1020 int kobj_ns_type_register(const struct kobj_ns_type_operations
*ops
)
1022 enum kobj_ns_type type
= ops
->type
;
1025 spin_lock(&kobj_ns_type_lock
);
1028 if (!kobj_ns_type_is_valid(type
))
1032 if (kobj_ns_ops_tbl
[type
])
1036 kobj_ns_ops_tbl
[type
] = ops
;
1039 spin_unlock(&kobj_ns_type_lock
);
1043 int kobj_ns_type_registered(enum kobj_ns_type type
)
1047 spin_lock(&kobj_ns_type_lock
);
1048 if (kobj_ns_type_is_valid(type
))
1049 registered
= kobj_ns_ops_tbl
[type
] != NULL
;
1050 spin_unlock(&kobj_ns_type_lock
);
1055 const struct kobj_ns_type_operations
*kobj_child_ns_ops(const struct kobject
*parent
)
1057 const struct kobj_ns_type_operations
*ops
= NULL
;
1059 if (parent
&& parent
->ktype
->child_ns_type
)
1060 ops
= parent
->ktype
->child_ns_type(parent
);
1065 const struct kobj_ns_type_operations
*kobj_ns_ops(const struct kobject
*kobj
)
1067 return kobj_child_ns_ops(kobj
->parent
);
1070 bool kobj_ns_current_may_mount(enum kobj_ns_type type
)
1072 bool may_mount
= true;
1074 spin_lock(&kobj_ns_type_lock
);
1075 if (kobj_ns_type_is_valid(type
) && kobj_ns_ops_tbl
[type
])
1076 may_mount
= kobj_ns_ops_tbl
[type
]->current_may_mount();
1077 spin_unlock(&kobj_ns_type_lock
);
1082 void *kobj_ns_grab_current(enum kobj_ns_type type
)
1086 spin_lock(&kobj_ns_type_lock
);
1087 if (kobj_ns_type_is_valid(type
) && kobj_ns_ops_tbl
[type
])
1088 ns
= kobj_ns_ops_tbl
[type
]->grab_current_ns();
1089 spin_unlock(&kobj_ns_type_lock
);
1093 EXPORT_SYMBOL_GPL(kobj_ns_grab_current
);
1095 const void *kobj_ns_netlink(enum kobj_ns_type type
, struct sock
*sk
)
1097 const void *ns
= NULL
;
1099 spin_lock(&kobj_ns_type_lock
);
1100 if (kobj_ns_type_is_valid(type
) && kobj_ns_ops_tbl
[type
])
1101 ns
= kobj_ns_ops_tbl
[type
]->netlink_ns(sk
);
1102 spin_unlock(&kobj_ns_type_lock
);
1107 const void *kobj_ns_initial(enum kobj_ns_type type
)
1109 const void *ns
= NULL
;
1111 spin_lock(&kobj_ns_type_lock
);
1112 if (kobj_ns_type_is_valid(type
) && kobj_ns_ops_tbl
[type
])
1113 ns
= kobj_ns_ops_tbl
[type
]->initial_ns();
1114 spin_unlock(&kobj_ns_type_lock
);
1119 void kobj_ns_drop(enum kobj_ns_type type
, void *ns
)
1121 spin_lock(&kobj_ns_type_lock
);
1122 if (kobj_ns_type_is_valid(type
) &&
1123 kobj_ns_ops_tbl
[type
] && kobj_ns_ops_tbl
[type
]->drop_ns
)
1124 kobj_ns_ops_tbl
[type
]->drop_ns(ns
);
1125 spin_unlock(&kobj_ns_type_lock
);
1127 EXPORT_SYMBOL_GPL(kobj_ns_drop
);