4a310e55a886fbbdde0e413327f7cfab2b54b2fe
[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("%s: path = '%s'\n",__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 /**
127  *      kobject_init - initialize object.
128  *      @kobj:  object in question.
129  */
130 void kobject_init(struct kobject * kobj)
131 {
132         if (!kobj)
133                 return;
134         kref_init(&kobj->kref);
135         INIT_LIST_HEAD(&kobj->entry);
136         kobj->kset = kset_get(kobj->kset);
137 }
138
139
140 /**
141  *      unlink - remove kobject from kset list.
142  *      @kobj:  kobject.
143  *
144  *      Remove the kobject from the kset list and decrement
145  *      its parent's refcount.
146  *      This is separated out, so we can use it in both 
147  *      kobject_del() and kobject_add() on error.
148  */
149
150 static void unlink(struct kobject * kobj)
151 {
152         if (kobj->kset) {
153                 spin_lock(&kobj->kset->list_lock);
154                 list_del_init(&kobj->entry);
155                 spin_unlock(&kobj->kset->list_lock);
156         }
157         kobject_put(kobj);
158 }
159
160 /**
161  *      kobject_add - add an object to the hierarchy.
162  *      @kobj:  object.
163  */
164
165 int kobject_add(struct kobject * kobj)
166 {
167         int error = 0;
168         struct kobject * parent;
169
170         if (!(kobj = kobject_get(kobj)))
171                 return -ENOENT;
172         if (!kobj->k_name)
173                 kobject_set_name(kobj, "NO_NAME");
174         if (!*kobj->k_name) {
175                 pr_debug("kobject attempted to be registered with no name!\n");
176                 WARN_ON(1);
177                 kobject_put(kobj);
178                 return -EINVAL;
179         }
180         parent = kobject_get(kobj->parent);
181
182         pr_debug("kobject %s: registering. parent: %s, set: %s\n",
183                  kobject_name(kobj), parent ? kobject_name(parent) : "<NULL>", 
184                  kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>" );
185
186         if (kobj->kset) {
187                 spin_lock(&kobj->kset->list_lock);
188
189                 if (!parent)
190                         parent = kobject_get(&kobj->kset->kobj);
191
192                 list_add_tail(&kobj->entry,&kobj->kset->list);
193                 spin_unlock(&kobj->kset->list_lock);
194                 kobj->parent = parent;
195         }
196
197         error = create_dir(kobj);
198         if (error) {
199                 /* unlink does the kobject_put() for us */
200                 unlink(kobj);
201                 kobject_put(parent);
202
203                 /* be noisy on error issues */
204                 if (error == -EEXIST)
205                         printk(KERN_ERR "kobject_add failed for %s with "
206                                "-EEXIST, don't try to register things with "
207                                "the same name in the same directory.\n",
208                                kobject_name(kobj));
209                 else
210                         printk(KERN_ERR "kobject_add failed for %s (%d)\n",
211                                kobject_name(kobj), error);
212                 dump_stack();
213         }
214
215         return error;
216 }
217
218 /**
219  *      kobject_register - initialize and add an object.
220  *      @kobj:  object in question.
221  */
222
223 int kobject_register(struct kobject * kobj)
224 {
225         int error = -EINVAL;
226         if (kobj) {
227                 kobject_init(kobj);
228                 error = kobject_add(kobj);
229                 if (!error)
230                         kobject_uevent(kobj, KOBJ_ADD);
231         }
232         return error;
233 }
234
235 /**
236  * kobject_set_name_vargs - Set the name of an kobject
237  * @kobj: struct kobject to set the name of
238  * @fmt: format string used to build the name
239  * @vargs: vargs to format the string.
240  */
241 static int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
242                                   va_list vargs)
243 {
244         va_list aq;
245         char *name;
246
247         va_copy(aq, vargs);
248         name = kvasprintf(GFP_KERNEL, fmt, vargs);
249         va_end(aq);
250
251         if (!name)
252                 return -ENOMEM;
253
254         /* Free the old name, if necessary. */
255         kfree(kobj->k_name);
256
257         /* Now, set the new name */
258         kobj->k_name = name;
259
260         return 0;
261 }
262
263 /**
264  * kobject_set_name - Set the name of a kobject
265  * @kobj: struct kobject to set the name of
266  * @fmt: format string used to build the name
267  *
268  * This sets the name of the kobject.  If you have already added the
269  * kobject to the system, you must call kobject_rename() in order to
270  * change the name of the kobject.
271  */
272 int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
273 {
274         va_list args;
275         int retval;
276
277         va_start(args, fmt);
278         retval = kobject_set_name_vargs(kobj, fmt, args);
279         va_end(args);
280
281         return retval;
282 }
283 EXPORT_SYMBOL(kobject_set_name);
284
285 /**
286  *      kobject_rename - change the name of an object
287  *      @kobj:  object in question.
288  *      @new_name: object's new name
289  */
290
291 int kobject_rename(struct kobject * kobj, const char *new_name)
292 {
293         int error = 0;
294         const char *devpath = NULL;
295         char *devpath_string = NULL;
296         char *envp[2];
297
298         kobj = kobject_get(kobj);
299         if (!kobj)
300                 return -EINVAL;
301         if (!kobj->parent)
302                 return -EINVAL;
303
304         /* see if this name is already in use */
305         if (kobj->kset) {
306                 struct kobject *temp_kobj;
307                 temp_kobj = kset_find_obj(kobj->kset, new_name);
308                 if (temp_kobj) {
309                         printk(KERN_WARNING "kobject '%s' cannot be renamed "
310                                "to '%s' as '%s' is already in existence.\n",
311                                kobject_name(kobj), new_name, new_name);
312                         kobject_put(temp_kobj);
313                         return -EINVAL;
314                 }
315         }
316
317         devpath = kobject_get_path(kobj, GFP_KERNEL);
318         if (!devpath) {
319                 error = -ENOMEM;
320                 goto out;
321         }
322         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
323         if (!devpath_string) {
324                 error = -ENOMEM;
325                 goto out;
326         }
327         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
328         envp[0] = devpath_string;
329         envp[1] = NULL;
330
331         error = sysfs_rename_dir(kobj, new_name);
332
333         /* This function is mostly/only used for network interface.
334          * Some hotplug package track interfaces by their name and
335          * therefore want to know when the name is changed by the user. */
336         if (!error)
337                 kobject_uevent_env(kobj, KOBJ_MOVE, envp);
338
339 out:
340         kfree(devpath_string);
341         kfree(devpath);
342         kobject_put(kobj);
343
344         return error;
345 }
346
347 /**
348  *      kobject_move - move object to another parent
349  *      @kobj:  object in question.
350  *      @new_parent: object's new parent (can be NULL)
351  */
352
353 int kobject_move(struct kobject *kobj, struct kobject *new_parent)
354 {
355         int error;
356         struct kobject *old_parent;
357         const char *devpath = NULL;
358         char *devpath_string = NULL;
359         char *envp[2];
360
361         kobj = kobject_get(kobj);
362         if (!kobj)
363                 return -EINVAL;
364         new_parent = kobject_get(new_parent);
365         if (!new_parent) {
366                 if (kobj->kset)
367                         new_parent = kobject_get(&kobj->kset->kobj);
368         }
369         /* old object path */
370         devpath = kobject_get_path(kobj, GFP_KERNEL);
371         if (!devpath) {
372                 error = -ENOMEM;
373                 goto out;
374         }
375         devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
376         if (!devpath_string) {
377                 error = -ENOMEM;
378                 goto out;
379         }
380         sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
381         envp[0] = devpath_string;
382         envp[1] = NULL;
383         error = sysfs_move_dir(kobj, new_parent);
384         if (error)
385                 goto out;
386         old_parent = kobj->parent;
387         kobj->parent = new_parent;
388         new_parent = NULL;
389         kobject_put(old_parent);
390         kobject_uevent_env(kobj, KOBJ_MOVE, envp);
391 out:
392         kobject_put(new_parent);
393         kobject_put(kobj);
394         kfree(devpath_string);
395         kfree(devpath);
396         return error;
397 }
398
399 /**
400  *      kobject_del - unlink kobject from hierarchy.
401  *      @kobj:  object.
402  */
403
404 void kobject_del(struct kobject * kobj)
405 {
406         if (!kobj)
407                 return;
408         sysfs_remove_dir(kobj);
409         unlink(kobj);
410 }
411
412 /**
413  *      kobject_unregister - remove object from hierarchy and decrement refcount.
414  *      @kobj:  object going away.
415  */
416
417 void kobject_unregister(struct kobject * kobj)
418 {
419         if (!kobj)
420                 return;
421         pr_debug("kobject %s: unregistering\n",kobject_name(kobj));
422         kobject_uevent(kobj, KOBJ_REMOVE);
423         kobject_del(kobj);
424         kobject_put(kobj);
425 }
426
427 /**
428  *      kobject_get - increment refcount for object.
429  *      @kobj:  object.
430  */
431
432 struct kobject * kobject_get(struct kobject * kobj)
433 {
434         if (kobj)
435                 kref_get(&kobj->kref);
436         return kobj;
437 }
438
439 /**
440  *      kobject_cleanup - free kobject resources. 
441  *      @kobj:  object.
442  */
443
444 void kobject_cleanup(struct kobject * kobj)
445 {
446         struct kobj_type * t = get_ktype(kobj);
447         struct kset * s = kobj->kset;
448         struct kobject * parent = kobj->parent;
449         const char *name = kobj->k_name;
450
451         pr_debug("kobject %s: cleaning up\n",kobject_name(kobj));
452         if (t && t->release) {
453                 t->release(kobj);
454                 /* If we have a release function, we can guess that this was
455                  * not a statically allocated kobject, so we should be safe to
456                  * free the name */
457                 kfree(name);
458         }
459         if (s)
460                 kset_put(s);
461         kobject_put(parent);
462 }
463
464 static void kobject_release(struct kref *kref)
465 {
466         kobject_cleanup(container_of(kref, struct kobject, kref));
467 }
468
469 /**
470  *      kobject_put - decrement refcount for object.
471  *      @kobj:  object.
472  *
473  *      Decrement the refcount, and if 0, call kobject_cleanup().
474  */
475 void kobject_put(struct kobject * kobj)
476 {
477         if (kobj)
478                 kref_put(&kobj->kref, kobject_release);
479 }
480
481
482 static void dir_release(struct kobject *kobj)
483 {
484         kfree(kobj);
485 }
486
487 static struct kobj_type dir_ktype = {
488         .release        = dir_release,
489         .sysfs_ops      = NULL,
490         .default_attrs  = NULL,
491 };
492
493 /**
494  *      kobject_kset_add_dir - add sub directory of object.
495  *      @kset:          kset the directory is belongs to.
496  *      @parent:        object in which a directory is created.
497  *      @name:  directory name.
498  *
499  *      Add a plain directory object as child of given object.
500  */
501 struct kobject *kobject_kset_add_dir(struct kset *kset,
502                                      struct kobject *parent, const char *name)
503 {
504         struct kobject *k;
505         int ret;
506
507         if (!parent)
508                 return NULL;
509
510         k = kzalloc(sizeof(*k), GFP_KERNEL);
511         if (!k)
512                 return NULL;
513
514         k->kset = kset;
515         k->parent = parent;
516         k->ktype = &dir_ktype;
517         kobject_set_name(k, name);
518         ret = kobject_register(k);
519         if (ret < 0) {
520                 printk(KERN_WARNING "%s: kobject_register error: %d\n",
521                         __func__, ret);
522                 kobject_del(k);
523                 return NULL;
524         }
525
526         return k;
527 }
528
529 /**
530  *      kobject_add_dir - add sub directory of object.
531  *      @parent:        object in which a directory is created.
532  *      @name:  directory name.
533  *
534  *      Add a plain directory object as child of given object.
535  */
536 struct kobject *kobject_add_dir(struct kobject *parent, const char *name)
537 {
538         return kobject_kset_add_dir(NULL, parent, name);
539 }
540
541 /**
542  *      kset_init - initialize a kset for use
543  *      @k:     kset 
544  */
545
546 void kset_init(struct kset * k)
547 {
548         kobject_init(&k->kobj);
549         INIT_LIST_HEAD(&k->list);
550         spin_lock_init(&k->list_lock);
551 }
552
553
554 /**
555  *      kset_add - add a kset object to the hierarchy.
556  *      @k:     kset.
557  */
558
559 int kset_add(struct kset * k)
560 {
561         return kobject_add(&k->kobj);
562 }
563
564
565 /**
566  *      kset_register - initialize and add a kset.
567  *      @k:     kset.
568  */
569
570 int kset_register(struct kset * k)
571 {
572         int err;
573
574         if (!k)
575                 return -EINVAL;
576
577         kset_init(k);
578         err = kset_add(k);
579         if (err)
580                 return err;
581         kobject_uevent(&k->kobj, KOBJ_ADD);
582         return 0;
583 }
584
585
586 /**
587  *      kset_unregister - remove a kset.
588  *      @k:     kset.
589  */
590
591 void kset_unregister(struct kset * k)
592 {
593         if (!k)
594                 return;
595         kobject_unregister(&k->kobj);
596 }
597
598
599 /**
600  *      kset_find_obj - search for object in kset.
601  *      @kset:  kset we're looking in.
602  *      @name:  object's name.
603  *
604  *      Lock kset via @kset->subsys, and iterate over @kset->list,
605  *      looking for a matching kobject. If matching object is found
606  *      take a reference and return the object.
607  */
608
609 struct kobject * kset_find_obj(struct kset * kset, const char * name)
610 {
611         struct list_head * entry;
612         struct kobject * ret = NULL;
613
614         spin_lock(&kset->list_lock);
615         list_for_each(entry,&kset->list) {
616                 struct kobject * k = to_kobj(entry);
617                 if (kobject_name(k) && !strcmp(kobject_name(k),name)) {
618                         ret = kobject_get(k);
619                         break;
620                 }
621         }
622         spin_unlock(&kset->list_lock);
623         return ret;
624 }
625
626 int subsystem_register(struct kset *s)
627 {
628         return kset_register(s);
629 }
630
631 void subsystem_unregister(struct kset *s)
632 {
633         kset_unregister(s);
634 }
635
636 /**
637  *      subsystem_create_file - export sysfs attribute file.
638  *      @s:     subsystem.
639  *      @a:     subsystem attribute descriptor.
640  */
641
642 int subsys_create_file(struct kset *s, struct subsys_attribute *a)
643 {
644         int error = 0;
645
646         if (!s || !a)
647                 return -EINVAL;
648
649         if (kset_get(s)) {
650                 error = sysfs_create_file(&s->kobj, &a->attr);
651                 kset_put(s);
652         }
653         return error;
654 }
655
656 EXPORT_SYMBOL(kobject_init);
657 EXPORT_SYMBOL(kobject_register);
658 EXPORT_SYMBOL(kobject_unregister);
659 EXPORT_SYMBOL(kobject_get);
660 EXPORT_SYMBOL(kobject_put);
661 EXPORT_SYMBOL(kobject_add);
662 EXPORT_SYMBOL(kobject_del);
663
664 EXPORT_SYMBOL(kset_register);
665 EXPORT_SYMBOL(kset_unregister);
666
667 EXPORT_SYMBOL(subsystem_register);
668 EXPORT_SYMBOL(subsystem_unregister);
669 EXPORT_SYMBOL(subsys_create_file);