正点原子嵌入式linux驱动开发——异步通知

上一篇笔记中使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的，对于非阻塞方式来说还需要应用程序通过poll函数不断的轮询。最好的方式就是驱动程序能主动向应用程序发出通知，报告自己可以访问，然后应用程序再从驱动程序中读取或写入数据，类似于中断。Linux提供了异步通知这个机制来完成此功能，本章就来学习一下异步通知以及如何在驱动中添加异步通知相关处理代码。

异步通知

异步通知简介

首先来回顾一下“中断”，中断是处理器提供的一种异步机制，配置好中断以后就可以让处理器去处理其他的事情了，当中断发生以后会触发事先设置好的中断服务函数，在中断服务函数中做具体的处理。比如以前学习单片机的时候用到的GPIO按键中断，通过按键去开关蜂鸣器，采用中断以后处理器就不需要时刻的去查看按键有没有被按下，因为按键按下以后会自动触发中断。同样的，Linux应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备，通过阻塞方式访问的话应用程序会处于休眠态，等待驱动设备可以使用。非阻塞方式的话会通过poll函数来不断的轮询，查看驱动设备文件是否可以使用。这两种方式都需要应用程序主动去查询设备的使用情况，如果能提供一种类似中断的机制，当驱动程序可以访问的时候主动告诉应用程序那就最好了。

“信号”为此应运而生，信号类似于硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉
给应用程序的。

阻塞、非阻塞、异步通知，这三种是针对不同的场合提出来的不同的解决方法，没有优劣之分，在实际的工作和学习中，根据实际需求选择合适的处理方法即可。

异步通知的核心就是信号，在arch/xtensa/include/uapi/asm/signal.h文件中定义了Linux所支持的所有信号，这些信号如下所示：

示例代码33.1.1.1 Linux信号 
18 #define SIGHUP 1 /* 终端挂起或控制进程终止 */ 
19 #define SIGINT 2 /* 终端中断(Ctrl+C组合键) */ 
20 #define SIGQUIT 3 /* 终端退出(Ctrl+\组合键) */ 
21 #define SIGILL 4 /* 非法指令 */ 
22 #define SIGTRAP 5 /* debug使用，有断点指令产生 */ 
23 #define SIGABRT 6 /* 由abort(3)发出的退出指令 */ 
24 #define SIGIOT 6 /* IOT指令 */ 
25 #define SIGBUS 7 /* 总线错误 */ 
26 #define SIGFPE 8 /* 浮点运算错误 */ 
27 #define SIGKILL 9 /* 杀死、终止进程 */ 
28 #define SIGUSR1 10 /* 用户自定义信号1 */ 
30 #define SIGSEGV 11 /* 段违例(无效的内存段) */ 
31 #define SIGUSR2 12 /* 用户自定义信号2 */ 
32 #define SIGPIPE 13 /* 向非读管道写入数据 */ 
33 #define SIGALRM 14 /* 闹钟 */ 
34 #define SIGTERM 15 /* 软件终止 */ 
35 #define SIGSTKFLT 16 /* 栈异常 */ 
36 #define SIGCHLD 17 /* 子进程结束 */ 
37 #define SIGCONT 18 /* 进程继续 */ 
38 #define SIGSTOP 19 /* 停止进程的执行，只是暂停 */
39 #define SIGTSTP 20 /* 停止进程的运行(Ctrl+Z组合键) */ 
40 #define SIGTTIN 21 /* 后台进程需要从终端读取数据 */ 
41 #define SIGTTOU 22 /* 后台进程需要向终端写数据 */ 
42 #define SIGURG 23 /* 有"紧急"数据 */ 
43 #define SIGXCPU 24 /* 超过CPU资源限制 */ 
44 #define SIGXFSZ 25 /* 文件大小超额 */ 
45 #define SIGVTALRM 26 /* 虚拟时钟信号 */ 
46 #define SIGPROF 27 /* 时钟信号描述 */ 
47 #define SIGWINCH 28 /* 窗口大小改变 */ 
48 #define SIGIO 29 /* 可以进行输入/输出操作 */ 
49 #define SIGPOLL SIGIO 
50 /* #define SIGLOS 29 */ 
51 #define SIGPWR 30 /* 断点重启 */ 
52 #define SIGSYS 31 /* 非法的系统调用 */ 
53 #define SIGUNUSED 31 /* 未使用信号 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在示例代码33.1.1.1中的这些信号中，除了SIGKILL(9)和SIGSTOP(19)这两个信号不能被
忽略外，其他的信号都可以忽略。这些信号就相当于中断号，不同的中断号代表了不同的中断，不同的中断所做的处理不同，因此，驱动程序可以通过向应用程序发送不同的信号来实现不同的功能。

使用中断的时候需要设置中断处理函数，同样的，如果要在应用程序中使用信号，那么就必须设置信号所使用的信号处理函数，在应用程序中使用signal函数来设置指定信号的处理函数， signal函数原型如下所示：

sighandler_t signal(int signum, sighandler_t handler) 
1

函数参数和返回值含义如下：

• signum：要设置处理函数的信号。
• handler：信号的处理函数。
• 返回值：设置成功的话返回信号的前一个处理函数，设置失败的话返回SIG_ERR。

信号处理函数原型如下所示：

typedef void (*sighandler_t)(int)
1

前面讲解的使用“kill -9 PID”杀死指定进程的方法就是向指定的进程(PID)发送SIGKILL这个信号。当按下键盘上的CTRL+C组合键以后会向当前正在占用终端的应用程序发出SIGINT信号，SIGINT信号默认的动作是关闭当前应用程序。这里修改一下SIGINT信号的默认处理函数，当按下CTRL+C组合键以后先在终端上打印出“SIGINT signal！”这行字
符串，然后再关闭当前应用程序。新建signaltest.c文件，然后输入如下所示内容：

示例代码33.1.1.2 信号测试 
1  #include <stdlib.h> 
2  #include <stdio.h> 
3  #include <signal.h> 
4 
5  void sigint_handler(int num) 
6  { 
7      printf("\r\nSIGINT signal!\r\n"); 
8      exit(0);
9  } 
10 
11 int main(void) 
12 { 
13     signal(SIGINT, sigint_handler); 
14     while(1); 
15     return 0; 
16 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在示例代码33.1.1.2中设置SIGINT信号的处理函数为sigint_handler，当按下CTRL+C向signaltest发送SIGINT信号以后sigint_handler函数就会执行，此函数先输出一行“SIGINT signal!”字符串，然后调用exit函数关闭signaltest应用程序。使用如下命令编译signaltest.c：

gcc signaltest.c -o signaltest
1

然后输入“./signaltest”命令打开signaltest这个应用程序，然后按下键盘上的CTRL+C组合键，结果如下图所示：

从上图可以看出，当按下CTRL+C组合键以后sigint_handler这个SIGINT信号处理函数执行了，并且输出了“SIGINT signal！”这行字符串。

驱动中的信号处理

fasync_struct结构体

首先需要在驱动程序中定义一个fasync_struct结构体指针变量，fasync_struct结构体内容如下：

一般将fasync_struct结构体指针变量定义到设备结构体中，比如在之前的阻塞IO实验中的key_dev结构体中添加一个fasync_struct结构体指针变量，结果如下所示：

示例代码33.1.2.2 在设备结构体中添加fasync_struct类型变量指针 
1 struct key_dev{ 
2     dev_t devid; 
3     struct cdev cdev; 
4     struct class *class;
...... 
12    struct fasync_struct *async_queue; /* fasync_struct结构体 */ 
13 };
1
2
3
4
5
6
7
8

fasync函数

如果要使用异步通知，需要在设备驱动中实现file_operations操作集中的fasync函数，此
函数格式如下所示：

int (*fasync) (int fd, struct file *filp, int on) 
1

fasync函数里面一般通过调用fasync_helper函数来初始化前面定义的fasync_struct结构体指针，fasync_helper函数原型如下：

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp) 
1

fasync_helper函数的前三个参数就是fasync函数的那三个参数，第四个参数就是要初始化的fasync_struct结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync标记的时候，驱动程序file_operations操作集中的fasync函数就会执行。

驱动程序中的fasync函数参考示例如下：

示例代码33.1.2.3 驱动中fasync函数参考示例 
1  struct xxx_dev { 
2      ...... 
3      struct fasync_struct *async_queue; /* 异步相关结构体 */ 
4  }; 
5 
6  static int xxx_fasync(int fd, struct file *filp, int on) 
7  { 
8      struct xxx_dev *dev = (xxx_dev)filp->private_data; 
9 
10     if (fasync_helper(fd, filp, on, &dev->async_queue) < 0) 
11         return -EIO; 
12     return 0; 
13 } 
14 
15 static struct file_operations xxx_ops = { 
16     ...... 
17     .fasync = xxx_fasync, 
18     ...... 
19 };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在关闭驱动文件的时候需要在file_operations操作集中的release函数中释放fasync_struct，fasync_struct的释放函数同样为fasync_helper，release函数参数参考实例如下：

示例代码33.1.2.4 释放fasync_struct参考示例 
1 static int xxx_release(struct inode *inode, struct file *filp) 
2 { 
3     return xxx_fasync(-1, filp, 0); /* 删除异步通知 */ 
4 } 
5
6 static struct file_operations xxx_ops = { 
7     ...... 
8         .release = xxx_release, 
9 };
1
2
3
4
5
6
7
8
9
10

kill_fasync函数

当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断”。kill_fasync函数负责发送指定的信号，kill_fasync函数原型如下所示：

void kill_fasync(struct fasync_struct **fp, int sig, int band) 
1

函数参数和返回值含义如下：

• fp：要操作的 fasync_struct。
• sig：要发送的信号。
• band：可读时设置为POLL_IN，可写时设置为POLL_OUT。
• 返回值：无。

应用程序对异步通知的处理

包括以下3步：

注册信号处理函数

应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用signal函数来设置信号的处理函数。

将本应用程序的进程号告诉内核

使用fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核。

开启异步通知

使用如下两行程序开启异步通知：

flags = fcntl(fd, F_GETFL); /* 获取当前的进程状态 */ 
fcntl(fd, F_SETFL, flags | FASYNC); /* 开启当前进程异步通知功能 */
1
2

重点就是通过fcntl函数设置进程状态为FASYNC，经过这一步，驱动程序中的fasync函数就会执行。

硬件原理图分析

这里就是按键的原理图。

实验程序编写

可以在之前的非阻塞IO的基础上完成异步通知相关内容的添加即可。

修改设备树文件

之前已经添加过按键的设备了，这里就不需要进行修改。

驱动程序编写

在之前的非阻塞IO的基础上修改。

在设备结构体key_dev中，除了之前已经添加的等待队列头以及原子变量，最后添加一个fasync_struct的结构体，struct fasync_struct* async_queue结构体指针。

之后的定时处理函数key_timer_function中，同样使用阻塞IO的API wake_up_interruptible来唤醒，之后通过调用kill_fasync来向应用程序发送SIGIO信号，通知应用程序按键可以读取。

之后要新写一个key_fasync函数来处理异步通知，这其中直接调用fasync_helper函数即可，然后把这个函数的返回值return出来。

在关闭设备的release函数中，通过key_fasync，传入参数-1,filp和0就可以成功释放了。

最后再file_operations这个操作集中，最后添加.fasync，传入key_fasync即可。

编写测试APP

在之前的基础上进行修改。

首先需要定义一个信号处理函数sigio_signal_func，其中通过read读取数据之后，输出对应的按键状态。

open了设备之后，添加信号SIGIO的处理函数，加上signal函数，传入SIGIO以及自己编写的信号处理函数sigio_signal_func，之后通过fcntl(fd,F_SETOWN,getpid())把进程号传给内核，通过fcntl(fd,F_GETFD)获取当前进程状态，最后通过fcntl(fd,F_SETFL,flags|FASYNC)设置进程启用异步通知功能。

最后再for死循环中，等待信号产生，直接sleep即可。

运行测试

编译驱动程序和测试APP

编译驱动程序

直接修改Makefile的obj-m为asyncnoti.o，然后“make”即可。

编译测试APP

通过如下命令编译：

运行测试

将上一小节编译出来asyncnoti.ko和asyncnotiApp这两个文件拷贝到rootfs/lib/modules/5.4.31目录中，重启开发板，进入到目录lib/modules/5.4.31中，输入如下命令加载asyncnoti.ko驱动模块：

驱动加载成功后可通过如下命令测试中断：

如果要卸载驱动输入如下命令即可：

总结

这一章节，祖耀学习了异步通知，就是类似裸机开发中的各种GPIO中断，通过驱动来通知应用程序进行处理。

只需要在设备结构体中，添加一个fasync_struct类型的结构体指针，然后在定时处理函数中，在进程被wake_up_interruptible被唤醒后，在key.async_queue被检测到后(即有信号产生，该值就不为0)，通过kill_fasync来进行数据读取；然后编写自己的fasync函数，在里面调用fasync_helper然后return出来；在关闭设备的release函数中，调用自己写的fasync函数，传入-1,filp,0即可释放；最后在file_operations中添加.fasync即可。

测试APP中，只要编写一个信号处理函数，并在open设备杭州，通过signal函数设置对应信号的处理函数，并通过3次fcntl开启当前进程的异步通知功能即可。