异步通知：
阻塞与非阻塞访问、poll()函数提供了较好地解决设备访问的机制（应用程序主动访问）
异步通知：一旦设备就绪，则主动通知应用程序，这样应用程序根本就不需要查询设备状态，这一点非常类似于硬件上“中断”的概念，比较准确的称谓是“信号驱动的异步 I/O”
阻塞 I/O 意味着一直等待设备可访问后再访问，非阻塞 I/O 中使用 poll()意味着查询设备是否可访问，而异步通知则意味着设备通知自身可访问，实现了异步 I/O。由此可见，这几种方式 I/O可以互为补充。
阻塞、非阻塞 I/O、异步通知本身没有优劣，应该根据不同的应用场景合理选择。
linux异步通知编程：
1.信号的接受：
在用户程序中，为了捕获信号，可以使用 signal()函数来设置对应信号的处理函数：
void (*signal(int signum, void (*handler))(int)))(int);
该函数原型较难理解，它可以分解为：
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler));
第一个参数指定信号的值，第二个参数指定针对前面信号值的处理函数，若为SIG_IGN，表示 忽略该信号；若为 SIG_DFL，表示采用系统默认方式处理信号；若为用户自定义的函数，则信号 被捕获到后，该函数将被执行。 如果 signal()调用成功，它返回最后一次为信号 signum 绑定的处理函数 handler 值，失败则返 回 SIG_ERR。
使用信号实现异步通知的应用程序实例：
1 #include <sys/types.h>
2 #include <sys/stat.h>
3 #include <stdio.h>
4 #include <fcntl.h>
5 #include <signal.h>
6 #include <unistd.h>
7 #define MAX_LEN 100
8 void input_handler(int num)
9 {
10 char data[MAX_LEN];
11 int len;
12
13 /* 读取并输出 STDIN_FILENO 上的输入 */
14 len = read(STDIN_FILENO, &data, MAX_LEN);
15 data[len] = 0;
16 printf("input available:%s\n", data);
17 }
18
19 main()
20 {
21 int oflags;
22
23 /* 启动信号驱动机制 */
24 signal(SIGIO, input_handler);
25 fcntl(STDIN_FILENO, F_SETOWN, getpid());
26 oflags = fcntl(STDIN_FILENO, F_GETFL);
27 fcntl(STDIN_FILENO, F_SETFL, oflags | FASYNC);
28
29 /* 最后进入一个死循环，仅为保持进程不终止，如果程序中
30 没有这个死循会立即执行完毕 */
31 while (1);
32 }
上述代码 24 行为 SIGIO 信号安装 input_handler()作为处理函数，第 25 行设置本进程为 STDIN_FILENO 文件的拥有者（owner），没有这一步内核不会知道应该将信号发给哪个进程。而 为了启用异步通知机制，还需对设备设置 FASYNC 标志，26～27 行代码实现此目的。
由此可见，为了在用户空间中能处理一个设备释放的信号，它必须完成 3 项工作。 （1）通过 F_SETOWN IO 控制命令设置设备文件的拥有者为本进程，这样从设备驱动发出的 信号才能被本进程接收到。 （2）通过 F_SETFL IO 控制命令设置设备文件支持 FASYNC，即异步通知模式。 （3）通过 signal()函数连接信号和信号处理函数。
相关链接：http://blog.csdn.net/bailyzheng/article/details/7463775
信号的释放：
在设备驱动和应用程序的异步通知交互中，仅仅在应用程序端捕获信号是不够的，因为信号 没有的源头在设备驱动端。因此，应该在合适的时机让设备驱动释放信号，在设备驱动程序中增 加信号释放的相关代码。 为了使设备支持异步通知机制，驱动程序中涉及 3 项工作。
（1）支持 F_SETOWN 命令，能在这个控制命令处理中设置 filp->f_owner 为对应进程 ID。不 过此项工作已由内核完成，设备驱动无需处理。
（2）支持 F_SETFL 命令的处理，每当FASYNC 标志改变时，驱动程序中的fasync()函数将得 以执行。因此，驱动中应该实现 fasync()函数。 （
3）在设备资源可获得时，调用 kill_fasync()函数激发相应的信号
设备驱动中异步通知编程比较简单，主要用到一项数据结构和两个函数。数据结构是
fasync_struct 结构体，两个函数分别是：
处理 FASYNC 标志变更的。
int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **fa);
释放信号用的函数。
void kill_fasync(struct fasync_struct **fa, int sig, int band);
相关驱动：
#include <linux/module.h>//support module load and unload
#include <linux/types.h>//special type definition,like dev_t off_t defined by typedef
#include <linux/fs.h>//struct file_operations
#include <linux/errno.h>//return value
#include <linux/mm.h>//memory mannage ,include kmalloc.kfree and so on
#include <linux/sched.h>//process schedule
#include <linux/init.h>//
#include <linux/cdev.h>//char device structure definition
#include <linux/io.h>//io operation function ,like ioremap,iowrite
#include <linux/poll.h> MODULE_AUTHOR("qigaohua") ;
MODULE_LICENSE("Dual BSD/GPL") ; #define GLOBALFIFO_SIZE 0x1000 //1M
#define CLEAR_ALL 0x01 //clear fifo
#define GLOBALFIFO_MAJOR 0//major device No static int globalfifo_major = GLOBALFIFO_MAJOR ;
/*define globalfifo structure*/
struct globalfifo_dev {
struct cdev dev ;
unsigned int current_len ;
unsigned char mem[GLOBALFIFO_SIZE] ;
struct semaphore sem ;
wait_queue_head_t r_wait ;
wait_queue_head_t w_wait ;
struct fasync_struct fasync_queue;
} ;
struct globalfifo_dev *globalfifo_devp = NULL; static int globalfifo_open(struct inode *inode, struct file *filp)
{
filp->private_data = globalfifo_devp ;
return ;
}
static int globalfifo_release(struct inode *inode ,struct file *filp)
{
globalfifo_fasync(-, filp, );
return ;
} static int globalfifo_ioctl(struct inode *inode, struct file *filp,
int cmd, unsigned long arg)
{
struct globalfifo_dev *dev = filp->private_data ;
switch (cmd)
{
case CLEAR_ALL:
/*note:down_intterruptible is more suitable,why?*/
down_interruptible(&dev->sem) ;
dev->current_len = ;
memset(dev->mem,,GLOBALFIFO_SIZE) ;
up(&dev->sem) ;
printk(KERN_INFO "clear globalfifo successfully!\n") ;
break ;
default:
printk(KERN_INFO "invalid command!\n") ;
return -EINVAL ;
}
} static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)
{
unsigned int mask = ;
struct globalfifo_dev *dev = filp->private_data ; down_interruptible(&dev->sem) ; poll_wait(filp,&dev->r_wait,wait) ;
poll_wait(filp,&dev->w_wait,wait) ; if(dev->current_len != )
{
mask |= POLLIN | POLLRDNORM ;
}
if(dev->current_len< GLOBALFIFO_SIZE )
{
mask |= POLLOUT | POLLWRNORM ;
}
up(&dev->sem) ;
return mask ;
}
static ssize_t globalfifo_read(struct file *filp, char __user *buf,
size_t count, loff_t *ppos)
{
int ret ;
struct globalfifo_dev *dev = filp->private_data ;
DECLARE_WAITQUEUE(wait,current) ;
down_interruptible(&dev->sem) ;
add_wait_queue(&dev->r_wait,&wait) ;
if(dev->current_len == )
{
if( filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN ;
goto out ;
}
__set_current_state(TASK_INTERRUPTIBLE) ;
up(&dev->sem) ;
schedule() ;
if(signal_pending(current))
{
ret = - ERESTARTSYS ;
goto out2 ;
}
down_interruptible(&dev->sem) ;
}
if(count>dev->current_len)
{
count = dev->current_len ;
}
if(copy_to_user(buf,dev->mem,count))
{
ret = -EFAULT ;
goto out ;
}else
{
memcpy(dev->mem,dev->mem+count,dev->current_len-count) ;
dev->current_len -= count ;
printk(KERN_INFO "read %d bytes(s),current_len:%d\n",
count,dev->current_len) ;
wake_up_interruptible(&dev->w_wait) ;
ret = count ;
}
out:
up(&dev->sem) ;
out2:
remove_wait_queue(&dev->w_wait,&wait) ;
set_current_state(TASK_RUNNING) ;
return ret ;
} static int globalfifo_fasync(int fd, struct file *filp, int mode)
{
struct globalfifo_dev *dev = file->private_data;
return fasync_helper(fd, filp, mode, &dev->fasync_queue);
} static ssize_t globalfifo_write(struct file *filp, const char __user *buf,
size_t count, loff_t *ppos)
{
struct globalfifo_dev *dev = filp->private_data ;
int ret = - ;
DECLARE_WAITQUEUE(wait,current) ; down_interruptible(&dev->sem) ;
add_wait_queue(&dev->w_wait,&wait) ; if(dev->current_len == GLOBALFIFO_SIZE)
{
if(filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN ;
goto out ;
}
__set_current_state(TASK_INTERRUPTIBLE) ;
up(&dev->sem) ; schedule() ;
if(signal_pending(current))
{
ret = -ERESTARTSYS ;
goto out2 ;
}
down_interruptible(&dev->sem) ;
} if(count>GLOBALFIFO_SIZE-dev->current_len)
{
count = GLOBALFIFO_SIZE - dev->current_len ;
}
if(copy_from_user(dev->mem+dev->current_len,buf,count))
{
ret = - EFAULT ;
goto out ;
}else
{
dev->current_len += count ;
printk(KERN_INFO "written %d bytes(s),cuurent_len:%d",
count , dev->current_len ) ;
wake_up_interruptible(&dev->r_wait) ;
if(dev->fasync_queue)
kill_fasync(&dev->fasync_queue, SIGIO, POLLIN);
ret = count ;
}
out:
up(&dev->sem) ;
out2:
remove_wait_queue(&dev->w_wait,&wait) ;
set_current_state(TASK_RUNNING) ;
return ret ;
}
static const struct file_operations globalfifo_fops = {
.owner = THIS_MODULE ,
.open = globalfifo_open ,
.read = globalfifo_read ,
.write = globalfifo_write ,
.ioctl = globalfifo_ioctl ,
.poll = globalfifo_poll ,
.fasync = globalfifo_fasync,
.release = globalfifo_release ,
} ;
int __init globalfifo_init(void)
{
int ret ;
dev_t devno = MKDEV(globalfifo_major, ) ;
if(globalfifo_major)
{
ret = register_chrdev_region(devno,,"globalfifo") ;
}else
{
ret = alloc_chrdev_region(&devno,,,"globalfifo") ;
globalfifo_major = MAJOR(devno) ;
}
if(ret<){
printk(KERN_INFO "apply for device No failed! major:%d,minor:%d\n",MAJOR(devno),MINOR(devno)) ;
return ret ;
}
globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev),GFP_KERNEL) ;
if(!globalfifo_devp){
ret = - ENOMEM ;
goto fail_malloc ;
} memset(globalfifo_devp, , sizeof(struct globalfifo_dev)) ; cdev_init(&globalfifo_devp->dev, &globalfifo_fops) ; globalfifo_devp->dev.owner = THIS_MODULE ;
globalfifo_devp->dev.ops = &globalfifo_fops ;
if(cdev_add(&globalfifo_devp->dev, devno,)) {
printk(KERN_NOTICE "add cdev failed!\n") ;
} INIT_MUTEX(&globalfifo_devp->sem) ;
init_waitqueue_head(&globalfifo_devp->r_wait) ;
init_waitqueue_head(&globalfifo_devp->w_wait) ;
printk(KERN_INFO "init globalfifo device successfully!\n" ) ;
return ;
fail_malloc:
unregister_chrdev_region(devno,) ;
return ret ;
}
void __exit globalfifo_exit(void)
{
if(globalfifo_devp != NULL ){
cdev_del(&globalfifo_devp->dev) ;
kfree(globalfifo_devp) ;
unregister_chrdev_region(MKDEV(globalfifo_major,),) ;
}
printk(KERN_INFO "unload globalfifo device successfully!\n") ;
}
//module_param(globalfifo_major, int , S_IRUGO) ; module_init(globalfifo_init) ;
module_exit(globalfifo_exit) ;
来自《Linux设备驱动开发详解》