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