异步通知fasync

「爱情、让人受尽委屈。」 2022-03-28 02:52 310阅读 0赞

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

异步通知fasync是应用于系统调用signal和sigaction函数，下面我会使用signal函数。简单的说，signal函数就是让一个信号与与一个函数对应，没当接收到这个信号就会调用相应的函数。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、什么是异步通知

个人认为，异步通知类似于中断的机制，如下面的将要举例的程序，当设备可写时，设备驱动函数发送一个信号给内核，告知内核有数据可读,在条件不满足之前，并不会造成阻塞。而不像之前学的阻塞型IO和poll，它们是调用函数进去检查，条件不满足时还会造成阻塞。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、应用层中启用异步通知机制

其实就三个步骤：

1）signal(SIGIO, sig\_handler);

调用signal函数，让指定的信号SIGIO与处理函数sig\_handler对应。

2）fcntl(fd, F\_SET\_OWNER, getpid());

指定一个进程作为文件的“属主(filp->owner)”，这样内核才知道信号要发给哪个进程。

3）f\_flags = fcntl(fd, F\_GETFL);

fcntl(fd, F\_SETFL, f\_flags | FASYNC);

在设备文件中添加FASYNC标志，驱动中就会调用将要实现的test\_fasync函数。

三个步骤执行后，一旦有信号产生，相应的进程就会收到。

来个应用程序：

/\*3rd\_char\_7/1st/app/monitor.c\*/

1 \#include <stdio.h>

2 \#include <sys/types.h>

3 \#include <sys/stat.h>

4 \#include <fcntl.h>

5 \#include <sys/select.h>

6 \#include <unistd.h>

7 \#include <signal.h>

8

9 unsigned int flag;

10

11 void sig\_handler(int sig)

12 \{

13 printf("<app>%s\\n", \_\_FUNCTION\_\_);

14 flag = 1;

15 \}

16

17 int main(void)

18 \{

19 char buf\[20\];

20 int fd;

21 int f\_flags;

22 flag = 0;

23

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

25 if(fd < 0)

26 \{

27 perror("open");

28 return -1;

29 \}

30 /\*三个步骤\*/

31 signal(SIGIO, sig\_handler);

32 fcntl(fd, F\_SETOWN, getpid());

33 f\_flags = fcntl(fd, F\_GETFL);

34 fcntl(fd, F\_SETFL, FASYNC | f\_flags);

35

36 while(1)

37 \{

38 printf("waiting \\n"); //在还没收到信号前，程序还在不停的打印

39 sleep(4);

40 if(flag)

41 break;

42 \}

43

44 read(fd, buf, 10);

45 printf("finish: read\[%s\]\\n", buf);

46

47 close(fd);

48 return 0;

49 \}

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、驱动中需要实现的异步通知

上面说的三个步骤，内核已经帮忙实现了前两个步骤，只需要我们稍稍实现第三个步骤的一个简单的传参。

实现异步通知，内核需要知道几个东西：哪个文件(filp)，什么信号(SIGIIO)，发给哪个进程(pid)，收到信号后做什么(sig\_handler)。这些都由前两个步骤完成了。

回想一下，在实现等待队列中，我们需要将一个等待队列wait\_queue\_t添加到指定的等待队列头wait\_queue\_head\_t中。

在这里，同样需要把一个结构体struct fasync\_struct添加到内核的异步队列头(名字是我自己取的)中。这个结构体用来存放对应设备文件的信息(如fd, filp)并交给内核来管理。一但收到信号，内核就会在这个所谓的异步队列头找到相应的文件(fd)，并在filp->owner中找到对应的进程PID，并且调用对应的sig\_handler了。

看一下fasync\_struct

1097 struct fasync\_struct \{

1098 int magic;

1099 int fa\_fd;

1100 struct fasync\_struct \*fa\_next; /\* singly linked list \*/ //一看就觉得他是链表

1101 struct file \*fa\_file;

1102 \};

上面红色标记说所的步骤都是由内核来完成，我们只要做两件事情：

1）定义结构体fasync\_struct。

struct fasync\_struct \*async\_queue;

2）实现test\_fasync，把函数fasync\_helper将fd,filp和定义的结构体传给内核。

108 int test\_fasync (int fd, struct file \*filp, int mode)

109 \{

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

111

112 return fasync\_helper(fd, filp, mode, &dev->async\_queue);

113 \}

讲一下函数fasync\_helper:

int fasync\_helper(int fd, struct file \* filp, int on, struct fasync\_struct \*\*fapp)

一看就知道，前面的三个参数其实就是teat\_fasync的三个参数，只要我们定义号的fasync\_struct结构体也传进去就可以了。内核会完成我上面红色自己所说的事情。

另外还有两件事：

3）当设备可写时，调用函数kill\_fasync发送信号SIGIO给内核。

83 if (dev->async\_queue)\{

84 kill\_fasync(&dev->async\_queue, SIGIO, POLL\_IN);

85 \}

讲解一下这个函数：

void kill\_fasync(struct fasync\_struct \*\*fp, int sig, int band)

sig就是我们要发送的信号。

band(带宽)，一般都是使用POLL\_IN，表示设备可读，如果设备可写，使用POLL\_OUT

4）当设备关闭时，需要将fasync\_struct从异步队列中删除：

117 test\_fasync(-1, filp, 0);

删除也是调用test\_fasync，不过改了一下参数而已。

既然说完了就上程序：上面的函数需要包含<linux/fs.h>

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

23 struct \_test\_t\{

24 char kbuf\[DEV\_SIZE\];

25 unsigned int major;

26 unsigned int minor;

27 unsigned int cur\_size;

28 dev\_t devno;

29 struct cdev test\_cdev;

30 wait\_queue\_head\_t test\_queue;

31 wait\_queue\_head\_t read\_queue;

32 wait\_queue\_head\_t write\_queue;

33 struct fasync\_struct \*async\_queue; //1.定义结构体

34 \};

。。。。省略。。。。

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

69 \{

70 int ret;

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

72

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

74 ret = - EFAULT;

75 \}else\{

76 ret = count;

77 dev->cur\_size += count;

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

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

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

81 wake\_up\_interruptible(&dev->read\_queue);

82

83 if (dev->async\_queue)\{

84 kill\_fasync(&dev->async\_queue, SIGIO, POLL\_IN); //3.可写时发送信号

85 \}

86 \}

87

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

89 \}

。。。。省略。。。。

108 int test\_fasync (int fd, struct file \*filp, int mode) //2.实现test\_fasync

109 \{

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

111

112 return fasync\_helper(fd, filp, mode, &dev->async\_queue);

113 \}

114

115 int test\_close(struct inode \*node, struct file \*filp)

116 \{

117 test\_fasync(-1, filp, 0); //4文件关闭时将结构体从伊部队列中删除

118 return 0;

119 \}

120

121 struct file\_operations test\_fops = \{

122 .open = test\_open,

123 .release = test\_close,

124 .write = test\_write,

125 .read = test\_read,

126 .poll = test\_poll,

127 .fasync = test\_fasync, //此步骤切记

128 \};

.。。。。。。

程序写完了就得验证一下：

\[root: app\]\# insmod ../test.ko

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

hello kernel

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

\[root: app\]\# ./monitor& //后台运行monitor

waiting

\[root: app\]\# waiting //不停的打印，没有休眠

waiting

waiting

waiting

waiting

waiting

\[root: app\]\# ./app\_write //调用函数写数据，

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

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

<app>s<kernel>\[test\_read\]read data..... //写完后minoter接收到信号，跳出循环读数据

<kernel>\[test\_read\]read 10 bytes, cur\_size:\[0\]

ig\_handler //这是在sig\_hanler里面打印的，本应出现在读函数之前，因为各个函数抢着打印，所以，出现了乱序，不过不影响验证。

finish: read\[xiao bai\]

\[1\] + Done ./monitor

贴张图总结一下：

![25014876_1293609596uR26.png][]

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、阻塞型IO、poll和异步通知的区别：

宋宝华书上的图，描述的挺好的：图片不态清晰，将就一下。

![25014876_1293609617f2kD.png][]

一个最重要的区别：

1）异步通知是不会造成阻塞的。

2）调用阻塞IO时如果条件不满足，会在驱动函数中的test\_read或test\_write中阻塞。

3）如果条件不满足，selcet会在系统调用中阻塞。

所谓的异步，就是进程可以在信号没到前干别的事情，等到信号到来了，进程就会被内核通知去做相应的信号操作。进程是不知道信号什么时候来的。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五，总结

今天只是讲了异步通知在内核中的实现，并且对应的应用函数和驱动函数需要做什么事情。最后总结了一下阻塞IO、poll和异步通知的区别。

[25014876_1293609596uR26.png]: http://blog168.chinaunix.net/attachment/201012/29/25014876_1293609596uR26.png
[25014876_1293609617f2kD.png]: http://blog168.chinaunix.net/attachment/201012/29/25014876_1293609617f2kD.png

发表评论取消回复

表情：

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

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

相关阅读

相关异步通知

要弄明白这个问题，我们得从最基本的原理开始。我们知道，驱动程序运行在内核空间中，应用程序运行在用户空间中，两者是不能直接通信的。但在实际应用中，在设备已经准备好的时候，我们

本是古典何须时尚/ 2022年09月29日 10:58/ 0 赞/ 178 阅读

相关 angularJS系列之$q处理异步通知

代码结构 ![这里写图片描述][20160707140238506] html代码 <!DOCTYPE html> <html ng-app="d

「爱情、让人受尽委屈。」/ 2022年09月23日 08:22/ 0 赞/ 169 阅读

相关 zookeeper系列之异步通知模式-Watcher

Watcher介绍 Watcher是Zookeeper用来实现distribute lock, distribute configure, distribute queue等

秒速五厘米/ 2022年05月28日 10:05/ 0 赞/ 164 阅读

相关 springboot中使用redis实现异步消息通知

为什么我要用redis来完成异步消息,而不是消息队列mq之类的? 1. 因为很多的单体项目可能只需要需要一个略微简单的消息通知,而不需要如kafka那种完善的消息队列,

客官°小女子只卖身不卖艺/ 2022年04月17日 01:05/ 0 赞/ 790 阅读

相关异步通知fasync

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

「爱情、让人受尽委屈。」/ 2022年03月28日 02:52/ 0 赞/ 311 阅读

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

相关 php 微信退款,异步通知实现

需要注意的事项： 1.微信退款到零钱要求必传证书，需要到[https://pay.weixin.qq.com][https_pay.weixin.qq.com] 账户中

快来打我*/ 2022年03月14日 15:12/ 0 赞/ 578 阅读

相关 Spring_事件通知实例_进程内异步

Spring事件监听实现了观察者模式。主要有三个类：事件类、监听器类、事件发布类（入口） 1、事件类 package com.listen.demo.eve

ゞ浴缸里的玫瑰/ 2022年01月17日 03:15/ 0 赞/ 190 阅读

相关使用php服务异步通知

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][] 今天代码在审核注册用户通过时，发送会员短信。发现系统页面

我不是女神ヾ/ 2022年01月15日 23:47/ 0 赞/ 322 阅读

相关 java项目测试支付异步通知接口

个人资源与分享网站：[http://xiaocaoshare.com/][http_xiaocaoshare.com] 1、需求说明在进行支付的时候，总会有一个异步通知接

小咪咪/ 2021年09月24日 03:32/ 0 赞/ 268 阅读