| /* |
| * kobject.c - library routines for handling generic kernel objects |
| */ |
| |
| #undef DEBUG |
| |
| #include <linux/kobject.h> |
| #include <linux/string.h> |
| #include <linux/module.h> |
| #include <linux/stat.h> |
| |
| static spinlock_t kobj_lock = SPIN_LOCK_UNLOCKED; |
| |
| static inline struct kobj_type * get_ktype(struct kobject * k) |
| { |
| if (k->kset && k->kset->ktype) |
| return k->kset->ktype; |
| else |
| return k->ktype; |
| } |
| |
| /** |
| * populate_dir - populate directory with attributes. |
| * @kobj: object we're working on. |
| * |
| * Most subsystems have a set of default attributes that |
| * are associated with an object that registers with them. |
| * This is a helper called during object registration that |
| * loops through the default attributes of the subsystem |
| * and creates attributes files for them in sysfs. |
| * |
| */ |
| |
| static int populate_dir(struct kobject * kobj) |
| { |
| struct kobj_type * t = get_ktype(kobj); |
| struct attribute * attr; |
| int error = 0; |
| int i; |
| |
| if (t && t->default_attrs) { |
| for (i = 0; (attr = t->default_attrs[i]); i++) { |
| if ((error = sysfs_create_file(kobj,attr))) |
| break; |
| } |
| } |
| return error; |
| } |
| |
| static int create_dir(struct kobject * kobj) |
| { |
| int error = 0; |
| if (strlen(kobj->name)) { |
| error = sysfs_create_dir(kobj); |
| if (!error) { |
| if ((error = populate_dir(kobj))) |
| sysfs_remove_dir(kobj); |
| } |
| } |
| return error; |
| } |
| |
| |
| static inline struct kobject * to_kobj(struct list_head * entry) |
| { |
| return container_of(entry,struct kobject,entry); |
| } |
| |
| |
| /** |
| * kobject_init - initialize object. |
| * @kobj: object in question. |
| */ |
| |
| void kobject_init(struct kobject * kobj) |
| { |
| atomic_set(&kobj->refcount,1); |
| INIT_LIST_HEAD(&kobj->entry); |
| kobj->kset = kset_get(kobj->kset); |
| } |
| |
| |
| /** |
| * unlink - remove kobject from kset list. |
| * @kobj: kobject. |
| * |
| * Remove the kobject from the kset list and decrement |
| * its parent's refcount. |
| * This is separated out, so we can use it in both |
| * kobject_del() and kobject_add() on error. |
| */ |
| |
| static void unlink(struct kobject * kobj) |
| { |
| if (kobj->kset) { |
| down_write(&kobj->kset->subsys->rwsem); |
| list_del_init(&kobj->entry); |
| up_write(&kobj->kset->subsys->rwsem); |
| } |
| if (kobj->parent) |
| kobject_put(kobj->parent); |
| kobject_put(kobj); |
| } |
| |
| /** |
| * kobject_add - add an object to the hierarchy. |
| * @kobj: object. |
| */ |
| |
| int kobject_add(struct kobject * kobj) |
| { |
| int error = 0; |
| struct kobject * parent; |
| |
| if (!(kobj = kobject_get(kobj))) |
| return -ENOENT; |
| |
| parent = kobject_get(kobj->parent); |
| |
| pr_debug("kobject %s: registering. parent: %s, set: %s\n", |
| kobj->name, parent ? parent->name : "<NULL>", |
| kobj->kset ? kobj->kset->kobj.name : "<NULL>" ); |
| |
| if (kobj->kset) { |
| down_write(&kobj->kset->subsys->rwsem); |
| if (parent) |
| list_add_tail(&kobj->entry,&parent->entry); |
| else { |
| list_add_tail(&kobj->entry,&kobj->kset->list); |
| kobj->parent = kobject_get(&kobj->kset->kobj); |
| } |
| up_write(&kobj->kset->subsys->rwsem); |
| } |
| error = create_dir(kobj); |
| if (error) |
| unlink(kobj); |
| return error; |
| } |
| |
| |
| /** |
| * kobject_register - initialize and add an object. |
| * @kobj: object in question. |
| */ |
| |
| int kobject_register(struct kobject * kobj) |
| { |
| int error = 0; |
| if (kobj) { |
| kobject_init(kobj); |
| error = kobject_add(kobj); |
| WARN_ON(error); |
| } else |
| error = -EINVAL; |
| return error; |
| } |
| |
| /** |
| * kobject_del - unlink kobject from hierarchy. |
| * @kobj: object. |
| */ |
| |
| void kobject_del(struct kobject * kobj) |
| { |
| sysfs_remove_dir(kobj); |
| unlink(kobj); |
| } |
| |
| /** |
| * kobject_unregister - remove object from hierarchy and decrement refcount. |
| * @kobj: object going away. |
| */ |
| |
| void kobject_unregister(struct kobject * kobj) |
| { |
| pr_debug("kobject %s: unregistering\n",kobj->name); |
| kobject_del(kobj); |
| kobject_put(kobj); |
| } |
| |
| /** |
| * kobject_get - increment refcount for object. |
| * @kobj: object. |
| */ |
| |
| struct kobject * kobject_get(struct kobject * kobj) |
| { |
| struct kobject * ret = kobj; |
| spin_lock(&kobj_lock); |
| if (kobj && atomic_read(&kobj->refcount) > 0) |
| atomic_inc(&kobj->refcount); |
| else |
| ret = NULL; |
| spin_unlock(&kobj_lock); |
| return ret; |
| } |
| |
| /** |
| * kobject_cleanup - free kobject resources. |
| * @kobj: object. |
| */ |
| |
| void kobject_cleanup(struct kobject * kobj) |
| { |
| struct kobj_type * t = get_ktype(kobj); |
| struct kset * s = kobj->kset; |
| |
| pr_debug("kobject %s: cleaning up\n",kobj->name); |
| if (t && t->release) |
| t->release(kobj); |
| if (s) |
| kset_put(s); |
| } |
| |
| /** |
| * kobject_put - decrement refcount for object. |
| * @kobj: object. |
| * |
| * Decrement the refcount, and if 0, call kobject_cleanup(). |
| */ |
| |
| void kobject_put(struct kobject * kobj) |
| { |
| if (!atomic_dec_and_lock(&kobj->refcount, &kobj_lock)) |
| return; |
| spin_unlock(&kobj_lock); |
| kobject_cleanup(kobj); |
| } |
| |
| |
| /** |
| * kset_init - initialize a kset for use |
| * @k: kset |
| */ |
| |
| void kset_init(struct kset * k) |
| { |
| kobject_init(&k->kobj); |
| INIT_LIST_HEAD(&k->list); |
| } |
| |
| |
| /** |
| * kset_add - add a kset object to the hierarchy. |
| * @k: kset. |
| * |
| * Simply, this adds the kset's embedded kobject to the |
| * hierarchy. |
| * We also try to make sure that the kset's embedded kobject |
| * has a parent before it is added. We only care if the embedded |
| * kobject is not part of a kset itself, since kobject_add() |
| * assigns a parent in that case. |
| * If that is the case, and the kset has a controlling subsystem, |
| * then we set the kset's parent to be said subsystem. |
| */ |
| |
| int kset_add(struct kset * k) |
| { |
| if (!k->kobj.parent && !k->kobj.kset && k->subsys) |
| k->kobj.parent = &k->subsys->kset.kobj; |
| |
| return kobject_add(&k->kobj); |
| } |
| |
| |
| /** |
| * kset_register - initialize and add a kset. |
| * @k: kset. |
| */ |
| |
| int kset_register(struct kset * k) |
| { |
| kset_init(k); |
| return kset_add(k); |
| } |
| |
| |
| /** |
| * kset_unregister - remove a kset. |
| * @k: kset. |
| */ |
| |
| void kset_unregister(struct kset * k) |
| { |
| kobject_unregister(&k->kobj); |
| } |
| |
| |
| /** |
| * kset_find_obj - search for object in kset. |
| * @kset: kset we're looking in. |
| * @name: object's name. |
| * |
| * Lock kset via @kset->subsys, and iterate over @kset->list, |
| * looking for a matching kobject. Return object if found. |
| */ |
| |
| struct kobject * kset_find_obj(struct kset * kset, const char * name) |
| { |
| struct list_head * entry; |
| struct kobject * ret = NULL; |
| |
| down_read(&kset->subsys->rwsem); |
| list_for_each(entry,&kset->list) { |
| struct kobject * k = to_kobj(entry); |
| if (!strcmp(k->name,name)) { |
| ret = k; |
| break; |
| } |
| } |
| up_read(&kset->subsys->rwsem); |
| return ret; |
| } |
| |
| |
| void subsystem_init(struct subsystem * s) |
| { |
| init_rwsem(&s->rwsem); |
| kset_init(&s->kset); |
| } |
| |
| /** |
| * subsystem_register - register a subsystem. |
| * @s: the subsystem we're registering. |
| * |
| * Once we register the subsystem, we want to make sure that |
| * the kset points back to this subsystem for correct usage of |
| * the rwsem. |
| */ |
| |
| int subsystem_register(struct subsystem * s) |
| { |
| int error; |
| |
| subsystem_init(s); |
| pr_debug("subsystem %s: registering\n",s->kset.kobj.name); |
| |
| if (!(error = kset_add(&s->kset))) { |
| if (!s->kset.subsys) |
| s->kset.subsys = s; |
| } |
| return error; |
| } |
| |
| void subsystem_unregister(struct subsystem * s) |
| { |
| pr_debug("subsystem %s: unregistering\n",s->kset.kobj.name); |
| kset_unregister(&s->kset); |
| } |
| |
| |
| /** |
| * subsystem_create_file - export sysfs attribute file. |
| * @s: subsystem. |
| * @a: subsystem attribute descriptor. |
| */ |
| |
| int subsys_create_file(struct subsystem * s, struct subsys_attribute * a) |
| { |
| int error = 0; |
| if (subsys_get(s)) { |
| error = sysfs_create_file(&s->kset.kobj,&a->attr); |
| subsys_put(s); |
| } |
| return error; |
| } |
| |
| |
| /** |
| * subsystem_remove_file - remove sysfs attribute file. |
| * @s: subsystem. |
| * @a: attribute desciptor. |
| */ |
| |
| void subsys_remove_file(struct subsystem * s, struct subsys_attribute * a) |
| { |
| if (subsys_get(s)) { |
| sysfs_remove_file(&s->kset.kobj,&a->attr); |
| subsys_put(s); |
| } |
| } |
| |
| |
| EXPORT_SYMBOL(kobject_init); |
| EXPORT_SYMBOL(kobject_register); |
| EXPORT_SYMBOL(kobject_unregister); |
| EXPORT_SYMBOL(kobject_get); |
| EXPORT_SYMBOL(kobject_put); |
| |
| EXPORT_SYMBOL(kset_find_obj); |
| |
| EXPORT_SYMBOL(subsystem_init); |
| EXPORT_SYMBOL(subsystem_register); |
| EXPORT_SYMBOL(subsystem_unregister); |
| EXPORT_SYMBOL(subsys_create_file); |
| EXPORT_SYMBOL(subsys_remove_file); |