对LDD3前七章的一个小节

最近又重读了LDD3(Linux Device Driver, 3rd Edition) , 对LDD的前面一部分, 即如何写一个字符设备进行了一个小结. 希望能够对初学者有用.

对于下面这一段代码, 演示了如何创建一个字符设备, 涉及到如下知识点:
1. 如何创建字符设备, 2. 使用信号量进行互斥, 3. 创建等待队列, 4. 设计一个定时器
分别包括了LDD3中第二, 三, 五, 六, 七章中的小部分内容.

1. #include<linux/module.h>
   
2. #include<linux/kernel.h>
   
3. #include<linux/init.h>
   
4. #include<linux/cdev.h>
   
5. #include<linux/types.h>
   
6. #include<linux/fs.h>
   
7. #include<linux/sched.h>
   
8. #include<linux/delay.h>
   
9. #include<asm/semaphore.h>
   
10. #include<asm/uaccess.h>
    
11. 
    
12. MODULE_LICENSE("GPL");
    
13. 
    
14. static struct semaphore my_lock;
    
15. static wait_queue_head_t my_wait;
    
16. static int flag = 0;
    
17. static int major;
    
18. struct timer_list my_timer;
    
19. 
    
20. 
    
21. /*
    
22. * my_handler 是定时器处理函数, 其将flag设定为1, 并唤醒等待队列上的进程.
    
23. */ 
    
24. void my_handler(unsigned long data)
    
25. {
    
26.         printk("in handler function\n");
    
27.         flag = 1;
    
28.         wake_up_interruptible(&my_wait);
    
29.         printk("wake it up\n");
    
30. }
    
31. /*
    
32. * my_read 由char_read调用, 当flag为0时就将自己放置到等待队列中去. 并阻塞当前进程
    
33. */ 
    
34. int my_read(int i)
    
35. {
    
36.         printk("waiting...\n");
    
37.         wait_event_interruptible(my_wait, flag != 0);
    
38.         printk("I am waked\n");
    
39.         flag = 0;
    
40.         return (i + 10);
    
41. }
    
42. /*
    
43. * char_open 是打开设备时调用的函数, try_module_get()表示当前模块正在被使用中
    
44. */ 
    
45. static int char_open(struct inode *i, struct file* filp)
    
46. {
    
47.         printk("char_open is called\n");
    
48.         try_module_get(THIS_MODULE);
    
49.         return 0;
    
50. }
    
51. 
    
52. static int char_release(struct inode *i, struct file* filp)
    
53. {
    
54.         module_put(THIS_MODULE);
    
55.         return 0;
    
56. }
    
57. /*
    
58. * char_read 是读设备时调用的函数, 首先使用信号量完成互斥操作, 然后进行定时器的初始化, 5*HZ表示等待5秒钟. 
    
59. * 最后调用copy_to_user将数据拷贝给用户态的程序.
    
60. */ 
    
61. static ssize_t char_read(struct file* filp, char *buffer, size_t count, loff_t *ppos)
    
62. {
    
63.         int ret = 0;
    
64.         if (down_interruptible(&my_lock))
    
65.                 return -ERESTARTSYS;
    
66.         printk("char_read is called\n");
    
67.         init_timer(&my_timer);
    
68.         my_timer.expires = jiffies + 5 * HZ;
    
69.         my_timer.data = 0;
    
70.         my_timer.function = my_handler;
    
71.         add_timer(&my_timer);
    
72. 
    
73.         ret = my_read(0);
    
74.         printk("return value is %d\n", ret);
    
75.         del_timer(&my_timer);
    
76.         copy_to_user(buffer, (char*)&ret, sizeof(int));
    
77.         up(&my_lock);
    
78.         return (sizeof(int));
    
79. }
    
80. 
    
81. static struct file_operations char_fops =
    
82. {
    
83.         .open = char_open,
    
84.         .read = char_read,
    
85.         .release = char_release
    
86. };
    
87. 
    
88. static struct cdev *my_cdev;
    
89. /*
    
90. * char_init 模块的注册函数.
    
91. */ 
    
92. static int __init char_init(void)
    
93. {
    
94.         int err;
    
95.         dev_t devid;
    
96.         alloc_chrdev_region(&devid, 0, 1, "chardev");
    
97.         major = MAJOR(devid);
    
98.         my_cdev = cdev_alloc();
    
99.         cdev_init(my_cdev, &char_fops);
    
100.         err = cdev_add(my_cdev, devid, 1);
     
101.         if (err)
     
102.         {
     
103.                 printk("error\n");
     
104.                 return -1;
     
105.         }
     
106.         printk("The major number is %d\n", major);
     
107.         init_MUTEX(&my_lock);
     
108.         init_waitqueue_head(&my_wait);
     
109.         return 0;
     
110. }
     
111. 
     
112. static void __exit char_exit(void)
     
113. {
     
114.         cdev_del(my_cdev);
     
115.         printk("rmmod is called\n");
     
116. }
     
117. 
     
118. module_init(char_init);
     
119. module_exit(char_exit);

复制代码

下面对代码进行一些简要的说明.
1. 首先是char_init函数, 该函数完成了对字符设备的注册功能. 如果注册成功, 则输出字符设备的主设备号. 另一方面, 还完成了对信号量的初始化, 以及对等待队列的初始化. 因此, 当insmod结束之后, 正常情况下就完成了对字符设备的注册等一系列的初始化动作了. 
2. 然后再看打开设备的操作char_open. 当你在程序中调用open时, 就会去调用这个函数. 这个函数中有一个try_module_get(THIS_MODULE);它表示当前这个模块处于使用之中. 此时通过lsmod可以看到used一栏中不为0. 如果此时调用rmmod去卸载这个模块, 则会出错. 提示当前模块正在使用中, 不能被卸载. 
3. 打开之后就是去读这个字符设备. 此时在程序中调用read时, 就会去调用模块中的char_read这个函数. 这个函数首先调用down_interruptible函数, 进行锁定. 这样, 只有一个进程能够运行char_read这个函数. 然后再是初始化定时器. 时间为5秒钟. 之后再去调用my_read这个函数. 在这个函数中检查flag是否为0, 如果为0了, 则将当前进程放到等待队列中去, 等待其它的进程将自己唤醒. 当过了五秒钟之后, 由于定时器的作用, 调用了my_handler这个函数, 它一方面将flag的值设为1, 另一方面调用wake_up_interruptible将该等待队列上的进程唤醒. 因此, 此时my_read函数又开始继续往下面执行了. 剩下的工作就是删除定时器, 并将值传递给用户态的程序. 
4. 最后用户态的程序调用close()时则关于了这个设备, 此时调用了module_put(THIS_MODULE); 与之前的try_module_get相对应, 即表示当前模块没有被占用, 此时可以调用rmmod将模块卸载掉.

下面就编写一个用户态的程序来试验这个字符设备
test.c

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<unistd.h>
   
4. #include<fcntl.h>
   
5. #include<sys/types.h>
   
6. 
   
7. int main()
   
8. {
   
9.         int fd;
   
10.         int i;
    
11.         fd = open("/dev/chardev", O_RDONLY);
    
12.         if (fd < 0)
    
13.         {
    
14.                 printf("error\n");
    
15.                 return -1;
    
16.         }
    
17. 
    
18.         if (read(fd, &i, sizeof(int)) < 0)
    
19.         {
    
20.                 printf("read error\n");
    
21.                 return -1;
    
22.         }
    
23.         printf("i = %d\n", i);
    
24.         return 0;
    
25. }

复制代码

最后是实验步骤.
1. 首先编写Makefile. 

1. obj-m+=mytime.o
   
2. KERNELDIR:=/lib/modules/$(shell uname -r)/build
   
3. 
   
4. default:
   
5.         make -C $(KERNELDIR) M=$(shell pwd) modules
   
6. install:
   
7.         insmod mytime.ko
   
8. uninstall:
   
9.         rmmod mytime.ko
   
10. clean:
    
11.         make -C $(KERNELDIR) M=$(shell pwd) clean

复制代码

2. 在当前目录下使用make进行编译, 然后再使用make install将模块加载进内核. 此时使用dmesg可以查看系统给该字符设备分配的设备号是多少. 假如为253. 则创建该字符设备. mknod /dev/chardev c 253 0
3. 编译test.c, 然后运行, 在运行时, 其等待了5秒钟, 即为等待定时器的那个过程. 最后得到输出的结果. 此时再通过dmesg命令可以查看模块中函数的调用过程. 
4. 实验完之后调用make uninstall卸载该模块, 并调用make clean清除一些临时文件. 

下面的结果为我在自己的机器上运行后通过dmesg打印出来的结果.

The major number is 253
char_open is called
char_read is called
waiting...
in handler function
wake it up
I am waked
return value is 10

    另外, 如果test程序在等待时执行rmmod chardev时会提示设备正在忙. 就是前面的try_module_get()所引起的. 同时如果在两个终端运行test这个程序, 则第二个test程序会阻塞, 并在第一个test程序结束之后才得以执行. 防止了并发. 
    上面对字符设备的注册, 信号量, 等待队列以及定时器的使用作了一个简单的介绍, 当然, LDD3前七章的内容远不止这些. 还有很多需要去参透的地方.  
    我以前第一次看LDD的时候, 对里面的很多东西也不理解, 第一次看完之后完全不知道自己看了什么. 所以写这篇文章希望能对刚开始看LDD的朋友有一点用处.