Linux设备驱动模型(kobject、kset、ktype、udev)

Linux设备驱动模型的核心即是kobject,最初设计kobject模型的目的是为了实现智能电源管理。后来为了管理日益增加的设备,使得设备在底层都具有同一的接口,使其得以成为设备驱动模型的核心。每个kobject对象都与与sysfs文件系统紧密相连,每个注册的kobject 都对应sysfs文件系统中的一个目录。

首先来分析下kobject ,kobject - kernel object 内核对象
kobject 数据结构 的定义在include/linux/kobject.h

struct kobject {
 	const char  *name; //名称作为一个目录显示在sysfs
	 struct list_head entry; 
	 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; //是否已注册到sysfs
	 unsigned int state_add_uevent_sent:1;
 	unsigned int state_remove_uevent_sent:1;
 	unsigned int uevent_suppress:1;
};

一个设备驱动至少会建立一个kobject,偶尔也有因为功能复杂的原因而建立多个kobject。
每个kobject都会有一个kobj_type属性
关于kobj_type数据结构的定义在include/linux/kobject.h中

struct kobj_type {
 	void (*release)(struct kobject *kobj);/*用于释放kobject占用的资源*/ 
 	const struct sysfs_ops *sysfs_ops;/*提供操作属性的方法*/
 	struct attribute **default_attrs;/*用于保存类型属性列表(指针的指针)*/  
 	fconst struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
	const void *(*namespace)(struct kobject *kobj);
};

每个kobject都必须有一个release方法,但是我们在kobject结构体自身内并没有找到,而是放在了kobj_type中。
关于kobj_type中几个中要的成员:

1、sysfs_ops—sysfs_ops中提供了实现属性的方法:

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

在读取属性文件时会执行show函数,在写属性文件时会执行store。

2、default_attrs—default_attrs指向的地方是一个指针数组,attribute就是kobject的属性:name是属性的名字,在相应的sys目录下表示为以name为名称的属性文件,mode为保护位。

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 中还包含了一个kset结构体指针,关于kset数据结构定义:

struct kset {
	 struct list_head list; /*链表*/
	 spinlock_t list_lock; /*链表操作时使用的锁*/
	 struct kobject kobj;
 	const struct kset_uevent_ops *uevent_ops; //事件处理
};

kset结构中有一个链表,它目录下的一些相同类型的kobj会在创建时加入这个链表。

内核常用的kobject举例:
sturct kobject *dev_kobj; //设备对象
sturct ko、bject *sysfs_dev_char_kobj; //字符设备对象
sturct kobject *sysfs_dev_block_kobj; //块设备对象
内核中使用的kset举例:
struct kset *bus_kset; //总线相关
sturct kset *class_kset; //类型相同

下面了解一些关于sysfs的相关知识:
sysfs是一个最初基于ramfs且位于内存的文件系统。它提供到处内核数据结构及其属性,以及它们之间的关联到用户空间的方法。sysfs是一个虚拟文件系统,他是kobject对象的完整视图。
以ubuntu下的sys目录为例,ls后可以看多的很多目录
block bus class dev devices firmware fs hypervisor kernel module power
其中:
block 系统中所有的块设备,独立于所连接的总线
bus 系统中用于连接设备的总线
class 设备类型(例如scsi_class),系统中设备的类型(声卡、网卡、显卡);同一类设备可能包含不同总线连接的设备,于是由不同 的驱动程序驱动。
devices 系统中所有的设备
power 处理一些硬件设备电源状态的文件
sysfs在linux中的文件夹、文件全部都是“虚拟出来的”,对文件的读写,不是真的读写,只是对相应函数的调用。

下面我们来结合kobject和sysfs,联系以下两者之间的关系:
从sysfs角度分析,kset代表一个文件夹,而kset文件夹下面的kobj就是这个文件夹里的内容,而内容kobj可能是文件也可能是文件夹。sysfs在linux中的文件夹、文件全部都是“虚拟出来的”,对文件的读写也不是真的读写,只是对相应函数的调用。

接下来就可以看一下在内核源码中在sys目录下的子目录是如何创建的了:
init/main.c中 start_kernel —>rset_init() —> kernel_thread —> kernel_init —> do_basic_setup —> driver_init (drivers/base/init.c)
分析driver_init函数

void __init driver_init(void)
{
	/* These are the core pieces */
	devtmpfs_init();
	devices_init();/*sys 下device、dev目录*/
	buses_init();/*sys下bus目录*/
	classes_init();/*sys 下class目录*/
	firmware_init();/*sys 下firmware目录*/
	hypervisor_init();/*sys 下hypervisor目录*/
	/* These are also core pieces, but must come after the
	* core core pieces.
	*/
	platform_bus_init(); 
	cpu_dev_init();
	memory_dev_init();
	container_dev_init();
	of_core_init();
	}

driver_init函数中执行了xxx_init函数后就会在sys目录下生成了相应的目录。我们以devices_init()为例

int __init devices_init(void)
{
	 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	 if (!devices_kset)
	  return -ENOMEM;
	 dev_kobj = kobject_create_and_add("dev", NULL);
	 if (!dev_kobj)
	  goto dev_kobj_err;
	 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
	 if (!sysfs_dev_block_kobj)
	  goto block_kobj_err;
	 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
	 if (!sysfs_dev_char_kobj)
	  goto char_kobj_err;
	 return 0;	 
	 char_kobj_err:
	 	kobject_put(sysfs_dev_block_kobj);
	 block_kobj_err:
		 kobject_put(dev_kobj);
	 dev_kobj_err:
		 kset_unregister(devices_kset);
	 return -ENOMEM;
	}

1、首先调用了kset_create_and_add(“devices”, &device_uevent_ops, NULL),创建kset并加入sysfs并返回了devices_kset,这个函数的第个三个参数为NULL表示这个device_kset没有父节点,所以直接会在sys目录下生成名为"devices"的目录。
2、又调用了kobject_create_and_add(“dev”, NULL)创建了dev_kobj 并加入sysfs,调用时第二个参数也就是父节点为NULL,所以在在/sys目录下创建了dev目录。
Linux内核在dev目录下维护了一个按照字符设备和块设备的主次号码(major:minor)链接到真实设备(/sys/devices)的符号链接文件,应用程序可以通过对这些文件的读写和控制来访问实际的设备。
3、分别调用了kobject_create_and_add(“block”, dev_kobj);kobject_create_and_add(“char”, dev_kobj)这次调用第二个参数不是NULL而是在上面创建的dev_kobj,所以最终在在/sys/dev目录下创建了block和char目录。

关于kset_create_and_add函数和kobject_create_and_add函数,位于lib/kobject.c

/**
 * 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,
 						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;
}

kset_create_and_add中最重要的两个函数:kset_create负责创建,kset_register负责加入sysfs中。

/**
 * 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,
					const struct kset_uevent_ops *uevent_ops,
					struct kobject *parent_kobj)
{
 	struct kset *kset;
	 int retval;	
	 kset = kzalloc(sizeof(*kset), GFP_KERNEL);	/*为kset分配内存空间*/
	 if (!kset)
	  	return NULL;
	 retval = kobject_set_name(&kset->kobj, name);	/*设置kset名称*/
	 if (retval) {
	 	 kfree(kset);
	 	 return NULL;
	 }
	 kset->uevent_ops = uevent_ops;
	 kset->kobj.parent = parent_kobj;	/*设置kset的父节点*/
	/*
  	* 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.type = &kset_ktype;
  	kset->kobj.kset = NULL;

	return kset;
}

kset_create函数主要是为kset结构体申请了存储空间,并对其kset成员进行了初始化,至此还未在sys目录下创建东西。这就是我们说的只有注册的kset才会在sys目录下生成相对应的文件。
我们追踪一下kset_register函数,发现kset_register->kobject_add_internal->create_dir->sysfs_create_dir
populate_dir->sysfs_create_files

/**
 * kset_register - initialize and add a kset.
 * @k: kset.
 */
 int kset_register(struct kset *k)
 {
 	int err;
 	if (!k)
 		return -EINVAL;
 	
 	kset_init(k); /*对传入的kset进行初始化*/
 	err = kobject_add_internal(&k->kobj); 	/*加入k->kobj*/
	 if (err)
 		 return err;
 	kobject_uevent(&k->kobj, KOBJ_ADD);
 		return 0;
 }

kset_init -initialize a kset for use

void kset_init(struct kset *k)
{
	 kobject_init_internal(&k->kobj);	/*kobj->kref引用计数置1,初始化一些kobj的state参数*/
	 INIT_LIST_HEAD(&k->list);	/*初始化链表节点*/
 	spin_lock_init(&k->list_lock);	/*初始化自旋锁*/
}

kobject_add_internal函数

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

	if (!kobj)
		  return -ENOENT;
	/*kobj->name不存在或为空,报错返回*/
	if (!kobj->name || !kobj->name[0]) {
  		WARN(1, "kobject: (%p): attempted to be registered with empty "
   			 "name!\n", kobj);
  	return -EINVAL;
	/*若kobj->parent存在,则增加kobj->parent引用计数*/
	parent = kobject_get(kobj->parent); 

	/* join kset if set, use it as parent if we do not already have one */
	 if (kobj->kset) {
 		 if (!parent)	/*parent为NULL,则使用其自己的kobj作为父节点*/
  			parent = kobject_get(&kobj->kset->kobj);
		  kobj_kset_join(kobj);	/*add the kobject to its kset's list*/
		  kobj->parent = parent;
 	}
 	/*调试信息*/
	pr_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\n",
   		kobject_name(kobj), kobj, __func__,
  		 parent ? kobject_name(parent) : "<NULL>",
  		 kobj->kset ? kobject_name(&kobj->kset->kobj) : "<NULL>");
		
		error = create_dir(kobj);
		if (error) {	/*创建失败后的处理*/
			kobj_kset_leave(kobj);
 			kobject_put(parent);
 			kobj->parent = NULL;
			
			/* be noisy on error issues */
 			 if (error == -EEXIST)
  				 WARN(1, "%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
   				WARN(1, "%s failed for %s (error: %d parent: %s)\n",
        				__func__, kobject_name(kobj), error,
        				parent ? kobject_name(parent) : "'none'");
        		} else
  			kobj->state_in_sysfs = 1;	/*置1表示已经加入sysfs*/
  		return error;
   }

create_dir函数的内容很少只调用了 sysfs_create_dir 、 populate_dir去生成文件,如果生成失败则调用sysfs_remove_dir移除目录。
create_dir位于lib/kobject.c

static int create_dir(struct kobject *kobj)
{
 	int error = 0;
	 error = sysfs_create_dir(kobj);
 	if (!error) {
  		error = populate_dir(kobj);
 	 if (error)
   		sysfs_remove_dir(kobj);
	 }
	 return error;
}

sysfs_create_dir函数位于fs/sysfs/dir.c

/**
 * sysfs_create_dir - create a directory for an object.
 * @kobj:  object we're creating directory for. 
 */
int sysfs_create_dir(struct kobject * kobj)
{
	 enum kobj_ns_type type;
	 struct sysfs_dirent *parent_sd, *sd;
	 const void *ns = NULL;
	 int error = 0;

	BUG_ON(!kobj);
	
	if (kobj->parent)
	 	parent_sd = kobj->parent->sd;
	 else
  		parent_sd = &sysfs_root;
  	if (!parent_sd)
  		return -ENOENT;
	if (sysfs_ns_type(parent_sd))
 		ns = kobj->ktype->namespace(kobj);
 	type = sysfs_read_ns_type(kobj);

	error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
	 if (!error)
  		kobj->sd = sd;
	 return error;	

这个函数中会获取传入的kobj的parent信息,如果为NULL会使用&sysfs_root,不为NULL则使用parent->sd的信息。此处就对应了为什么有的目录生成在了sys根目录下,有的sys目录里的子目录下。

create_dir函数里还有一个populate_dir函数
populate_dir位于lib/kobject.c

/*
 * populate_dir - populate directory with attributes.
 * @kobj: object we're working on.
 *
 * Most subsystems have a set of default attributes that are associated
 * with an object that registers with them.  This is a helper called during
 * object registration that loops through the default attributes of the
 * subsystem and creates attributes files for them in sysfs.
 */
 static int populate_dir(struct kobject *kobj)
{
	 struct kobj_type *t = get_ktype(kobj);
	 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;
 		 }
 	}
 	return error;
}

这个函数的逻辑就很清晰了,获取kobject的属性,然后调用sysfs_create_file生成对应的属性文件加入到kobject对应的sys目录下。

总结一下
1、kset目录下可以放一个或多个kset
2、kset目录下可以放一个或多个kobj
3、kobj不一定需要一个kset
4、kobj目录下还可以放kobj
5、kobj目录下会存在属性文件

展开阅读全文

没有更多推荐了,返回首页