projects/linux·blob v6.4 · refs

1128 lines · 27.8 KiB

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