kobject.c

Go to the documentation of this file.

/*
 * kobject.c - library routines for handling generic kernel objects
 *
 * Copyright (c) 2002-2003 Patrick Mochel <[email protected]>
 * Copyright (c) 2006-2007 Greg Kroah-Hartman <[email protected]>
 * Copyright (c) 2006-2007 Novell Inc.
 *
 * This file is released under the GPLv2.
 *
 *
 * Please see the file Documentation/kobject.txt for critical information
 * about using the kobject interface.
 */

#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/export.h>
#include <linux/stat.h>
#include <linux/slab.h>

/*
 * 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]) != NULL; i++) {
            error = sysfs_create_file(kobj, attr);
            if (error)
                break;
        }
    }
    return error;
}

static int create_dir(struct kobject *kobj)
{
    int error = 0;
    error = sysfs_create_dir(kobj);
    if (!error) {
        error = populate_dir(kobj);
        if (error)
            sysfs_remove_dir(kobj);
    }
    return error;
}

static int get_kobj_path_length(struct kobject *kobj)
{
    int length = 1;
    struct kobject *parent = kobj;

    /* walk up the ancestors until we hit the one pointing to the
     * root.
     * Add 1 to strlen for leading '/' of each level.
     */
    do {
        if (kobject_name(parent) == NULL)
            return 0;
        length += strlen(kobject_name(parent)) + 1;
        parent = parent->parent;
    } while (parent);
    return length;
}

static void fill_kobj_path(struct kobject *kobj, char *path, int length)
{
    struct kobject *parent;

    --length;
    for (parent = kobj; parent; parent = parent->parent) {
        int cur = strlen(kobject_name(parent));
        /* back up enough to print this name with '/' */
        length -= cur;
        strncpy(path + length, kobject_name(parent), cur);
        *(path + --length) = '/';
    }

    pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
         kobj, __func__, path);
}

char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
{
    char *path;
    int len;

    len = get_kobj_path_length(kobj);
    if (len == 0)
        return NULL;
    path = kzalloc(len, gfp_mask);
    if (!path)
        return NULL;
    fill_kobj_path(kobj, path, len);

    return path;
}
EXPORT_SYMBOL_GPL(kobject_get_path);

/* add the kobject to its kset's list */
static void kobj_kset_join(struct kobject *kobj)
{
    if (!kobj->kset)
        return;

    kset_get(kobj->kset);
    spin_lock(&kobj->kset->list_lock);
    list_add_tail(&kobj->entry, &kobj->kset->list);
    spin_unlock(&kobj->kset->list_lock);
}

/* remove the kobject from its kset's list */
static void kobj_kset_leave(struct kobject *kobj)
{
    if (!kobj->kset)
        return;

    spin_lock(&kobj->kset->list_lock);
    list_del_init(&kobj->entry);
    spin_unlock(&kobj->kset->list_lock);
    kset_put(kobj->kset);
}

static void kobject_init_internal(struct kobject *kobj)
{
    if (!kobj)
        return;
    kref_init(&kobj->kref);
    INIT_LIST_HEAD(&kobj->entry);
    kobj->state_in_sysfs = 0;
    kobj->state_add_uevent_sent = 0;
    kobj->state_remove_uevent_sent = 0;
    kobj->state_initialized = 1;
}


static int kobject_add_internal(struct kobject *kobj)
{
    int error = 0;
    struct kobject *parent;

    if (!kobj)
        return -ENOENT;

    if (!kobj->name || !kobj->name[0]) {
        WARN(1, "kobject: (%p): attempted to be registered with empty "
             "name!\n", kobj);
        return -EINVAL;
    }

    parent = kobject_get(kobj->parent);

    /* join kset if set, use it as parent if we do not already have one */
    if (kobj->kset) {
        if (!parent)
            parent = kobject_get(&kobj->kset->kobj);
        kobj_kset_join(kobj);
        kobj->parent = parent;
    }

    pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
         kobject_name(kobj), kobj, __func__,
         parent ? kobject_name(parent) : "<NULL>",
         kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");

    error = create_dir(kobj);
    if (error) {
        kobj_kset_leave(kobj);
        kobject_put(parent);
        kobj->parent = NULL;

        /* be noisy on error issues */
        if (error == -EEXIST)
            WARN(1, "%s failed for %s with "
                 "-EEXIST, don't try to register things with "
                 "the same name in the same directory.\n",
                 __func__, kobject_name(kobj));
        else
            WARN(1, "%s failed for %s (error: %d parent: %s)\n",
                 __func__, kobject_name(kobj), error,
                 parent ? kobject_name(parent) : "'none'");
    } else
        kobj->state_in_sysfs = 1;

    return error;
}

int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
                  va_list vargs)
{
    const char *old_name = kobj->name;
    char *s;

    if (kobj->name && !fmt)
        return 0;

    kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
    if (!kobj->name)
        return -ENOMEM;

    /* ewww... some of these buggers have '/' in the name ... */
    while ((s = strchr(kobj->name, '/')))
        s[0] = '!';

    kfree(old_name);
    return 0;
}

int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
{
    va_list vargs;
    int retval;

    va_start(vargs, fmt);
    retval = kobject_set_name_vargs(kobj, fmt, vargs);
    va_end(vargs);

    return retval;
}
EXPORT_SYMBOL(kobject_set_name);

void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
{
    char *err_str;

    if (!kobj) {
        err_str = "invalid kobject pointer!";
        goto error;
    }
    if (!ktype) {
        err_str = "must have a ktype to be initialized properly!\n";
        goto error;
    }
    if (kobj->state_initialized) {
        /* do not error out as sometimes we can recover */
        printk(KERN_ERR "kobject (%p): tried to init an initialized "
               "object, something is seriously wrong.\n", kobj);
        dump_stack();
    }

    kobject_init_internal(kobj);
    kobj->ktype = ktype;
    return;

error:
    printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
    dump_stack();
}
EXPORT_SYMBOL(kobject_init);

static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
                const char *fmt, va_list vargs)
{
    int retval;

    retval = kobject_set_name_vargs(kobj, fmt, vargs);
    if (retval) {
        printk(KERN_ERR "kobject: can not set name properly!\n");
        return retval;
    }
    kobj->parent = parent;
    return kobject_add_internal(kobj);
}

int kobject_add(struct kobject *kobj, struct kobject *parent,
        const char *fmt, ...)
{
    va_list args;
    int retval;

    if (!kobj)
        return -EINVAL;

    if (!kobj->state_initialized) {
        printk(KERN_ERR "kobject '%s' (%p): tried to add an "
               "uninitialized object, something is seriously wrong.\n",
               kobject_name(kobj), kobj);
        dump_stack();
        return -EINVAL;
    }
    va_start(args, fmt);
    retval = kobject_add_varg(kobj, parent, fmt, args);
    va_end(args);

    return retval;
}
EXPORT_SYMBOL(kobject_add);

int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
             struct kobject *parent, const char *fmt, ...)
{
    va_list args;
    int retval;

    kobject_init(kobj, ktype);

    va_start(args, fmt);
    retval = kobject_add_varg(kobj, parent, fmt, args);
    va_end(args);

    return retval;
}
EXPORT_SYMBOL_GPL(kobject_init_and_add);

int kobject_rename(struct kobject *kobj, const char *new_name)
{
    int error = 0;
    const char *devpath = NULL;
    const char *dup_name = NULL, *name;
    char *devpath_string = NULL;
    char *envp[2];

    kobj = kobject_get(kobj);
    if (!kobj)
        return -EINVAL;
    if (!kobj->parent)
        return -EINVAL;

    devpath = kobject_get_path(kobj, GFP_KERNEL);
    if (!devpath) {
        error = -ENOMEM;
        goto out;
    }
    devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
    if (!devpath_string) {
        error = -ENOMEM;
        goto out;
    }
    sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
    envp[0] = devpath_string;
    envp[1] = NULL;

    name = dup_name = kstrdup(new_name, GFP_KERNEL);
    if (!name) {
        error = -ENOMEM;
        goto out;
    }

    error = sysfs_rename_dir(kobj, new_name);
    if (error)
        goto out;

    /* Install the new kobject name */
    dup_name = kobj->name;
    kobj->name = name;

    /* This function is mostly/only used for network interface.
     * Some hotplug package track interfaces by their name and
     * therefore want to know when the name is changed by the user. */
    kobject_uevent_env(kobj, KOBJ_MOVE, envp);

out:
    kfree(dup_name);
    kfree(devpath_string);
    kfree(devpath);
    kobject_put(kobj);

    return error;
}
EXPORT_SYMBOL_GPL(kobject_rename);

int kobject_move(struct kobject *kobj, struct kobject *new_parent)
{
    int error;
    struct kobject *old_parent;
    const char *devpath = NULL;
    char *devpath_string = NULL;
    char *envp[2];

    kobj = kobject_get(kobj);
    if (!kobj)
        return -EINVAL;
    new_parent = kobject_get(new_parent);
    if (!new_parent) {
        if (kobj->kset)
            new_parent = kobject_get(&kobj->kset->kobj);
    }
    /* old object path */
    devpath = kobject_get_path(kobj, GFP_KERNEL);
    if (!devpath) {
        error = -ENOMEM;
        goto out;
    }
    devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
    if (!devpath_string) {
        error = -ENOMEM;
        goto out;
    }
    sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
    envp[0] = devpath_string;
    envp[1] = NULL;
    error = sysfs_move_dir(kobj, new_parent);
    if (error)
        goto out;
    old_parent = kobj->parent;
    kobj->parent = new_parent;
    new_parent = NULL;
    kobject_put(old_parent);
    kobject_uevent_env(kobj, KOBJ_MOVE, envp);
out:
    kobject_put(new_parent);
    kobject_put(kobj);
    kfree(devpath_string);
    kfree(devpath);
    return error;
}

void kobject_del(struct kobject *kobj)
{
    if (!kobj)
        return;

    sysfs_remove_dir(kobj);
    kobj->state_in_sysfs = 0;
    kobj_kset_leave(kobj);
    kobject_put(kobj->parent);
    kobj->parent = NULL;
}

struct kobject *kobject_get(struct kobject *kobj)
{
    if (kobj)
        kref_get(&kobj->kref);
    return kobj;
}

/*
 * kobject_cleanup - free kobject resources.
 * @kobj: object to cleanup
 */
static void kobject_cleanup(struct kobject *kobj)
{
    struct kobj_type *t = get_ktype(kobj);
    const char *name = kobj->name;

    pr_debug("kobject: '%s' (%p): %s\n",
         kobject_name(kobj), kobj, __func__);

    if (t && !t->release)
        pr_debug("kobject: '%s' (%p): does not have a release() "
             "function, it is broken and must be fixed.\n",
             kobject_name(kobj), kobj);

    /* send "remove" if the caller did not do it but sent "add" */
    if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
        pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
             kobject_name(kobj), kobj);
        kobject_uevent(kobj, KOBJ_REMOVE);
    }

    /* remove from sysfs if the caller did not do it */
    if (kobj->state_in_sysfs) {
        pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
             kobject_name(kobj), kobj);
        kobject_del(kobj);
    }

    if (t && t->release) {
        pr_debug("kobject: '%s' (%p): calling ktype release\n",
             kobject_name(kobj), kobj);
        t->release(kobj);
    }

    /* free name if we allocated it */
    if (name) {
        pr_debug("kobject: '%s': free name\n", name);
        kfree(name);
    }
}

static void kobject_release(struct kref *kref)
{
    kobject_cleanup(container_of(kref, struct kobject, kref));
}

void kobject_put(struct kobject *kobj)
{
    if (kobj) {
        if (!kobj->state_initialized)
            WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
                   "initialized, yet kobject_put() is being "
                   "called.\n", kobject_name(kobj), kobj);
        kref_put(&kobj->kref, kobject_release);
    }
}

static void dynamic_kobj_release(struct kobject *kobj)
{
    pr_debug("kobject: (%p): %s\n", kobj, __func__);
    kfree(kobj);
}

static struct kobj_type dynamic_kobj_ktype = {
    .release    = dynamic_kobj_release,
    .sysfs_ops  = &kobj_sysfs_ops,
};

struct kobject *kobject_create(void)
{
    struct kobject *kobj;

    kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
    if (!kobj)
        return NULL;

    kobject_init(kobj, &dynamic_kobj_ktype);
    return kobj;
}

struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
{
    struct kobject *kobj;
    int retval;

    kobj = kobject_create();
    if (!kobj)
        return NULL;

    retval = kobject_add(kobj, parent, "%s", name);
    if (retval) {
        printk(KERN_WARNING "%s: kobject_add error: %d\n",
               __func__, retval);
        kobject_put(kobj);
        kobj = NULL;
    }
    return kobj;
}
EXPORT_SYMBOL_GPL(kobject_create_and_add);

void kset_init(struct kset *k)
{
    kobject_init_internal(&k->kobj);
    INIT_LIST_HEAD(&k->list);
    spin_lock_init(&k->list_lock);
}

/* default kobject attribute operations */
static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
                  char *buf)
{
    struct kobj_attribute *kattr;
    ssize_t ret = -EIO;

    kattr = container_of(attr, struct kobj_attribute, attr);
    if (kattr->show)
        ret = kattr->show(kobj, kattr, buf);
    return ret;
}

static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
                   const char *buf, size_t count)
{
    struct kobj_attribute *kattr;
    ssize_t ret = -EIO;

    kattr = container_of(attr, struct kobj_attribute, attr);
    if (kattr->store)
        ret = kattr->store(kobj, kattr, buf, count);
    return ret;
}

const struct sysfs_ops kobj_sysfs_ops = {
    .show   = kobj_attr_show,
    .store  = kobj_attr_store,
};

int kset_register(struct kset *k)
{
    int err;

    if (!k)
        return -EINVAL;

    kset_init(k);
    err = kobject_add_internal(&k->kobj);
    if (err)
        return err;
    kobject_uevent(&k->kobj, KOBJ_ADD);
    return 0;
}

void kset_unregister(struct kset *k)
{
    if (!k)
        return;
    kobject_put(&k->kobj);
}

struct kobject *kset_find_obj(struct kset *kset, const char *name)
{
    struct kobject *k;
    struct kobject *ret = NULL;

    spin_lock(&kset->list_lock);

    list_for_each_entry(k, &kset->list, entry) {
        if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
            ret = kobject_get(k);
            break;
        }
    }

    spin_unlock(&kset->list_lock);
    return ret;
}

static void kset_release(struct kobject *kobj)
{
    struct kset *kset = container_of(kobj, struct kset, kobj);
    pr_debug("kobject: '%s' (%p): %s\n",
         kobject_name(kobj), kobj, __func__);
    kfree(kset);
}

static struct kobj_type kset_ktype = {
    .sysfs_ops  = &kobj_sysfs_ops,
    .release = kset_release,
};

static struct kset *kset_create(const char *name,
                const struct kset_uevent_ops *uevent_ops,
                struct kobject *parent_kobj)
{
    struct kset *kset;
    int retval;

    kset = kzalloc(sizeof(*kset), GFP_KERNEL);
    if (!kset)
        return NULL;
    retval = kobject_set_name(&kset->kobj, name);
    if (retval) {
        kfree(kset);
        return NULL;
    }
    kset->uevent_ops = uevent_ops;
    kset->kobj.parent = parent_kobj;

    /*
     * The kobject of this kset will have a type of kset_ktype and belong to
     * no kset itself.  That way we can properly free it when it is
     * finished being used.
     */
    kset->kobj.ktype = &kset_ktype;
    kset->kobj.kset = NULL;

    return kset;
}

struct kset *kset_create_and_add(const char *name,
                 const struct kset_uevent_ops *uevent_ops,
                 struct kobject *parent_kobj)
{
    struct kset *kset;
    int error;

    kset = kset_create(name, uevent_ops, parent_kobj);
    if (!kset)
        return NULL;
    error = kset_register(kset);
    if (error) {
        kfree(kset);
        return NULL;
    }
    return kset;
}
EXPORT_SYMBOL_GPL(kset_create_and_add);


static DEFINE_SPINLOCK(kobj_ns_type_lock);
static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];

int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
{
    enum kobj_ns_type type = ops->type;
    int error;

    spin_lock(&kobj_ns_type_lock);

    error = -EINVAL;
    if (type >= KOBJ_NS_TYPES)
        goto out;

    error = -EINVAL;
    if (type <= KOBJ_NS_TYPE_NONE)
        goto out;

    error = -EBUSY;
    if (kobj_ns_ops_tbl[type])
        goto out;

    error = 0;
    kobj_ns_ops_tbl[type] = ops;

out:
    spin_unlock(&kobj_ns_type_lock);
    return error;
}

int kobj_ns_type_registered(enum kobj_ns_type type)
{
    int registered = 0;

    spin_lock(&kobj_ns_type_lock);
    if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
        registered = kobj_ns_ops_tbl[type] != NULL;
    spin_unlock(&kobj_ns_type_lock);

    return registered;
}

const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
{
    const struct kobj_ns_type_operations *ops = NULL;

    if (parent && parent->ktype->child_ns_type)
        ops = parent->ktype->child_ns_type(parent);

    return ops;
}

const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
{
    return kobj_child_ns_ops(kobj->parent);
}


void *kobj_ns_grab_current(enum kobj_ns_type type)
{
    void *ns = NULL;

    spin_lock(&kobj_ns_type_lock);
    if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
        kobj_ns_ops_tbl[type])
        ns = kobj_ns_ops_tbl[type]->grab_current_ns();
    spin_unlock(&kobj_ns_type_lock);

    return ns;
}

const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
{
    const void *ns = NULL;

    spin_lock(&kobj_ns_type_lock);
    if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
        kobj_ns_ops_tbl[type])
        ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
    spin_unlock(&kobj_ns_type_lock);

    return ns;
}

const void *kobj_ns_initial(enum kobj_ns_type type)
{
    const void *ns = NULL;

    spin_lock(&kobj_ns_type_lock);
    if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
        kobj_ns_ops_tbl[type])
        ns = kobj_ns_ops_tbl[type]->initial_ns();
    spin_unlock(&kobj_ns_type_lock);

    return ns;
}

void kobj_ns_drop(enum kobj_ns_type type, void *ns)
{
    spin_lock(&kobj_ns_type_lock);
    if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
        kobj_ns_ops_tbl[type] && kobj_ns_ops_tbl[type]->drop_ns)
        kobj_ns_ops_tbl[type]->drop_ns(ns);
    spin_unlock(&kobj_ns_type_lock);
}

EXPORT_SYMBOL(kobject_get);
EXPORT_SYMBOL(kobject_put);
EXPORT_SYMBOL(kobject_del);

EXPORT_SYMBOL(kset_register);
EXPORT_SYMBOL(kset_unregister);