当linux应用程序中存在多个异步通知时怎样处理

驱动程序运行在内核空间中，应用程序运行在用户空间中，两者是不能直接通信的。但在实际应用中，在设备已经准备好的时候，我们希望通知用户程序设备已经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)

}

void main()

{

int oflags

//启动信号驱动机制,将SIGIO信号同input_handler函数关联起来,一旦产生SIGIO信号,就会执行input_handler

signal(SIGIO, input_handler)

//STDIN_FILENO是打开的设备文件描述符,F_SETOWN用来决定 *** 作是干什么的,getpid()是个系统调用，

//功能是返回当前进程的进程号,整个函数的功能是STDIN_FILENO设置这个设备文件的拥有者为当前进程。

fcntl(STDIN_FILENO, F_SETOWN, getpid())

//得到打开文件描述符的状态

oflags = fcntl(STDIN_FILENO, F_GETFL)

//设置文件描述符的状态为oflags | FASYNC属性,一旦文件描述符被设置成具有FASYNC属性的状态，

//也就是将设备文件切换到异步 *** 作模式。这时系统就会自动调用驱动程序的fasync方法。

fcntl(STDIN_FILENO, F_SETFL, oflags | FASYNC)

//最后进入一个死循环，程序什么都不干了，只有信号能激发input_handler的运行

//如果程序中没有这个死循环，会立即执行完毕

while (1)

}

再看驱动层代码，驱动层其他部分代码不变，就是增加了一个fasync方法的实现以及一些改动

//首先是定义一个结构体，其实这个结构体存放的是一个列表，这个

//列表保存的是一系列设备文件，SIGIO信号就发送到这些设备上

static struct fasync_struct *fasync_queue

//fasync方法的实现

static int my_fasync(int fd, struct file * filp, int on)

{

int retval

//将该设备登记到fasync_queue队列中去

retval=fasync_helper(fd,filp,on,&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 用来向等待异步信号的设备链表中添加或者删除设备文件, kill_fasync被用来通知拥有相关设备的进程. 它的参数是被传递的信号(常常是 SIGIO)和 band, 这几乎都是 POLL_IN[25](但是这可用来发送"紧急"或者带外数据, 在网络代码里).

Linux异步信号

1.int pthread_kill(pthread_t threadid, intsigno)

向特定的线程发送信号signo

2.int pthread_sigmask(int how, const sigset_t*newmask, sigset_t *oldmask)

设置线程的信号屏蔽码

3.int sigwait(const sigset_t *set, int *sig)

阻塞线程，等待set中指定的信号之一到达，并将到达的信号存入*sig。

4.代码

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <signal.h>

//#define SIGUSRR 40

int SIGUSRR = 40

void* threadOne(void *arg)

{

sigset_tsigset

intsigno

sigemptyset(&sigset)

sigaddset(&sigset,SIGUSRR)

pthread_sigmask(SIG_BLOCK,&sigset, NULL)

while(1)

{

sigwait(&sigset,&signo)

printf("getthread cond sig!\n")

}

}

int main(int argc, char **argv)

{

if(argc != 1)

{

printf("Usage:\n")

printf("threadcond\n")

return1

}

pthread_tthreadId

if(pthread_create(&threadId,NULL, threadOne, NULL) != 0)

{

printf("threadcreate error! \n")

return1

}

//structsigaction act

//act.sa_handler=SIG_IGN

//sigemptyset(&act.sa_mask)

//act.sa_flags=0

//sigaction(SIGUSRR,&act,0)//设置信号SIGUSR1的处理方式忽略

usleep(1000000)

pthread_kill(threadId,SIGUSRR)

usleep(1000000)

pthread_kill(threadId,SIGUSRR)

usleep(2000000)

return0

}

首先，一句话总结它们之间的区别：

字面上相似，但是本质上存在巨大的差别！请看详细解答...

Linux信号（signal) 机制

signal，又简称为信号（软中断信号）用来通知进程发生了异步事件。

原理：

一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是进程间通信机制中唯一的异步通信机制，一个进程不必通过任何 *** 作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。信号机制除了基本通知功能外，还可以传递附加信息。

分类：

从两个不同的分类角度对信号进行：

可靠性方面：可靠信号与不可靠信号；

与时间的关系上：实时信号与非实时信号。

部分定义转自：http://www.cnblogs.com/hoys/archive/2012/08/19/2646377.html

Linux信号量（semaphore）机制

　Linux内核的信号量用来 *** 作系统进程间同步访问共享资源。

原理：信号量在创建时需要设置一个初始值，表示同时可以有几个任务可以访问该信号量保护的共享资源，初始值为1就变成互斥锁（Mutex），即同时只能有一个任务可以访问信号量保护的共享资源。

一个任务要想访问共享资源，首先必须得到信号量，获取信号量的 *** 作将把信号量的值减1，若当前信号量的值为负数，表明无法获得信号量，该任务必须挂起在该信号量的等待队列等待该信号量可用；若当前信号量的值为非负数，表示可以获得信号量，因而可以立刻访问被该信号量保护的共享资源。

当任务访问完被信号量保护的共享资源后，必须释放信号量，释放信号量通过把信号量的值加1实现，如果信号量的值为非正数，表明有任务等待当前信号量，因此它也唤醒所有等待该信号量的任务。

　常用的信号量的API：

DECLARE_MUTEX(name)

该宏声明一个信号量name并初始化它的值为0，即声明一个互斥锁。

DECLARE_MUTEX_LOCKED(name)

该宏声明一个互斥锁name，但把它的初始值设置为0，即锁在创建时就处在已锁状态。因此对于这种锁，一般是先释放后获得。

void sema_init (struct semaphore *sem, int val)

该函用于数初始化设置信号量的初值，它设置信号量sem的值为val。

void init_MUTEX (struct semaphore *sem)

该函数用于初始化一个互斥锁，即它把信号量sem的值设置为1。

void init_MUTEX_LOCKED (struct semaphore *sem)

该函数也用于初始化一个互斥锁，但它把信号量sem的值设置为0，即一开始就处在已锁状态。

void down(struct semaphore * sem)

该函数用于获得信号量sem，它会导致睡眠，因此不能在中断上下文（包括IRQ上下文和softirq上下文）使用该函数。该函数将把sem的值减1，如果信号量sem的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。

int down_interruptible(struct semaphore * sem)

该函数功能与down类似，不同之处为，down不会被信号（signal）打断，但down_interruptible能被信号打断，因此该函数有返回值来区分是正常返回还是被信号中断，如果返回0，表示获得信号量正常返回，如果被信号打断，返回-EINTR。

int down_trylock(struct semaphore * sem)

该函数试着获得信号量sem，如果能够立刻获得，它就获得该信号量并返回0，否则，表示不能获得信号量sem，返回值为非0值。因此，它不会导致调用者睡眠，可以在中断上下文使用。

void up(struct semaphore * sem)

该函数释放信号量sem，即把sem的值加1，如果sem的值为非正数，表明有任务等待该信号量，因此唤醒这些等待者。

　实例：

信号量在绝大部分情况下作为互斥锁使用，下面以console驱动系统为例说明信号量的使用。

在内核源码树的kernel/printk.c中，使用宏DECLARE_MUTEX声明了一个互斥锁console_sem，它用于保护console驱动列表console_drivers以及同步对整个console驱动系统的访问。

---