Kobject模型

一。Kobject

每个在内核中注册的kobject都对应于sysfs文件系统中的一个目录。

kobject在文件include/linux/kobject中定义

struct kobject {
    const char        *name;                    //kobject的名称
    struct list_head    entry;            //kobject结构链表
    struct kobject        *parent;        //父kobject结构体
    struct kset        *kset;                    //kset集合
    struct kobj_type    *ktype;            //kobject的类型描述符
    struct sysfs_dirent    *sd;            //sysfs文件目录
    struct kref        kref;                        //kobject引用计数
    unsigned int state_initialized:1;    //kobject是否初始化
    unsigned int state_in_sysfs:1;    //是否已经加入sysfs
    unsigned int state_add_uevent_sent:1;
    unsigned int state_remove_uevent_sent:1;
    unsigned int uevent_suppress:1;
};

sysfs组织结构，进入sysfs目录中。有block bus class dev devices firmware fs kernel module power这些目录。具体代表看名字差不多就可以看出。在层次结构上，假如有一个设备A。将有一个名称为A的目录。A设备是在B总线上。那A设备应该在bus目录下的B总线下。A设备肯定会有设备的属性（ktype），例如是音频设备则应该有音量属性，则音量属性将在A设备目录下有个音量属性文件。在使用设备时，如果要改变音量大小，则可以写属性文件入音量指。得到音量大小时，可以读取属性文件中的音量值。

 二。Kobject初始化

初始化一个kobject结构体变量，kobject_init函数（lib/kobject.c），调用此函数前应先将kobject变量成员全部置0

/**
 * kobject_init - initialize a kobject structure
 * @kobj: pointer to the kobject to initialize
 * @ktype: pointer to the ktype for this kobject.
 *
 * This function will properly initialize a kobject such that it can then
 * be passed to the kobject_add() call.
 *
 * After this function is called, the kobject MUST be cleaned up by a call
 * to kobject_put(), not by a call to kfree directly to ensure that all of
 * the memory is cleaned up properly.
 */
void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
{
    char *err_str;

    if (!kobj) {    //检查kobj变量是否为空
        err_str = "invalid kobject pointer!";
        goto error;
    }
    if (!ktype) {    //检查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内部成员
    kobj->ktype = ktype;    //将参数中传来的ktype变量赋值给kobj的ktype变量。
    return;

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

分析kobject_init_internal函数（lib/kobject.c），此函数主要设置一些kobj中的一些变量

static void kobject_init_internal(struct kobject *kobj)
{
    if (!kobj)    //kobj是否为空
        return;
    kref_init(&kobj->kref);    //增加kobject的引用计数，kref_set(kref, 1);
    INIT_LIST_HEAD(&kobj->entry);    //初始化kobj的链表
    kobj->state_in_sysfs = 0;    //kobject还没有注册到sysfs中
    kobj->state_add_uevent_sent = 0;    //
    kobj->state_remove_uevent_sent = 0;
    kobj->state_initialized = 1;
}

三。kobj_type

对象的属性结构体kobj_type(include/linux/kobject.h)

struct kobj_type {
    void (*release)(struct kobject *kobj);    //释放函数（驱动编写时提供），此函数会被kobject_put函数调用
    struct sysfs_ops *sysfs_ops;    //属性文件的操作函数（只有读和写操作）
    struct attribute **default_attrs;    //属性数组
};

1.讨论kobj_type和kobject的关系，就要先说说kobject的引用。引用一个kobject使用函数kobject_get()这个函数会增加kobject的引用并返回kobject的指针。增加其引用是通过其kobject中断哦kref变量完成的。对kobject的引用管理主要是为了知道被引用的情况，如引用不为0就不能销毁kobject对象，引用为0时则调用相应的释放函数等。

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

void kref_get(struct kref *kref)
{
    WARN_ON(!atomic_read(&kref->refcount));
    atomic_inc(&kref->refcount);    //将kref中的这个原子变量加1
    smp_mb__after_atomic_inc();
}

减少一个kobject对象的引用使用函数kobject_put()。当一个kobject对象的引用被减少到0时，程序就应该释放这个kobject相关的资源。所以在减少引用的函数中就应该有调用释放资源的相关代码，在下面内核代码中我们可以看到。

void kobject_put(struct kobject *kobj)
{
    if (kobj) {
        if (!kobj->state_initialized)    //若kobj没有初始化就不能减少其引用
            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); //减少kref计数
    }
}
int kref_put(struct kref *kref, void (*release)(struct kref *kref))
{
    WARN_ON(release == NULL);    //为空警告
    WARN_ON(release == (void (*)(struct kref *))kfree); //如果release函数就是kfree，则警告（即release函数不能是简单的kfree）

    if (atomic_dec_and_test(&kref->refcount)) {    //递减原子变量并检查其值
        release(kref);    //回调release函数
        return 1;
    }
    return 0;
}

那这个release函数在哪里保存呢，这就和kobj_type结构有关系了。上面我们可以看到kobj_type中有一个release函数指针，就是保存在这里。每一个kobject的ktype都指向一个kobj_type,它保存了这个kobject类型的release函数指针。

四。Kset集合

1.Kset是具有相同类型的kobject集合。一个Kset集合可以表示在/sys/drivers/目录下，表示一类驱动程序。kobject则表示一个具体的驱动目录。这样kset则可以将kobject组织成层次化结构。

/**
 * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
 *
 * A kset defines a group of kobjects.  They can be individually
 * different "types" but overall these kobjects all want to be grouped
 * together and operated on in the same manner.  ksets are used to
 * define the attribute callbacks and other common events that happen to
 * a kobject.
 *
 * @list: the list of all kobjects for this kset
 * @list_lock: a lock for iterating over the kobjects
 * @kobj: the embedded kobject for this kset (recursion, isn't it fun...)
 * @uevent_ops: the set of uevent operations for this kset.  These are
 * called whenever a kobject has something happen to it so that the kset
 * can add new environment variables, or filter out the uevents if so
 * desired.
 */
struct kset {
    struct list_head list;    //这个链表存放这个kset关联的所有kobject
    spinlock_t list_lock;        //维护此链表的锁
    struct kobject kobj;        //内嵌的kobject。这样kset本身也是一个kobject也被表现为一个目录
    struct kset_uevent_ops *uevent_ops;    //支持热插拔事件的函数集
};

kset中的kobject对象，所有属于这个kset集合的kobject对象的parent指针，均指向这个内嵌的kobject，也即表示在一个kset集合中的kobject是相同类型的他们有相同的parent对象。kset的引用计数也就是内嵌的kobject的引用计数。

所以kobject和kset的关系简单来讲，就是

1.kset是kobject的一个顶层容器，它包含了相同类型的kobject，kset中有链表成员保存所有的kobject指向。

2.kobject中的kset指针指向了一个kset

3.kset中有kobject对象，表明了kset也可以有kobject相关的操作。

4.kset链表中的kobject对象的parent指针一般都指向kset内嵌的kobject对象。

kset和kobject关系基本如下图，

kset_uevent_ops热插拔事件

热插拔事件是用内核空间发送到用户空间的通知。表明内核中的某些配置已经发生变化。用户空间则会根据这些信息做相应的处理。例如，U盘插入USB系统时，会产生一个热插拔事件，内核会捕捉到这个热插拔事件，然后调用/sbin/hotplug程序，该程序通知加载驱动程序来相应U盘的插入动作。

热插拔函数集的定义在include/linux/koject.h中

struct kset_uevent_ops {
    int (*filter)(struct kset *kset, struct kobject *kobj);        //事件过滤函数
    const char *(*name)(struct kset *kset, struct kobject *kobj);    //事件名称函数
    int (*uevent)(struct kset *kset, struct kobject *kobj,struct kobj_uevent_env *env);
        //uevent函数可在热插拔程序执行前，向环境变量写值
};

详细的热插拔事件先不在这里分析。

2.注册一个kset

/**
 * kset_register - initialize and add a kset.
 * @k: kset.
 */
int kset_register(struct kset *k)
{
    int err;

    if (!k)
        return -EINVAL;

    kset_init(k);
    err = kobject_add_internal(&k->kobj);    //将kset中的kobject添加进sysfs，函数将在后面讲解
    if (err)
        return err;
    kobject_uevent(&k->kobj, KOBJ_ADD);
    return 0;
}
/**
 * kset_init - initialize a kset for use
 * @k: kset
 */
void kset_init(struct kset *k)
{
    kobject_init_internal(&k->kobj);
    INIT_LIST_HEAD(&k->list);
    spin_lock_init(&k->list_lock);
}

我们使用函数kset_create_and_add()还可以一次性将kset创建并注册进sysyfs

/**
 * kset_create_and_add - create a struct kset dynamically and add it to sysfs
 *
 * @name: the name for the kset
 * @uevent_ops: a struct kset_uevent_ops for the kset
 * @parent_kobj: the parent kobject of this kset, if any.
 *
 * This function creates a kset structure dynamically and registers it
 * with sysfs.  When you are finished with this structure, call
 * kset_unregister() and the structure will be dynamically freed when it
 * is no longer being used.
 *
 * If the kset was not able to be created, NULL will be returned.
 */
struct kset *kset_create_and_add(const char *name,
                 struct kset_uevent_ops *uevent_ops,
                 struct kobject *parent_kobj)
{
    struct kset *kset;
    int error;

    kset = kset_create(name, uevent_ops, parent_kobj);    //根据参数创建一个kset
    if (!kset)
        return NULL;
    error = kset_register(kset);                //将kset注册进sysfs，函数在上面已经分析过
    if (error) {
        kfree(kset);
        return NULL;
    }
    return kset;
}

/**
 * kset_create - create a struct kset dynamically
 *
 * @name: the name for the kset
 * @uevent_ops: a struct kset_uevent_ops for the kset
 * @parent_kobj: the parent kobject of this kset, if any.
 *
 * This function creates a kset structure dynamically.  This structure can
 * then be registered with the system and show up in sysfs with a call to
 * kset_register().  When you are finished with this structure, if
 * kset_register() has been called, call kset_unregister() and the
 * structure will be dynamically freed when it is no longer being used.
 *
 * If the kset was not able to be created, NULL will be returned.
 */
static struct kset *kset_create(const char *name,
                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);    //设置kobject名称
    if (retval) {
        kfree(kset);
        return NULL;
    }
    kset->uevent_ops = uevent_ops;
    kset->kobj.parent = parent_kobj;            //设置kset的kobject的父对象

    /*
     * 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的kobject的默认属性
    kset->kobj.kset = NULL;

    return kset;
}

上面这些函数主要包含即调用关系如下，

kset_create_and_add

kset_create

kzalloc

kset_register

kset_init

kobject_add_internal

kset中嵌入了一个kobject，所以还有一些和kobject相似的函数如，

增加kset的引用，实际是调用kobject_get增加kset中的kobject的引用

static inline struct kset *kset_get(struct kset *k)
{
    return k ? to_kset(kobject_get(&k->kobj)) : NULL;
}

减少kset的引用，实际是调用kobject_put减少kset中的kobject的引用

static inline void kset_put(struct kset *k)
{
    kobject_put(&k->kobj);
}

顺便提一下，子系统subsystem，在新的内核中已经没有这个结构了。在原来的内核中它用来表示比kset更高一层的容器，kset应该属于一个子系统，子系统帮助内核在分层结构中定位kset。内核子系统包括 block_subsys(/sys/block 块设备)、 devices_subsys(/sys/devices 核心设备层)。现在subsystem已经被kset代替了。

五，将kobject注册进sysfs系统

我们在看一下如何将kobject注册进sysfs系统中。使用函数kobject_init_and_add()（lib/kobject.c）函数将一个kobject注册进sysfs系统，在/sys中表现为生成一个相应的目录。

/**
 * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy
 * @kobj: pointer to the kobject to initialize
 * @ktype: pointer to the ktype for this kobject.
 * @parent: pointer to the parent of this kobject.
 * @fmt: the name of the kobject.
 *
 * This function combines the call to kobject_init() and
 * kobject_add().  The same type of error handling after a call to
 * kobject_add() and kobject lifetime rules are the same here.
 */
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);            //调用初始化函数先初始化kobject变量

    va_start(args, fmt);            //解析可变参数列表
    retval = kobject_add_varg(kobj, parent, fmt, args); //给kobject添加参数，并且将其添加到sysfs系统。
    va_end(args);                            //结束解析参数列表

    return retval;
}

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);        //设置kobject的名称
    if (retval) {
        printk(KERN_ERR "kobject: can not set name properly!\n");
        return retval;
    }
    kobj->parent = parent;            //设置kobject的父kobject
    return kobject_add_internal(kobj);    //添加kobject
}

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

    if (!kobj)        //检查是否为空
        return -ENOENT;

    if (!kobj->name || !kobj->name[0]) {    //kobj是否有名称，如果没有则不能注册，生成目录。
        WARN(1, "kobject: (%p): attempted to be registered with empty "
             "name!\n", kobj);
        return -EINVAL;
    }

    parent = kobject_get(kobj->parent);    //获得父kobject，并增加父kobject的引用计数

    /* join kset if set, use it as parent if we do not already have one */
    if (kobj->kset) {                                        //是否有kset集合
        if (!parent)                                            //如果没有父kobject则用kset中的kobject对象
            parent = kobject_get(&kobj->kset->kobj);
        kobj_kset_join(kobj);            //将kobject添加进它关联的kset的list链表中。
        kobj->parent = parent;        //设置父koject
    }

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

    error = create_dir(kobj);                //创建kobject的相应目录

    if (error) {        //创建时出错处理
        kobj_kset_leave(kobj);
        kobject_put(parent);
        kobj->parent = NULL;

        /* be noisy on error issues */
        if (error == -EEXIST)
            printk(KERN_ERR "%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
            printk(KERN_ERR "%s failed for %s (%d)\n",
                   __func__, kobject_name(kobj), error);
        dump_stack();
    } else
        kobj->state_in_sysfs = 1;        //标记为已经注册进sysfs

    return error;
}

sysfs创建目录函数create_dir，在lib/kobject.c

static int create_dir(struct kobject *kobj)
{
    int error = 0;
    if (kobject_name(kobj)) {
        error = sysfs_create_dir(kobj);            //在sysfs中创建目录，将来有时间了可以分析下sysfs子系统。
        if (!error) {
            error = populate_dir(kobj);
            if (error)
                sysfs_remove_dir(kobj);
        }
    }
    return error;
}

以上函数的主要调用关系，如下

kobject_init_and_add

kobject_init

kobject_add_varg

kobject_add_internal

create_dir

还有一个函数kobject_add，也可以添加一个kobject，它只是没有kobject_init这一步。

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;
}