Linux字符设备驱动程序开发(2)-字符设备驱动模型分析

驱动模型

在Linux系统中,设备的类型非常繁多，如：字符设备，块设备，网络接口设备，USB设备，PCI设备，平台设备，混杂设备……，而设备类型不同，也意味着其对应的驱动程序模型不同，这样就导致了我们需要去掌握众多的驱动程序模型。那么能不能从这些众多的驱动模型中提炼出一些具有共性的规则，则是我们能不能学好Linux驱动的关键。

1.设备描述结构

在任何一种驱动模型中，设备都会用内核中的一种结构来描述。我们的字符设备在内核中使用struct cdev来描述。

struct cdev {

struct kobject kobj;
struct module *owner;
const struct file_operations *ops; //设备操作集
struct list_head list;
dev_t dev; //设备号
unsigned int count; //设备数
};

在这些成中有一些成员是开发者不需要关注的，有一些则要关注，比如说count是设备数，表示目前拥有的硬件设备个数，还有设备号，设备操作集。

1.1设备号

设备号包含主设备号和次设备号，使用：#ls -l /dev/来查看当前驱动文件的设备号。

在中间有2列用逗号隔开的数字，前面的是主设备号，后面的是次设备号。
主设备号用来将字符设备文件与字符驱动程序建立起对应关系。
次设备号用来区分同一种驱动下的不同设备，比如说有3个串口，它们只需要一个驱动程序即可，那么怎么区分这几个串口呢？答案就是使用次设备号。
设备号这个类型使用的是dev_t，那么主设备号和次设备号是怎么构成dev_t的呢？又怎么样从dev_t中得到主次设备号呢？
dev_t这种类型其实质为32位的unsigned int，其中高12位为主设备号，低20位为次设备号。
- 问1：如果知道主设备号，次设备号，怎么组合成dev_t类型
- 答：dev_t dev = MKDEV(主设备号，次设备号)
- 问2: 如何从dev_t中分解出主设备号?
- 答: 主设备号 = MAJOR(dev_t dev)
- 问3: 如何从dev_t中分解出次设备号？
- 答: 次设备号=MINOR(dev_t dev)
对程序员来说次设备号可以自己定义，但是主设备号却很敏感，容易发生冲突，如何为设备分配一个主设备号呢？
- 静态申请：开发者自己选择一个数字作为主设备号，然后通过函数register_chrdev_region向内核申请使用。缺点：如果申请使用的设备号已经被内核中的其他驱动使用了，则申请失败。
- 动态分配：使用alloc_chrdev_region由内核分配一个可用的主设备号。优点：因为内核知道哪些号已经被使用了，所以不会导致分配到已经被使用的号。
注销设备号：为了避免设备号的浪费，不论使用何种方法分配设备号，都应该在驱动退出时，使用unregister_chrdev_region函数释放这些设备号。

1.2 操作函数集

操作集函数ops，它是struct file_operations *ops，在内核代码中打开这个结构：

struct file_operations {
	struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	int (*readdir) (struct file *, void *, filldir_t);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, struct dentry *, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (*flock) (struct file *, int, struct file_lock *);
	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
	int (*setlease)(struct file *, long, struct file_lock **);
};

可以发现在这个结构里面全部成员都是函数指针，这些名字都是系统调用的函数。其实这个结构就是实现应用程序系统调用时的函数到内核驱动函数映射的功能。
Struct file_operations是一个函数指针的集合，定义能在设备上进行的操作。结构中的函数指针指向驱动中的函数，这些函数实现一个针对设备的操作, 对于不支持的操作则设置函数指针为 NULL。例如：

struct file_operations dev_fops = {
.llseek = NULL,
.read = dev_read,
.write = dev_write,
.ioctl = dev_ioctl,
.open = dev_open,
.release = dev_release,
};

2.字符设备驱动模型

设备驱动模型需遵循下面3个流程：

2.1 驱动初始化

驱动初始化一般在模块初始化函数中完成，这里的工作主要和设备描述结构和硬件初始化相关。流程一般为

2.1.1 分配设备描述结构cdev

cdev变量的定义可以采用静态和动态两种办法
静态分配，就是直接自己定义一个：struct cdev mdev;
动态分配，就是由内核动态分配：struct cdev *pdev = cdev_alloc();

2.1.2 初始化设备描述结构cdev

struct cdev的初始化使用cdev_init函数来完成。
cdev_init(struct cdev *cdev, const struct file_operations *fops)
参数：
- cdev: 待初始化的cdev结构
- fops: 设备对应的操作函数集

2.1.3 注册设备描述结构cdev

字符设备的注册使用cdev_add函数来完成。
cdev_add(struct cdev *p, dev_t dev, unsigned count)
参数：
- p：待添加到内核的字符设备结构
- dev：设备号
- count：该类设备的设备个数

2.1.4 硬件初始化

根据相应硬件的芯片手册，完成初始化。

2.2 实现设备操作

设备操作又称设备方法，这里实现几个函数：

int (*open) (struct inode *, struct file *);  // 打开设备，响应open系统
int (*release) (struct inode *, struct file *);  // 关闭设备，响应close系统调用
loff_t (*llseek) (struct file *, loff_t, int);  // 重定位读写指针，响应lseek系统调用
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);  // 从设备读取数据，响应read系统调用
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);// 向设备写入数据，响应write系统调用

这些设备函数在应用程序调用open、read、write、close时将会通过file_operations 的映射，调用上面几个设备文件。
那么这些函数改怎么实现呢？这里先介绍几个重要的知识点。

struct file：

struct file { 
　　struct file *f_next，**f_pprev; 
　　struct dentry *f_dentry; 
　　struct file_operations *f_op; 
　　mode_t f_mode; 
　　loff_t f_pos; 
　　unsigned int f_count，f_flags; 
　　unsigned long f_reada，f_ramax，f_raend，f_ralen，f_rawin; 
　　struct fown_struct f_owner; 
　　unsigned long f_version; 
　　void *private_data; 
　　};

在Linux系统中，每一个打开的文件，在内核中都会关联一个struct_file，它由内核在打开文件时创建，在文件关闭后释放。
重要成员：
- loff_t f_pos /*文件位置读写指针*/
- struct file_operations *f_op /*该文件所对应的操作，实现用户空间函数到内核函数的映射*/

struct inode

每一个存在于文件系统里面的文件都会关联一个inode结构，该结构主要用来记录文件物理上的信息。因此, 它和代表打开文件的file结构是不同的。一个文件没有被打开时不会关联file结构，但是却会关联一个inode结构。
重要成员：
- dev_t i_rdev：次设备号

设备操作--open

int mem_open(struct inode *inode, struct file *filep)
open设备方法是驱动程序用来为以后的操作完成初始化准备工作的。在大部分驱动程序中，open完成如下工作：
标明次设备号
启动设备

设备操作---release

int mem_release(struct inode *inode, struct file *filep)
release方法的作用正好与open相反。这个设备方法有时也称为close，它应该：
关闭设备

设备操作--read

static ssize_t mem_read(struct file *filep, char __user *buf, size_t size, loff_t *ppos)
read设备方法通常完成2件事情：
1.从设备中读取数据(属于硬件访问类操作)
2.将读取到的数据返回给应用程序
参数分析：
ssize_t (*read) (struct file *filp, char __user *buff, size_t count, loff_t *offp)
- filp：与字符设备文件关联的file结构指针, 由内核创建。
- buff : 从设备读取到的数据，需要保存到的位置。由read系统调用提供该参数。
- count: 请求传输的数据量，由read系统调用提供该参数。
- offp: 文件的读写位置，由内核从file结构中取出后，传递进来。
buff参数是来源于用户空间的指针，这类指针都不能被内核代码直接引用，必须使用专门的函数，read一般使用copy_to_user
int copy_to_user(void __user *to, const void *from, int n)
int copy_from_user(void *to, const void __user *from, int n)

设备操作--write

static ssize_t mem_write(struct file *filep, const char __user *buf, size_t size, loff_t *ppos)
write设备方法通常完成2件事情：
1.从应用程序提供的地址中取出数据
2.将数据写入设备(属于硬件访问类操作)一般使用：int copy_from_user(void *to, const void __user *from, int n)
参数分析：
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);//其参数类似于read

设备操作--llseek函数（文件定位函数）

当前读写位置保存在filp->ops，根据whence和偏移来确定需要读写的位置，最后修改fpos即可。
如果是SEEK_SET，则是从起始位置开始偏置
如果是SEEK_CUR，则是从当前位置开始偏移
如果是SEEK_END，则是从文件尾部开始偏置
判断新的位置是否合法，如果合法写入f_ops中

2.3 注销驱动设备

当我们从内核中卸载驱动程序的时候，需要使用cdev_del函数来完成字符设备的注销。

3 范例驱动分析

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

int dev1_registers[5];
int dev2_registers[5];

struct cdev cdev; 
dev_t devno;

/* 文件打开函数 */
int mem_open(struct inode *inode, struct file *filp)
{
	/* 获取次设备号 */
	int num = MINOR(inode->i_rdev);
    
	if (num == 0)
		filp->private_data = dev1_registers;
	else if(num == 1)
		filp->private_data = dev2_registers;
	else
		return -ENODEV;  // 无效的次设备号
    
	return 0; 
}

/*文件释放函数*/
int mem_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/*读函数*/
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
	unsigned long p =  *ppos;
	unsigned int count = size;
	int ret = 0;
	int *register_addr = filp->private_data;  /*获取设备的寄存器基地址*/

	/*判断读位置是否有效*/
	if (p >= 5*sizeof(int))
		return 0;
	if (count > 5*sizeof(int) - p)
		count = 5*sizeof(int) - p;

/*读数据到用户空间*/
	if (copy_to_user(buf, register_addr + p, count))
	{
		ret = -EFAULT;
	}
	else
	{
		*ppos += count;
		ret = count;
	}

	return ret;
}

/*写函数*/
static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
	unsigned long p =  *ppos;
	unsigned int count = size;
	int ret = 0;
	int *register_addr = filp->private_data; /*获取设备的寄存器地址*/
  
	/*分析和获取有效的写长度*/
	if (p >= 5*sizeof(int))
		return 0;
	if (count > 5*sizeof(int) - p)
		count = 5*sizeof(int) - p;
    
	/*从用户空间写入数据*/
	if (copy_from_user(register_addr + p, buf, count))
		ret = -EFAULT;
	else
	{
		*ppos += count;
		ret = count;
	}

	return ret;
}

/* seek文件定位函数 */
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
{ 
	loff_t newpos;

	switch(whence) 
	{
		case SEEK_SET: 
			newpos = offset;
			break;

		case SEEK_CUR: 
			newpos = filp->f_pos + offset;
			break;

		case SEEK_END: 
			newpos = 5*sizeof(int)-1 + offset;
			break;

		default: 
			return -EINVAL;
	}

	if ((newpos < 0) || (newpos > 5*sizeof(int)))
		return -EINVAL;
    	
	filp->f_pos = newpos;
	return newpos;
}

/* 文件操作结构体 */
static const struct file_operations mem_fops =
{
	.llseek = mem_llseek,
	.read = mem_read,
	.write = mem_write,
	.open = mem_open,
	.release = mem_release,
};

/* 设备驱动模块加载函数 */
static int memdev_init(void)
{
	/*初始化cdev结构*/
	cdev_init(&cdev, &mem_fops);
  
	/* 注册字符设备 */
	alloc_chrdev_region(&devno, 0, 2, "memdev"); // memdev驱动名字
	cdev_add(&cdev, devno, 2);
}

/*模块卸载函数*/
static void memdev_exit(void)
{
	cdev_del(&cdev);   /*注销设备*/
	unregister_chrdev_region(devno, 2); /*释放设备号*/
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

首先看模块初始化函数，先完成cdev的分配，这里采用静态分配的方法，然后是初始化cdev，参数一是cdev指针，参数二是mem_fops，即支持的操作函数。
注册使用cdev_add()函数，参数有3个，参数一是cdev指针，参数二是devno设备号，设备号通过alloc_chrdev_region()函数动态分配，它的参数有4个，设备号填入的地方，后面2个参数是次设备号开始的数字和次设备号的个数，最后使用设备号的驱动的名字。参数三是同类型设备的个数，这里有2个。
接下来就要实现设备操作方法，即实现mem_fops里面定义的函数。
open函数：
- 提取次设备号，然后根据次设备号获取寄存器的基地址。由于这里是模拟的硬件，这里没有设备启动函数。
read函数：
- read函数首先需要根据struct_file文件提取出寄存器的基地址，才能对正确的设备进行读写。
- 然后判断读写位置是否有效，如果当前读写位置p比设备总字节数都大，显然是不能读取的，如果需要读写字节数count大于可读写字节数(总字节减去当前读写位置)，那么只能令count = 总字节数-当前读写位置，即还有多少读多少。
- 读写位置合法后就可以把数据从设备发送给用户了，使用copy_to_user函数，参数分别为应用程序存放数据的地址，设备存放数据的地址（基地址加上读写位置），读写直接个数
- 最后根据读写情况修改当前读写位置和其他参数即可。
write函数：这个函数和read函数类似，这里不在分析
llseek函数（文件定位函数）：
- 当前读写位置保存在filp->ops，根据whence和偏移来确定需要读写的位置，最后修改fpos即可。
- 如果是SEEK_SET，则是从起始位置开始偏置
- 如果是SEEK_CUR，则是从当前位置开始偏移
- 如果是SEEK_END，则是从文件尾部开始偏置
- 判断新的位置是否合法，如果合法写入f_ops中
release函数，设备关闭函数：
- 由于这里是模拟的硬件设备，所以不需要做什么，直接返回即可。
设备注销：
- 这一步需要注销设备并释放设备号。
  - cdev_del(&cdev); /*注销设备*/
  - unregister_chrdev_region(devno, 2); /*释放设备号*/

4 自己编写驱动代码

根据下面分析的模型，就可以编写出自己需要的驱动代码了。

memdev.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

struct cdev mdev;  // 分配cdev
dev_t devno;

int dev1_regs[5];
int dev2_regs[5];

loff_t mem_lseek(struct file *filp, loff_t offset, int whence)
{
	loff_t new_pos = 0;
	
	switch (whence) 
	{
		case SEEK_SET:
			new_pos = 0 + offset;
			break;
            
        case SEEK_CUR:
            new_pos = filp->f_pos + offset;
            break;
            
        case SEEK_END:
            new_pos = 5*sizeof(int) + offset;
            break;
    }

	filp->f_pos = new_pos;
	   
	return new_pos;
}

ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
	int *reg_base = filp->private_data;
	    
	// 读取数据到用户空间
	copy_to_user(buf, reg_base + (*ppos), size);
	    
	filp->f_pos += size;
	
	return size;	
}

ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
	int *reg_base = filp->private_data;

	// 把用户数据写到设备
	copy_from_user(reg_base + (*ppos), buf, size);

	filp->f_pos += size;

	return size;
}

int mem_open(struct inode *node, struct file *filp)
{
	int num = MINOR(node->i_rdev);  // 提取次设备号
		    
	if (num == 0)
		filp->private_data = dev1_regs;      
	if (num == 1)
		filp->private_data = dev2_regs;
	        
	return 0;   	
}

int mem_close(struct inode *node, struct file *filp)
{
	return 0;
}

const struct file_operations memfops =
{
	.llseek = mem_lseek,
	.read = mem_read,
	.write = mem_write,
	.open = mem_open,
	.release = mem_close,
};
 
int memdev_init(void)
{
	// 初始化cdev
	cdev_init(&mdev, &memfops);

	// 注册cdev
	// 1.由内核分配设备号
	alloc_chrdev_region(&devno, 0, 2, "memdev");
	// 2.注册
	cdev_add(&mdev, devno, 2);

	return 0;
}
	
void memdev_exit(void)
{
	cdev_del(&mdev);   /*注销设备*/

	unregister_chrdev_region(devno, 2); /*释放设备号*/
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

5 驱动访问大解密（从应用程序系统调用找到驱动程序的设备方法？）

以read系统调用，read系统调用通过软中断方式引发一个异常来促使系统切换到内核态去执行异常处理程序，进而执行对应的内核服务例程sys_read（具体见Linux系统调用）。
内核中sys_read实现代码：在Read_write.c中

SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
	struct file *file;
	ssize_t ret = -EBADF;
	int fput_needed;

	file = fget_light(fd, &fput_needed);
	if (file) {
		loff_t pos = file_pos_read(file);
		ret = vfs_read(file, buf, count, &pos);
		file_pos_write(file, pos);
		fput_light(file, fput_needed);
	}

	return ret;
}

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
	ssize_t ret;

	if (!(file->f_mode & FMODE_READ))
		return -EBADF;
	if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
		return -EINVAL;
	if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
		return -EFAULT;

	ret = rw_verify_area(READ, file, pos, count);
	if (ret >= 0) {
		count = ret;
		if (file->f_op->read)
			ret = file->f_op->read(file, buf, count, pos);  // 找到设备方法
		else
			ret = do_sync_read(file, buf, count, pos);
		if (ret > 0) {
			fsnotify_access(file->f_path.dentry);
			add_rchar(current, ret);
		}
		inc_syscr(current);
	}

	return ret;
}

通过源代码可知，sys_read()函数会调用vfs_read()函数，vfs_read()函数得到file结构中的file_operations，在定义file_operations结构的时候就有xxx_read设备方法。

Linux字符设备驱动程序开发(2)-字符设备驱动模型分析

猜你喜欢