Linux设备模型（上）之底层模型

最新推荐文章于 2024-09-25 15:20:18 发布

白水煮鸡蛋

最新推荐文章于 2024-09-25 15:20:18 发布

阅读量867

点赞数

分类专栏： linux driver 文章标签： linux filter module hierarchy 数据结构 struct

linux driver 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

努力成为linux kernel hacker的人李万鹏原创作品，转载请标明出处

http://blog.csdn.net/woshixingaaa/archive/2011/05/05/6396618.aspx

如果哪里有理解不对的请指教，文章引用的内核源码版本为2.6.29.1的。

建立设备模型主要为了管理方便。最初引入设备模型是为了电源管理。建立一个全局的设备树（device tree），当系统进入休眠时，系统可以通过这棵树找到所有的设备，随时让他们挂起（suspend）或者唤醒（resume）。

2.6版内核提供的功能：

电源管理和系统关机

完成这些工作需要对一些系统结构的理解。比如一个USB宿主适配器，在处理完所有与其连接的设备前是不能被关闭的。设备模型使得操作系统能够以正确的顺序遍历硬件。

与用户空间通信

sysfs虚拟文件系统的实现与设备模型密切相关，并且向外界展示了它所表示的结构。向用户空间所提供的系统信息，以及改变操作参数的接口，将越来越多的通过sysfs实现，也就是说通过设备模型实现。

热插拔设备

内核中的热插拔机制可以处理热插拔设备，特别是能够与用户空间进行关于热插拔设备的通信，而这种机制也是通过热插拔管理的。

设备类型

把设备分门别类有助于设备的管理与使用。比如要找USB鼠标，只要去classes/input/里去找就可以了，而不必关心这个鼠标是接到哪个USB主机控制器的哪个Hub的第几个端口上。

对象生命周期

得有一个好的机制来实现设备生命周期的管理。比如把USB鼠标拔了之后，全局设备树和sysfs里面得相应去掉。

设备底层模型：

Linux设备模型的底层是数据结构kobject，内核用kobject结构将各个对象连接起来组成一个分层的结构体系，从而与模块化的子系统相匹配。一个kset是嵌入相同类型结构的kobject集合。kset和他的kobject的关系与下图类似，请记住：

ü 在图中所有被包含的kobject，实际上是被嵌入到其他类型中的，甚至可能是其他的kset。
ü 一个kobject的父节点不一定是包含它的kset。

Kobject是组成设备模型的基本结构，最初他只是被理解为一个简单的引用计数，但是随着时间的推移，他的任务越来越多，因此也有了许多成员，他的结构体如下：

[c-sharp] view plain copy

struct kobject {
const char *name;
struct list_head entry; //挂接到所在kset中去的单元
struct kobject *parent; //指向父对象的指针
struct kset *kset; //所属kset的指针
struct kobj_type *ktype; //指向其对象类型描述符的指针
struct sysfs_dirent *sd; //sysfs文件系统中与该对象对应的目录实体的指针
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;
};

name指向设备的名字，entry，parent，kset就是用来形成树状结构的指针。Kobj_type *type用来表示该kobject的类型，struct sysfs_dirent类型的指针指向了该kobject在sysfs中的目录实体，sysfs中每一个dentry都会对应一个sysfs_dirent结构。每个在内核中注册的kobject对象都对应于sysfs文件系统中的一个目录。/sys是专为Linux设备模型建立的，kobject是帮助建立/sys文件系统的。每当我们新增一个kobject结构时，同时会在/sys下创建一个目录。这里隐藏了如下程序调用流程：kobject_add()->kobject_add_varg()->kobject_add_internal()->create_dir()->sysfs_new_dirent()。在sysfs_new_dirent()函数中通过slab分配了一个dirent（至于什么是dirent会在<Linux设备模型（下）之sysfs文件系统>中讲解），并返回给一个指向这个dirent的指针sd给create_dir(),在create_dir()函数中有这么一句：sd->s_dir.kobj = kobj;也就是让dirent的一个成员的域指向了他所对应的kobject，kobject中struct sysfs_dirent *sd;又指向了dirent，所以kobject与sysfs死死的拥抱在一起，为了幸福的明天。在kobject_del()函数中会调用sysfs_remove_dir()，sysfs_remove_dir()中有这么一句：kobj->sd = NULL;表示kobject与sysfs_dirent的婚姻破裂了。

kobject的接口函数：

[c-sharp] view plain copy

void kobject_init(struct kobject *kobj);

kobject初始化函数，设置kobject引用计数为1。

[c-sharp] view plain copy

int kobject_set_name(struct kobject *kobj, const char *format, …);

设置kobject的名字。

[c-sharp] view plain copy

struct kobject *kobject_get(struct kobject *kobj);
struct kobject *kobject_put(struct kobject *kobj);

减少和增加kobject的引用计数。

[c-sharp] view plain copy

extern int __must_check kobject_init_and_add(struct kobject *kobj,
struct kobj_type *ktype,
struct kobject *parent,
const char *fmt, ...);

kobject注册函数，该函数只是kobjec_init和kobject_add_varg的简单组合。旧内核称为

[c-sharp] view plain copy

extern int kobject_register(struct kobject *kobj);

[c-sharp] view plain copy

void kobject_del(struct kobject *kobj);

从Linux设备层次中（hierarchy）中删除kobj对象。

[c-sharp] view plain copy

struct kset {
struct list_head list; //用于连接该kset中所有kobject的链表头
spinlock_t list_lock; //用于互斥访问
struct kobject kobj; //嵌入的kobject
struct kset_uevent_ops *uevent_ops;
};

包含在kset中的所有kobject被组织成一个双向循环链表，list真是该链表的链表头。kset数据结构还内嵌了一个kobject对象（由kobj表示），所有属于这个kset的kobject对象的parent域均指向这个内嵌的对象。此外，kset还依赖于kobj维护引用计数：kset的引用计数实际上就是内嵌的kobject对象的引用计数。

[c-sharp] view plain copy

struct kobj_type {
void (*release)(struct kobject *kobj);
const struct sysfs_ops *sysfs_ops;
struct attribute **default_attrs;
const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
const void *(*namespace)(struct kobject *kobj);
};

释放kobject使用release函数，release函数并没有包含在kobject自身内，他包含在与kobject相关联的kobj_type中。sysfs_ops是指向如何读写的函数的指针。

[c-sharp] view plain copy

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

show相当于read,store相当于write。

struct attribute **default_attrs;是属性数组。在sysfs中，kobject对应目录，kobject的属性对应这个目录下的文件。调用show和store函数来读写文件，就可以得到属性中的内容。

一个热插拔事件是从内核空间发送到用户空间的通知。它表明系统配置出现了变化。无论kobject被创建还是被删除，都会产生这种事件。比如，当数码相机通过USB线缆插入到系统时。热插拔事件会导致对/sbin/hotplug程序的调用，该程序通过加载驱动程序，创建设备节点，挂装分区，或者其他正确的动作来响应。对热插拔事件的控制由保存在结构体中的函数完成：

[c-sharp] view plain copy

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

我们可以在kset结构的hotplug_ops成员中发现指向这个结构的指针。如果在kset中不包含一个指定的kobject，内核将在分层结构中进行搜索（通过parent指针），直到找到一个包含有kset的kobject为止，然后使用这个kset的热插拔操作。下面是一个测试的程序：

kobject.c

[c-sharp] view plain copy

#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("David Xie");
MODULE_LICENSE("Dual BSD/GPL");
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);
struct attribute test_attr = {
.name = "kobj_config",
.mode = S_IRWXUGO,
};
static struct attribute *def_attrs[] = {
&test_attr,
NULL,
};
struct sysfs_ops obj_test_sysops =
{
.show = kobj_test_show,
.store = kobj_test_store,
};
struct kobj_type ktype =
{
.release = obj_test_release,
.sysfs_ops=&obj_test_sysops,
.default_attrs=def_attrs,
};
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);
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;
static int kobj_test_init()
{
printk("kboject test init./n");
kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test");
return 0;
}
static int kobj_test_exit()
{
printk("kobject test exit./n");
kobject_del(&kobj);
return 0;
}
module_init(kobj_test_init);
module_exit(kobj_test_exit);

kset.c

[c-sharp] view plain copy

#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>
#include <linux/kobject.h>
MODULE_AUTHOR("David Xie");
MODULE_LICENSE("Dual BSD/GPL");
struct kset kset_p;
struct kset kset_c;
int kset_filter(struct kset *kset, struct kobject *kobj)
{
printk("Filter: kobj %s./n",kobj->name);
return 1;
}
const char *kset_name(struct kset *kset, struct kobject *kobj)
{
static char buf[20];
printk("Name: kobj %s./n",kobj->name);
sprintf(buf,"%s","kset_name");
return buf;
}
int kset_uevent(struct kset *kset, struct kobject *kobj,struct kobj_uevent_env *env)
{
int i = 0;
printk("uevent: kobj %s./n",kobj->name);
while( i < env->envp_idx){
printk("%s./n",env->envp[i]);
i++;
}
return 0;
}
struct kset_uevent_ops uevent_ops =
{
.filter = kset_filter,
.name = kset_name,
.uevent = kset_uevent,
};
int kset_test_init()
{
printk("kset test init./n");
kobject_set_name(&kset_p.kobj,"kset_p");
kset_p.uevent_ops = &uevent_ops;
kset_register(&kset_p);
kobject_set_name(&kset_c.kobj,"kset_c");
kset_c.kobj.kset = &kset_p;
kset_register(&kset_c);
return 0;
}
int kset_test_exit()
{
printk("kset test exit./n");
kset_unregister(&kset_p);
kset_unregister(&kset_c);
return 0;
}
module_init(kset_test_init);
module_exit(kset_test_exit);