前言

前幾篇介紹了幾種IO模型，今天介紹另一種IO模型——異步IO。

相對于前面的幾種IO模型，異步IO在提交完IO操作請求后就立即返回，程序不需要等到IO操作完成再去做別的事情，具有非阻塞的特性。

當底層把IO操作完成后，可以給提交者發送信號，或者調用注冊的回調函數，告知請求提交者IO操作已完成。

在信號處理函數或者回調函數中，可以使用異步IO接口來獲得IO的完成情況，比如獲取讀寫操作返回的字節數或錯誤碼、讀取的數據等。

相關接口

struct aiocb結構體

struct aiocb {
    int aio_fildes;               /* file descriptor */
    off_t aio_offset;             /* file offset for I/O */
    volatile void *aio_buf;       /* buffer for I/O */
    size_t aio_nbytes;            /* number of bytes tdo transfer */
    int aio_reqprio;              /* priority */
    struct sigevent aio_sigevent; /* signal information */
    int aio_lio_opcode;           /* operation for list I/O */
};

aio_fildes：操作的文件描述符

aio_offset：偏移量，讀寫操作的起始位置

aio_buf：讀寫操作的數據緩沖區

aio_nbytes：傳輸數據的字節數

aio_reqprio：請求權限

aio_lio_opcode：操作碼，表示讀還是寫，LIO_READ代表讀，LIO_WRITE代表寫。

struct sigevent結構體

struct sigevent {
    int sigev_notify;          /* notify type */
    int sigev_signo;           /* signal number */
    union sigval sigev_value;  /* notify argument */
    void (*sigev_notify_function)(union sigval); /* notify function */
    pthread_attr_t *sigev_notify_attributes;    /* notify attrs */
};

sigev_notify：通知類型。SIGEV_NONE表示不通知；SIGEV_SIGNAL表示IO操作完成后，收到sigev_signo指定的信號；SIGEV_THREAD表示IO操作完成，內核會創建一個新線程執行一個回調函數，函數由sigev_notify_function指定

sigev_signo：指定的信號

sigev_notify_function：回調函數

sigev_notify_attributes：使用默認屬性，一般設置為NULL

應用層異步IO讀寫函數：

#include < aio.h >
int aio_read(struct aiocb *aiocb);
int aio_write(struct aiocb *aiocb);
 
//返回值：成功返回0;失敗返回-1

獲取一個異步讀、寫或者同步操作的完成狀態：

#include < aio.h >
int aio_error(const struct aiocb *aiocb);

調用aio_return函數，可以用來判斷異步IO的執行情況

#include < aio.h >
ssize_t aio_return(const struct aiocb *aiocb);

下面以一個實際例子說明異步IO的用法

應用層

#include < stdio.h >
#include < stdlib.h >
#include < string.h >
#include < sys/types.h >
#include < sys/stat.h >
#include < sys/ioctl.h >
#include < fcntl.h >
#include < errno.h >
#include < poll.h >
#include < linux/input.h >
#include < aio,h >


void aiow_completion_handler (sigval_t sigval)
{
 int ret;
 struct aiocb *req;

 req = (struct aiocb *)sigval.sival_ptr;

 if (aio_error(req) == 0) {
     ret = aio_return (req) ;
     printf ("aio write %d bytes\\n", ret);
 }

 return;
}

void aior_completion_handler ( sigval_t sigval )
{
    int ret;
    struct aiocb *req;
    
    req = (struct aiocb * )sigval.sival_ptr;
    
    if (aio_error (req > == 0 ) {
     ret = aio_return (req);
        if (ret)
            printf ("aio read: %s\\n", (char * ) req- >aio_buf );
    }
    
    return;
}
        
int main(int argc, char *argv [])
{
    
    int ret;
    int fd;
    struct aiocb aiow,aior;
    
    fd = open("/dev/vser0", O_RDWR);
    if (fd == -1)
        goto fail;
    
    memset (&aiow, 0, sizeof (aiow));
    memset (&aior, 0, sizeof (aior));
    
    aiow.aio_fildes = fd;
    aiow.aio_buf = malloc(32);
    strcpy((char *)aiow.aio_buf,"aio test");
 aiow.aio_nbytes = strlen ( (char * ) aiow.aio_buf ) + 1;
 aiow.a*io_of f set = 0;
 aiow.aio_sigevent.sigev_notify = SIGEV_THREAD;
 aiow.aio_sigevent.sigev_notify_function = aiow_completion_handler;
 aiow.aio_sigevent.sigev_notify_attributes = NULL;
 aiow.aio_sigevent.sigev_value.sival_ptr = &aiow;

    aior.aio_fildes = fd;
 aior.aio_buf = malloc (32);
 aior.aio_nbytes = 32;
 aior.aio_offset = 0;
 aior.aio_sigevent ?sigev_notify = SIGEV_THREAD;
    aior.aio_sigevent.sigev_notify_function = aior_completion_handler;
 aior.aio_sigevent.sigev_notify_attributes = NULL;
 aior.aio_sigevent.sigev_value.sival_ptr = &aior;
           
    while(1){
        if(aio_write(&aiow) == -1)
            goto fail;
        if(aio_read(&aior) == -1)
            goto fail;
        sleep(1);
    }
           
fail:
           perror("aio test");
           exit(EXIT_FAILURE);
}

1、首先定義兩個用于讀和寫的異步IO控制塊struct aiob

2、初始化異步IO控制塊，包括文件描述符、用讀寫的緩沖區、讀寫的字節數和回調函數

3、發起一個異步操作， 調用aio_wirte或者aio_read，該函數會立即返回，具體的讀寫操作會在驅動中完成 。

4、讀寫完成后，對應的回調函數會被自動調用

在寫操作回調函數中，通過aio_error和aio_return獲取了IO操作的錯誤碼及實際的寫操作的返回值。

在讀操作回調函數中，除了可以獲取完成狀態，還可以從aio_buf中獲取讀取的數據。

注意這里的關鍵點：1、 調用aio_wirte或者aio_read，該函數會立即返回，具體的讀寫操作會在驅動中完成 。2、讀寫完成后，對應的 回調函數會被自動調用 。

驅動層

驅動中異步IO相關代碼如下：

DEFINE_KFIFO(vsfifo, char, 32);

static ssize_t my_read(struct file *flip, char __user *buf, size_t count, loff_t *pos)
{
 int ret;
    unsigned int copied = 0;
    
    ret = kfifo_to_user(&vsfifo, buf, count, &copied);
    
 return ret == 0 ? copied : ret;
}

static ssize_t my_write(struct file *flip, const char __user *buf, size_t count, loff_tt *pos)
{
 int ret;
    unsigned int copied = 0;
    
    ret = kfifo_from_user(&vsfifo, buf, count, &copied);
        
 return ret == 0 ? copied :ret;
}


static ssize_t my_aio_read (struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos)
{
 size_t read = 0;
 unsigned long i;
    ssize_t reg;
    
    for(i = 0; i < nr_segs; i++) {
  ret = my_read(iocb- >ki_filp, iov[i].iov_base, iov[i].iov_len, &pos);
        if(ret < 0)
            break;
        read += ret;
 }
    
    return read ? read : -EFAULT;
}

static ssize_t my_aio_write (struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segsf loff_t pos)
{
 size_t written = 0;
 unsigned longi;
    ssize t ret;
    
    for (i = 0;i < nr_segs;i++) {
     ret = my_write(iocb- >lci_filp, iov [i].iov_base, iov [i].iov_len, &pos);
        if(ret < 0)
            break;
        written += ret;
    }
    
    return written ? written : -EFAULT;
}

static struct file_operations my_ops = {
......
    .aio_read = my_aio_read,
    .aio_write = my_aio_write,
}

從驅動中可以看到，我們分別實現了兩種讀寫函數my_read、my_write和my_aio_read、my_aio_write。

在一般的讀寫操作函數實現中，是這樣的：

static struct file_operations my_ops = {
......
    .read = my_read,
    .write = my_write,
}

my_read()和my_wirte()函數實際上實現的是struct file_operations的.read和.write接口。

但是在異步IO的實現中，``my_aio_read()和my_aio_write()分別實現的是.aio_read和.aio_write`接口：

static struct file_operations my_ops = {
......
    .aio_read = my_aio_read,
    .aio_write = my_aio_write,
}

而my_aio_read()函數又會去調用my_read()函數，my_aio_write()函數會去調用my_write()函數。

所以實際上，異步IO還是要先實現一遍.read和.write的接口函數，然后在.aio_read和.aio_write的接口實現中，去調用之前實現的.read和.write接口。 只不過這里的主要區別是，異步IO會多次調用my_read()和my_write()函數 。

以異步讀為例，在 my_aio_read函數中，最關鍵的還是調用了my_read函數，但是my_read函數被調用了nr_serg次，這和分散/聚集操作是類似的，即 一次讀操作實際上是分多次進行的，每次讀取一定的字節數（iov[i].iov_len），然后分別將讀到的數據放入分散的內存區域中（iov[i].iov_base） 。

從驅動中不難發現，異步IO可以在驅動中阻塞，但是上層的操作卻是非阻塞的。