linux设备驱动第三篇：写一个简单的字符设备驱动

Posted 2020-09-17 Avatarx

 

 

 

在linux设备驱动第一篇：设备驱动程序简介中简单介绍了字符驱动，本篇简单介绍如何写一个简单的字符设备驱动。本篇借鉴LDD中的源码，实现一个与硬件设备无关的字符设备驱动，仅仅操作从内核中分配的一些内存。

下面就开始学习如何写一个简单的字符设备驱动。首先我们来分解一下字符设备驱动都有那些结构或者方法组成，也就是说实现一个可以使用的字符设备驱动我们必须做些什么工作。

1、主设备号和次设备号

对于字符设备的访问是通过文件系统中的设备名称进行的。他们通常位于/dev目录下。如下：

[plain] view plain copy

 

 

1. [email protected]:~$ ls -l /dev/  
2. total 0  
3. brw-rw----  1 root disk        7,   0  3月 25 10:34 loop0  
4. brw-rw----  1 root disk        7,   1  3月 25 10:34 loop1  
5. brw-rw----  1 root disk        7,   2  3月 25 10:34 loop2  
6. crw-rw-rw-  1 root tty         5,   0  3月 25 12:48 tty  
7. crw--w----  1 root tty         4,   0  3月 25 10:34 tty0  
8. crw-rw----  1 root tty         4,   1  3月 25 10:34 tty1  
9. crw--w----  1 root tty         4,  10  3月 25 10:34 tty10  

其中b代表块设备，c代表字符设备。对于普通文件来说，ls -l会列出文件的长度，而对于设备文件来说，上面的7,5,4等代表的是对应设备的主设备号，而后面的0,1,2,10等则是对应设备的次设备号。那么主设备号和次设备号分别代表什么意义呢？一般情况下，可以这样理解，主设备号标识设备对应的驱动程序，也就是说1个主设备号对应一个驱动程序。当然，现在也有多个驱动程序共享主设备号的情况。而次设备号有内核使用，用于确定/dev下的设备文件对应的具体设备。举一个例子，虚拟控制台和串口终端有驱动程序4管理，而不同的终端分别有不同的次设备号。

1.1、设备编号的表达

在内核中，dev_t用来保存设备编号，包括主设备号和次设备号。在2.6的内核版本种，dev_t是一个32位的数，其中12位用来表示主设备号，其余20位用来标识次设备号。

通过dev_t获取主设备号和次设备号使用下面的宏：

MAJOR(dev_t dev);

MINOR(dev_t dev);

相反，通过主设备号和次设备号转换为dev_t类型使用：

MKDEV(int major, int minor);

1.2、分配和释放设备编号

在构建一个字符设备之前，驱动程序首先要获得一个或者多个设备编号，这类似一个营业执照，有了营业执照才在内核中正常工作营业。完成此工作的函数是：

[cpp] view plain copy

 

 

1. int register_chrdev_region(dev_t first, unsigned int count, const char *name);  

first是要分配的设备编号范围的起始值。count是连续设备的编号的个数。name是和该设备编号范围关联的设备名称，他将出现在/proc/devices和sysfs中。此函数成功返回0，失败返回负的错误码。此函数是在已知主设备号的情况下使用，在未知主设备号的情况下，我们使用下面的函数：

[cpp] view plain copy

 

 

1. int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, const char *name);  

dev用于输出申请到的设备编号，firstminor要使用的第一个此设备编号。

在不使用时需要释放这些设备编号，已提供其他设备程序使用：

[cpp] view plain copy

 

 

1. void unregister_chrdev_region(dev_t dev, unsigned int count);  

此函数多在模块的清除函数中调用。

分配到设备编号之后，我们只是拿到了营业执照，虽说现在已经准备的差不多了,但是我们只是从内核中申请到了设备号,应用程序还是不能对此设备作任何事情,我们需要一个简单的函数来把设备编号和此设备能实现的功能连接起来,这样我们的模块才能提供具体的功能.这个操作很简单，稍后就会提到，在此之前先介绍几个重要的数据结构。

2、重要的数据结构

注册设备编号仅仅是完成一个字符设备驱动的第一步。下面介绍大部分驱动都会包含的三个重要的内核的数据结构。

2.1、文件操作file_operations

file_operations是第一个重要的结构，定义在 <linux/fs.h>, 是一个函数指针的集合，设备所能提供的功能大部分都由此结构提供。这些操作也是设备相关的系统调用的具体实现。此结构的具体实现如下所示：

[cpp] view plain copy

 

 

1. struct file_operations {  
2.         //它是一个指向拥有这个结构的模块的指针. 这个成员用来在它的操作还在被使用时阻止模块被卸载. 几乎所有时间中, 它被简单初始化为 THIS_MODULE  
3.         struct module *owner;  
4.         loff_t (*llseek) (struct file *, loff_t, int);  
5.         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);  
6.         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);  
7.         ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);  
8.         ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);  
9.         ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);  
10.         ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);  
11.         int (*iterate) (struct file *, struct dir_context *);  
12.         unsigned int (*poll) (struct file *, struct poll_table_struct *);  
13.         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);  
14.         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);  
15.         int (*mmap) (struct file *, struct vm_area_struct *);  
16.         int (*open) (struct inode *, struct file *);  
17.         int (*flush) (struct file *, fl_owner_t id);  
18.         int (*release) (struct inode *, struct file *);  
19.         int (*fsync) (struct file *, loff_t, loff_t, int datasync);  
20.         int (*aio_fsync) (struct kiocb *, int datasync);  
21.         int (*fasync) (int, struct file *, int);  
22.         int (*lock) (struct file *, int, struct file_lock *);  
23.         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);  
24.         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);  
25.         int (*check_flags)(int);  
26.         int (*flock) (struct file *, int, struct file_lock *);  
27.         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);  
28.         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);  
29.         int (*setlease)(struct file *, long, struct file_lock **);  
30.         long (*fallocate)(struct file *file, int mode, loff_t offset,  
31.                           loff_t len);  
32.         int (*show_fdinfo)(struct seq_file *m, struct file *f);  
33. };  

需要说明的是这里面的函数在驱动中不用全部实现，不支持的操作留置为NULL。

2.2、文件结构struct file

struct file, 定义于 <linux/fs.h>, 是设备驱动中第二个最重要的数据结构。文件结构代表一个打开的文件. (它不特定给设备驱动; 系统中每个打开的文件有一个关联的 struct file 在内核空间). 它由内核在 open 时创建, 并传递给在文件上操作的任何函数, 直到最后的关闭. 在文件的所有实例都关闭后, 内核释放这个数据结构。file结构的详细可参考fs.h，这里列出来几个重要的成员。

• struct file_operations *f_op：就是上面刚刚介绍的文件操作的集合结构。
• mode_t f_mode：文件模式确定文件是可读的或者是可写的(或者都是), 通过位 FMODE_READ 和 FMODE_WRITE. 你可能想在你的 open 或者 ioctl 函数中检查这个成员的读写许可, 但是你不需要检查读写许可, 因为内核在调用你的方法之前检查. 当文件还没有为那种存取而打开时读或写的企图被拒绝, 驱动甚至不知道这个情况
• loff_t f_pos：当前读写位置. loff_t 在所有平台都是 64 位。驱动可以读这个值, 如果它需要知道文件中的当前位置, 但是正常地不应该改变它。
• unsigned int f_flags：这些是文件标志, 例如 O_RDONLY, O_NONBLOCK, 和 O_SYNC. 驱动应当检查 O_NONBLOCK 标志来看是否是请求非阻塞操作。
• void *private_data：open 系统调用设置这个指针为 NULL, 在为驱动调用 open 方法之前. 你可自由使用这个成员或者忽略它; 你可以使用这个成员来指向分配的数据, 但是接着你必须记住在内核销毁文件结构之前, 在 release 方法中释放那个内存. private_data 是一个有用的资源, 在系统调用间保留状态信息, 我们大部分例子模块都使用它

2.3、inode 结构

inode 结构由内核在内部用来表示文件. 因此, 它和代表打开文件描述符的文件结构是不同的. 可能有代表单个文件的多个打开描述符的许多文件结构, 但是它们都指向一个单个 inode 结构。

inode 结构包含大量关于文件的信息。但对于驱动程序编写来说一般不用关心，暂且不说。

3、字符设备的注册

内核在内部使用类型 struct cdev 的结构来代表字符设备. 在内核调用你的设备操作前, 你编写分配并注册一个或几个这些结构。

有 2 种方法来分配和初始化一个这些结构. 如果你想在运行时获得一个独立的 cdev 结构, 你可以为此使用这样的代码:

[cpp] view plain copy

 

1. struct cdev *my_cdev = cdev_alloc();  
2. my_cdev->ops = &my_fops;  

更多的情况是把cdv结构嵌入到你自己封装的设备结构中，这时需要使用下面的方法来分配和初始化：

[cpp] view plain copy

 

1. void cdev_init(struct cdev *cdev, struct file_operations *fops);  

后面的例子程序就是这么做的。一旦 cdev 结构建立, 最后的步骤是把它告诉内核：

[cpp] view plain copy

 

1. int cdev_add(struct cdev *dev, dev_t num, unsigned int count)  

这里, dev 是 cdev 结构, num 是这个设备响应的第一个设备号, count 是应当关联到设备的设备号的数目. 常常 count 是 1。

从系统去除一个字符设备, 调用:

[cpp] view plain copy

 

1. void cdev_del(struct cdev *dev);  

4、一个简单的字符设备

上面大致介绍了实现一个字符设备所要做的工作，下面就来一个真实的例子来总结上面介绍的内容。源码中的关键地方已经作了注释。

[cpp] view plain copy

 

1. #include <linux/module.h>  
2. #include <linux/types.h>  
3. #include <linux/fs.h>  
4. #include <linux/errno.h>  
5. #include <linux/mm.h>  
6. #include <linux/sched.h>  
7. #include <linux/init.h>  
8. #include <linux/cdev.h>  
9. #include <asm/io.h>  
10. #include <asm/uaccess.h>  
11. #include <linux/timer.h>  
12. #include <asm/atomic.h>  
13. #include <linux/slab.h>  
14. #include <linux/device.h>  
15.   
16. #define CDEVDEMO_MAJOR 255  /*预设cdevdemo的主设备号*/  
17.   
18. static int cdevdemo_major = CDEVDEMO_MAJOR;  
19.   
20. /*设备结构体,此结构体可以封装设备相关的一些信息等 
21.   信号量等也可以封装在此结构中，后续的设备模块一般都 
22.   应该封装一个这样的结构体，但此结构体中必须包含某些 
23.   成员，对于字符设备来说，我们必须包含struct cdev cdev*/  
24. struct cdevdemo_dev   
25. {  
26.     struct cdev cdev;  
27. };  
28.   
29. struct cdevdemo_dev *cdevdemo_devp; /*设备结构体指针*/  
30.   
31. /*文件打开函数，上层对此设备调用open时会执行*/  
32. int cdevdemo_open(struct inode *inode, struct file *filp)     
33. {  
34.     printk(KERN_NOTICE "======== cdevdemo_open ");  
35.     return 0;  
36. }  
37.   
38. /*文件释放，上层对此设备调用close时会执行*/  
39. int cdevdemo_release(struct inode *inode, struct file *filp)      
40. {  
41.     printk(KERN_NOTICE "======== cdevdemo_release ");     
42.     return 0;  
43. }  
44.   
45. /*文件的读操作，上层对此设备调用read时会执行*/  
46. static ssize_t cdevdemo_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)  
47. {  
48.     printk(KERN_NOTICE "======== cdevdemo_read ");    
49. }  
50.   
51. /* 文件操作结构体，文中已经讲过这个结构*/  
52. static const struct file_operations cdevdemo_fops =  
53. {  
54.     .owner = THIS_MODULE,  
55.     .open = cdevdemo_open,  
56.     .release = cdevdemo_release,  
57.     .read = cdevdemo_read,  
58. };  
59.   
60. /*初始化并注册cdev*/  
61. static void cdevdemo_setup_cdev(struct cdevdemo_dev *dev, int index)  
62. {  
63.     printk(KERN_NOTICE "======== cdevdemo_setup_cdev 1");     
64.     int err, devno = MKDEV(cdevdemo_major, index);  
65.     printk(KERN_NOTICE "======== cdevdemo_setup_cdev 2");  
66.   
67.     /*初始化一个字符设备，设备所支持的操作在cdevdemo_fops中*/     
68.     cdev_init(&dev->cdev, &cdevdemo_fops);  
69.     printk(KERN_NOTICE "======== cdevdemo_setup_cdev 3");     
70.     dev->cdev.owner = THIS_MODULE;  
71.     dev->cdev.ops = &cdevdemo_fops;  
72.     printk(KERN_NOTICE "======== cdevdemo_setup_cdev 4");     
73.     err = cdev_add(&dev->cdev, devno, 1);  
74.     printk(KERN_NOTICE "======== cdevdemo_setup_cdev 5");  
75.     if(err)  
76.     {  
77.         printk(KERN_NOTICE "Error %d add cdevdemo %d", err, index);   
78.     }  
79. }  
80.   
81. int cdevdemo_init(void)  
82. {  
83.     printk(KERN_NOTICE "======== cdevdemo_init ");    
84.     int ret;  
85.     dev_t devno = MKDEV(cdevdemo_major, 0);  
86.   
87.     struct class *cdevdemo_class;  
88.     /*申请设备号，如果申请失败采用动态申请方式*/  
89.     if(cdevdemo_major)  
90.     {  
91.         printk(KERN_NOTICE "======== cdevdemo_init 1");  
92.         ret = register_chrdev_region(devno, 1, "cdevdemo");  
93.     }else  
94.     {  
95.         printk(KERN_NOTICE "======== cdevdemo_init 2");  
96.         ret = alloc_chrdev_region(&devno,0,1,"cdevdemo");  
97.         cdevdemo_major = MAJOR(devno);  
98.     }  
99.     if(ret < 0)  
100.     {  
101.         printk(KERN_NOTICE "======== cdevdemo_init 3");  
102.         return ret;  
103.     }  
104.     /*动态申请设备结构体内存*/  
105.     cdevdemo_devp = kmalloc(sizeof(struct cdevdemo_dev), GFP_KERNEL);  
106.     if(!cdevdemo_devp)  /*申请失败*/  
107.     {  
108.         ret = -ENOMEM;  
109.         printk(KERN_NOTICE "Error add cdevdemo");     
110.         goto fail_malloc;  
111.     }  
112.   
113.     memset(cdevdemo_devp,0,sizeof(struct cdevdemo_dev));  
114.     printk(KERN_NOTICE "======== cdevdemo_init 3");  
115.     cdevdemo_setup_cdev(cdevdemo_devp, 0);  
116.   
117.     /*下面两行是创建了一个总线类型，会在/sys/class下生成cdevdemo目录 
118.       这里的还有一个主要作用是执行device_create后会在/dev/下自动生成 
119.       cdevdemo设备节点。而如果不调用此函数，如果想通过设备节点访问设备 
120.       需要手动mknod来创建设备节点后再访问。*/  
121.     cdevdemo_class = class_create(THIS_MODULE, "cdevdemo");  
122.     device_create(cdevdemo_class, NULL, MKDEV(cdevdemo_major, 0), NULL, "cdevdemo");  
123.   
124.     printk(KERN_NOTICE "======== cdevdemo_init 4");  
125.     return 0;  
126.   
127.     fail_malloc:  
128.         unregister_chrdev_region(devno,1);  
129. }  
130.   
131. void cdevdemo_exit(void)    /*模块卸载*/  
132. {  
133.     printk(KERN_NOTICE "End cdevdemo");   
134.     cdev_del(&cdevdemo_devp->cdev);  /*注销cdev*/  
135.     kfree(cdevdemo_devp);       /*释放设备结构体内存*/  
136.     unregister_chrdev_region(MKDEV(cdevdemo_major,0),1);    //释放设备号  
137. }  
138.   
139. MODULE_LICENSE("Dual BSD/GPL");  
140. module_param(cdevdemo_major, int, S_IRUGO);  
141. module_init(cdevdemo_init);  
142. module_exit(cdevdemo_exit);  

Makefile文件如下：

[plain] view plain copy

 

1. ifneq ($(KERNELRELEASE),)  
2. obj-m := cdevdemo.o  
3. else  
4. KERNELDIR ?= /lib/modules/$(shell uname -r)/build  
5. PWD := $(shell pwd)  
6. default:  
7.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules  
8. endif  
9.   
10. clean:  
11.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules.order  Module.symvers  

温馨提示：测试环境为Linux ubuntu 3.16.0-33-generic。

5、总结

本篇主要介绍了简单字符设备的编写与实现以及其中的关键点。下一篇会主要讲解下驱动的一些常用的调试技巧。