对LDD3前七章的一个小节

scutan

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

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

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

复制代码

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

1. 
   
2. obj-m+=mytime.o
   
3. KERNELDIR:=/lib/modules/$(shell uname -r)/build
   
4. 
   
5. default:
   
6.         make -C $(KERNELDIR) M=$(shell pwd) modules
   
7. install:
   
8.         insmod mytime.ko
   
9. uninstall:
   
10.         rmmod mytime.ko
    
11. clean:
    
12.         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的朋友有一点用处.

[ 本帖最后由 scutan 于 2007-11-12 21:37 编辑 ]

xuxd32

很好，要仔细品味  很好，要仔细品味

xuxd32

确实看ldd3时，真的是云里雾里。硬着头皮望下看。多记，回头看，才有一点收获。
多谢楼主能总结，这样对于锁，信号，就能知怎样用.

scutan

原帖由 xuxd32 于 2007-11-13 17:08 发表
确实看ldd3时，真的是云里雾里。硬着头皮望下看。多记，回头看，才有一点收获。
多谢楼主能总结，这样对于锁，信号，就能知怎样用.

我以前看的时候也是这样的, 主要是对内核整体没有什么感觉.
建议将LKD与LDD结合起来看效果会好一些. 将这两本看完之后再去看ULK就应该轻松多了.

xuxd32

今天我看了您的code。才google了一些spin_lock和semaphore了解一些，以前，总是在记忆嘛。有些时候，多记也许才能找到出路。以前看的一些，没有您code全面。很有收获。到是希望。有更多的论坛朋友，能想您一样，总结出来就好了。我可能想去华清远见培训一下，不知有没有人知道那里怎么样。当然，以自己为主嘛。可能会系统一点。不然，自学知识太散。什么都知一点，又什么都不能用。呵呵。

xuxd32

LKD我还不知道是什么书呢。我去google一下.

xuxd32

如果有空，那里有电子版下载。请您说一下.

xuxd32

我在论坛上找到了是linux内核开发。我去找找。

scutan

原帖由 xuxd32 于 2007-11-14 15:36 发表
如果有空，那里有电子版下载。请您说一下.

LKD是指<Linux Kernel Development>.
我这儿有电子书.

xuxd32

谢谢您。成都的朋友。我昨天也在论坛上找了一个，可是，没有办法解压。所以，不行。今天早上来看论坛。您这儿共享了。很高兴哟。