参考文章:
linux驱动开发第1讲:带你编写一个最简单的字符设备驱动
linux驱动开发第2讲:应用层的write如何调用到驱动中的write
驱动代码chardev.c如下:
#include
#include
#include
#include
#include
#include
#include
#include
#define BUFFER_MAX (10)
#define OK (0)
#define ERROR (-1)
struct cdev *gDev;
struct file_operations *gFile;
dev_t devNum;
unsigned int subDevNum = 1;
int reg_major = 232;
int reg_minor = 0;
char *buffer;
int flag = 0;
int hello_open(struct inode *p, struct file *f)
{
printk(KERN_EMERG"hello_open\r\n");
return 0;
}
ssize_t hello_write(struct file *f, const char __user *u, size_t s, loff_t *l)
{
printk(KERN_EMERG"hello_write\r\n");
return 0;
}
ssize_t hello_read(struct file *f, char __user *u, size_t s, loff_t *l)
{
printk(KERN_EMERG"hello_read\r\n");
return 0;
}
int hello_init(void)
{
devNum = MKDEV(reg_major, reg_minor); /* 获取设备号 */
if(OK == register_chrdev_region(devNum, subDevNum, "helloworld")){
printk(KERN_EMERG"register_chrdev_region ok \n");
}else {
printk(KERN_EMERG"register_chrdev_region error n");
return ERROR;
}
printk(KERN_EMERG" hello driver init \n");
gDev = kzalloc(sizeof(struct cdev), GFP_KERNEL);
gFile = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
gFile->open = hello_open;
gFile->read = hello_read;
gFile->write = hello_write;
gFile->owner = THIS_MODULE;
cdev_init(gDev, gFile);
cdev_add(gDev, devNum, 3);
return 0;
}
void __exit hello_exit(void)
{
cdev_del(gDev);
unregister_chrdev_region(devNum, subDevNum);
return;
}
module_init(hello_init); /* 驱动入口 */
module_exit(hello_exit); /* 驱动出口 */
MODULE_LICENSE("GPL");
hello_init是驱动的入口点,它通过moduel_init注册到系统中,在驱动被装载时调用,module_init()注册的函数原型必须是:
int my_init(void);
所以hello_init的返回值是int类型,没有参数。
hello_exit是驱动的出口函数,有module_exit()注册到系统中,在驱动被卸载时调用,module_exit()注册的函数原型必须是:
void my_exit(void);
所以hello_exit()没有返回,也没有参数。
内核提供打印函数printk(),和C库提供的printf()函数功能几乎相同。
printk(日志级别 "消息文本");
Makefile内容
obj-m := chardev.o
KERNELDIR := /lib/modules/$(shell uname -r)/build
all default:modules
install:modules_install
modules modules_install help clean:
$(MAKE) -C $(KERNELDIR) M=$(shell pwd) $@
linux应用层程序在编译的时候,需要链接c库和glibc库,那驱动需不需要呢?
驱动也需要,但是驱动不能链接和使用应用层层的任何lib库,驱动需要引用内核的头文件和函数。所以,编译的时候需要指定内核源码的位置,KERNERLDIR就是指定内核源码的位置。
在构建外部模块(makefile文件里面使用 obj-m)之前,需要有一个完整的、预编译的内核源代码树,内核源码树版本必须与将加载和使用模块的内核相同。有两种方法可以获得预构建的内核版本。
sudo apt-get update
sudo apt-get install linux-headers-$(uname -r)
这将只安装头文件,而不是整个源代码树,然后头文件将被安装在/usr/src/linux-headers-$(uname -r)下。有一个符号链接/lib/modules/$(uname -r)/build,指向前面安装的头文件,是在makefile中指定位内核目录的路径。这就是需要为预构建的内核所做的一切。
编译出来的驱动文件为chardev.ko。
在加载驱动之前,我们可以将日志清理一下,方便我们查看驱动产生的消息,使用命令:
dmesg -c
接下来我们把这个驱动加载到内核,使用命令:
sudo insmod chardev.ko
加载的时候就会执行hello_init函数,接着使用命令查看printk输出的消息:
使用lsmod命令查看系统加载的驱动,可以发现chardev已经加载了
卸载驱动使用命令:
sudo rmmod chardev.ko
卸载的时候会执行hello_exit()函数
本节来看驱动的测试。
我们需要编写一个应用层的程序来对驱动进行测试:(test.c)
#include
#include
#include
#include
#define DATA_NUM (64)
int main(int argc, char *argv[])
{
int fd, i;
int r_len, w_len;
fd_set fdset;
char buf[DATA_NUM]="hello world";
memset(buf,0,DATA_NUM);
fd = open("/dev/hello", O_RDWR);
printf("%d\r\n",fd);
if(-1 == fd) {
perror("open file error\r\n");
return -1;
}
else {
printf("open successe\r\n");
}
w_len = write(fd,buf, DATA_NUM);
r_len = read(fd, buf, DATA_NUM);
printf("%d %d\r\n", w_len, r_len);
printf("%s\r\n",buf);
return 0;
}
编译并执行,发现错误,找不到设备文件:
这是因为还没有创建驱动的设备文件,我们为驱动手动创建设备文件
sudo mknod /dev/hello c 232 0
注意,这里的232和0要跟驱动文件chardev.c里定义的主次设备号对应起来。
我们再次执行:sudo ./test
发现成功了,我们执行dmesg查看驱动输出,发现驱动里的hell_open, hello_write, hello_read被依次调用了。
这就是一个完整的、最简单的驱动的开发和测试的流程。
对于应用程序中的write函数如何调用到驱动力的write函数,先上一张图简单说明下调用流程。
用户空间的程序无法直接执行内核代码,它们不能直接调用内核空间中的函数,所以应用程序会以某种方式通知系统,告诉内核自己需要执行一个系统调用,系统系统切换到内核态,通知内核的机制是靠软中断实现的:通过一个异常来促使系统切换到内核态去执行异常处理程序,此时异常处理程序就是系统调用程序,叫system_call(),system_call()根据系统调用号去执行相关的系统调用。
整个流程,上图表现的已经非常明显,但是问题也是有的,操作系统中的系统调用最终是如何知道应该调用哪个驱动里的write函数呢?
如果我们没有记错,在驱动文件里,有定义主次设备号:
int reg_major = 232;
int reg_minor = 0;
int hello_init(void)
{
devNum = MKDEV(reg_major, reg_minor);
gDev = kzalloc(sizeof(struct cdev), GFP_KERNEL);
gFile = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
...
cdev_init(gDev, gFile);
cdev_add(gDev, devNum, 3);
}
在hello_init里,我们把主设备号232和此设备号0组合成了devNum。
cdev_t的结构体如下:
struct cdev
{
struct kobject kobj;
struct module *owner; //所属模块
const struct file_operations *ops; //文件操作结构
struct list_head list;
dev_t dev; //设备号,int 类型,高12位为主设备号,低20位为次设备号
unsigned int count;
};
cdev_init(gDev, gFile); 建立了gDev和gFile的逻辑关系,初始化gDev结构体中的ops。
cdev_add(gDev, devNum, 3); 建立了gDev和devNum的逻辑关系; cdev_add 用于向Linux内核系统中添加一个新的cdev结构体变量所描述的字符设备,并且使这个设备立即可用。gDev是被添加入Linux内核系统的字符设备,devNum代表设备的设备号,其中包括主设备号和次设备号,3代表想注册设备的设备号的范围,用于给struct cdev中的字段count赋值。
其实你翻开代码看细节会发现,以上两句代码其实建立了gFile和devNum的对应关系,也就是file_operations和devNum的对应关系,也就是建立了file_operation和主次设备号(232,0)的对应关系。
注意:在linux里,在应用层用文件句柄也就是fd表示一个打开的文件,但是在内核里用struct file 表示一个打开的文件,用struct file_operations表示对该文件的操作。fd和struct file是一一对应的,而struct file和struct file_operations也是一一对应的。这是struct file_operations的结构体定义:
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 *);
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 *, loff_t, loff_t, int datasync);
int (*fasync) (int, struct file *, int);
...
};
在上一讲的例子里,我们打开的文件名字是/dev/hello,这是一个设备文件,对应的主次设备号分别为232和0。所以,当你打开/dev/hello之后,就已经建立了这个文件和驱动里的 struct file 的对应关系,也就建立了这个文件和驱动里的struct file_operations的对应关系。
好,了解以上的背景之后,我们来看看代码。
我们从内核里write系统调用的实现部分开始阅读:
相关的代码在:fs/read_write.c
ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count)
{
struct fd f = fdget_pos(fd);
ssize_t ret = -EBADF;
if (f.file) {
loff_t pos = file_pos_read(f.file);
ret = vfs_write(f.file, buf, count, &pos);
if (ret >= 0)
file_pos_write(f.file, pos);
fdput_pos(f);
}
return ret;
}
关键代码在vfs_write。所以,我们继续跟进入:
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
ssize_t ret;
if (!(file->f_mode & FMODE_WRITE))
return -EBADF;
if (!(file->f_mode & FMODE_CAN_WRITE))
return -EINVAL;
if (unlikely(!access_ok(buf, count)))
return -EFAULT;
ret = rw_verify_area(WRITE, file, pos, count);
if (!ret) {
if (count > MAX_RW_COUNT)
count = MAX_RW_COUNT;
file_start_write(file);
ret = __vfs_write(file, buf, count, pos);
if (ret > 0) {
fsnotify_modify(file);
add_wchar(current, ret);
}
inc_syscw(current);
file_end_write(file);
}
return ret;
}
继续跟入__vfs_write:
ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
loff_t *pos)
{
if (file->f_op->write)
return file->f_op->write(file, p, count, pos);
else if (file->f_op->write_iter)
return new_sync_write(file, p, count, pos);
else
return -EINVAL;
}
关键代码在这里:
if (file->f_op->write)
return file->f_op->write(file, p, count, pos);
上面提到建立了/dev/hello和file_operations的关系。所以这里其实就是判断chardev驱动里有没有定义write函数,如果有,那就调用驱动里的write函数。
应用程序的write函数去调用C库里面的write函数,C库里面的write函数会产生一个异常,进入内核空间,调用系统调用函数system_call()。system_call()根据系统调用号去调用sys_wtite函数,sys_write函数根据应用程序传来的fd找到file operation,也就是驱动定义的文件(gDev)可以执行那些操作,找到file operation后,调用file operation里面的write操作
所以,按照如上的路径,应用程序里的write就顺利的调用到了hello驱动里的write函数。因为我们驱动里的hello_write和hello_read里都返回了0。所以,应用程序里的write和read也返回了0。
ssize_t hello_write(struct file *f, const char __user *u, size_t s, loff_t *l)
{
printk(KERN_EMERG"hello_write\r\n");
return 0;
}
ssize_t hello_read(struct file *f, char __user *u, size_t s, loff_t *l)
{
printk(KERN_EMERG"hello_read\r\n");
return 0;
}
如果你想让测试程序里的write和read返回非零值,只要把驱动里的return 0,改为任意值就好了,大家可以自己测试一下。