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