Linux驱动IO篇——异步IO

前言

---

前几篇介绍了几种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可以在驱动中阻塞，但是上层的操作却是非阻塞的。