kobject和kset之间的关系

Linux驱动基于kobject和kset构建设备模型,kobject作为设备属性的抽象,拥有属性和读写接口,类似文件夹包含属性文件。kset则如同更大文件夹,组织同类设备驱动。通过kobject和kset,设备以文件系统节点形式存在,允许属性读写。代码示例创建了/sys下的kobject目录,包含可读写的属性文件。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

linux驱动是一个整体的设备模型,这个模型是以kobject和kset作为基石的,因此搞懂kset和kobject的内部运作关系才能很好的理解统一设备模型.
首先linux对设备的抽象就是将设备描述为一个文件节点,因为设备有属性,比如说亮度、颜色等。因此kobject也就有属性.有了属性还要有统一的读写接口,写入的属性值通过内部再真正写到设备里面去.因此可以将一个kobject看成一个文件夹,里面有许多文件,一个文件描述一个属性.
而kset就可以看成是一个更大的文件夹,可以理解为类别,比如将所有驱动看成一个文件夹,这个文件夹是一个kset,然后这个文件夹下面有许多具体的驱动,这些驱动看成kobject.
先上图再看代码
图片来源:https://blog.youkuaiyun.com/qq_33160790/article/details/63800016

struct kobject {
	const char		*name; //名称,文件名称
	struct list_head	entry; //同一级kobject链接结点
	struct kobject		*parent; //指向父级的kobject
	struct kset		*kset; //指向父级kset
	struct kobj_type	*ktype; //属性
	struct sysfs_dirent	*sd; 
	struct kref		kref; //引用计数
	unsigned int state_initialized:1; //标志位
	unsigned int state_in_sysfs:1;
	unsigned int state_add_uevent_sent:1;
	unsigned int state_remove_uevent_sent:1;
	unsigned int uevent_suppress:1;
};
struct kset {
	struct list_head list; //连接下一级的链接结点
	spinlock_t list_lock; //当链接结点时的锁
	struct kobject kobj;  //kset本身包含一个kobject对象
	struct kset_uevent_ops *uevent_ops;
};

举个例子:

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/stat.h>

void obj_test_release(struct kobject *);
ssize_t kobj_test_show(struct kobject *kobject, 
		struct attribute *attr,char *buf);
ssize_t kobj_test_store(struct kobject *kobject,
		struct attribute *attr,const char *buf, 
		size_t count);MODULE_LICENSE("Dual BSD/GPL");

void obj_test_release(struct kobject *kobj)
{
	printk("%s release\n", kobj->name);
}
ssize_t kobj_test_show(struct kobject *kobject, 
		struct attribute *attr,char *buf)
{
	printk("attrname=%s\n", attr->name);
	sprintf(buf, "%s\n", attr->name);
	return strlen(attr->name)+2;
}
ssize_t kobj_test_store(struct kobject *kobject,
		struct attribute *attr,const char *buf, 
		size_t count)
{
	printk("store\n");
	printk("write %s\n", buf);
	return count;
}
struct attribute test1 = {
	
		"kobject_test1", 
		THIS_MODULE,
		S_IRWXUGO,
	
};
struct attribute test2 = {
	
		"kobject_test2", 
		THIS_MODULE,
		S_IRUGO|S_IWUGO,	
	
};
struct attribute *attr[] = {
	&test1,
	&test2,
	NULL,
};
struct sysfs_ops fops = {
//对结点读写的操作函数
	kobj_test_show,
	kobj_test_store,
};
struct kobject kobj;
struct kobj_type ktype = {
	obj_test_release,
	&fops,
	attr,
};

static int kobj_test_init(void)
{
	printk("enter kobj_test_init\n");
	kobject_init_and_add(&kobj, &ktype, NULL, "kobject_config");
	return 0;
}

static void kobj_test_exit(void)
{
	printk("exit kobj\n");
	kobject_del(&kobj);
	//return 0;
}

module_init(kobj_test_init);
module_exit(kobj_test_exit);
MODULE_LICENSE("Dual BSD/GPL");

上面这段代码运行之后,会在/sys目录下面产生一个kobject_config目录,这个目录下面有两个文件kobject_test,kobject_test2.这两个文件可以写入和读出内容.
常用的操作kobject和kset的接口如下:

void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
int kobject_add(struct kobject *kobj, struct kobject *parent,
		const char *fmt, ...);

这些函数的逻辑其实就是要理解上面的图.

<think>我们正在讨论Linux内核中的kobjectkset。用户希望绘制它们的类图并理解关系结构。回顾上一次回答:kobject是内核对象的基础,用于管理引用计数、生命周期、sysfs集成等;而kset(kernelobjectset)是kobject的集合,用于组织相关对象。现在需要详细解释kobjectkset的类图关系:1.kobject:是基础对象,每个kobject都嵌入到更大的结构体中(如device、driver)。2.kset:是一个容器,包含一组相关的kobjectkset本身也是一个kobject(它内嵌了一个kobject),因此它也具有kobject的所有特性(如引用计数、sysfs目录等),并且还能作为集合的容器。关系结构:-每个kobject可以属于一个kset(通过其kobj.kset字段指向所属kset)。-kset内部通过链表(list_head)来管理其包含的kobjectkset->list)。-ksetkobject(嵌入的)作为集合中所有kobject的父对象(在sysfs中体现为目录层次)。类图描述(采用UML风格):注意:由于是内核数据结构,我们用类图来表示它们的关系。首先,定义kobject结构:-属性:name,parent,kset,ktype,entry(链表节点),sd(sysfs目录)等。-方法:kobject_init(),kobject_add(),kobject_del(),kobject_put()等(这些是操作函数,不在结构体内,但在类图中可以表示为方法)。其次,定义kset结构:-属性:list(链表头,用于挂载kobject链表),kobj(内嵌的kobject),uevent_ops(事件操作)等。-方法:kset_create(),kset_register(),kset_unregister()等。关系:-kset内嵌了kobject,即kset具有一个kobject(组合关系)。-kset包含多个kobject,即ksetkobject是聚合关系(通过链表连接)。-kobject通过kset指针指向其所属的kset。此外,kobject还关联到kobj_type(描述对象类型,包含释放函数、sysfs操作等)。类图(用文本描述):classkobject{+name:constchar*+parent:structkobject*+kset:structkset*+ktype:structkobj_type*+entry:structlist_head+sd:structkernfs_node*...(还有其他字段)}classkset{+list:structlist_head//用于链接属于这个kset的所有kobject的链表头+kobj:structkobject//内嵌的kobject,代表这个集合本身+uevent_ops:conststructkset_uevent_ops*}classkobj_type{+release:void(*)(structkobject*)+sysfs_ops:structsysfs_ops*+default_attrs:structattribute**}关系说明:-kset"有一个"kobject(组合关系,强所有关系):即kset通过内嵌的kobject成为kobject。-kset"包含"kobject(聚合关系):每个kset有一个链表(list),所有属于该ksetkobject通过其entry字段链接到这个链表上。-kobject"属于"0个或1个kset(通过kobjectkset指针指向所属kset)。-kobject"有一个"kobj_type(指向kobj_type的指针),用于定义其行为(如释放函数、属性等)。另外,在sysfs中:-kset对应的kobject会在sysfs中创建一个目录(通过其内嵌的kobject)。-属于该ksetkobject的sysfs目录会作为该kset目录的子目录(因为ksetkobject是这些kobject的parent)。绘制类图(文本形式):```+----------------++----------------++-------------------+|kobject|<>---|kset||kobj_type|+----------------++----------------++-------------------+|name:char*||list:list_head||release:func||parent:kobj*||kobj:kobject||sysfs_ops:sysfs_ops*||kset:kset*||...||default_attrs:attr**||ktype:kobj_type*|+----------------++-------------------+|entry:list_head||...|+----------------+^|||+----------------+|kset|------------------------->[嵌入一个kobject,所以kset也是kobject]+----------------+||^|||||+--------------------------------+||||+-----------------+|||||+----------------+|||kobject|<---------+|+----------------+||...|||kset指针指向我|+--------->+----------------+通过list链接到kset的链表```但是,文本图形可能不够清晰,我们可以用文字描述:-kset结构体内嵌一个kobject(组合关系),因此kset本身就是一个kobject(继承关系,在C中通过结构体嵌入实现)。-kset有一个链表(list_head),用于链接属于该kset的所有kobject(每个kobject通过其entry字段加入到这个链表)。-kobject通过kset指针指向它所属于的kset(如果属于某个kset)。另外,kobject还有parent指针(指向父kobject,在sysfs中形成目录层次)。注意:parent不一定等于ksetkobject,但通常如果一个kobject属于一个kset,那么它的parent会被设置为ksetkobject(在kobject_add()中自动设置,除非显式指定了parent)。总结关系kset->内嵌的kobject:1对1(组合)kset->kobject(多个):1对多(聚合)kobject->kset:1对1(关联)为了更精确,下面是内核中kobjectkset的定义(基于Linux内核源代码):kobject定义(简化):structkobject{constchar*name;structlist_headentry;//用于链接到kset的链表structkobject*parent;//父对象(sysfs中的父目录)structkset*kset;//所属的ksetstructkobj_type*ktype;//类型structkernfs_node*sd;//sysfs目录节点structkrefkref;//引用计数...};kset定义(简化):structkset{structlist_headlist;//用于挂载该kset中所有kobject的链表头spinlock_tlist_lock;structkobjectkobj;//内嵌的kobject,代表该kset本身conststructkset_uevent_ops*uevent_ops;};注意:kobject的entry字段用于链入kset的list链表。使用类图表示:```+--------------------+|kobject|+--------------------+|-name:char*|+-------------------+|-parent:kobject*||kset||-kset:kset*|+-------------------+|-entry:list_head|<---->|-list:list_head|(一对多)|-*ktype||-kobj:kobject||...||-...|+--------------------++-------------------+^^|||嵌入(组合)|+-----------------------------+(kset内嵌kobject,因此kset也是一个kobject,但kset类型是kobject的扩展)```这里有一个重要的点:由于kset内嵌了kobject,当我们操作kset时,实际上是通过内嵌的kobject来管理kset设备模型中的位置属性。所以,最终的类图关系可以这样理解:-ksetkobject的子类(通过内嵌实现,因此kset拥有kobject的全部功能,并且增加了集合功能)。-kset包含多个kobject(通过链表管理)。在sysfs中的表现:-kset的内嵌kobject在sysfs中创建一个目录(例如/sys/bus/)。-每个属于该ksetkobject在sysfs中会显示为该kset目录下的子目录。现在,我们可以绘制一个更规范的类图(文本UML):```+------------------------++---------------------+|<<struct>>kobj_type||<<struct>>kobject|+------------------------++---------------------+|+release:func||+name:char*||+sysfs_ops:sysfs_ops*||+parent:kobject*||+default_attrs:attr**|<-------|+kset:kset*|+------------------------+1|+ktype:kobj_type*|关联|+entry:list_head||+sd:kernfs_node*|+---------------------+^|继承(嵌入)|+---------------------+|<<struct>>kset|+---------------------+|+list:list_head|(链表头)|+list_lock:spinlock||+kobj:kobject|(内嵌对象)|...|+---------------------+|1|聚合(通过list链接多个kobject)|+---------------------+|kobjects||(通过entry链入kset的list)|+---------------------+```注意:在UML中,聚合关系用空心菱形表示。而组合关系用实心菱形。这里ksetkobject的聚合关系kset包含多个kobject)以及kset内嵌kobject的组合关系kset包含一个kobject)都要表示出来。由于文本限制,我们用箭头文本描述。另外,每个kobject都有一个ktype,因此kobj_type被kobject关联(每个kobject都指向一个kobj_type)。用户还要求生成相关问题:1.ksetsysfs目录结构的关系是怎样的?2.kobject的ktype在内核中起什么作用?3.如何创建一个kset并添加kobject到其中?4.在设备模型中,kset如何用于组织设备?回答用户问题:我们将用以下方式呈现:-首先解释kobjectkset关系(含文本类图)。-然后简要描述sysfs中的表现。-最后提供相关问题。</think> ### kobjectkset的类图关系解析 以下是kobjectkset在内核中的关系结构图示,采用UML类图风格表示(基于Linux 6.x内核数据结构): ``` $$ \begin{array}{c} \text{+-------------------+} \\ \text{| \textbf{kobject} |} \\ \text{+-------------------+} \\ \text{| - name: char* |} \\ \text{| - parent: kobject*|} \\ \text{| - kset: kset* |} \\ \text{| - ktype: kobj_type*|} \\ \text{| - entry: list_head|} \\ \text{| - sd: kernfs_node*|} \\ \text{+-------↑-----------↑} \\ \qquad \text{继承} \uparrow \quad \text{关联} \uparrow \\ \begin{array}{c} \text{+-------------------+} \quad \text{+-------------------+} \\ \text{| \textbf{kset} |} \quad \text{| \textbf{kobj_type} |} \\ \text{+-------------------+} \quad \text{+-------------------+} \\ \text{| - list: list_head |} \quad \text{| - release: func* |} \\ \text{| - kobj: kobject |} \quad \text{| - sysfs_ops: ops* |} \\ \text{| - uevent_ops: ops*|} \\ \text{+-------------------+} \\ \end{array} \\ \end{array} $$ ``` #### 核心关系说明: 1. **继承关系** kset **内嵌**一个kobject(组合关系) $$ \text{struct kset} \\{ \\ \quad \text{struct kobject kobj}; \\ \\}; $$ 这使得kset本身也是一个kobject,具有所有基本特性 2. **聚合关系** kset **包含**多个kobject(一对多关系) $$ \text{struct kset} \\{ \\ \quad \text{struct list_head list}; \\ \\}; $$ 每个kobject通过`entry`字段链接到该链表 3. **关联关系** - kobject通过`kset`指针指向所属的kset - kobject通过`ktype`指向其类型描述符 - kset通过`uevent_ops`处理热插拔事件 #### 关键数据结构源码解析 ```c // kobject核心结构 (include/linux/kobject.h) struct kobject { const char *name; // sysfs显示名称 struct list_head entry; // 链入kset的节点 struct kobject *parent; // sysfs父目录 struct kset *kset; // 所属集合 struct kobj_type *ktype; // 类型描述符 struct kernfs_node *sd; // sysfs目录节点 struct kref kref; // 引用计数 }; // kset结构 (include/linux/kobject.h) struct kset { struct list_head list; // 成员kobject链表头 spinlock_t list_lock; // 链表锁 struct kobject kobj; // 内嵌的kobject const struct kset_uevent_ops *uevent_ops; // 事件回调 }; // kobj_type结构 (include/linux/kobject.h) struct kobj_type { void (*release)(struct kobject *); // 对象销毁函数 const struct sysfs_ops *sysfs_ops; // sysfs操作集 const struct attribute_group **default_groups; // 默认属性组 }; ``` #### sysfs中的层次结构 当kobjectkset注册时,sysfs生成如下目录树: ``` /sys/ ├── bus/ ← kset (总线集合) │ ├── usb/ ← kset (USB子系统) │ │ ├── devices/ ← kset (设备容器) │ │ │ └── 1-1/ ← kobject (具体设备) │ │ └── drivers/ ← kset (驱动容器) └── class/ ← kset (设备类集合) └── net/ ← kset (网络设备) └── eth0/ ← kobject (网卡) ``` - 每个**kset**对应sysfs目录(由内嵌kobject创建) - 目录内容由`kobj_type`的`default_groups`定义 - 子目录通过`parent`指针建立层次 #### 生命周期运作流程 1. **创建对象** ```c struct my_obj { struct kobject kobj; int custom_data; }; ``` 2. **注册到kset** ```c kobject_init(&obj->kobj, &my_ktype); kobj_set_kset_s(&obj->kobj, my_kset); // 设置所属kset ret = kobject_add(&obj->kobj); ``` 3. **引用管理** ```c kobject_get(&obj->kobj); // 增加引用计数 kobject_put(&obj->kobj); // 减少引用计数 ``` 4. **销毁回调** 当计数归零时自动调用ktype的release函数 ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值