Smart20学习记录----异步通知

异步通知：

阻塞与非阻塞访问、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
", 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 0 ;
}
static int globalfifo_release(struct inode *inode ,struct file *filp)
{
    globalfifo_fasync(-1, filp, 0);
    return 0 ;
}

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 = 0 ;
            memset(dev->mem,0,GLOBALFIFO_SIZE) ;
            up(&dev->sem) ;
            printk(KERN_INFO "clear globalfifo successfully!
") ;
            break ;
        default:
            printk(KERN_INFO "invalid command!
") ;
            return -EINVAL ;
    }
}

static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)
{
    unsigned int mask = 0 ;
    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 !=0 )
    {
        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 == 0 )
    {
        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
",
            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 = -1 ;
    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, 0 ) ;
    if(globalfifo_major)
    {
        ret = register_chrdev_region(devno,1,"globalfifo") ;
    }else
    {
        ret = alloc_chrdev_region(&devno,0,1,"globalfifo") ;
        globalfifo_major = MAJOR(devno) ;
    }
    if(ret<0){
        printk(KERN_INFO "apply for device No failed! major:%d,minor:%d
",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, 0, 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,1)) {
        printk(KERN_NOTICE "add cdev failed!
") ;
    }

    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!
" ) ;
    return 0 ;
fail_malloc:
    unregister_chrdev_region(devno,1) ;
    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,0),1) ;
    }
    printk(KERN_INFO "unload globalfifo device successfully!
") ;
}
//module_param(globalfifo_major, int , S_IRUGO) ;

module_init(globalfifo_init) ;
module_exit(globalfifo_exit) ;

来自《Linux设备驱动开发详解》