結合阻塞與非阻塞訪問、poll 函式可以較好地解決裝置的讀寫，但是如果有了非同步通知就更方便了。非同步通知的意思是：一旦裝置就緒，則主動通知應用程式，這樣應用程式根本就不需要查詢裝置狀態，這一點非常類似於硬體上“中斷”地概念，比較準確的稱謂是：訊號驅動(SIGIO)的非同步 I/O。可以使用signal()函式來設定對應的訊號的處理函式。函式原型是：

void (*signal(int signo,void (*func)(int))) (int)

我們先來看一個使用訊號驅動的例子，通過signal(SIGIO,input_handler) 對開啟的檔案fd 啟動訊號機制，輸入可獲得時inputhandler被呼叫，程式碼如下：

/*async_io_app.c*/

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <fcntl.h>

#include <signal.h>

#include <unistd.h>

#include <stdlib.h>

#define MAX_LEN 100

int fd;

void input_handler(int num)
{

    char data[MAX_LEN];

    int
 
 len;

 

    //讀取並輸出 STDIN_FILENO 上的輸入

    len = read(fd, &data, MAX_LEN);

    data[len] = 0;

    printf("input available:%s\n", data);

}

int main()
{

    int oflags;

    //啟動訊號驅動機制

    fd = open("/dev/CDEV_ZHU", O_RDWR, S_IRUSR | S_IWUSR);

    if(fd == -1)
    {

              printf("Device Open Failure !\n
 
");

              exit(0);

    }

    signal(SIGIO, input_handler);

    fcntl(fd, F_SETOWN, getpid());

    oflags = fcntl(fd, F_GETFL);

    fcntl(fd, F_SETFL, oflags | FASYNC);

    //最後進入一個死迴圈，程式什麼都不幹了，只有訊號能激發 input_handler 的執行
    //如果程式中沒有這個死迴圈，會立即執行完畢

    while (1);

    return 0;

}

下面來解釋一下上面的程式碼。為了一個使用者在使用者空間中能處理一個裝置釋放的訊號，它必須完成一下3份工作：

 1)通過F_SETOWN控制指令設定裝置檔案的擁有者為本程序,這樣從裝置驅動中發出的訊號才能被本程序收到。

 2)通過F_SETFL 控制命令設定裝置檔案支援FASYNC,即非同步通知模式。

 3)通過signal()連結訊號和訊號處理函式。

有了訊號的傳送，那麼就一定得有訊號的釋放了：

  在裝置驅動和應用程式的非同步通知互動中，僅僅在應用程式端捕獲訊號是不夠的，因為訊號沒有的源頭是在驅動端，因此要在適當的時機讓裝置驅動釋放訊號。

 為了使裝置支援非同步通知機制，驅動程式中涉及三個操作：

 1)支援F_SETOWN命令，能在這個控制命令處理中設定filp->f_owner為對應的程序ID。不過此項工作已由核心完成，裝置驅動無須處理。

 2)支援F_SETFL命令的處理,每當FASYNC標誌改變時，驅動程式中fasync()函式將得以進行。因此,驅動程式必須實現fasync()函式。

 3)在裝置資源可獲得時,呼叫kill_fasync()函式激發相應的訊號。

 驅動程式中上面的三步是和應用程式是一一對應的。如下圖：

裝置驅動中非同步通知程式設計還是比較簡單的，主要就是一些資料結構，和兩個函式：

資料結構：fasync_struct結構體

函式：1）處理FASYNC標誌變更的函式int fasync_helper(int fd, struct file *filp, int mode ,struct fasync_struct **fa);

2) 釋放訊號用的函式void kill_fasync(struct fasync_struct **fa, int sig, int band);

和其他裝置驅動一樣，一般將fasync_struct放到裝置結構體中。

下面給出驅動程式部分實現支援非同步IO的程式碼：

/* async_io_driver.c */

#include <linux/module.h>

#include <linux/init.h>

#include <linux/fs.h>

#include <asm/uaccess.h>

#include <linux/wait.h>

#include <linux/semaphore.h>

#include <linux/device.h>

#include <linux/cdev.h>

#include <linux/sched.h>

#include <linux/fcntl.h>

#include <linux/poll.h>

MODULE_LICENSE("GPL");

#define LEN  30

#define init_MUTEX(LOCKNAME) sema_init(LOCKNAME,1)

#define DEVICE_NAME  "CDEV_ZHU"

static struct class *cdev_class;

struct asycIO                                    

{                                                        

  struct cdev dev_c; /*cdev結構體*/   

  dev_t  dev; 

  char  mem[LEN];

  int   flag ;

  struct semaphore sem; /*併發控制用的訊號量*/          

  wait_queue_head_t r_wait; /*阻塞讀用的等待佇列頭*/    

  struct fasync_struct *async_queue; /* 非同步結構體指標，用於讀 */

};

struct asycIO  asyc_device;

static int asyc_io_fasync(int fd, struct file *filp, int mode)

{

         return fasync_helper(fd, filp, mode, &asyc_device.async_queue);

}

/*檔案釋放函式*/

int asyc_io_release(struct inode *inode, struct file *filp)

{

         /* 將檔案從非同步通知列表中刪除 */

  asyc_io_fasync( - 1, filp, 0);

  return 0;

}

/*寫操作*/

static ssize_t asyc_write(struct file *filp, const char __user *buf,size_t count, loff_t *ppos)

{

   int ret = count;

  printk("In asyc_write!　\n");

  down(&asyc_device.sem);  //獲取訊號量

  memset(asyc_device.mem,0,LEN);

  if (copy_from_user(asyc_device.mem, buf, count))

  {

        up(&asyc_device.sem);

        return    - EFAULT;

  }

  printk("kernel recieve: %s  and the length is %d \n",asyc_device.mem,count);

  up(&asyc_device.sem);

  asyc_device.flag = 1;

  if (asyc_device.async_queue)

       kill_fasync(&asyc_device.async_queue, SIGIO, POLL_IN);

  wake_up_interruptible(&asyc_device.r_wait);

  return ret;

}

static ssize_t asyc_read(struct file *filp, char *buf, size_t len, loff_t *off)

{

         int ret = len;

         printk("In asyc_read \n");

    if (wait_event_interruptible(asyc_device.r_wait, asyc_device.flag != 0))

    {

        return    - ERESTARTSYS;

    }

    if (down_interruptible(&asyc_device.sem))

    {

        return    - ERESTARTSYS;

    }

    asyc_device.flag = 0;

    if (copy_to_user(buf, asyc_device.mem, len))

    {

        up(&asyc_device.sem);

        return    - EFAULT;

    }

    up(&asyc_device.sem);

    return ret;

}

struct file_operations asyc_fops =

{

         read: asyc_read,

         write: asyc_write,

         fasync: asyc_io_fasync,

         release: asyc_io_release,

};

static int __init asyc_init(void)

{

    int ret,err;

    ret = alloc_chrdev_region(&(asyc_device.dev),0,1,DEVICE_NAME) ;

    if (ret)

    {

        printk("globalvar register failure");

    }

    else

    {

                   cdev_init(&(asyc_device.dev_c),&asyc_fops);

                   err = cdev_add(&(asyc_device.dev_c),asyc_device.dev,1);

                   if(err)

                   {

                            printk(KERN_NOTICE "error %d adding FC_dev\n",err);

                            unregister_chrdev_region(asyc_device.dev, 1);

                            return err;

                   }

                   else

                   {

                            printk("device register success! \n");

                   }

                   cdev_class = class_create(THIS_MODULE,DEVICE_NAME);

                   if(IS_ERR(cdev_class))

                   {

                            printk("ERR:cannot create a cdev_class\n"); 

                            unregister_chrdev_region(asyc_device.dev, 1);

                            return -1;

                   }

                   device_create(cdev_class, NULL, asyc_device.dev, 0, DEVICE_NAME);

                   asyc_device.flag = 0;

                   init_MUTEX(&(asyc_device.sem));

                   init_waitqueue_head(&(asyc_device.r_wait));

    }

    return ret;

} 

static void __exit asyc_exit(void)

{

         device_destroy(cdev_class,asyc_device.dev);

         class_destroy(cdev_class);

         unregister_chrdev_region(asyc_device.dev,1);

         printk(" device exit! \n");

}

module_init(asyc_init);

module_exit(asyc_exit);

應用程式實現寫入功能：

/* async_io_app_w.c*/

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <fcntl.h>

#include <string.h>

int main()

{

    int fd, num;

    char buffer[100] = {0};

    fd = open("/dev/CDEV_ZHU", O_RDWR, S_IRUSR | S_IWUSR);

    printf("open /dev/CDEV_ZHU fd = %d \n",fd);

    if (fd != -1)

    {

        while (1)

        {

             memset(buffer,0,sizeof(buffer));

            printf("Please input the buffer:\n");

            scanf("%s", buffer);

             if (buffer[0] == '0') //如果輸入 0，退出

            {

                close(fd);

                break;

            }

            write(fd, buffer, strlen(buffer));   

            printf("We have written: %s\n",buffer);

        }

    }

    else

    {

        printf("device open failure\n");

    }

         return 0;

}

將上面的“async_io_app.c”、“async_io_driver.c”、“async_io_app_w.c”進行編譯，載入驅動之後，開兩個終端，分別執行async_io_app 和 async_io_app_w，當async_io_app_w有資料寫入的時候，async_io_app的終端會列印所寫入的資料，當然核心也會列印資料，下面是結果：

 說明：上面圖是三個終端的列印結果，從左到右一次是async_io_app_w , async_io_app 和使用dmesg 列印核心的結果。

注：我本來也想用程式碼格式，但是感覺在vim上排版很舒服的，上來用程式碼格式反而還不好看了，於是就這樣了