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