sysfs: Shadow directory support
[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  *
6  * This file is released under the GPLv2.
7  *
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/module.h>
16 #include <linux/stat.h>
17 #include <linux/slab.h>
18
19 /**
20  *      populate_dir - populate directory with attributes.
21  *      @kobj:  object we're working on.
22  *
23  *      Most subsystems have a set of default attributes that 
24  *      are associated with an object that registers with them.
25  *      This is a helper called during object registration that 
26  *      loops through the default attributes of the subsystem 
27  *      and creates attributes files for them in sysfs.
28  *
29  */
30
31 static int populate_dir(struct kobject * kobj)
32 {
33         struct kobj_type * t = get_ktype(kobj);
34         struct attribute * attr;
35         int error = 0;
36         int i;
37         
38         if (t && t->default_attrs) {
39                 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
40                         if ((error = sysfs_create_file(kobj,attr)))
41                                 break;
42                 }
43         }
44         return error;
45 }
46
47 static int create_dir(struct kobject * kobj, struct dentry *shadow_parent)
48 {
49         int error = 0;
50         if (kobject_name(kobj)) {
51                 error = sysfs_create_dir(kobj, shadow_parent);
52                 if (!error) {
53                         if ((error = populate_dir(kobj)))
54                                 sysfs_remove_dir(kobj);
55                 }
56         }
57         return error;
58 }
59
60 static inline struct kobject * to_kobj(struct list_head * entry)
61 {
62         return container_of(entry,struct kobject,entry);
63 }
64
65 static int get_kobj_path_length(struct kobject *kobj)
66 {
67         int length = 1;
68         struct kobject * parent = kobj;
69
70         /* walk up the ancestors until we hit the one pointing to the 
71          * root.
72          * Add 1 to strlen for leading '/' of each level.
73          */
74         do {
75                 if (kobject_name(parent) == NULL)
76                         return 0;
77                 length += strlen(kobject_name(parent)) + 1;
78                 parent = parent->parent;
79         } while (parent);
80         return length;
81 }
82
83 static void fill_kobj_path(struct kobject *kobj, char *path, int length)
84 {
85         struct kobject * parent;
86
87         --length;
88         for (parent = kobj; parent; parent = parent->parent) {
89                 int cur = strlen(kobject_name(parent));
90                 /* back up enough to print this name with '/' */
91                 length -= cur;
92                 strncpy (path + length, kobject_name(parent), cur);
93                 *(path + --length) = '/';
94         }
95
96         pr_debug("%s: path = '%s'\n",__FUNCTION__,path);
97 }
98
99 /**
100  * kobject_get_path - generate and return the path associated with a given kobj
101  * and kset pair.  The result must be freed by the caller with kfree().
102  *
103  * @kobj:       kobject in question, with which to build the path
104  * @gfp_mask:   the allocation type used to allocate the path
105  */
106 char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
107 {
108         char *path;
109         int len;
110
111         len = get_kobj_path_length(kobj);
112         if (len == 0)
113                 return NULL;
114         path = kzalloc(len, gfp_mask);
115         if (!path)
116                 return NULL;
117         fill_kobj_path(kobj, path, len);
118
119         return path;
120 }
121 EXPORT_SYMBOL_GPL(kobject_get_path);
122
123 /**
124  *      kobject_init - initialize object.
125  *      @kobj:  object in question.
126  */
127 void kobject_init(struct kobject * kobj)
128 {
129         if (!kobj)
130                 return;
131         kref_init(&kobj->kref);
132         INIT_LIST_HEAD(&kobj->entry);
133         init_waitqueue_head(&kobj->poll);
134         kobj->kset = kset_get(kobj->kset);
135 }
136
137
138 /**
139  *      unlink - remove kobject from kset list.
140  *      @kobj:  kobject.
141  *
142  *      Remove the kobject from the kset list and decrement
143  *      its parent's refcount.
144  *      This is separated out, so we can use it in both 
145  *      kobject_del() and kobject_add() on error.
146  */
147
148 static void unlink(struct kobject * kobj)
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         kobject_put(kobj);
156 }
157
158 /**
159  *      kobject_add - add an object to the hierarchy.
160  *      @kobj:  object.
161  *      @shadow_parent: sysfs directory to add to.
162  */
163
164 int kobject_shadow_add(struct kobject * kobj, struct dentry *shadow_parent)
165 {
166         int error = 0;
167         struct kobject * parent;
168
169         if (!(kobj = kobject_get(kobj)))
170                 return -ENOENT;
171         if (!kobj->k_name)
172                 kobj->k_name = kobj->name;
173         if (!kobj->k_name) {
174                 pr_debug("kobject attempted to be registered with no name!\n");
175                 WARN_ON(1);
176                 return -EINVAL;
177         }
178         parent = kobject_get(kobj->parent);
179
180         pr_debug("kobject %s: registering. parent: %s, set: %s\n",
181                  kobject_name(kobj), parent ? kobject_name(parent) : "<NULL>", 
182                  kobj->kset ? kobj->kset->kobj.name : "<NULL>" );
183
184         if (kobj->kset) {
185                 spin_lock(&kobj->kset->list_lock);
186
187                 if (!parent)
188                         parent = kobject_get(&kobj->kset->kobj);
189
190                 list_add_tail(&kobj->entry,&kobj->kset->list);
191                 spin_unlock(&kobj->kset->list_lock);
192         }
193         kobj->parent = parent;
194
195         error = create_dir(kobj, shadow_parent);
196         if (error) {
197                 /* unlink does the kobject_put() for us */
198                 unlink(kobj);
199                 kobject_put(parent);
200
201                 /* be noisy on error issues */
202                 if (error == -EEXIST)
203                         printk("kobject_add failed for %s with -EEXIST, "
204                                "don't try to register things with the "
205                                "same name in the same directory.\n",
206                                kobject_name(kobj));
207                 else
208                         printk("kobject_add failed for %s (%d)\n",
209                                kobject_name(kobj), error);
210                  dump_stack();
211         }
212
213         return error;
214 }
215
216 /**
217  *      kobject_add - add an object to the hierarchy.
218  *      @kobj:  object.
219  */
220 int kobject_add(struct kobject * kobj)
221 {
222         return kobject_shadow_add(kobj, NULL);
223 }
224
225
226 /**
227  *      kobject_register - initialize and add an object.
228  *      @kobj:  object in question.
229  */
230
231 int kobject_register(struct kobject * kobj)
232 {
233         int error = -EINVAL;
234         if (kobj) {
235                 kobject_init(kobj);
236                 error = kobject_add(kobj);
237                 if (!error)
238                         kobject_uevent(kobj, KOBJ_ADD);
239         }
240         return error;
241 }
242
243
244 /**
245  *      kobject_set_name - Set the name of an object
246  *      @kobj:  object.
247  *      @fmt:   format string used to build the name
248  *
249  *      If strlen(name) >= KOBJ_NAME_LEN, then use a dynamically allocated
250  *      string that @kobj->k_name points to. Otherwise, use the static 
251  *      @kobj->name array.
252  */
253 int kobject_set_name(struct kobject * kobj, const char * fmt, ...)
254 {
255         int error = 0;
256         int limit = KOBJ_NAME_LEN;
257         int need;
258         va_list args;
259         char * name;
260
261         /* 
262          * First, try the static array 
263          */
264         va_start(args,fmt);
265         need = vsnprintf(kobj->name,limit,fmt,args);
266         va_end(args);
267         if (need < limit) 
268                 name = kobj->name;
269         else {
270                 /* 
271                  * Need more space? Allocate it and try again 
272                  */
273                 limit = need + 1;
274                 name = kmalloc(limit,GFP_KERNEL);
275                 if (!name) {
276                         error = -ENOMEM;
277                         goto Done;
278                 }
279                 va_start(args,fmt);
280                 need = vsnprintf(name,limit,fmt,args);
281                 va_end(args);
282
283                 /* Still? Give up. */
284                 if (need >= limit) {
285                         kfree(name);
286                         error = -EFAULT;
287                         goto Done;
288                 }
289         }
290
291         /* Free the old name, if necessary. */
292         if (kobj->k_name && kobj->k_name != kobj->name)
293                 kfree(kobj->k_name);
294
295         /* Now, set the new name */
296         kobj->k_name = name;
297  Done:
298         return error;
299 }
300
301 EXPORT_SYMBOL(kobject_set_name);
302
303
304 /**
305  *      kobject_rename - change the name of an object
306  *      @kobj:  object in question.
307  *      @new_name: object's new name
308  */
309
310 int kobject_rename(struct kobject * kobj, const char *new_name)
311 {
312         int error = 0;
313
314         kobj = kobject_get(kobj);
315         if (!kobj)
316                 return -EINVAL;
317         if (!kobj->parent)
318                 return -EINVAL;
319         error = sysfs_rename_dir(kobj, kobj->parent->dentry, new_name);
320         kobject_put(kobj);
321
322         return error;
323 }
324
325 /**
326  *      kobject_rename - change the name of an object
327  *      @kobj:  object in question.
328  *      @new_name: object's new name
329  */
330
331 int kobject_shadow_rename(struct kobject * kobj, struct dentry *new_parent,
332                           const char *new_name)
333 {
334         int error = 0;
335
336         kobj = kobject_get(kobj);
337         if (!kobj)
338                 return -EINVAL;
339         error = sysfs_rename_dir(kobj, new_parent, new_name);
340         kobject_put(kobj);
341
342         return error;
343 }
344
345 /**
346  *      kobject_move - move object to another parent
347  *      @kobj:  object in question.
348  *      @new_parent: object's new parent (can be NULL)
349  */
350
351 int kobject_move(struct kobject *kobj, struct kobject *new_parent)
352 {
353         int error;
354         struct kobject *old_parent;
355         const char *devpath = NULL;
356         char *devpath_string = NULL;
357         char *envp[2];
358
359         kobj = kobject_get(kobj);
360         if (!kobj)
361                 return -EINVAL;
362         new_parent = kobject_get(new_parent);
363         if (!new_parent) {
364                 if (kobj->kset)
365                         new_parent = kobject_get(&kobj->kset->kobj);
366         }
367         /* old object path */
368         devpath = kobject_get_path(kobj, GFP_KERNEL);
369         if (!devpath) {
370                 error = -ENOMEM;
371                 goto out;
372         }
373         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
374         if (!devpath_string) {
375                 error = -ENOMEM;
376                 goto out;
377         }
378         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
379         envp[0] = devpath_string;
380         envp[1] = NULL;
381         error = sysfs_move_dir(kobj, new_parent);
382         if (error)
383                 goto out;
384         old_parent = kobj->parent;
385         kobj->parent = new_parent;
386         kobject_put(old_parent);
387         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
388 out:
389         kobject_put(kobj);
390         kfree(devpath_string);
391         kfree(devpath);
392         return error;
393 }
394
395 /**
396  *      kobject_del - unlink kobject from hierarchy.
397  *      @kobj:  object.
398  */
399
400 void kobject_del(struct kobject * kobj)
401 {
402         if (!kobj)
403                 return;
404         sysfs_remove_dir(kobj);
405         unlink(kobj);
406 }
407
408 /**
409  *      kobject_unregister - remove object from hierarchy and decrement refcount.
410  *      @kobj:  object going away.
411  */
412
413 void kobject_unregister(struct kobject * kobj)
414 {
415         if (!kobj)
416                 return;
417         pr_debug("kobject %s: unregistering\n",kobject_name(kobj));
418         kobject_uevent(kobj, KOBJ_REMOVE);
419         kobject_del(kobj);
420         kobject_put(kobj);
421 }
422
423 /**
424  *      kobject_get - increment refcount for object.
425  *      @kobj:  object.
426  */
427
428 struct kobject * kobject_get(struct kobject * kobj)
429 {
430         if (kobj)
431                 kref_get(&kobj->kref);
432         return kobj;
433 }
434
435 /**
436  *      kobject_cleanup - free kobject resources. 
437  *      @kobj:  object.
438  */
439
440 void kobject_cleanup(struct kobject * kobj)
441 {
442         struct kobj_type * t = get_ktype(kobj);
443         struct kset * s = kobj->kset;
444         struct kobject * parent = kobj->parent;
445
446         pr_debug("kobject %s: cleaning up\n",kobject_name(kobj));
447         if (kobj->k_name != kobj->name)
448                 kfree(kobj->k_name);
449         kobj->k_name = NULL;
450         if (t && t->release)
451                 t->release(kobj);
452         if (s)
453                 kset_put(s);
454         kobject_put(parent);
455 }
456
457 static void kobject_release(struct kref *kref)
458 {
459         kobject_cleanup(container_of(kref, struct kobject, kref));
460 }
461
462 /**
463  *      kobject_put - decrement refcount for object.
464  *      @kobj:  object.
465  *
466  *      Decrement the refcount, and if 0, call kobject_cleanup().
467  */
468 void kobject_put(struct kobject * kobj)
469 {
470         if (kobj)
471                 kref_put(&kobj->kref, kobject_release);
472 }
473
474
475 static void dir_release(struct kobject *kobj)
476 {
477         kfree(kobj);
478 }
479
480 static struct kobj_type dir_ktype = {
481         .release        = dir_release,
482         .sysfs_ops      = NULL,
483         .default_attrs  = NULL,
484 };
485
486 /**
487  *      kobject_add_dir - add sub directory of object.
488  *      @parent:        object in which a directory is created.
489  *      @name:  directory name.
490  *
491  *      Add a plain directory object as child of given object.
492  */
493 struct kobject *kobject_add_dir(struct kobject *parent, const char *name)
494 {
495         struct kobject *k;
496         int ret;
497
498         if (!parent)
499                 return NULL;
500
501         k = kzalloc(sizeof(*k), GFP_KERNEL);
502         if (!k)
503                 return NULL;
504
505         k->parent = parent;
506         k->ktype = &dir_ktype;
507         kobject_set_name(k, name);
508         ret = kobject_register(k);
509         if (ret < 0) {
510                 printk(KERN_WARNING "kobject_add_dir: "
511                         "kobject_register error: %d\n", ret);
512                 kobject_del(k);
513                 return NULL;
514         }
515
516         return k;
517 }
518
519 /**
520  *      kset_init - initialize a kset for use
521  *      @k:     kset 
522  */
523
524 void kset_init(struct kset * k)
525 {
526         kobject_init(&k->kobj);
527         INIT_LIST_HEAD(&k->list);
528         spin_lock_init(&k->list_lock);
529 }
530
531
532 /**
533  *      kset_add - add a kset object to the hierarchy.
534  *      @k:     kset.
535  *
536  *      Simply, this adds the kset's embedded kobject to the 
537  *      hierarchy. 
538  *      We also try to make sure that the kset's embedded kobject
539  *      has a parent before it is added. We only care if the embedded
540  *      kobject is not part of a kset itself, since kobject_add()
541  *      assigns a parent in that case. 
542  *      If that is the case, and the kset has a controlling subsystem,
543  *      then we set the kset's parent to be said subsystem. 
544  */
545
546 int kset_add(struct kset * k)
547 {
548         if (!k->kobj.parent && !k->kobj.kset && k->subsys)
549                 k->kobj.parent = &k->subsys->kset.kobj;
550
551         return kobject_add(&k->kobj);
552 }
553
554
555 /**
556  *      kset_register - initialize and add a kset.
557  *      @k:     kset.
558  */
559
560 int kset_register(struct kset * k)
561 {
562         if (!k)
563                 return -EINVAL;
564         kset_init(k);
565         return kset_add(k);
566 }
567
568
569 /**
570  *      kset_unregister - remove a kset.
571  *      @k:     kset.
572  */
573
574 void kset_unregister(struct kset * k)
575 {
576         if (!k)
577                 return;
578         kobject_unregister(&k->kobj);
579 }
580
581
582 /**
583  *      kset_find_obj - search for object in kset.
584  *      @kset:  kset we're looking in.
585  *      @name:  object's name.
586  *
587  *      Lock kset via @kset->subsys, and iterate over @kset->list,
588  *      looking for a matching kobject. If matching object is found
589  *      take a reference and return the object.
590  */
591
592 struct kobject * kset_find_obj(struct kset * kset, const char * name)
593 {
594         struct list_head * entry;
595         struct kobject * ret = NULL;
596
597         spin_lock(&kset->list_lock);
598         list_for_each(entry,&kset->list) {
599                 struct kobject * k = to_kobj(entry);
600                 if (kobject_name(k) && !strcmp(kobject_name(k),name)) {
601                         ret = kobject_get(k);
602                         break;
603                 }
604         }
605         spin_unlock(&kset->list_lock);
606         return ret;
607 }
608
609
610 void subsystem_init(struct subsystem * s)
611 {
612         init_rwsem(&s->rwsem);
613         kset_init(&s->kset);
614 }
615
616 /**
617  *      subsystem_register - register a subsystem.
618  *      @s:     the subsystem we're registering.
619  *
620  *      Once we register the subsystem, we want to make sure that 
621  *      the kset points back to this subsystem for correct usage of 
622  *      the rwsem. 
623  */
624
625 int subsystem_register(struct subsystem * s)
626 {
627         int error;
628
629         if (!s)
630                 return -EINVAL;
631
632         subsystem_init(s);
633         pr_debug("subsystem %s: registering\n",s->kset.kobj.name);
634
635         if (!(error = kset_add(&s->kset))) {
636                 if (!s->kset.subsys)
637                         s->kset.subsys = s;
638         }
639         return error;
640 }
641
642 void subsystem_unregister(struct subsystem * s)
643 {
644         if (!s)
645                 return;
646         pr_debug("subsystem %s: unregistering\n",s->kset.kobj.name);
647         kset_unregister(&s->kset);
648 }
649
650
651 /**
652  *      subsystem_create_file - export sysfs attribute file.
653  *      @s:     subsystem.
654  *      @a:     subsystem attribute descriptor.
655  */
656
657 int subsys_create_file(struct subsystem * s, struct subsys_attribute * a)
658 {
659         int error = 0;
660
661         if (!s || !a)
662                 return -EINVAL;
663
664         if (subsys_get(s)) {
665                 error = sysfs_create_file(&s->kset.kobj,&a->attr);
666                 subsys_put(s);
667         }
668         return error;
669 }
670
671
672 /**
673  *      subsystem_remove_file - remove sysfs attribute file.
674  *      @s:     subsystem.
675  *      @a:     attribute desciptor.
676  */
677 #if 0
678 void subsys_remove_file(struct subsystem * s, struct subsys_attribute * a)
679 {
680         if (subsys_get(s)) {
681                 sysfs_remove_file(&s->kset.kobj,&a->attr);
682                 subsys_put(s);
683         }
684 }
685 #endif  /*  0  */
686
687 EXPORT_SYMBOL(kobject_init);
688 EXPORT_SYMBOL(kobject_register);
689 EXPORT_SYMBOL(kobject_unregister);
690 EXPORT_SYMBOL(kobject_get);
691 EXPORT_SYMBOL(kobject_put);
692 EXPORT_SYMBOL(kobject_add);
693 EXPORT_SYMBOL(kobject_del);
694
695 EXPORT_SYMBOL(kset_register);
696 EXPORT_SYMBOL(kset_unregister);
697
698 EXPORT_SYMBOL(subsystem_register);
699 EXPORT_SYMBOL(subsystem_unregister);
700 EXPORT_SYMBOL(subsys_create_file);