kobject: catch kobjects that are not initialized
[linux-2.6.git] / lib / kobject.c
1 /*
2  * kobject.c - library routines for handling generic kernel objects
3  *
4  * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org>
5  * Copyright (c) 2006-2007 Greg Kroah-Hartman <greg@kroah.com>
6  * Copyright (c) 2006-2007 Novell Inc.
7  *
8  * This file is released under the GPLv2.
9  *
10  *
11  * Please see the file Documentation/kobject.txt for critical information
12  * about using the kobject interface.
13  */
14
15 #include <linux/kobject.h>
16 #include <linux/string.h>
17 #include <linux/module.h>
18 #include <linux/stat.h>
19 #include <linux/slab.h>
20
21 /*
22  * populate_dir - populate directory with attributes.
23  * @kobj: object we're working on.
24  *
25  * Most subsystems have a set of default attributes that are associated
26  * with an object that registers with them.  This is a helper called during
27  * object registration that loops through the default attributes of the
28  * subsystem and creates attributes files for them in sysfs.
29  */
30 static int populate_dir(struct kobject *kobj)
31 {
32         struct kobj_type *t = get_ktype(kobj);
33         struct attribute *attr;
34         int error = 0;
35         int i;
36
37         if (t && t->default_attrs) {
38                 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
39                         error = sysfs_create_file(kobj, attr);
40                         if (error)
41                                 break;
42                 }
43         }
44         return error;
45 }
46
47 static int create_dir(struct kobject *kobj)
48 {
49         int error = 0;
50         if (kobject_name(kobj)) {
51                 error = sysfs_create_dir(kobj);
52                 if (!error) {
53                         error = populate_dir(kobj);
54                         if (error)
55                                 sysfs_remove_dir(kobj);
56                 }
57         }
58         return error;
59 }
60
61 static inline struct kobject *to_kobj(struct list_head *entry)
62 {
63         return container_of(entry, struct kobject, entry);
64 }
65
66 static int get_kobj_path_length(struct kobject *kobj)
67 {
68         int length = 1;
69         struct kobject *parent = kobj;
70
71         /* walk up the ancestors until we hit the one pointing to the
72          * root.
73          * Add 1 to strlen for leading '/' of each level.
74          */
75         do {
76                 if (kobject_name(parent) == NULL)
77                         return 0;
78                 length += strlen(kobject_name(parent)) + 1;
79                 parent = parent->parent;
80         } while (parent);
81         return length;
82 }
83
84 static void fill_kobj_path(struct kobject *kobj, char *path, int length)
85 {
86         struct kobject *parent;
87
88         --length;
89         for (parent = kobj; parent; parent = parent->parent) {
90                 int cur = strlen(kobject_name(parent));
91                 /* back up enough to print this name with '/' */
92                 length -= cur;
93                 strncpy(path + length, kobject_name(parent), cur);
94                 *(path + --length) = '/';
95         }
96
97         pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
98                  kobj, __FUNCTION__, path);
99 }
100
101 /**
102  * kobject_get_path - generate and return the path associated with a given kobj and kset pair.
103  *
104  * @kobj:       kobject in question, with which to build the path
105  * @gfp_mask:   the allocation type used to allocate the path
106  *
107  * The result must be freed by the caller with kfree().
108  */
109 char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
110 {
111         char *path;
112         int len;
113
114         len = get_kobj_path_length(kobj);
115         if (len == 0)
116                 return NULL;
117         path = kzalloc(len, gfp_mask);
118         if (!path)
119                 return NULL;
120         fill_kobj_path(kobj, path, len);
121
122         return path;
123 }
124 EXPORT_SYMBOL_GPL(kobject_get_path);
125
126 /* add the kobject to its kset's list */
127 static void kobj_kset_join(struct kobject *kobj)
128 {
129         if (!kobj->kset)
130                 return;
131
132         kset_get(kobj->kset);
133         spin_lock(&kobj->kset->list_lock);
134         list_add_tail(&kobj->entry, &kobj->kset->list);
135         spin_unlock(&kobj->kset->list_lock);
136 }
137
138 /* remove the kobject from its kset's list */
139 static void kobj_kset_leave(struct kobject *kobj)
140 {
141         if (!kobj->kset)
142                 return;
143
144         spin_lock(&kobj->kset->list_lock);
145         list_del_init(&kobj->entry);
146         spin_unlock(&kobj->kset->list_lock);
147         kset_put(kobj->kset);
148 }
149
150 static void kobject_init_internal(struct kobject *kobj)
151 {
152         if (!kobj)
153                 return;
154         kref_init(&kobj->kref);
155         INIT_LIST_HEAD(&kobj->entry);
156         kobj->state_in_sysfs = 0;
157         kobj->state_add_uevent_sent = 0;
158         kobj->state_remove_uevent_sent = 0;
159         kobj->state_initialized = 1;
160 }
161
162
163 static int kobject_add_internal(struct kobject *kobj)
164 {
165         int error = 0;
166         struct kobject *parent;
167
168         if (!kobj)
169                 return -ENOENT;
170
171         if (!kobj->name || !kobj->name[0]) {
172                 pr_debug("kobject: (%p): attempted to be registered with empty "
173                          "name!\n", kobj);
174                 WARN_ON(1);
175                 return -EINVAL;
176         }
177
178         parent = kobject_get(kobj->parent);
179
180         /* join kset if set, use it as parent if we do not already have one */
181         if (kobj->kset) {
182                 if (!parent)
183                         parent = kobject_get(&kobj->kset->kobj);
184                 kobj_kset_join(kobj);
185                 kobj->parent = parent;
186         }
187
188         pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
189                  kobject_name(kobj), kobj, __FUNCTION__,
190                  parent ? kobject_name(parent) : "<NULL>",
191                  kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
192
193         error = create_dir(kobj);
194         if (error) {
195                 kobj_kset_leave(kobj);
196                 kobject_put(parent);
197                 kobj->parent = NULL;
198
199                 /* be noisy on error issues */
200                 if (error == -EEXIST)
201                         printk(KERN_ERR "%s failed for %s with "
202                                "-EEXIST, don't try to register things with "
203                                "the same name in the same directory.\n",
204                                __FUNCTION__, kobject_name(kobj));
205                 else
206                         printk(KERN_ERR "%s failed for %s (%d)\n",
207                                __FUNCTION__, kobject_name(kobj), error);
208                 dump_stack();
209         } else
210                 kobj->state_in_sysfs = 1;
211
212         return error;
213 }
214
215 /**
216  * kobject_set_name_vargs - Set the name of an kobject
217  * @kobj: struct kobject to set the name of
218  * @fmt: format string used to build the name
219  * @vargs: vargs to format the string.
220  */
221 static int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
222                                   va_list vargs)
223 {
224         va_list aq;
225         char *name;
226
227         va_copy(aq, vargs);
228         name = kvasprintf(GFP_KERNEL, fmt, vargs);
229         va_end(aq);
230
231         if (!name)
232                 return -ENOMEM;
233
234         /* Free the old name, if necessary. */
235         kfree(kobj->name);
236
237         /* Now, set the new name */
238         kobj->name = name;
239
240         return 0;
241 }
242
243 /**
244  * kobject_set_name - Set the name of a kobject
245  * @kobj: struct kobject to set the name of
246  * @fmt: format string used to build the name
247  *
248  * This sets the name of the kobject.  If you have already added the
249  * kobject to the system, you must call kobject_rename() in order to
250  * change the name of the kobject.
251  */
252 int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
253 {
254         va_list args;
255         int retval;
256
257         va_start(args, fmt);
258         retval = kobject_set_name_vargs(kobj, fmt, args);
259         va_end(args);
260
261         return retval;
262 }
263 EXPORT_SYMBOL(kobject_set_name);
264
265 /**
266  * kobject_init - initialize a kobject structure
267  * @kobj: pointer to the kobject to initialize
268  * @ktype: pointer to the ktype for this kobject.
269  *
270  * This function will properly initialize a kobject such that it can then
271  * be passed to the kobject_add() call.
272  *
273  * After this function is called, the kobject MUST be cleaned up by a call
274  * to kobject_put(), not by a call to kfree directly to ensure that all of
275  * the memory is cleaned up properly.
276  */
277 void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
278 {
279         char *err_str;
280
281         if (!kobj) {
282                 err_str = "invalid kobject pointer!";
283                 goto error;
284         }
285         if (!ktype) {
286                 err_str = "must have a ktype to be initialized properly!\n";
287                 goto error;
288         }
289         if (kobj->state_initialized) {
290                 /* do not error out as sometimes we can recover */
291                 printk(KERN_ERR "kobject (%p): tried to init an initialized "
292                        "object, something is seriously wrong.\n", kobj);
293                 dump_stack();
294         }
295
296         kobject_init_internal(kobj);
297         kobj->ktype = ktype;
298         return;
299
300 error:
301         printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
302         dump_stack();
303 }
304 EXPORT_SYMBOL(kobject_init);
305
306 static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
307                             const char *fmt, va_list vargs)
308 {
309         va_list aq;
310         int retval;
311
312         va_copy(aq, vargs);
313         retval = kobject_set_name_vargs(kobj, fmt, aq);
314         va_end(aq);
315         if (retval) {
316                 printk(KERN_ERR "kobject: can not set name properly!\n");
317                 return retval;
318         }
319         kobj->parent = parent;
320         return kobject_add_internal(kobj);
321 }
322
323 /**
324  * kobject_add - the main kobject add function
325  * @kobj: the kobject to add
326  * @parent: pointer to the parent of the kobject.
327  * @fmt: format to name the kobject with.
328  *
329  * The kobject name is set and added to the kobject hierarchy in this
330  * function.
331  *
332  * If @parent is set, then the parent of the @kobj will be set to it.
333  * If @parent is NULL, then the parent of the @kobj will be set to the
334  * kobject associted with the kset assigned to this kobject.  If no kset
335  * is assigned to the kobject, then the kobject will be located in the
336  * root of the sysfs tree.
337  *
338  * If this function returns an error, kobject_put() must be called to
339  * properly clean up the memory associated with the object.
340  * Under no instance should the kobject that is passed to this function
341  * be directly freed with a call to kfree(), that can leak memory.
342  *
343  * Note, no "add" uevent will be created with this call, the caller should set
344  * up all of the necessary sysfs files for the object and then call
345  * kobject_uevent() with the UEVENT_ADD parameter to ensure that
346  * userspace is properly notified of this kobject's creation.
347  */
348 int kobject_add(struct kobject *kobj, struct kobject *parent,
349                 const char *fmt, ...)
350 {
351         va_list args;
352         int retval;
353
354         if (!kobj)
355                 return -EINVAL;
356
357         if (!kobj->state_initialized) {
358                 printk(KERN_ERR "kobject '%s' (%p): tried to add an "
359                        "uninitialized object, something is seriously wrong.\n",
360                        kobject_name(kobj), kobj);
361                 dump_stack();
362                 return -EINVAL;
363         }
364         va_start(args, fmt);
365         retval = kobject_add_varg(kobj, parent, fmt, args);
366         va_end(args);
367
368         return retval;
369 }
370 EXPORT_SYMBOL(kobject_add);
371
372 /**
373  * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
374  * @kobj: pointer to the kobject to initialize
375  * @ktype: pointer to the ktype for this kobject.
376  * @parent: pointer to the parent of this kobject.
377  * @fmt: the name of the kobject.
378  *
379  * This function combines the call to kobject_init() and
380  * kobject_add().  The same type of error handling after a call to
381  * kobject_add() and kobject lifetime rules are the same here.
382  */
383 int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
384                          struct kobject *parent, const char *fmt, ...)
385 {
386         va_list args;
387         int retval;
388
389         kobject_init(kobj, ktype);
390
391         va_start(args, fmt);
392         retval = kobject_add_varg(kobj, parent, fmt, args);
393         va_end(args);
394
395         return retval;
396 }
397 EXPORT_SYMBOL_GPL(kobject_init_and_add);
398
399 /**
400  * kobject_rename - change the name of an object
401  * @kobj: object in question.
402  * @new_name: object's new name
403  */
404 int kobject_rename(struct kobject *kobj, const char *new_name)
405 {
406         int error = 0;
407         const char *devpath = NULL;
408         char *devpath_string = NULL;
409         char *envp[2];
410
411         kobj = kobject_get(kobj);
412         if (!kobj)
413                 return -EINVAL;
414         if (!kobj->parent)
415                 return -EINVAL;
416
417         /* see if this name is already in use */
418         if (kobj->kset) {
419                 struct kobject *temp_kobj;
420                 temp_kobj = kset_find_obj(kobj->kset, new_name);
421                 if (temp_kobj) {
422                         printk(KERN_WARNING "kobject '%s' cannot be renamed "
423                                "to '%s' as '%s' is already in existence.\n",
424                                kobject_name(kobj), new_name, new_name);
425                         kobject_put(temp_kobj);
426                         return -EINVAL;
427                 }
428         }
429
430         devpath = kobject_get_path(kobj, GFP_KERNEL);
431         if (!devpath) {
432                 error = -ENOMEM;
433                 goto out;
434         }
435         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
436         if (!devpath_string) {
437                 error = -ENOMEM;
438                 goto out;
439         }
440         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
441         envp[0] = devpath_string;
442         envp[1] = NULL;
443
444         error = sysfs_rename_dir(kobj, new_name);
445
446         /* This function is mostly/only used for network interface.
447          * Some hotplug package track interfaces by their name and
448          * therefore want to know when the name is changed by the user. */
449         if (!error)
450                 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
451
452 out:
453         kfree(devpath_string);
454         kfree(devpath);
455         kobject_put(kobj);
456
457         return error;
458 }
459
460 /**
461  * kobject_move - move object to another parent
462  * @kobj: object in question.
463  * @new_parent: object's new parent (can be NULL)
464  */
465 int kobject_move(struct kobject *kobj, struct kobject *new_parent)
466 {
467         int error;
468         struct kobject *old_parent;
469         const char *devpath = NULL;
470         char *devpath_string = NULL;
471         char *envp[2];
472
473         kobj = kobject_get(kobj);
474         if (!kobj)
475                 return -EINVAL;
476         new_parent = kobject_get(new_parent);
477         if (!new_parent) {
478                 if (kobj->kset)
479                         new_parent = kobject_get(&kobj->kset->kobj);
480         }
481         /* old object path */
482         devpath = kobject_get_path(kobj, GFP_KERNEL);
483         if (!devpath) {
484                 error = -ENOMEM;
485                 goto out;
486         }
487         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
488         if (!devpath_string) {
489                 error = -ENOMEM;
490                 goto out;
491         }
492         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
493         envp[0] = devpath_string;
494         envp[1] = NULL;
495         error = sysfs_move_dir(kobj, new_parent);
496         if (error)
497                 goto out;
498         old_parent = kobj->parent;
499         kobj->parent = new_parent;
500         new_parent = NULL;
501         kobject_put(old_parent);
502         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
503 out:
504         kobject_put(new_parent);
505         kobject_put(kobj);
506         kfree(devpath_string);
507         kfree(devpath);
508         return error;
509 }
510
511 /**
512  * kobject_del - unlink kobject from hierarchy.
513  * @kobj: object.
514  */
515 void kobject_del(struct kobject *kobj)
516 {
517         if (!kobj)
518                 return;
519
520         sysfs_remove_dir(kobj);
521         kobj->state_in_sysfs = 0;
522         kobj_kset_leave(kobj);
523         kobject_put(kobj->parent);
524         kobj->parent = NULL;
525 }
526
527 /**
528  * kobject_get - increment refcount for object.
529  * @kobj: object.
530  */
531 struct kobject *kobject_get(struct kobject *kobj)
532 {
533         if (kobj)
534                 kref_get(&kobj->kref);
535         return kobj;
536 }
537
538 /*
539  * kobject_cleanup - free kobject resources.
540  * @kobj: object to cleanup
541  */
542 static void kobject_cleanup(struct kobject *kobj)
543 {
544         struct kobj_type *t = get_ktype(kobj);
545         const char *name = kobj->name;
546
547         pr_debug("kobject: '%s' (%p): %s\n",
548                  kobject_name(kobj), kobj, __FUNCTION__);
549
550         if (t && !t->release)
551                 pr_debug("kobject: '%s' (%p): does not have a release() "
552                          "function, it is broken and must be fixed.\n",
553                          kobject_name(kobj), kobj);
554
555         /* send "remove" if the caller did not do it but sent "add" */
556         if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
557                 pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
558                          kobject_name(kobj), kobj);
559                 kobject_uevent(kobj, KOBJ_REMOVE);
560         }
561
562         /* remove from sysfs if the caller did not do it */
563         if (kobj->state_in_sysfs) {
564                 pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
565                          kobject_name(kobj), kobj);
566                 kobject_del(kobj);
567         }
568
569         if (t && t->release) {
570                 pr_debug("kobject: '%s' (%p): calling ktype release\n",
571                          kobject_name(kobj), kobj);
572                 t->release(kobj);
573         }
574
575         /* free name if we allocated it */
576         if (name) {
577                 pr_debug("kobject: '%s': free name\n", name);
578                 kfree(name);
579         }
580 }
581
582 static void kobject_release(struct kref *kref)
583 {
584         kobject_cleanup(container_of(kref, struct kobject, kref));
585 }
586
587 /**
588  * kobject_put - decrement refcount for object.
589  * @kobj: object.
590  *
591  * Decrement the refcount, and if 0, call kobject_cleanup().
592  */
593 void kobject_put(struct kobject *kobj)
594 {
595         if (kobj) {
596                 if (!kobj->state_initialized) {
597                         printk(KERN_WARNING "kobject: '%s' (%p): is not "
598                                "initialized, yet kobject_put() is being "
599                                "called.\n", kobject_name(kobj), kobj);
600                         WARN_ON(1);
601                 }
602                 kref_put(&kobj->kref, kobject_release);
603         }
604 }
605
606 static void dynamic_kobj_release(struct kobject *kobj)
607 {
608         pr_debug("kobject: (%p): %s\n", kobj, __FUNCTION__);
609         kfree(kobj);
610 }
611
612 static struct kobj_type dynamic_kobj_ktype = {
613         .release        = dynamic_kobj_release,
614         .sysfs_ops      = &kobj_sysfs_ops,
615 };
616
617 /**
618  * kobject_create - create a struct kobject dynamically
619  *
620  * This function creates a kobject structure dynamically and sets it up
621  * to be a "dynamic" kobject with a default release function set up.
622  *
623  * If the kobject was not able to be created, NULL will be returned.
624  * The kobject structure returned from here must be cleaned up with a
625  * call to kobject_put() and not kfree(), as kobject_init() has
626  * already been called on this structure.
627  */
628 struct kobject *kobject_create(void)
629 {
630         struct kobject *kobj;
631
632         kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
633         if (!kobj)
634                 return NULL;
635
636         kobject_init(kobj, &dynamic_kobj_ktype);
637         return kobj;
638 }
639
640 /**
641  * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs
642  *
643  * @name: the name for the kset
644  * @parent: the parent kobject of this kobject, if any.
645  *
646  * This function creates a kobject structure dynamically and registers it
647  * with sysfs.  When you are finished with this structure, call
648  * kobject_put() and the structure will be dynamically freed when
649  * it is no longer being used.
650  *
651  * If the kobject was not able to be created, NULL will be returned.
652  */
653 struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
654 {
655         struct kobject *kobj;
656         int retval;
657
658         kobj = kobject_create();
659         if (!kobj)
660                 return NULL;
661
662         retval = kobject_add(kobj, parent, "%s", name);
663         if (retval) {
664                 printk(KERN_WARNING "%s: kobject_add error: %d\n",
665                        __FUNCTION__, retval);
666                 kobject_put(kobj);
667                 kobj = NULL;
668         }
669         return kobj;
670 }
671 EXPORT_SYMBOL_GPL(kobject_create_and_add);
672
673 /**
674  * kset_init - initialize a kset for use
675  * @k: kset
676  */
677 void kset_init(struct kset *k)
678 {
679         kobject_init_internal(&k->kobj);
680         INIT_LIST_HEAD(&k->list);
681         spin_lock_init(&k->list_lock);
682 }
683
684 /* default kobject attribute operations */
685 static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
686                               char *buf)
687 {
688         struct kobj_attribute *kattr;
689         ssize_t ret = -EIO;
690
691         kattr = container_of(attr, struct kobj_attribute, attr);
692         if (kattr->show)
693                 ret = kattr->show(kobj, kattr, buf);
694         return ret;
695 }
696
697 static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
698                                const char *buf, size_t count)
699 {
700         struct kobj_attribute *kattr;
701         ssize_t ret = -EIO;
702
703         kattr = container_of(attr, struct kobj_attribute, attr);
704         if (kattr->store)
705                 ret = kattr->store(kobj, kattr, buf, count);
706         return ret;
707 }
708
709 struct sysfs_ops kobj_sysfs_ops = {
710         .show   = kobj_attr_show,
711         .store  = kobj_attr_store,
712 };
713
714 /**
715  * kset_register - initialize and add a kset.
716  * @k: kset.
717  */
718 int kset_register(struct kset *k)
719 {
720         int err;
721
722         if (!k)
723                 return -EINVAL;
724
725         kset_init(k);
726         err = kobject_add_internal(&k->kobj);
727         if (err)
728                 return err;
729         kobject_uevent(&k->kobj, KOBJ_ADD);
730         return 0;
731 }
732
733 /**
734  * kset_unregister - remove a kset.
735  * @k: kset.
736  */
737 void kset_unregister(struct kset *k)
738 {
739         if (!k)
740                 return;
741         kobject_put(&k->kobj);
742 }
743
744 /**
745  * kset_find_obj - search for object in kset.
746  * @kset: kset we're looking in.
747  * @name: object's name.
748  *
749  * Lock kset via @kset->subsys, and iterate over @kset->list,
750  * looking for a matching kobject. If matching object is found
751  * take a reference and return the object.
752  */
753 struct kobject *kset_find_obj(struct kset *kset, const char *name)
754 {
755         struct list_head *entry;
756         struct kobject *ret = NULL;
757
758         spin_lock(&kset->list_lock);
759         list_for_each(entry, &kset->list) {
760                 struct kobject *k = to_kobj(entry);
761                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
762                         ret = kobject_get(k);
763                         break;
764                 }
765         }
766         spin_unlock(&kset->list_lock);
767         return ret;
768 }
769
770 static void kset_release(struct kobject *kobj)
771 {
772         struct kset *kset = container_of(kobj, struct kset, kobj);
773         pr_debug("kobject: '%s' (%p): %s\n",
774                  kobject_name(kobj), kobj, __FUNCTION__);
775         kfree(kset);
776 }
777
778 static struct kobj_type kset_ktype = {
779         .sysfs_ops      = &kobj_sysfs_ops,
780         .release = kset_release,
781 };
782
783 /**
784  * kset_create - create a struct kset dynamically
785  *
786  * @name: the name for the kset
787  * @uevent_ops: a struct kset_uevent_ops for the kset
788  * @parent_kobj: the parent kobject of this kset, if any.
789  *
790  * This function creates a kset structure dynamically.  This structure can
791  * then be registered with the system and show up in sysfs with a call to
792  * kset_register().  When you are finished with this structure, if
793  * kset_register() has been called, call kset_unregister() and the
794  * structure will be dynamically freed when it is no longer being used.
795  *
796  * If the kset was not able to be created, NULL will be returned.
797  */
798 static struct kset *kset_create(const char *name,
799                                 struct kset_uevent_ops *uevent_ops,
800                                 struct kobject *parent_kobj)
801 {
802         struct kset *kset;
803
804         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
805         if (!kset)
806                 return NULL;
807         kobject_set_name(&kset->kobj, name);
808         kset->uevent_ops = uevent_ops;
809         kset->kobj.parent = parent_kobj;
810
811         /*
812          * The kobject of this kset will have a type of kset_ktype and belong to
813          * no kset itself.  That way we can properly free it when it is
814          * finished being used.
815          */
816         kset->kobj.ktype = &kset_ktype;
817         kset->kobj.kset = NULL;
818
819         return kset;
820 }
821
822 /**
823  * kset_create_and_add - create a struct kset dynamically and add it to sysfs
824  *
825  * @name: the name for the kset
826  * @uevent_ops: a struct kset_uevent_ops for the kset
827  * @parent_kobj: the parent kobject of this kset, if any.
828  *
829  * This function creates a kset structure dynamically and registers it
830  * with sysfs.  When you are finished with this structure, call
831  * kset_unregister() and the structure will be dynamically freed when it
832  * is no longer being used.
833  *
834  * If the kset was not able to be created, NULL will be returned.
835  */
836 struct kset *kset_create_and_add(const char *name,
837                                  struct kset_uevent_ops *uevent_ops,
838                                  struct kobject *parent_kobj)
839 {
840         struct kset *kset;
841         int error;
842
843         kset = kset_create(name, uevent_ops, parent_kobj);
844         if (!kset)
845                 return NULL;
846         error = kset_register(kset);
847         if (error) {
848                 kfree(kset);
849                 return NULL;
850         }
851         return kset;
852 }
853 EXPORT_SYMBOL_GPL(kset_create_and_add);
854
855 EXPORT_SYMBOL(kobject_get);
856 EXPORT_SYMBOL(kobject_put);
857 EXPORT_SYMBOL(kobject_del);
858
859 EXPORT_SYMBOL(kset_register);
860 EXPORT_SYMBOL(kset_unregister);