【Linux 内核】设备模型基石:Kobject内核源码解析

• 操作：当内核中的某部分代码想要使用一个对象时，会调用kobject_get()增加其引用计数；使用完毕后，调用kobject_put()减少计数

• 释放：当引用计数降为0时，表示没有任何代码在使用该对象，内核便会自动调用预先设定的release方法来安全地释放它，从而避免“野指针”和内存泄漏问题

• 机制：每个kobject都有一个parent指针，指向其父 kobject

• 效果：这种父子关系在sysfs文件系统中被映射为目录的层级结构

structkobject {    const char *name;         // 对象名称，会作为 sysfs 目录名    struct list_head entry;   // 用于将该对象加入 kset 的链表    struct kobject *parent;   // 指向父对象的指针，构建层次结构    struct kset *kset;        // 指向所属的 kset 集合    struct kobj_type *ktype;  // 指向对象类型描述符，定义共同行为    struct kernfs_node *sd;   // 指向 sysfs 中对应的目录项（VFS 层节点）    struct kref kref;         // 引用计数，管理对象生命周期    unsigned int state_initialized:1; // 初始化状态位    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;   // 是否抑制发送 uevent 事件};

• initialized标记是否完成初始化；

• in_sysfs标记是否已在sysfs创建目录；

• add/remove_uevent保证添加和事件各只发一次；

• uevent_suppress则允许驱动临时抑制事件（比如对象还在内部调整、不希望用户空间过早看到）

structdevice {    struct device *parent;    struct device_privatet *p;    struct kobject kobj; // <-- device 通过内嵌 kobject 接入设备模型    const char *init_name;    const struct device_type *type;    struct bus_type *bus;    struct device_driver *driver;dev_tdevt;    struct class *class;    void (*release)(structdevice *dev);    /* ... 省略 ... */};// 从 kobject 反推所在 device（典型用法）struct device *dev = container_of(kobj, struct device, kobj);

// 定义在 include/linux/kernfs.hstruct kernfs_node {    const char *name;  /* 节点名称（目录名/文件名） */    struct rb_node rb; /* 红黑树节点，用于在父目录中按名称查找 */    struct kernfs_node *parent; /* 指向父节点的指针 */    unsigned int hash; /* 名称哈希值，加速查找 */    const void *ns;    /* 命名空间标签，用于支持命名空间隔离 */    union {        struct kernfs_elem_dir dir;         /* 目录特有信息 */        struct kernfs_elem_symlink symlink; /* 符号链接特有信息 */        struct kernfs_elem_attr attr;       /* 文件（属性）特有信息 */    };    void *priv;         /* 私有数据，可以存储kobject */    unsigned int flags; /* 节点标志（类型、状态等） */    umode_t mode;    union kernfs_node_id id;    struct kernfs_iattrs *iattr; /* inode 属性（权限、时间戳等），延迟分配 */    atomic_t count;     /* 引用计数，管理生命周期 */    atomic_t active;    /* 活动引用计数，用于保护正在进行的操作 */};

kobject_create_and_add() 

├── kobject_create()           // 1. 创建并初始化kobject 

│    └── kzalloc()             // 1.1 分配内存 

│    └── kobject_init()        // 1.2 初始化结构体 

│          ├── kref_init()     // 1.2.1 初始化引用计数为1 

│          └── INIT_LIST_HEAD()// 1.2.2 初始化链表节点 

└── kobject_add()              // 2. 添加到内核并关联sysfs 

     └── kobject_add_varg()    // 2.1 处理可变参数 

          └── kobject_set_name_vargs()  // 2.1.1 设置kobject的名称 

          └── kobject_add_internal()    // 2.2 核心添加操作 

               ├── kset检查,加入kset链表  // 2.2.1 处理父子关系

               └── create_dir()         // 2.2.2 在sysfs中创建目录 

                    ├── sysfs_create_dir()    // 在sysfs中创建目录项 

                    ├── populate_dir()        // 填充default_attrs属性 

                    └── sysfs_create_groups() // 填充default_groups属性

kernfs_node结构体

/*** 动态创建kobject并将其注册到sysfs* @name: kobject的名称* @parent: 该kobject的父kobject指针*/struct kobject *kobject_create_and_add(const char *name, struct kobject *parent){    struct kobject *kobj;    int retval;    // 第一步：动态创建并初始化一个kobject    kobj = kobject_create();    if (!kobj)        return NULL;    // 第二步：将创建好的kobject添加到设备模型并注册到sysfs    retval = kobject_add(kobj, parent, "%s", name);    if (retval) {        printk(KERN_WARNING"%s: kobject_add error: %d\n",                    __FUNCTION__, retval);        // 如果添加失败，释放引用计数，触发清理        kobject_put(kobj);        kobj = NULL;    }    return kobj;}EXPORT_SYMBOL_GPL(kobject_create_and_add);

structkobject *kobject_create(void){    struct kobject *kobj;    kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);    if (!kobj)        return NULL;    // 使用默认的 dynamic_kobj_ktype 进行初始化    kobject_init(kobj, &dynamic_kobj_ktype);    return kobj;}EXPORT_SYMBOL_GPL(kobject_create);

staticconststructkobj_typedynamic_kobj_ktype = {
    // 引用计数器为0时，释放内存
    .release = dynamic_kobj_release,     .sysfs_ops = &kobj_sysfs_ops,};

conststructsysfs_opskobj_sysfs_ops = {    .show = kobj_attr_show,     // 取出数据    .store = kobj_attr_store,   // 存入数据};

// 读操作转发函数static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,                            char *buf){    struct kobj_attribute *kattr;    ssize_t ret = -EIO;    // 通过 container_of 从基础类型 attribute 获取包含它的 kobj_attribute    kattr = container_of(attr, struct kobj_attribute, attr);    if (kattr->show)        ret = kattr->show(kobj, kattr, buf); // 调用开发者自定义的 show 函数    returnret;}// 写操作转发函数 (逻辑完全相同)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); // 调用开发者自定义的 store 函数    return ret;}

structkobj_attribute {    struct attribute attr; // 嵌入一个标准属性，包含 char* name 和 short mode    ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,                char *buf);    ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,                const char *buf, size_t count);};

intkobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...) {va_listargs;    int retval;    // 检查空指针等    va_start(arg, fmt);    retval = kobject_add_varg(kobj, parent, fmt, args);    va_end(args);    return retval;}

kobject_add()    --> kobject_add_varg()     // 处理变参，设置名称        --> kobject_add_internal() // 核心实现            --> create_dir()   // 创建 sysfs 目录

staticint kobject_add_internal(struct kobject *kobj) {    int error = 0;    struct kobject *parent;    // 省略错误检查...    parent = kobject_get(kobj->parent); // 增加 parent 的 kref 引用计数    if (kobj->kset) {        if (!parent)            parent = kobject_get(&kobj->kset->kobj); // 如果未设置 parent，则使用 kset 的 kobject 作为 parent        kobj_kset_join(kobj); // 将 kobject 加入 kset 的链表        kobj->parent = parent;    }    // 在父目录 parent 下创建目录    error = create_dir(kobj);    return error;}

// 定义在 /lib//kobject.c 文件中static int create_dir(struct kobject *kobj) {    const struct kobj_type *ktype = get_ktype(kobj);    const struct kobj_ns_type_operations *ops;    // 1.为kobj创建目录节点    sysfs_create_dir_ns(kobj, kobject_namespace(kobj));    // 2.实际上没有操作    populate_dir(kobj);    if (ktype)        sysfs_create_groups(kobj, ktype->default_groups);}

/*** @kobj: 目标 kobject* @ns: 命名空间标签（可选）* 返回值：成功返回 0，失败返回负错误码。*/int sysfs_create_dir_ns(struct kobject *kobj, const void *ns){    struct kernfs_node *parent, *kn;    kuid_t uid;    kgid_t gid;    /* 如果 kobject 有父对象，则父目录为父 kobject 的 kernfs 节点；否则为 sysfs 根目录 */    if (kobj->parent)        parent = kobj->parent->sd;    else        parent = sysfs_root_kn;    /* 获取该 kobject 目录的所有者（uid/gid） */    kobject_get_ownership(kobj, &uid, &gid);    /* 调用 kernfs 创建目录节点 */    kn = kernfs_create_dir_ns(parent, kobject_name(kobj),            S_IRWXU | S_IRUGO | S_IXUGO,            uid, gid, kobj, ns);    if (IS_ERR(kn)) {        if (PTR_ERR(kn) == -EEXIST)            sysfs_warn_dup(kobject_name(kobj));        return PTR_ERR(kn);    }    /* 将新创建的 kernfs 节点指针保存到 kobject 中 */    kobj->sd = kn;    return 0;}EXPORT_SYMBOL_GPL(sysfs_create_dir_ns);

structkernfs_node *kernfs_create_dir_ns(structkernfs_node *parent,                constchar *name,                umode_t mode,                kuid_t uid,                kgid_t gid,                void *priv,                constvoid *ns){    struct kernfs_node *kn;    int rc;    /* 1. 参数校验：父节点必须存在 */    if (!parent)        return ERR_PTR(-EINVAL);    /* 2. 创建新的 kernfs 节点，类型为目录 */    kn = kernfs_new_node(parent, name, mode | S_IFDIR, uid, gid,                    KERNFS_DIR);    if (!kn)        return ERR_PTR(-ENOMEM);    /* 3. 设置私有数据和命名空间标签 */    kn->priv = priv;    kn->ns = ns;    /* 4. 将新节点添加到父目录的红黑树中 */    rc = kernfs_add_one(kn);    if (rc) {        kernfs_put(kn);        return ERR_PTR(rc);    }    /* 5. 返回新节点 */    return kn;}EXPORT_SYMBOL_GPL(kernfs_create_dir_ns);

/*** @kobj: 目标 kobject* 返回值：成功返回 0，失败返回负错误码。*/static int populate_dir(struct kobject *kobj){    struct kobj_type *t = get_ktype(kobj);    const 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;        }    if (error)        while (--i >= 0)            sysfs_remove_file(kobj, t->default_attrs[i]);    }    return error;}

/*** @kobj: 目标 kobject* @groups: 以 NULL 结尾的属性组指针数组* 返回值：成功返回 0，失败返回负错误码。*/int __must_check sysfs_create_groups(struct kobject *kobj,        const struct attribute_group **groups){    int i, error = 0;    if (!groups)        return0;    for (i = 0; groups[i] && !error; i++)        error = Internal_create_group(kobj, update, groups[i]);    if (error)        while (--i >= 0)            sysfs_remove_group(kobj, groups[i]);    return error;}EXPORT_SYMBOL_GPL(sysfs_create_groups);

// include/linux/kref.hstruct kref {    atomic_t refcount;};static inline void kref_init(struct kref *kref){    atomic_set(&kref->refcount, 1);}static inline void kref_get(struct kref *kref){    atomic_inc(&kref->refcount);}

// lib/kref.c (简化自内核实现)void kref_get(struct kref *kref){    WARN_ON(!atomic_read(&kref->refcount));    atomic_inc(&kref->refcount);    smp_mb__after_atomic();}int kref_put(struct kref *kref, void (*release)(struct kref *kref)){    WARN_ON(release == NULL);    if (atomic_dec_and_test(&kref->refcount)) {        release(kref); /* 计数归零，释放对象 */        return 1;    }    return 0;}

// lib/kobject.cstruct kobject *kobject_get(struct kobject *kobj){    if (kobj)        kref_get(&kobj->kref);    return kobj;}void kobject_put(struct kobject *kobj){    if (kobj) {        if (!kobj->state_initialized)            WARN(1, KERN_WARNING"kobject: '%s' is not initialized, "                    "yet kobject_put() is being called.\n",        kobject_name(kobj));        kref_put(&kobj->kref, kobject_release);    }}static void kobject_release(struct kref *kref){    kobject_cleanup(container_of(kref, struct kobject, kref));}

// include/linux/kobject.hstruct kset {    struct list_head list; // 链表头，串起本集合内所有 kobjectspinlock_t list_lock;  // 保护链表的自旋锁    struct kobject kobj;   // kset 内嵌的 kobject，自身在 sysfs 中也占一个目录    const struct kset_uevent_ops *uevent_ops; // uevent 过滤/构造回调};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); // 追加环境变量};

// lib/kobject.cstruct 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);

// lib/kobject_uevent.c (核心调用链裁剪)int kobject_uevent(struct kobject *kobj, enum kobject_actionaction){    return kobject_uevent_env(kobj, action, NULL);}int kobject_uevent_env(struct kobject *kobj, enum kobject_actionaction,        char *envp_ext[]){    struct kobj_uevent_env *env;    const char *action_string = kobject_actions[action];    const char *devpath = NULL;    struct kset *kset = NULL;    /* 1. 向上回溯，找到所属的最顶层 kset */    struct kobject *top_kobj = kobj;    while (!top_kobj->kset && top_kobj->parent)        top_kobj = top_kobj->parent;    if (!top_kobj->kset)        return -EINVAL; /* 没有 kset 就无法发送 uevent */    kset = top_kobj->kset;    /* 2. uevent_suppress 为真则丢弃事件 */    if (kobj->uevent_suppress)        return 0;    /* 3. 通过 kset->uevent_ops->filter 决定该对象是否允许上报 */    if (kset->uevent_ops && kset->uevent_ops->filter)        if (!kset->uevent_ops->filter(kset, kobj))            return 0;    /* 4. 构造环境变量：ACTION / DEVPATH / SUBSYSTEM / SEQNUM ... */    add_uevent_var(env, "ACTION=%s", action_string);    add_uevent_var(env, "DEVPATH=%s", devpath);    add_uevent_var(env, "SEQNUM=%llu", ++uevent_seqnum);    /* 5. 通过 Netlink 广播到用户空间 (NETLINK_KOBJECT_UEVENT = 15) */    return kobject_uevent_net_broadcast(kobj, env, action_string, devpath);}

// include/linux/kernel.h#definecontainer_of(ptr, type, member) ({ \    consttypeof(((type *)0)->member) * __mptr = (ptr); \    (type *)((char *)__mptr - offsetof(type, member)); })// 实际使用示例：从 attribute 反推包含它的 kobj_attributestructkobj_attribute *kattr;kattr = container_of(attr, structkobj_attribute, attr);

#include<linux/module.h>#include <linux/kernel.h>#include <linux/kobject.h>#include <linux/sysfs.h>#include <linux/init.h>static int foo;static int baz;static int bar;static ssize_t foo_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){    return sprintf(buf, "%d\n", foo);}static ssize_t foo_store(struct kobject *kobj, struct kobj_attribute *attr,                const char *buf, size_t count){    sscanf(buf, "%d", &foo);    return count;}static struct kobj_attribute foo_attribute = __ATTR(foo, 0666, foo_show, foo_store);static ssize_t b_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf){    int var;    if (strcmp(attr->attr.name, "baz") == 0)        var = baz;    else        var = bar;    return sprintf(buf, "%d\n", var);}static ssize_t b_store(struct kobject *kobj, struct kobj_attribute *attr,                const char *buf, size_t count){    int var;    sscanf(buf, "%d", &var);    if (strcmp(attr->attr.name, "baz") == 0)        baz = var;    else        bar = var;    return count;}static struct kobj_attribute baz_attribute = __ATTR(baz, 0666, b_show, b_store);static struct kobj_attribute bar_attribute = __ATTR(bar, 0666, b_show, b_store);static struct attribute *attrs[] = {    &foo_attribute.attr,    &baz_attribute.attr,    &bar_attribute.attr,    NULL,};static struct attribute_groupattr_group = {    .attrs = attrs,};static struct kobject *example_kobj;static int __init example_init(void){    int retval;    example_kobj = kobject_create_and_add("kobject_example", kernel_kobj);    if (!example_kobj)        return -ENOMEM;    retval = sysfs_create_group(example_kobj, &attr_group);    if (retval)        kobject_put(example_kobj);    return retval;}static void __exit example_exit(void){    kobject_put(example_kobj);}module_init(example_init);module_exit(example_exit);MODULE_LICENSE("GPL");MODULE_AUTHOR("Greg Kroah-Hartman");

// include/linux/device.h (节选)struct device {    struct device *parent;    struct device_private *p;    struct kobject kobj; // <-- device 通过内嵌 kobject 接入设备模型    const char *init_name;    const struct device_type *type;    struct bus_type *bus;    struct device_driver *driver;    dev_t devt;    struct class *class;    void (*release)(structdevice *dev);    /* ... */};// 从 kobject 反推所在 device（典型用法）struct device *dev = container_of(kobj, struct device, kobj);