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