linux设备驱动归纳总结（三）：5.阻塞型IO实现

今天药忘吃喽~ 2022-03-20 19:28 174阅读 0赞

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、休眠简介：

进程休眠，简单的说就是正在运行的进程让出CPU。休眠的进程会被内核搁置在在一边，只有当内核再次把休眠的进程唤醒，进程才会会重新在CPU运行。这是内核中的进程调度，以后的章节会介绍。

现在应该先知道这样的一个概念，一个CPU在同一时间只能有一个进程在运行，在宏观上，我们觉得是所有进程同时进行的。实际上并不是这样，内核给每个进程分配了4G的虚拟内存，并且让每个进程傻乎乎的以为自己霸占着CPU运行。同时，内核暗中的将所有的进程按一定的算法将CPU轮流的给每个进程使用，而休眠就是进程没有被运行时的一种形式。在休眠下，进程不占用CPU，等待被唤醒。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、阻塞型IO的实现：

知道什么是休眠，接下来就好办了。接下来就是要实现阻塞型的read和write函数，函数将实现一下功能：

read：当没数据可读时，函数让出CPU，进入休眠状态，等待write写入数据后唤醒read。

write：写入数据，并唤醒read。

先上函数：我只上需要修改的函数，open和release就不贴了

/\*3rd\_char\_5/1st/test.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

3 \#include <linux/fs.h>

4 \#include <linux/cdev.h>

5

6 \#include <linux/wait.h>

7 \#include <linux/sched.h>

8

9 \#include <asm/uaccess.h>

10 \#include <linux/errno.h>

11

12 \#define DEBUG\_SWITCH 1

13 \#if DEBUG\_SWITCH

14 \#define P\_DEBUG(fmt, args...) printk("<1>" "<kernel>\[%s\]"fmt, \_\_FUNCT ION\_\_, \#\#args)

15 \#else

16 \#define P\_DEBUG(fmt, args...) printk("<7>" "<kernel>\[%s\]"fmt, \_\_FUNCT ION\_\_, \#\#args)

17 \#endif

18

19 \#define DEV\_SIZE 100

20

21 struct \_test\_t\{

22 char kbuf\[DEV\_SIZE\];

23 unsigned int major;

24 unsigned int minor;

25 unsigned int cur\_size;

26 dev\_t devno;

27 struct cdev test\_cdev;

28 wait\_queue\_head\_t test\_queue; //1、定义等待队列头

29 \};

30

。。。。。。省略。。。。。。。

43

44 ssize\_t test\_read(struct file \*filp, char \_\_user \*buf, size\_t count, loff\_t \*offset)

45 \{

46 int ret;

47 struct \_test\_t \*dev = filp->private\_data;

48

49 /\*休眠\*/

50 P\_DEBUG("read data.....\\n");

51 if(wait\_event\_interruptible(dev->test\_queue, dev->cur\_size > 0))

52 return - ERESTARTSYS;

53

54 if (copy\_to\_user(buf, dev->kbuf, count))\{

55 ret = - EFAULT;

56 \}else\{

57 ret = count;

58 dev->cur\_size -= count;

59 P\_DEBUG("read %d bytes, cur\_size:\[%d\]\\n", count, dev->cur\_size);

60 \}

61

62 return ret; //返回实际写入的字节数或错误号

63 \}

64

65 ssize\_t test\_write(struct file \*filp, const char \_\_user \*buf, size\_t count, loff\_t \*offset)

66 \{

67 int ret;

68 struct \_test\_t \*dev = filp->private\_data;

69

70 if(copy\_from\_user(dev->kbuf, buf, count))\{

71 ret = - EFAULT;

72 \}else\{

73 ret = count;

74 dev->cur\_size += count;

75 P\_DEBUG("write %d bytes, cur\_size:\[%d\]\\n", count, dev->cur\_size);

76 P\_DEBUG("kbuf is \[%s\]\\n", dev->kbuf);

77 /\*唤醒\*/

78 wake\_up\_interruptible(&dev->test\_queue);

79 \}

80

81 return ret; //返回实际写入的字节数或错误号

82 \}

83

84 struct file\_operations test\_fops = \{

85 .open = test\_open,

86 .release = test\_close,

87 .write = test\_write,

88 .read = test\_read,

89 \};

90

91 struct \_test\_t my\_dev;

92

93 static int \_\_init test\_init(void) //模块初始化函数

94 \{

95 int result = 0;

96 my\_dev.cur\_size = 0;

97 my\_dev.major = 0;

98 my\_dev.minor = 0;

99

100 if(my\_dev.major)\{

101 my\_dev.devno = MKDEV(my\_dev.major, my\_dev.minor);

102 result = register\_chrdev\_region(my\_dev.devno, 1, "test new driver") ;

103 \}else\{

104 result = alloc\_chrdev\_region(&my\_dev.devno, my\_dev.minor, 1, "test alloc diver");

105 my\_dev.major = MAJOR(my\_dev.devno);

106 my\_dev.minor = MINOR(my\_dev.devno);

107 \}

108

109 if(result < 0)\{

110 P\_DEBUG("register devno errno!\\n");

111 goto err0;

112 \}

113

114 printk("major\[%d\] minor\[%d\]\\n", my\_dev.major, my\_dev.minor);

115

116 cdev\_init(&my\_dev.test\_cdev, &test\_fops);

117 my\_dev.test\_cdev.owner = THIS\_MODULE;

118 /\*初始化等待队列头，注意函数调用的位置\*/

119 init\_waitqueue\_head(&my\_dev.test\_queue);

120

121 result = cdev\_add(&my\_dev.test\_cdev, my\_dev.devno, 1);

122 if(result < 0)\{

123 P\_DEBUG("cdev\_add errno!\\n");

124 goto err1;

125 \}

126

127 printk("hello kernel\\n");

128 return 0;

129

130 err1:

131 unregister\_chrdev\_region(my\_dev.devno, 1);

132 err0:

133 return result;

134 \}

为了方便讲解，函数我精简了很多，红色好亮代码是新加的知识点，其他都是之前已经讲过的。

下面开始介绍上面使用的知识：

知识1）什么是等待队列。

前面说了进程休眠，而其他进程为了能够唤醒休眠的进程，它必须知道休眠的进程在哪里，出于这样的原因，需要有一个称为等待队列的结构体。等待队列是一个存放着等待某个特定事件进程链表。

在这里的程序，用于存放等待唤醒的进程。

既然是队列，当然要有个队列头，在使用等待队列之前，必须先定义并初始化等待队列头。

先看一下队列头的样子：

/\*linux/wait.h\*/

50 struct \_\_wait\_queue\_head \{

51 spinlock\_t lock; //这个是自旋锁，在这里不需要理会。

52 struct list\_head task\_list; //这就是队列头中的核心，链表头。

53 \};

54 typedef struct \_\_wait\_queue\_head wait\_queue\_head\_t;

说白了就是定义并初始化一个链表。以后就能够在这个链表添加需要等待的进程了。

定义并初始化队列头有两种方法：

1）静态定义并初始化，一个函数执行完两个操作。省力又省心。

DECLARE\_WAIT\_QUEUE\_HEAD(name)

使用：定义并初始化一个叫name的等待队列。

2）分开两步执行。

2.1）定义

wait\_queue\_head\_t test\_queue;

2.2）初始化

init\_waitqueue\_head(&test\_queue);

我使用的是第二种方法，这些都是在加载模块时应该完成的操作。其中，等待队列头的定义我放在”struct \_test\_t”结构体中，初始化放在模块加载函数中。

这里值得注意的是初始化函数的位置，它必须在cdev添加函数”cdev\_add”前。因为”cdev\_add”执行成功就意味着设备可以被操作，设备被操作前当然需要把所有的事情都干完，包括等待队列的初始化。

知识2）进程休眠

在test\_read函数中就实现了进程休眠，使用了函数”wait\_evenr\_interruptible”。

wait\_event\_interruptible(wq, condition)

使用：

如果condition为真，函数将进程添加到等待队列头wq并等待唤醒。

返回值：

添加成功返回0。另外，interruptition的意思是休眠进程可以被某个信号中断中断，如果被中断，驱动程序应该返回\-ERESTARTSYS。

这有一类的函数，操作跟”wait\_evevt\_interruptition”类似

wait\_event(queue, condition)

/\*函数成功会进入不可中断休眠,不推荐\*/  
wait\_event\_interruptible(queue, condition)

/\*函数调用成功会进入可中断休眠，推荐，返回非零值意味着休眠被中断,且驱动应返回\-ERESTARTSYS\*/  
wait\_event\_timeout(queue, condition, timeout)  
wait\_event\_interruptible\_timeout(queue, condition, timeout)  
/\*比上面两个函数多了限时功能，若休眠超时，则不管条件为何值返回0，\*/

上面的四个函数大致都是完成一下的操作：

以wait\_event\_interruptible(dev->test\_queue, dev->cur\_size > 0)举例：

1、定义并初始化一个wait\_queue\_t结构体，然后将它添加到等待队列test\_queue中。

2、更改进程的状态，休眠的状态有两种：（可中断休眠）TASK\_INTERRUPTIBLE和（不可中断休眠）TASK\_UNINTERRUPTIBLE。上面的函数会切换到可中断休眠。

3、判断条件 dev->cur\_size > 0是否成立，如果不成立，则调用函数schedule()让出CPU。注意，一旦让出CPU进入休眠后，进程再次被唤醒后就会从这一步开始，再次检测条件是否成立，如果还是不成立，继续让出CPU，等待下一次的唤醒。如果成立，则进行下一步的操作。所以，这个函数的条件会被多次判断，因此这个判断语句并不能对这个进程带来任何副作用。

4、条件成立后做一些相应的清理工作，并把进程状态更改为TASK\_RUNNING。

我刚学的时候还在纳闷，为什么定义了一个队列头后，就可以在test\_read函数直接根据条件进入休眠？

现在我总算是明白了。进程休眠是需要在等待队列添加一个wait\_queue\_t结构体，但是上面的休眠函数内部已经帮我们实现了这个操作。

既然上面的函数有四个操作，内核肯定会有拆分出来的操作。这就是《linux设备驱动程序》（第三版）P155上面讲的高级休眠。有兴趣可以自己看书。

知识3）唤醒休眠进程。

在test\_write函数中使用wake\_up\_interruptible(&dev->test\_queue)唤醒指定等待队列中睡眠的进程。

这里也有两个类似的函数：

void wake\_up(wait\_queue\_head\_t \*queue); //唤醒等待队列中所有休眠的进程  
void wake\_up\_interruptible(wait\_queue\_head\_t \*queue); //唤醒等待队列中所有可中断睡眠的进程

一般来说，用 wake\_up 唤醒 wait\_event ；用 wake\_up\_interruptible 唤醒wait\_event\_interruptible。

一旦上面的函数调用成功，等待队列里面所有符合休眠状态的进程都会被唤醒，所有进程都会执行上面说的休眠函数的第三步——轮流占用CPU来是判断时候否符合条件。一旦有一个进程符合条件，那个进程就会运行下去，其他进程变回原来的休眠状态等待下一次的被唤醒。如果全部都不符合，全部都会变回原来的休眠状态。

《linux设备驱动程序》P160有介绍独占等待的概念，大概的意思就是不要让所有符号休眠状态的进程同时被唤醒，只唤醒其中的一个。

知识点已经介绍完，总结一下上面驱动函数的操作：

1）首先需要定义并初始化一个等待队列。

2）test\_read函数中，如果条件不符合，调用该函数的进程就会进入休眠。

3）每当另一个进程调用test\_write函数唤醒等待队列，test\_read中的函数就会再一次判断条件是否符合，如果不符合，就会继续休眠，直到哪次的唤醒时条件符合。

写两个应用程序验证驱动：

/\*app\_read.c\*/

1 \#include <stdio.h>

2 \#include <sys/types.h>

3 \#include <sys/stat.h>

4 \#include <fcntl.h>

5

6 int main(void)

7 \{

8 char buf\[20\];

9 int fd;

10 int ret;

11

12 fd = open("/dev/test", O\_RDWR);

13 if(fd < 0)

14 \{

15 perror("open");

16 return -1;

17 \}

18

19 read(fd, buf, 10);

20 printf("<app>buf is \[%s\]\\n", buf);

21

22 close(fd);

23 return 0;

24 \}

/\*app\_write\*/

1 \#include <stdio.h>

2 \#include <sys/types.h>

3 \#include <sys/stat.h>

4 \#include <fcntl.h>

5

6 int main(void)

7 \{

8 char buf\[20\];

9 int fd;

10 int ret;

11

12 fd = open("/dev/test", O\_RDWR);

13 if(fd < 0)

14 \{

15 perror("open");

16 return -1;

17 \}

18

19 write(fd, "xiao bai", 10);

20

21 close(fd);

22 return 0;

23 \}

验证一下：

\[root: 1st\]\# insmod test.ko

major\[253\] minor\[0\]

hello kernel

\[root: 1st\]\# mknod /dev/test c 253 0

\[root: 1st\]\# ./app\_read& //先后台运行app\_read

<kernel>\[test\_read\]read data..... //因为没有数据，程序阻塞

\[root: 1st\]\# ./app\_write //再运行app\_write

<kernel>\[test\_write\]write 10 bytes, cur\_size:\[10\]

<kernel>\[test\_write\]kbuf is \[xiao bai\]

<kernel>\[test\_read\]read 10 bytes, cur\_size:\[0\] //read继续执行

<app>buf is \[xiao bai\] //打印读到的内容

\[1\] + Done ./app\_read

\[root: 1st\]\#

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、非阻塞型操作的实现

上面的程序虽然不是很完善，但基本的功能已经实现了，但还有一个问题需要解决，当我们在应用层以非阻塞方式打开文件时，读写操作不满足条件时并不阻塞，而是直接返回。

实现非阻塞操作也很简单，判断filp->f\_flags中的是否存在O\_NONBLOCK标志（标志在<linux/fcntl.h>定义，并被<linux/fs.h>自动包含），如果有就返回\-EAGAIN。

贴上修改后的程序，其实就加了两行：

/\*3rd\_char\_5/2nd/test.c\*/

44 ssize\_t test\_read(struct file \*filp, char \_\_user \*buf, size\_t count, loff\_t \*offset)

45 \{

46 int ret;

47 struct \_test\_t \*dev = filp->private\_data;

48

49 if(filp->f\_flags & O\_NONBLOCK)

50 return - EAGAIN;

51

52 /\*休眠\*/

53 P\_DEBUG("read data.....\\n");

54 if(wait\_event\_interruptible(dev->test\_queue, dev->cur\_size > 0))

55 return - ERESTARTSYS;

56

57 if (copy\_to\_user(buf, dev->kbuf, count))\{

58 ret = - EFAULT;

59 \}else\{

60 ret = count;

61 dev->cur\_size -= count;

62 P\_DEBUG("read %d bytes, cur\_size:\[%d\]\\n", count, dev->cur\_size);

63 \}

64

65 return ret; //返回实际写入的字节数或错误号

66 \}

再来个应用程序：

2 \#include <sys/types.h>

3 \#include <sys/stat.h>

4 \#include <fcntl.h>

5 \#include <errno.h>

6

7 int main(void)

8 \{

9 char buf\[20\];

10 int fd;

11 int ret;

12

13 fd = open("/dev/test", O\_RDWR | O\_NONBLOCK);

14 if(fd < 0)

15 \{

16 perror("open");

17 return -1;

18 \}

19

20 ret = read(fd, buf, 10);

21 if (ret = -1) 检查错误的原因

22 \{

23 perror("open");

24 printf("errno = %d\\n", errno);

25 \}

26 else

27 \{

28 printf("<app>buf is \[%s\]\\n", buf);

29 \}

30

31 close(fd);

32 return 0;

33 \}

验证一下：

\[root: 2nd\]\# ./app\_read

open: Resource temporarily unavailable

errno = 29 //这就是\-EAGAIN错误号返回给用户态的errno

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、总结

上面讲了四个内容：

1什么是休眠.

2什么是等待队列

3怎么通过等待队列把进程休眠

4怎么唤醒进程

其中有三处处扩展：

1我只是实现了read的阻塞性IO，在一般的驱动中，write也是有阻塞功能的，大家可以尝试实现。

2我只介绍了如何使用最简单的函数把进程休眠，在《linux设备驱动程序》有介绍高级休眠，其实就是细说wait\_event的内部是用什么函数实现——我上面讲述的四个步骤。

3.唤醒进程时的高级操作——独占等待。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

发表评论取消回复

表情：

评论列表（有 0 条评论，174人围观）

还没有评论，来说两句吧...

相关阅读

相关 linux设备驱动归纳总结（六）：1.中断的实现

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

分手后的思念是犯贱/ 2022年04月23日 10:56/ 0 赞/ 206 阅读

相关 Linux设备驱动——阻塞型I/O

在Linux驱动中，有时候驱动程序有时候无法立即响应用户的需要，比如：read的时候没有数据返回给用户，或者write的时候缓冲区满了。在这种情况下驱动程序应该阻塞该进程，将

浅浅的花香味﹌/ 2022年04月12日 14:00/ 0 赞/ 208 阅读

相关 linux设备驱动归纳总结（三）：7.异步通知fasync

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

àì夳堔傛蜴生んèń/ 2022年03月20日 19:40/ 0 赞/ 324 阅读

相关 linux设备驱动归纳总结（三）：6.poll和sellct

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

朴灿烈づ我的快乐病毒、/ 2022年03月20日 19:39/ 0 赞/ 180 阅读

相关 linux设备驱动归纳总结（三）：5.阻塞型IO实现

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

今天药忘吃喽~/ 2022年03月20日 19:28/ 0 赞/ 175 阅读

相关 linux设备驱动归纳总结（三）：4.ioctl的实现

一、ioctl的简介：虽然在文件操作结构体"struct file\_operations"中有很多对应的设备操作函数，但是有些命令是实在找不到对应的操作函数。如CD-RO

旧城等待，/ 2022年03月20日 19:26/ 0 赞/ 248 阅读

相关 linux设备驱动归纳总结（三）：3.设备驱动面向对象思想和lseek的实现

一、结构体struct file和struct inode 在之前写的函数，全部是定义了一些零散的全局变量。有没有办法整合成到一个结构体当中？这样的话，看起来和用起

古城微笑少年丶/ 2022年03月20日 19:24/ 0 赞/ 206 阅读

相关 linux设备驱动归纳总结（三）：2.字符型设备的操作open、close、read、write

一、文件操作结构体file\_operations 继续上次没讲完的问题，文件操作结构体到底是什么东西，为什么我注册了设备之后什么现象都没有？可以验证文件操作结构体

今天药忘吃喽~/ 2022年03月20日 19:22/ 0 赞/ 272 阅读

相关 linux设备驱动归纳总结（三）：1.字符型设备之设备申请

操作系统：Ubunru 10.04 实验平台：S3C2440 + linux2.6.29内核注：在今后驱动程序的学习中经常需要查看内核源代码，建议大家新加一个内核目录，去

清疚/ 2022年03月20日 19:19/ 0 赞/ 265 阅读

相关 linux设备驱动归纳总结（八）：1.总线、设备和驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

悠悠/ 2022年03月19日 03:54/ 0 赞/ 427 阅读