projects/linux·blob v6.7 · refs

1127 lines · 27.7 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 bool kobj_ns_type_is_valid(enum kobj_ns_type type)
60{
61 if ((type <= KOBJ_NS_TYPE_NONE) || (type >= KOBJ_NS_TYPES))
62 return false;
63
64 return true;
65}
66
67static int create_dir(struct kobject *kobj)
68{
69 const struct kobj_type *ktype = get_ktype(kobj);
70 const struct kobj_ns_type_operations *ops;
71 int error;
72
73 error = sysfs_create_dir_ns(kobj, kobject_namespace(kobj));
74 if (error)
75 return error;
76
77 error = sysfs_create_groups(kobj, ktype->default_groups);
78 if (error) {
79 sysfs_remove_dir(kobj);
80 return error;
81 }
82
83 /*
84 * @kobj->sd may be deleted by an ancestor going away. Hold an
85 * extra reference so that it stays until @kobj is gone.
86 */
87 sysfs_get(kobj->sd);
88
89 /*
90 * If @kobj has ns_ops, its children need to be filtered based on
91 * their namespace tags. Enable namespace support on @kobj->sd.
92 */
93 ops = kobj_child_ns_ops(kobj);
94 if (ops) {
95 BUG_ON(!kobj_ns_type_is_valid(ops->type));
96 BUG_ON(!kobj_ns_type_registered(ops->type));
97
98 sysfs_enable_ns(kobj->sd);
99 }
100
101 return 0;
102}
103
104static int get_kobj_path_length(const struct kobject *kobj)
105{
106 int length = 1;
107 const struct kobject *parent = kobj;
108
109 /* walk up the ancestors until we hit the one pointing to the
110 * root.
111 * Add 1 to strlen for leading '/' of each level.
112 */
113 do {
114 if (kobject_name(parent) == NULL)
115 return 0;
116 length += strlen(kobject_name(parent)) + 1;
117 parent = parent->parent;
118 } while (parent);
119 return length;
120}
121
122static int fill_kobj_path(const struct kobject *kobj, char *path, int length)
123{
124 const struct kobject *parent;
125
126 --length;
127 for (parent = kobj; parent; parent = parent->parent) {
128 int cur = strlen(kobject_name(parent));
129 /* back up enough to print this name with '/' */
130 length -= cur;
131 if (length <= 0)
132 return -EINVAL;
133 memcpy(path + length, kobject_name(parent), cur);
134 *(path + --length) = '/';
135 }
136
137 pr_debug("'%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
138 kobj, __func__, path);
139
140 return 0;
141}
142
143/**
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
147 *
148 * Return: The newly allocated memory, caller must free with kfree().
149 */
150char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)
151{
152 char *path;
153 int len;
154
155retry:
156 len = get_kobj_path_length(kobj);
157 if (len == 0)
158 return NULL;
159 path = kzalloc(len, gfp_mask);
160 if (!path)
161 return NULL;
162 if (fill_kobj_path(kobj, path, len)) {
163 kfree(path);
164 goto retry;
165 }
166
167 return path;
168}
169EXPORT_SYMBOL_GPL(kobject_get_path);
170
171/* add the kobject to its kset's list */
172static void kobj_kset_join(struct kobject *kobj)
173{
174 if (!kobj->kset)
175 return;
176
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);
181}
182
183/* remove the kobject from its kset's list */
184static void kobj_kset_leave(struct kobject *kobj)
185{
186 if (!kobj->kset)
187 return;
188
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);
193}
194
195static void kobject_init_internal(struct kobject *kobj)
196{
197 if (!kobj)
198 return;
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;
205}
206
207
208static int kobject_add_internal(struct kobject *kobj)
209{
210 int error = 0;
211 struct kobject *parent;
212
213 if (!kobj)
214 return -ENOENT;
215
216 if (!kobj->name || !kobj->name[0]) {
217 WARN(1,
218 "kobject: (%p): attempted to be registered with empty name!\n",
219 kobj);
220 return -EINVAL;
221 }
222
223 parent = kobject_get(kobj->parent);
224
225 /* join kset if set, use it as parent if we do not already have one */
226 if (kobj->kset) {
227 if (!parent)
228 parent = kobject_get(&kobj->kset->kobj);
229 kobj_kset_join(kobj);
230 kobj->parent = parent;
231 }
232
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>");
237
238 error = create_dir(kobj);
239 if (error) {
240 kobj_kset_leave(kobj);
241 kobject_put(parent);
242 kobj->parent = NULL;
243
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));
248 else
249 pr_err("%s failed for %s (error: %d parent: %s)\n",
250 __func__, kobject_name(kobj), error,
251 parent ? kobject_name(parent) : "'none'");
252 } else
253 kobj->state_in_sysfs = 1;
254
255 return error;
256}
257
258/**
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.
263 */
264int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
265 va_list vargs)
266{
267 const char *s;
268
269 if (kobj->name && !fmt)
270 return 0;
271
272 s = kvasprintf_const(GFP_KERNEL, fmt, vargs);
273 if (!s)
274 return -ENOMEM;
275
276 /*
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.
281 */
282 if (strchr(s, '/')) {
283 char *t;
284
285 t = kstrdup(s, GFP_KERNEL);
286 kfree_const(s);
287 if (!t)
288 return -ENOMEM;
289 s = strreplace(t, '/', '!');
290 }
291 kfree_const(kobj->name);
292 kobj->name = s;
293
294 return 0;
295}
296
297/**
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
301 *
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.
305 */
306int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
307{
308 va_list vargs;
309 int retval;
310
311 va_start(vargs, fmt);
312 retval = kobject_set_name_vargs(kobj, fmt, vargs);
313 va_end(vargs);
314
315 return retval;
316}
317EXPORT_SYMBOL(kobject_set_name);
318
319/**
320 * kobject_init() - Initialize a kobject structure.
321 * @kobj: pointer to the kobject to initialize
322 * @ktype: pointer to the ktype for this kobject.
323 *
324 * This function will properly initialize a kobject such that it can then
325 * be passed to the kobject_add() call.
326 *
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.
330 */
331void kobject_init(struct kobject *kobj, const struct kobj_type *ktype)
332{
333 char *err_str;
334
335 if (!kobj) {
336 err_str = "invalid kobject pointer!";
337 goto error;
338 }
339 if (!ktype) {
340 err_str = "must have a ktype to be initialized properly!\n";
341 goto error;
342 }
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",
346 kobj);
347 dump_stack_lvl(KERN_ERR);
348 }
349
350 kobject_init_internal(kobj);
351 kobj->ktype = ktype;
352 return;
353
354error:
355 pr_err("kobject (%p): %s\n", kobj, err_str);
356 dump_stack_lvl(KERN_ERR);
357}
358EXPORT_SYMBOL(kobject_init);
359
360static __printf(3, 0) int kobject_add_varg(struct kobject *kobj,
361 struct kobject *parent,
362 const char *fmt, va_list vargs)
363{
364 int retval;
365
366 retval = kobject_set_name_vargs(kobj, fmt, vargs);
367 if (retval) {
368 pr_err("can not set name properly!\n");
369 return retval;
370 }
371 kobj->parent = parent;
372 return kobject_add_internal(kobj);
373}
374
375/**
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.
380 *
381 * The kobject name is set and added to the kobject hierarchy in this
382 * function.
383 *
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.
389 *
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.
394 *
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.
400 *
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.
403 *
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
406 * everything.
407 */
408int kobject_add(struct kobject *kobj, struct kobject *parent,
409 const char *fmt, ...)
410{
411 va_list args;
412 int retval;
413
414 if (!kobj)
415 return -EINVAL;
416
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);
421 return -EINVAL;
422 }
423 va_start(args, fmt);
424 retval = kobject_add_varg(kobj, parent, fmt, args);
425 va_end(args);
426
427 return retval;
428}
429EXPORT_SYMBOL(kobject_add);
430
431/**
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.
438 *
439 * This function combines the call to kobject_init() and kobject_add().
440 *
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.
445 */
446int kobject_init_and_add(struct kobject *kobj, const struct kobj_type *ktype,
447 struct kobject *parent, const char *fmt, ...)
448{
449 va_list args;
450 int retval;
451
452 kobject_init(kobj, ktype);
453
454 va_start(args, fmt);
455 retval = kobject_add_varg(kobj, parent, fmt, args);
456 va_end(args);
457
458 return retval;
459}
460EXPORT_SYMBOL_GPL(kobject_init_and_add);
461
462/**
463 * kobject_rename() - Change the name of an object.
464 * @kobj: object in question.
465 * @new_name: object's new name
466 *
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.
471 */
472int kobject_rename(struct kobject *kobj, const char *new_name)
473{
474 int error = 0;
475 const char *devpath = NULL;
476 const char *dup_name = NULL, *name;
477 char *devpath_string = NULL;
478 char *envp[2];
479
480 kobj = kobject_get(kobj);
481 if (!kobj)
482 return -EINVAL;
483 if (!kobj->parent) {
484 kobject_put(kobj);
485 return -EINVAL;
486 }
487
488 devpath = kobject_get_path(kobj, GFP_KERNEL);
489 if (!devpath) {
490 error = -ENOMEM;
491 goto out;
492 }
493 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
494 if (!devpath_string) {
495 error = -ENOMEM;
496 goto out;
497 }
498 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
499 envp[0] = devpath_string;
500 envp[1] = NULL;
501
502 name = dup_name = kstrdup_const(new_name, GFP_KERNEL);
503 if (!name) {
504 error = -ENOMEM;
505 goto out;
506 }
507
508 error = sysfs_rename_dir_ns(kobj, new_name, kobject_namespace(kobj));
509 if (error)
510 goto out;
511
512 /* Install the new kobject name */
513 dup_name = kobj->name;
514 kobj->name = name;
515
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);
520
521out:
522 kfree_const(dup_name);
523 kfree(devpath_string);
524 kfree(devpath);
525 kobject_put(kobj);
526
527 return error;
528}
529EXPORT_SYMBOL_GPL(kobject_rename);
530
531/**
532 * kobject_move() - Move object to another parent.
533 * @kobj: object in question.
534 * @new_parent: object's new parent (can be NULL)
535 */
536int kobject_move(struct kobject *kobj, struct kobject *new_parent)
537{
538 int error;
539 struct kobject *old_parent;
540 const char *devpath = NULL;
541 char *devpath_string = NULL;
542 char *envp[2];
543
544 kobj = kobject_get(kobj);
545 if (!kobj)
546 return -EINVAL;
547 new_parent = kobject_get(new_parent);
548 if (!new_parent) {
549 if (kobj->kset)
550 new_parent = kobject_get(&kobj->kset->kobj);
551 }
552
553 /* old object path */
554 devpath = kobject_get_path(kobj, GFP_KERNEL);
555 if (!devpath) {
556 error = -ENOMEM;
557 goto out;
558 }
559 devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
560 if (!devpath_string) {
561 error = -ENOMEM;
562 goto out;
563 }
564 sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
565 envp[0] = devpath_string;
566 envp[1] = NULL;
567 error = sysfs_move_dir_ns(kobj, new_parent, kobject_namespace(kobj));
568 if (error)
569 goto out;
570 old_parent = kobj->parent;
571 kobj->parent = new_parent;
572 new_parent = NULL;
573 kobject_put(old_parent);
574 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
575out:
576 kobject_put(new_parent);
577 kobject_put(kobj);
578 kfree(devpath_string);
579 kfree(devpath);
580 return error;
581}
582EXPORT_SYMBOL_GPL(kobject_move);
583
584static void __kobject_del(struct kobject *kobj)
585{
586 struct kernfs_node *sd;
587 const struct kobj_type *ktype;
588
589 sd = kobj->sd;
590 ktype = get_ktype(kobj);
591
592 sysfs_remove_groups(kobj, ktype->default_groups);
593
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);
599 }
600
601 sysfs_remove_dir(kobj);
602 sysfs_put(sd);
603
604 kobj->state_in_sysfs = 0;
605 kobj_kset_leave(kobj);
606 kobj->parent = NULL;
607}
608
609/**
610 * kobject_del() - Unlink kobject from hierarchy.
611 * @kobj: object.
612 *
613 * This is the function that should be called to delete an object
614 * successfully added via kobject_add().
615 */
616void kobject_del(struct kobject *kobj)
617{
618 struct kobject *parent;
619
620 if (!kobj)
621 return;
622
623 parent = kobj->parent;
624 __kobject_del(kobj);
625 kobject_put(parent);
626}
627EXPORT_SYMBOL(kobject_del);
628
629/**
630 * kobject_get() - Increment refcount for object.
631 * @kobj: object.
632 */
633struct kobject *kobject_get(struct kobject *kobj)
634{
635 if (kobj) {
636 if (!kobj->state_initialized)
637 WARN(1, KERN_WARNING
638 "kobject: '%s' (%p): is not initialized, yet kobject_get() is being called.\n",
639 kobject_name(kobj), kobj);
640 kref_get(&kobj->kref);
641 }
642 return kobj;
643}
644EXPORT_SYMBOL(kobject_get);
645
646struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
647{
648 if (!kobj)
649 return NULL;
650 if (!kref_get_unless_zero(&kobj->kref))
651 kobj = NULL;
652 return kobj;
653}
654EXPORT_SYMBOL(kobject_get_unless_zero);
655
656/*
657 * kobject_cleanup - free kobject resources.
658 * @kobj: object to cleanup
659 */
660static void kobject_cleanup(struct kobject *kobj)
661{
662 struct kobject *parent = kobj->parent;
663 const struct kobj_type *t = get_ktype(kobj);
664 const char *name = kobj->name;
665
666 pr_debug("'%s' (%p): %s, parent %p\n",
667 kobject_name(kobj), kobj, __func__, kobj->parent);
668
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);
673 __kobject_del(kobj);
674 } else {
675 /* avoid dropping the parent reference unnecessarily */
676 parent = NULL;
677 }
678
679 if (t->release) {
680 pr_debug("'%s' (%p): calling ktype release\n",
681 kobject_name(kobj), kobj);
682 t->release(kobj);
683 } else {
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);
686 }
687
688 /* free name if we allocated it */
689 if (name) {
690 pr_debug("'%s': free name\n", name);
691 kfree_const(name);
692 }
693
694 kobject_put(parent);
695}
696
697#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
698static void kobject_delayed_cleanup(struct work_struct *work)
699{
700 kobject_cleanup(container_of(to_delayed_work(work),
701 struct kobject, release));
702}
703#endif
704
705static void kobject_release(struct kref *kref)
706{
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);
713
714 schedule_delayed_work(&kobj->release, delay);
715#else
716 kobject_cleanup(kobj);
717#endif
718}
719
720/**
721 * kobject_put() - Decrement refcount for object.
722 * @kobj: object.
723 *
724 * Decrement the refcount, and if 0, call kobject_cleanup().
725 */
726void kobject_put(struct kobject *kobj)
727{
728 if (kobj) {
729 if (!kobj->state_initialized)
730 WARN(1, KERN_WARNING
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);
734 }
735}
736EXPORT_SYMBOL(kobject_put);
737
738static void dynamic_kobj_release(struct kobject *kobj)
739{
740 pr_debug("(%p): %s\n", kobj, __func__);
741 kfree(kobj);
742}
743
744static const struct kobj_type dynamic_kobj_ktype = {
745 .release = dynamic_kobj_release,
746 .sysfs_ops = &kobj_sysfs_ops,
747};
748
749/**
750 * kobject_create() - Create a struct kobject dynamically.
751 *
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.
754 *
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.
759 */
760static struct kobject *kobject_create(void)
761{
762 struct kobject *kobj;
763
764 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
765 if (!kobj)
766 return NULL;
767
768 kobject_init(kobj, &dynamic_kobj_ktype);
769 return kobj;
770}
771
772/**
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.
777 *
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.
782 *
783 * If the kobject was not able to be created, NULL will be returned.
784 */
785struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
786{
787 struct kobject *kobj;
788 int retval;
789
790 kobj = kobject_create();
791 if (!kobj)
792 return NULL;
793
794 retval = kobject_add(kobj, parent, "%s", name);
795 if (retval) {
796 pr_warn("%s: kobject_add error: %d\n", __func__, retval);
797 kobject_put(kobj);
798 kobj = NULL;
799 }
800 return kobj;
801}
802EXPORT_SYMBOL_GPL(kobject_create_and_add);
803
804/**
805 * kset_init() - Initialize a kset for use.
806 * @k: kset
807 */
808void kset_init(struct kset *k)
809{
810 kobject_init_internal(&k->kobj);
811 INIT_LIST_HEAD(&k->list);
812 spin_lock_init(&k->list_lock);
813}
814
815/* default kobject attribute operations */
816static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
817 char *buf)
818{
819 struct kobj_attribute *kattr;
820 ssize_t ret = -EIO;
821
822 kattr = container_of(attr, struct kobj_attribute, attr);
823 if (kattr->show)
824 ret = kattr->show(kobj, kattr, buf);
825 return ret;
826}
827
828static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
829 const char *buf, size_t count)
830{
831 struct kobj_attribute *kattr;
832 ssize_t ret = -EIO;
833
834 kattr = container_of(attr, struct kobj_attribute, attr);
835 if (kattr->store)
836 ret = kattr->store(kobj, kattr, buf, count);
837 return ret;
838}
839
840const struct sysfs_ops kobj_sysfs_ops = {
841 .show = kobj_attr_show,
842 .store = kobj_attr_store,
843};
844EXPORT_SYMBOL_GPL(kobj_sysfs_ops);
845
846/**
847 * kset_register() - Initialize and add a kset.
848 * @k: kset.
849 *
850 * NOTE: On error, the kset.kobj.name allocated by() kobj_set_name()
851 * is freed, it can not be used any more.
852 */
853int kset_register(struct kset *k)
854{
855 int err;
856
857 if (!k)
858 return -EINVAL;
859
860 if (!k->kobj.ktype) {
861 pr_err("must have a ktype to be initialized properly!\n");
862 return -EINVAL;
863 }
864
865 kset_init(k);
866 err = kobject_add_internal(&k->kobj);
867 if (err) {
868 kfree_const(k->kobj.name);
869 /* Set it to NULL to avoid accessing bad pointer in callers. */
870 k->kobj.name = NULL;
871 return err;
872 }
873 kobject_uevent(&k->kobj, KOBJ_ADD);
874 return 0;
875}
876EXPORT_SYMBOL(kset_register);
877
878/**
879 * kset_unregister() - Remove a kset.
880 * @k: kset.
881 */
882void kset_unregister(struct kset *k)
883{
884 if (!k)
885 return;
886 kobject_del(&k->kobj);
887 kobject_put(&k->kobj);
888}
889EXPORT_SYMBOL(kset_unregister);
890
891/**
892 * kset_find_obj() - Search for object in kset.
893 * @kset: kset we're looking in.
894 * @name: object's name.
895 *
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.
899 */
900struct kobject *kset_find_obj(struct kset *kset, const char *name)
901{
902 struct kobject *k;
903 struct kobject *ret = NULL;
904
905 spin_lock(&kset->list_lock);
906
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);
910 break;
911 }
912 }
913
914 spin_unlock(&kset->list_lock);
915 return ret;
916}
917EXPORT_SYMBOL_GPL(kset_find_obj);
918
919static void kset_release(struct kobject *kobj)
920{
921 struct kset *kset = container_of(kobj, struct kset, kobj);
922 pr_debug("'%s' (%p): %s\n",
923 kobject_name(kobj), kobj, __func__);
924 kfree(kset);
925}
926
927static void kset_get_ownership(const struct kobject *kobj, kuid_t *uid, kgid_t *gid)
928{
929 if (kobj->parent)
930 kobject_get_ownership(kobj->parent, uid, gid);
931}
932
933static const struct kobj_type kset_ktype = {
934 .sysfs_ops = &kobj_sysfs_ops,
935 .release = kset_release,
936 .get_ownership = kset_get_ownership,
937};
938
939/**
940 * kset_create() - Create a struct kset dynamically.
941 *
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.
945 *
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.
951 *
952 * If the kset was not able to be created, NULL will be returned.
953 */
954static struct kset *kset_create(const char *name,
955 const struct kset_uevent_ops *uevent_ops,
956 struct kobject *parent_kobj)
957{
958 struct kset *kset;
959 int retval;
960
961 kset = kzalloc(sizeof(*kset), GFP_KERNEL);
962 if (!kset)
963 return NULL;
964 retval = kobject_set_name(&kset->kobj, "%s", name);
965 if (retval) {
966 kfree(kset);
967 return NULL;
968 }
969 kset->uevent_ops = uevent_ops;
970 kset->kobj.parent = parent_kobj;
971
972 /*
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.
976 */
977 kset->kobj.ktype = &kset_ktype;
978 kset->kobj.kset = NULL;
979
980 return kset;
981}
982
983/**
984 * kset_create_and_add() - Create a struct kset dynamically and add it to sysfs.
985 *
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.
989 *
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.
994 *
995 * If the kset was not able to be created, NULL will be returned.
996 */
997struct kset *kset_create_and_add(const char *name,
998 const struct kset_uevent_ops *uevent_ops,
999 struct kobject *parent_kobj)
1000{
1001 struct kset *kset;
1002 int error;
1003
1004 kset = kset_create(name, uevent_ops, parent_kobj);
1005 if (!kset)
1006 return NULL;
1007 error = kset_register(kset);
1008 if (error) {
1009 kfree(kset);
1010 return NULL;
1011 }
1012 return kset;
1013}
1014EXPORT_SYMBOL_GPL(kset_create_and_add);
1015
1016
1017static DEFINE_SPINLOCK(kobj_ns_type_lock);
1018static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
1019
1020int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
1021{
1022 enum kobj_ns_type type = ops->type;
1023 int error;
1024
1025 spin_lock(&kobj_ns_type_lock);
1026
1027 error = -EINVAL;
1028 if (!kobj_ns_type_is_valid(type))
1029 goto out;
1030
1031 error = -EBUSY;
1032 if (kobj_ns_ops_tbl[type])
1033 goto out;
1034
1035 error = 0;
1036 kobj_ns_ops_tbl[type] = ops;
1037
1038out:
1039 spin_unlock(&kobj_ns_type_lock);
1040 return error;
1041}
1042
1043int kobj_ns_type_registered(enum kobj_ns_type type)
1044{
1045 int registered = 0;
1046
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);
1051
1052 return registered;
1053}
1054
1055const struct kobj_ns_type_operations *kobj_child_ns_ops(const struct kobject *parent)
1056{
1057 const struct kobj_ns_type_operations *ops = NULL;
1058
1059 if (parent && parent->ktype->child_ns_type)
1060 ops = parent->ktype->child_ns_type(parent);
1061
1062 return ops;
1063}
1064
1065const struct kobj_ns_type_operations *kobj_ns_ops(const struct kobject *kobj)
1066{
1067 return kobj_child_ns_ops(kobj->parent);
1068}
1069
1070bool kobj_ns_current_may_mount(enum kobj_ns_type type)
1071{
1072 bool may_mount = true;
1073
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);
1078
1079 return may_mount;
1080}
1081
1082void *kobj_ns_grab_current(enum kobj_ns_type type)
1083{
1084 void *ns = NULL;
1085
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);
1090
1091 return ns;
1092}
1093EXPORT_SYMBOL_GPL(kobj_ns_grab_current);
1094
1095const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
1096{
1097 const void *ns = NULL;
1098
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);
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 (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);
1115
1116 return ns;
1117}
1118
1119void kobj_ns_drop(enum kobj_ns_type type, void *ns)
1120{
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);
1126}
1127EXPORT_SYMBOL_GPL(kobj_ns_drop);