linux 设备模型(一)对象层

linux提供了新的设备模型：总线（bus）、设备（device）、驱动（driver）。其中总线是处理器与设备之间通道，在设备模型中，所有的设备都通过总线相连；设备是对于一个设备的详细信息描述，驱动是设备的相关驱动。其基本关系如下：bus 相当于一个容器，是device 和device_driver 的管理机构，它包含了一个device 集合和一个driver 集合。其中，device集合包含了挂在该总线下的所有设备，这些设备通过链表链接起来；driver集合包含了挂在该总线下的所有驱动程序，这些驱动程序通过链表链接起来。

首先分析linux内核要有层次的概念，linux从设计上来说是一层套一层的，那么在这一层之下，还有一层由kobject、kobj_type、kset这三者组成，也可以认为其属于驱动模型的范围内，我们可以看到内核对它的描述是：generic kernel object infrastructure。就是通用内核对象基础的意思。我们暂且叫它内核对象层吧。在驱动模型的上层我们可以封装各种子模块子系统

先看看内核对象层重要的数据结构，他们定义在\linux\kobject.h中：

struct kobject {
 const char  *name;/*指向设备名称的指针 */
 struct list_head entry; /*kobject 之间的双向链表，与所属的kset形成环形链表*/  
 struct kobject  *parent;/*在sysfs分层结构中定位对象，指向上一级kset中的struct kobject kobj*/
 struct kset  *kset;/*指向所属的kset*/
 struct kobj_type *ktype;;/*负责对该kobject类型进行跟踪的struct kobj_type的指针*/
 struct sysfs_dirent *sd;
 struct kref  kref;/*kobject 的引用计数*/
 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;;/*用于连接该kset中所有kobject以形成环形链表的链表头*/
	spinlock_t list_lock;/*用于避免竞态的自旋锁*/
	struct kobject kobj;/*嵌入的kobject*/
	const struct kset_uevent_ops *uevent_ops;/*原有的struct kset_hotplug_ops * hotplug_ops;已经不存在，被kset_uevent_ops 结构体替换，在热插拔操作中会介绍*/
};

struct kobj_type {
	void (*release)(struct kobject *kobj);//	用于释放kobject占用的资源,当kobject的引用计数为0时被调用。
	const struct sysfs_ops *sysfs_ops;
	struct attribute **default_attrs;//对应于kobject的目录下的一个文件,Name成员就是文件名。
	const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
	const void *(*namespace)(struct kobject *kobj);
};

struct attribute {
	const char		*name;/*属性文件名*/
	umode_t			mode;/*属性的保护位*/
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	bool			ignore_lockdep:1;
	struct lock_class_key	*key;
	struct lock_class_key	skey;
#endif
};

Kobject与sysfs文件系统紧密相连，在内核中注册每个kobject对象都对应sysfs文件系统中的一个目录。每个kobject都有它的父节点parent、kset、kobj_type指针，这三者是驱动模型的基本结构，kset是kobject的集合。

可以看到每个kset内嵌了一个kobject（kobj字段），用来表示其自身节点，其list字段指向了所包含的kobject的链表头。kobject如果没有指定父节点，parent将指向其kset内嵌的kobject。每个kobject都有它的kobj_type字段指针，用来表示kobject在文件系统中的操作方法。release方法是在kobject释放是调用，sysfs_ops指向kobject对应的文件操作，default_attrskobject的默认属性，sysfs_ops的将使用default_attrs属性。

kobject、kset、kobj_type简单的层次结构：

 

内核为我们提供了操作这些数据的接口函数，

1）voidkobject_init(struct kobject * kobj)初始化kobject结构

2）intkobject_add(struct kobject * kobj)将kobject对象注册到Linux系统

3）intkobject_init_and_add(struct kobject *kobj, struct kobj_type*ktype,struct kobject *parent, const char *fmt, ...)初始化kobject,并将其注册到linux系统

4）voidkobject_del(struct kobject * kobj)从Linux系统中删除kobject对象

5）structkobject *kobject_get(struct kobject*kobj)将kobject对象的引用计数加1,同时返回该对象指针。

6）voidkobject_put(struct kobject *kobj)将kobject对象的引用计数减1,如果引用计数降为0,则调用release方法释放该kobject对象。

struct sysfs_ops {
	ssize_t	(*show)(struct kobject *, struct attribute *,char *);
	ssize_t	(*store)(struct kobject *,struct attribute *,const char *, size_t);
	const void *(*namespace)(struct kobject *, const struct attribute *);
};

1）Show:当用户读属性文件时,该函数被调用,该函数将属性值存入buffer中返回给用户态;

2）Store:当用户写属性文件时,该函数被调用,用于存储用户传入的属性值。 

已kobject为核心的设备对象层，在我们实际驱动中可能解除很少，但在它是建立我们的设备模型的总线（bus）、设备（device）、驱动（driver）的基础。下面看看一个简单kobject实例：

#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> 
  
MODULE_AUTHOR("example"); 
MODULE_LICENSE("Dual BSD/GPL"); 

/*声明release、show、store函数*/
void obj_test_release(struct kobject *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);

/*对应于kobject的目录下的一个文件,Name成员就是文件名*/  
struct attribute test_attr = { 
        .name = "kobj_config", 
        .mode = S_IRWXUGO, 
}; 
  
static struct attribute *def_attrs[] = { 
        &test_attr, 
        NULL, 
}; 
  
//kobject对象的操作 
struct sysfs_ops obj_test_sysops = 
{ 
        .show = kobj_test_show, 
        .store = kobj_test_store, 
}; 
 
/*定义kobject对象的一些属性及对应的操作*/ 
struct kobj_type ktype =  
{ 
        .release = obj_test_release, 
        .sysfs_ops=&obj_test_sysops, 
        .default_attrs=def_attrs, 
}; 

/*release方法释放该kobject对象*/  
void obj_test_release(struct kobject *kobject) 
{ 
        printk("eric_test: release .\n"); 
}

/*当读文件时执行的操作*/ 
ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf)
{ 
        printk("have show.\n"); 
        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("havestore\n"); 
        printk("write: %s\n",buf); 
        return count; 
} 
  
struct kobject kobj;//声明kobject对象 
static int kobj_test_init(void) 
{ 
        printk("kboject test init.\n"); 
        kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test");//初始化kobject对象kobj,并将其注册到linux系统
        return 0; 
} 
  
static void kobj_test_exit(void) 
{ 
        printk("kobject test exit.\n"); 
        kobject_del(&kobj); 
} 
module_init(kobj_test_init); 
module_exit(kobj_test_exit);

测试效果：

1）在sys下创建一个子目录kobject_test

2）在kobject_test创建一个文件kobj_config

3）当读kobj_config时，打印信息

4）当写kobj_config时，打印信息