异步通知

本是古典何须时尚 2022-09-29 10:58 201阅读 0赞

要弄明白这个问题，我们得从最基本的原理开始。我们知道，驱动程序运行在内核空间中，应用程序运行

在用户空间中，两者是不能直接通信的。但在实际应用中，在设备已经准备好的时候，我们希望通知用户

程序设备已经ok，用户程序可以读取了，这样应用程序就不需要一直查询该设备的状态，从而节约了资源

，这就是异步通知。  
好，那下一个问题就来了，这个过程如何实现呢？简单，两方面的工作。  
一 驱动方面：  
1. 在设备抽象的数据结构中增加一个struct fasync\_struct的指针  
2. 实现设备操作中的fasync函数，这个函数很简单，其主体就是调用内核的fasync\_helper函数。  
3. 在需要向用户空间通知的地方(例如中断中)调用内核的kill\_fasync函数。  
4. 在驱动的release方法中调用前面定义的fasync函数  
呵呵，简单吧，就三点。其中fasync\_helper和kill\_fasync都是内核函数，我们只需要调用就可以了。在

1中定义的指针是一个重要参数，fasync\_helper和kill\_fasync会使用这个参数。  
二 应用层方面  
1. 利用signal或者sigaction设置SIGIO信号的处理函数  
2. fcntl的F\_SETOWN指令设置当前进程为设备文件owner  
3. fcntl的F\_SETFL指令设置FASYNC标志  
完成了以上的工作的话，当内核执行到kill\_fasync函数，用户空间SIGIO函数的处理函数就会被调用了。  
呵呵，看起来不是很复杂把，让我们结合具体代码看看就更明白了。  
先从应用层代码开始吧：  
\#include <sys/types.h>  
\#include <sys/stat.h>  
\#include <stdio.h>  
\#include <fcntl.h>  
\#include <signal.h>  
\#include <unistd.h>  
\#define MAX\_LEN 100  
void input\_handler(int num)  
//处理函数，没什么好讲的，用户自己定义  
\{  
　char data\[MAX\_LEN\];  
　int len;    
　//读取并输出STDIN\_FILENO上的输入  
　len = read(STDIN\_FILENO, &data, MAX\_LEN);  
　data\[len\] = 0;  
　printf("input available:%s/n", data);  
\}

main()  
\{  
　int oflags;

//启动信号驱动机制  
　signal(SIGIO, input\_handler);  
  /\*  
  将SIGIO信号同input\_handler函数关联起来，  
  一旦产生SIGIO信号,就会执行input\_handler，  
  有点软中断的意思吧  
  \*/  
　fcntl(STDIN\_FILENO, F\_SETOWN, getpid());  
  /\*  
    STDIN\_FILENO是打开的设备文件描述符,  
    F\_SETOWN用来决定操作是干什么的,    
    getpid()是个系统调用，功能是找到一个进程号pid分配给当前进程  
    整个函数的功能是STDIN\_FILENO设置这个设备文件的主人为当前进程。  
  \*/  
　oflags = fcntl(STDIN\_FILENO, F\_GETFL);  
  /\*得到打开文件描述符的状态\*/  
　fcntl(STDIN\_FILENO, F\_SETFL, oflags | FASYNC);  
  /\*  
   设置文件描述符的状态为oflags | FASYNC属性,  
   一旦文件描述符被设置成具有FASYNC属性的状态，  
   也就是将设备文件切换到异步操作模式。  
   这时系统就会自动调用驱动程序的fasync方法。  
  \*/

//最后进入一个死循环，程序什么都不干了，只有信号能激发input\_handler的运行  
　//如果程序中没有这个死循环，会立即执行完毕  
　while (1);  
\}  
再看驱动层代码，驱动层其他部分代码不变，就是增加了一个fasync方法的实现以及一些改动  
static struct fasync\_struct \*fasync\_queue;  
/\*首先是定义一个结构体，其实这个结构体存放的是一个列表，这个列表保存的是  
  一系列设备文件，SIGIO信号就发送到这些设备上\*/  
static int my\_fasync(int fd, struct file \* filp, int on)    
/\*fasync方法的实现\*/  
\{  
    int retval;  
    retval=fasync\_helper(fd,filp,on,&fasync\_queue);  
    /\*将该设备登记到fasync\_queue队列中去\*/  
    if(retval<0)  
      return retval;  
    return 0;  
\}  
在驱动的release方法中我们再调用my\_fasync方法  
int my\_release(struct inode \*inode, struct file \*filp)  
\{  
 /\*..processing..\*/  
        drm\_fasync(-1, filp, 0);  
        /\*..processing..\*/  
\}

这样后我们在需要的地方（比如中断）调用下面的代码,就会向fasync\_queue队列里的设备发送SIGIO信号

，应用程序收到信号，执行处理程序  
    if (fasync\_queue)  
      kill\_fasync(&fasync\_queue, SIGIO, POLL\_IN);  
好了，这下大家知道该怎么用异步通知机制了吧？

以下是几点说明\[1\]：    
1 两个函数的原型  
int fasync\_helper(struct inode \*inode, struct file \*filp, int mode, struct fasync\_struct \*\*fa);    
一个"帮忙者", 来实现 fasync 设备方法. mode 参数是传递给方法的相同的值, 而 fa 指针指向一个设

备特定的 fasync\_struct \*

void kill\_fasync(struct fasync\_struct \*fa, int sig, int band);    
如果这个驱动支持异步通知, 这个函数可用来发送一个信号到登记在 fa 中的进程.

2.    
fasync\_helper 被调用来从相关的进程列表中添加或去除入口项, 当 FASYNC 标志因一个打开文件而改变

. 它的所有参数除了最后一个, 都被提供给 fasync 方法并且被直接传递. 当数据到达时 kill\_fasync

被用来通知相关的进程. 它的参数是被传递的信号(常常是 SIGIO)和 band, 这几乎都是 POLL\_IN\[25\](但

是这可用来发送"紧急"或者带外数据, 在网络代码里).  
这是 scullpipe 如何实现 fasync 方法的:

static int scull\_p\_fasync(int fd, struct file \*filp, int mode)  
\{  
 struct scull\_pipe \*dev = filp->private\_data;  
 return fasync\_helper(fd, filp, mode, &dev->async\_queue);  
\}

显然所有的工作都由 fasync\_helper 进行. 但是, 不可能实现这个功能在没有一个方法在驱动里的情况

下, 因为这个帮忙函数需要存取正确的指向 struct fasync\_struct (这里是 与dev->async\_queue)的指针, 并且只有驱动可提供这个信息.

当数据到达, 下面的语句必须被执行来通知异步读者. 因为对 sucllpipe 读者的新数据通过一个发出

write 的进程被产生, 这个语句出现在 scullpipe 的 write 方法中.

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

注意, 一些设备还实现异步通知来指示当设备可被写入时; 在这个情况, 当然, kill\_fasnyc 必须被使用

一个 POLL\_OUT 模式来调用.  
\[1\]参考自LLD3