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

àì夳堔傛蜴生んèń 2022-03-20 19:40 346阅读 0赞

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

一个最重要的区别：

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

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

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

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五，总结

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

发表评论取消回复

表情：

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

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

相关阅读

相关异步通知fasync

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

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

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

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

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

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

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

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

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

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

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

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

相关 linux设备驱动归纳总结（十）：1.udev&misc

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

骑猪看日落/ 2022年03月19日 03:56/ 0 赞/ 310 阅读

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

相关 linux设备驱动归纳总结（七）：2.内核定时器

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

￡神魔★判官ぃ/ 2022年03月19日 03:53/ 0 赞/ 268 阅读