【正点原子Linux连载】第五十三章异步通知实验--摘自【正点原子】I.MX6U嵌入式Linux驱动开发指南V1.0

正点原子运营 · 发表于 2020-3-9 11:01:17

本帖最后由正点原子01 于 2020-3-9 11:01 编辑

1）实验平台：正点原子阿尔法Linux开发板
2）平台购买地址：：https://item.taobao.com/item.htm?id=603672744434
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-300792-1-1.html
4）本章实例源码下载：

异步通知实验.zip (11.45 KB, 下载次数: 0)

2020-2-28 16:18 上传

点击文件名下载附件
5）关注正点原子公众号，获取最新资料更新

第五十三章异步通知实验

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

53.1 异步通知53.1.1 异步通知简介

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

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

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

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

示例代码53.1.1.1 Linux信号

#defineSIGHUP 1 /* 终端挂起或控制进程终止 */
#defineSIGINT 2 /* 终端中断(Ctrl+C组合键) */
#defineSIGQUIT 3 /* 终端退出(Ctrl+\组合键) */
#defineSIGILL 4 /* 非法指令 */
#defineSIGTRAP 5 /* debug使用，有断点指令产生 */
#defineSIGABRT 6 /* 由abort(3)发出的退出指令 */
#defineSIGIOT 6 /* IOT指令 */
#defineSIGBUS 7 /* 总线错误 */
#defineSIGFPE 8 /* 浮点运算错误 */
#defineSIGKILL 9 /* 杀死、终止进程 */
#defineSIGUSR1 10 /* 用户自定义信号1 */
#defineSIGSEGV 11 /* 段违例(无效的内存段) */
#defineSIGUSR2 12 /* 用户自定义信号2 */
#defineSIGPIPE 13 /* 向非读管道写入数据 */
#defineSIGALRM 14 /* 闹钟 */
#defineSIGTERM 15 /* 软件终止 */
#defineSIGSTKFLT 16 /* 栈异常 */
#defineSIGCHLD 17 /* 子进程结束 */
#defineSIGCONT 18 /* 进程继续 */
#defineSIGSTOP 19 /* 停止进程的执行，只是暂停 */
#defineSIGTSTP 20 /* 停止进程的运行(Ctrl+Z组合键) */
#defineSIGTTIN 21 /* 后台进程需要从终端读取数据 */
#defineSIGTTOU 22 /* 后台进程需要向终端写数据 */
#defineSIGURG 23 /* 有"紧急"数据 */
#defineSIGXCPU 24 /* 超过CPU资源限制 */
#defineSIGXFSZ 25 /* 文件大小超额 */
#defineSIGVTALRM 26 /* 虚拟时钟信号 */
#defineSIGPROF 27 /* 时钟信号描述 */
#defineSIGWINCH 28 /* 窗口大小改变 */
#define SIGIO 29 /* 可以进行输入/输出操作 */
#defineSIGPOLL SIGIO
/* #defineSIGLOS 29 */
#defineSIGPWR 30 /* 断点重启 */
#defineSIGSYS 31 /* 非法的系统调用 */
#define SIGUNUSED 31 /* 未使用信号 */

复制代码

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

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

sighandler_t signal(int signum, sighandler_thandler)

复制代码

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

signum：要设置处理函数的信号。

handler：信号的处理函数。

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

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

typedef void (*sighandler_t)(int)

复制代码

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

示例代码53.1.1.2 信号测试

1 #include "stdlib.h"
2 #include "stdio.h"
3 #include "signal.h"
4
5void sigint_handler(int num)
6{
7 printf("\r\nSIGINT signal!\r\n");
8 exit(0);
9}
10
11int main(void)
12{
13 signal(SIGINT, sigint_handler);
14while(1);
15return0;
16}

复制代码

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

使用如下命令编译signaltest.c：

gcc signaltest.c -o signaltest

复制代码

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

图53.1.1.1 signaltest软件运行结果

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

53.1.2 驱动中的信号处理

1、fasync_struct结构体

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

<div style="text-align: center;">示例代码53.1.2.1 fasync_struct发结构体</div>struct fasync_struct {
spinlock_t fa_lock;
int magic;
int fa_fd;
struct fasync_struct *fa_next;
struct file *fa_file;
struct rcu_head fa_rcu;
};

复制代码

一般将fasync_struct结构体指针变量定义到设备结构体中，比如在上一章节的imx6uirq_dev结构体中添加一个fasync_struct结构体指针变量，结果如下所示：

示例代码53.1.2.2 在设备结构体中添加fasync_struct类型变量指针

struct imx6uirq_dev {
struct device *dev;
struct class *cls;
struct cdev cdev;
......
struct fasync_struct *async_queue;/* 异步相关结构体 */
};

复制代码

第14行就是在imx6uirq_dev中添加了一个fasync_struct结构体指针变量。

2、fasync函数

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

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

复制代码

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

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

复制代码

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

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

示例代码53.1.2.3 驱动中fasync函数参考示例

struct xxx_dev {
......
struct fasync_struct *async_queue;/* 异步相关结构体 */
};
staticint xxx_fasync(int fd,struct file *filp,int on)
{
struct xxx_dev *dev =(xxx_dev)filp->private_data;
if(fasync_helper(fd, filp, on,&dev->async_queue)<0)
return-EIO;
return0;
}
staticstruct file_operations xxx_ops ={
......
.fasync = xxx_fasync,
......
};

复制代码

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

示例代码53.1.2.4 释放fasync_struct参考示例

staticint xxx_release(struct inode *inode,struct file *filp)
{
return xxx_fasync(-1, filp,0);/* 删除异步通知 */
}
staticstruct file_operations xxx_ops ={
......
.release = xxx_release,
};

复制代码

第3行通过调用示例代码53.1.2.3中的xxx_fasync函数来完成fasync_struct的释放工作，但是，其最终还是通过fasync_helper函数完成释放工作。

1、kill_fasync函数

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

void kill_fasync(struct fasync_struct **fp, intsig, int band)

复制代码

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

fp：要操作的fasync_struct。

sig：要发送的信号。

band：可读时设置为POLL_IN，可写时设置为POLL_OUT。

返回值：无。

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

应用程序对异步通知的处理包括以下三部：

1、注册信号处理函数

应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用signal函数来设置信号的处理函数。前面已经详细的讲过了，这里就不细讲了。

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

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

3、开启异步通知

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

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

复制代码

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

53.2 硬件原理图分析

本章实验硬件原理图参考15.2小节即可。

53.3 实验程序编写

本实验对应的例程路径为：开发板光盘->2、Linux驱动例程->16_asyncnoti。

本章实验我们在上一章实验“15_noblockio”的基础上完成，在其中加入异步通知相关内容即可，当按键按下以后驱动程序向应用程序发送SIGIO信号，应用程序获取到SIGIO信号以后读取并且打印出按键值。

53.3.1 修改设备树文件

因为是在实验“15_noblockio”的基础上完成的，因此，不需要修改设备树。

53.3.2 程序编写

新建名为“16_asyncnoti”的文件夹，然后在16_asyncnoti文件夹里面创建vscode工程，工作区命名为“asyncnoti”。将“15_noblockio”实验中的noblockio.c复制到16_asyncnoti文件夹中，并重命名为asyncnoti.c。接下来我们就修改asyncnoti.c这个文件，在其中添加异步通知关的代码，完成以后的asyncnoti.c内容如下所示(因为是在上一章实验的noblockio.c文件的基础上修改的，因为了减少篇幅，下面的代码有省略)：

示例代码53.3.2.1 asyncnoti.c文件代码段

#include <linux/types.h>
......
#include <linux/fcntl.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
/***************************************************************
Copyright ? ALIENTEK Co., Ltd. 1998-2029. Allrights reserved.
文件名 : asyncnoti.c
作者 : 左忠凯
版本 : V1.0
描述 : 非阻塞IO访问
其他 : 无
论坛 : www.openedv.com
日志 : 初版V1.02019/8/13 左忠凯创建
***************************************************************/
#define IMX6UIRQ_CNT 1 /* 设备号个数 */
#define IMX6UIRQ_NAME "asyncnoti" /* 名字 */
#define KEY0VALUE 0X01 /* KEY0按键值 */
#define INVAKEY 0XFF /* 无效的按键值 */
#define KEY_NUM 1 /* 按键数量 */
......
/* imx6uirq设备结构体 */
struct imx6uirq_dev{
......
struct fasync_struct *async_queue;/* 异步相关结构体 */
};
struct imx6uirq_dev imx6uirq;/* irq设备 */
......
/* @description : 定时器服务函数，用于按键消抖，定时器到了以后
* 再次读取按键值，如果按键还是处于按下状态就表示按键有效。
* @param - arg : 设备结构变量
* @return :无
*/
void timer_function(unsignedlong arg)
{
unsignedchar value;
unsignedchar num;
struct irq_keydesc *keydesc;
struct imx6uirq_dev *dev =(struct imx6uirq_dev *)arg;
......
if(atomic_read(&dev->releasekey)){/* 一次完整的按键过程 */
if(dev->async_queue)
kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
}
#if0
/* 唤醒进程 */
if(atomic_read(&dev->releasekey)){ /* 完成一次按键过程 */
/*wake_up(&dev->r_wait); */
wake_up_interruptible(&dev->r_wait);
}
#endif
}
......
/*
* @description : fasync函数，用于处理异步通知
* @param - fd : 文件描述符
* @param - filp : 要打开的设备文件(文件描述符)
* @param - on : 模式
* @return :负数表示函数执行失败
*/
staticint imx6uirq_fasync(int fd,struct file *filp,int on)
{
struct imx6uirq_dev *dev =(struct imx6uirq_dev *)
filp->private_data;
return fasync_helper(fd, filp, on,&dev->async_queue);
}
/*
* @description :release函数，应用程序调用close关闭驱动文件的时候会执行
* @param – inode : inode节点
* @param – filp : 要打开的设备文件(文件描述符)
* @return :负数表示函数执行失败
*/
staticint imx6uirq_release(struct inode *inode,struct file *filp)
{
return imx6uirq_fasync(-1, filp,0);
}
/* 设备操作函数 */
staticstruct file_operations imx6uirq_fops ={
.owner = THIS_MODULE,
.open = imx6uirq_open,
.read = imx6uirq_read,
.poll = imx6uirq_poll,
.fasync = imx6uirq_fasync,
.release = imx6uirq_release,
};
/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
staticint __init imx6uirq_init(void)
{
......
/* 5、始化按键 */
atomic_set(&imx6uirq.keyvalue, INVAKEY);
atomic_set(&imx6uirq.releasekey,0);
keyio_init();
return0;
}
/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
staticvoid __exit imx6uirq_exit(void)
{
unsigned i =0;
......
class_destroy(imx6uirq.class);
}
module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");

复制代码

第20行，添加fcntl.h头文件，因为要用到相关的API函数。

第64行，在设备结构体imx6uirq_dev中添加fasync_struct指针变量。

第109~112行，如果是一次完整的按键过程，那么就通过kill_fasync函数发送SIGIO信号。

第114~120行，屏蔽掉以前的唤醒进程相关程序。

第269~273行，imx6uirq_fasync 函数，为file_operations操作集中的fasync函数，此函数内容很简单，就是调用一下fasync_helper。

第281~284行，release函数，应用程序调用close函数关闭驱动设备文件的时候此函数就会执行，在此函数中释放掉fasync_struct指针变量。

第292~293行，设置file_operations操作集中的fasync和release这两个成员变量。

53.3.3 编写测试APP

测试APP要实现的内容很简单，设置SIGIO信号的处理函数为sigio_signal_func，当驱动程序向应用程序发送SIGIO信号以后sigio_signal_func函数就会执行。sigio_signal_func函数内容很简单，就是通过read函数读取按键值。新建名为asyncnotiApp.c的文件，然后输入如下所示内容：

示例代码53.3.3.2 asyncnotiApp.c文件代码段

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "linux/ioctl.h"
#include "signal.h"
/***************************************************************
文件名 : asyncnotiApp.c
作者 : 左忠凯
版本 : V1.0
描述 : 异步通知测试APP
其他 : 无
使用方法：./asyncnotiApp/dev/asyncnoti 打开测试App
论坛 : www.openedv.com
日志 : 初版V1.02019/8/13 左忠凯创建
***************************************************************/
staticint fd =0;/* 文件描述符 */
/*
* SIGIO信号处理函数
* @param - signum : 信号值
* @return :无
*/
staticvoid sigio_signal_func(int signum)
{
int err =0;
unsignedint keyvalue =0;
err = read(fd,&keyvalue,sizeof(keyvalue));
if(err <0){
/* 读取错误 */
}else{
printf("sigio signal! key value=%d\r\n", keyvalue);
}
}
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return :0 成功;其他失败
*/
int main(int argc,char*argv[])
{
int flags =0;
char*filename;
if(argc !=2){
printf("Error Usage!\r\n");
return-1;
}
filename = argv[1];
fd = open(filename, O_RDWR);
if(fd <0){
printf("Can't open file %s\r\n", filename);
return-1;
}
/* 设置信号SIGIO的处理函数 */
signal(SIGIO, sigio_signal_func);
fcntl(fd, F_SETOWN, getpid()); /* 将当前进程的进程号告诉给内核 */
flags = fcntl(fd, F_GETFD); /* 获取当前的进程状态 */
fcntl(fd, F_SETFL, flags | FASYNC);/* 设置进程启用异步通知功能 */
while(1){
sleep(2);
}
close(fd);
return0;
}

复制代码

第32~43行，sigio_signal_func函数，SIGIO信号的处理函数，当驱动程序有效按键按下以后就会发送SIGIO信号，此函数就会执行。此函数通过read函数读取按键值，然后通过printf函数打印在终端上。

第69行，通过signal函数设置SIGIO信号的处理函数为sigio_signal_func。

第71~73行，设置当前进程的状态，开启异步通知的功能。

第75~77行，while循环，等待信号产生。

53.4 运行测试53.4.1 编译驱动程序和测试APP

1、编译驱动程序

编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为asyncnoti.o，Makefile内容如下所示：

示例代码53.4.1.1 Makefile文件

KERNELDIR:=/home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
......
obj-m := asyncnoti.o
......
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

第4行，设置obj-m变量的值为asyncnoti.o。

输入如下命令编译出驱动模块文件：