USB: serial: cp210x: add ID for IMST iM871A-USB
[platform/kernel/linux-rpi.git] / lib / kobject.c
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 const 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  */
50 void 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
59 static 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
67 static 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
104 static 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
122 static 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  */
150 char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)
151 {
152         char *path;
153         int len;
154
155 retry:
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 }
169 EXPORT_SYMBOL_GPL(kobject_get_path);
170
171 /* add the kobject to its kset's list */
172 static 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 */
184 static 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
195 static 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
208 static 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  */
264 int 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  */
306 int 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 }
317 EXPORT_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  */
331 void 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
354 error:
355         pr_err("kobject (%p): %s\n", kobj, err_str);
356         dump_stack_lvl(KERN_ERR);
357 }
358 EXPORT_SYMBOL(kobject_init);
359
360 static __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  */
408 int 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 }
429 EXPORT_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  */
446 int 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 }
460 EXPORT_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  */
472 int 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
521 out:
522         kfree_const(dup_name);
523         kfree(devpath_string);
524         kfree(devpath);
525         kobject_put(kobj);
526
527         return error;
528 }
529 EXPORT_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  */
536 int 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);
575 out:
576         kobject_put(new_parent);
577         kobject_put(kobj);
578         kfree(devpath_string);
579         kfree(devpath);
580         return error;
581 }
582 EXPORT_SYMBOL_GPL(kobject_move);
583
584 static 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  */
616 void 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 }
627 EXPORT_SYMBOL(kobject_del);
628
629 /**
630  * kobject_get() - Increment refcount for object.
631  * @kobj: object.
632  */
633 struct 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 }
644 EXPORT_SYMBOL(kobject_get);
645
646 struct 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 }
654 EXPORT_SYMBOL(kobject_get_unless_zero);
655
656 /*
657  * kobject_cleanup - free kobject resources.
658  * @kobj: object to cleanup
659  */
660 static 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
698 static 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
705 static 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  */
726 void 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 }
736 EXPORT_SYMBOL(kobject_put);
737
738 static void dynamic_kobj_release(struct kobject *kobj)
739 {
740         pr_debug("(%p): %s\n", kobj, __func__);
741         kfree(kobj);
742 }
743
744 static 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  */
760 static 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  */
785 struct 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 }
802 EXPORT_SYMBOL_GPL(kobject_create_and_add);
803
804 /**
805  * kset_init() - Initialize a kset for use.
806  * @k: kset
807  */
808 void 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 */
816 static 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
828 static 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
840 const struct sysfs_ops kobj_sysfs_ops = {
841         .show   = kobj_attr_show,
842         .store  = kobj_attr_store,
843 };
844 EXPORT_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  */
853 int 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 }
876 EXPORT_SYMBOL(kset_register);
877
878 /**
879  * kset_unregister() - Remove a kset.
880  * @k: kset.
881  */
882 void kset_unregister(struct kset *k)
883 {
884         if (!k)
885                 return;
886         kobject_del(&k->kobj);
887         kobject_put(&k->kobj);
888 }
889 EXPORT_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  */
900 struct 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 }
917 EXPORT_SYMBOL_GPL(kset_find_obj);
918
919 static 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
927 static 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
933 static 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  */
954 static 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  */
997 struct 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 }
1014 EXPORT_SYMBOL_GPL(kset_create_and_add);
1015
1016
1017 static DEFINE_SPINLOCK(kobj_ns_type_lock);
1018 static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
1019
1020 int 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
1038 out:
1039         spin_unlock(&kobj_ns_type_lock);
1040         return error;
1041 }
1042
1043 int 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
1055 const 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
1065 const struct kobj_ns_type_operations *kobj_ns_ops(const struct kobject *kobj)
1066 {
1067         return kobj_child_ns_ops(kobj->parent);
1068 }
1069
1070 bool 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
1082 void *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 }
1093 EXPORT_SYMBOL_GPL(kobj_ns_grab_current);
1094
1095 const 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
1107 const 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
1119 void 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 }
1127 EXPORT_SYMBOL_GPL(kobj_ns_drop);