Hasen的linux设备驱动开发学习之旅--异步I/O
/** * Author:hasen * 参考 :《linux设备驱动开发详解》 * 简介:android小菜鸟的linux * 设备驱动开发学习之旅 * 主题:异步I/O * Date:2014-11-11 */
linux中最常用的输入/输出(I/O)模型是同步I/O。在这个模型中,请求发出后,应用就会阻塞,知道请求满足
为止。但是在某些情况下,I/O请求可能需要与其他的进程进行交叠。可移植操作系统接口(POSIX)异步I/O(AIO)应用程序接口(API)就提供了这种功能。
AIO基本思想是允许进程发起很多的I/O操作,而不用阻塞或者等待任何操作完成。稍后或在接受到I/O操作完成的通知时,进程再检索I/O操作的结果。
在异步非阻塞I/O中,每个传输操作都有唯一的上下文,通过aiocb(AIO I/O Control Block)结构体进行区分,包含了有关传输的所有信息,以及为数据准备的用户缓冲区。在产生I/O通知(称为完成)时,该结构唯一标
识所完成的I/O操作。
AIO系列API被GNU C库函数所包含,它被POSIX.1b所要求,主要有以下的函数:
(1)aio_read int aio_read(struct aiocb *aiocbp) ;/*对一个有效的文件描述符进行异步操作*/ 文件描述符可以表示文件,套接字,管道,aio_read()在请求进行排队后立即返回,执行成功返回0, 出现错误返回-1,并设置errno的值。 (2)aio_write int aio_write(struct aiocb *aiocbp) ;/*用来请求一个异步写操作*/ aio_write()函数会立即返回,说明请求已经进行排队,成功返回0,失败返回-1,并相应地设置errno。 (3)aio_error aio_error(struct aiocb *aiocbp) ;/*用来确定请求的状态*/ 这个函数可以返回以下内容。 EINPROGRESS:说明请求尚未完成。 ECANCELLED:说明请求被应用程序取消了。 -1:说明发生了错误,具体错误原因由errno记录。 (4)aio_return /*异步I/O和标准I/O方式之间的另一个区别是不能立即访问这个函数的返回状态,因为异步I/O并没有阻塞 在read()调用上。在标准的read()调用中,返回状态是在该函数返回时提供的。但是在异步I/O中,使用 aio_return()函数*/ ssize_t aio_return(struct aiocb *aiocbp) ; 只有在aio_error()调用确定请求已经完成(可能成功,或者发生错误)之后,才会调用这个函数, aio_return()函数的返回值就等价于同步情况中read()和write()的返回值,成功返回字节数, 错误返回负值。
下面的代码示例给出了用户空间进行异步读操作,它首先打开文档,然后准备aiocb结构体,之后调用aio_read(&my_aiocb)进行提出异步读请求,当aio_error(&my_aiocb)==EINPROGRESS,即操作还在进行中,一直等待,结束后通过aio_return(&my_aiocb)获得返回值。
#include <aio.h> ... int fd ,ret ; struct aiocb my_aiocb ; fd = open("file.txt",O_RDONLY) ; if(fd<0) perror("open") ; /*清零aiocb结构体*/ bzero((char *)&my_aiocb,sizeof(struct aiocb)) ; /*为aiocb结构体请求分配数据缓冲区*/ my_aiocb.aio_buf = malloc(BUFSIZE + 1) ; if(!my_aiocb.aio_buf) perror("malloc") ; /*初始化aiocb的成员*/ my_aiocb.aio_fildes = fd ; my_aiocb.aio_nbytes = BUFSIZE ; my_aiocb.aio_offset = 0 ; ret = aio_read(&my_aiocb) ; if(ret < 0) perror("aio_read") ; while(aio_error(&my_aiocb) == EINPROGRESS) continue ; if((ret = aio_return(&my_aiocb)) > 0){ /*获得异步读的返回值*/ }else{ /*读失败,分析errno*/ }
(5)aio_suspend 用户可以使用aio_suspend()函数来挂起(或阻塞)调用进程,直到异步请求完成为止,此时会产生一个信号, 或者发生其他超时操作。调用者提供了一个aiocb引用列表,其中任何一个完成都会导致aio_suspend()返回。 int aio_suspend(const struct aiocb cblist[] ,int n,const struct timespec *timeout) ; 注意,aio_suspend 的第二个参数是 cblist 中元素的个数,而不是 aiocb 引用的个数。cblist中任何 NULL元素都会被 aio_suspend 忽略。如果为 aio_suspend 提供了超时,而超时情况的确发生了,那么它 就会返回 -1,errno 中会包含 EAGAIN。示例:用户空间异步I/O aio_suspend()函数使用
struct aioct *cblist[MAX_LIST] /*清零aioct结构体链表*/ bzero((char *)cblist,sizeof(cblist)) ; /*将一个或更多的aiocb放入aioct结构体链表*/ cblist[0] = &my_aiocb ; ret = aio_read(&my_aiocb) ; ret = aio_suspend(cblist,MAX_LIST,NULL) ;
(6)aio_cancel aio_cancel()函数允许用户取消对某个文件描述符执行的一个或者所有的I/O请求,原型如下: int aio_cancel(int fd ,struct aiocb *aiocbp) ; 要取消一个请求,我们需要提供文件描述符和 aiocb 引用。如果这个请求被成功取消了,那么这个函数 就会返回AIO_CANCELED。如果请求完成了,这个函数就会返回 AIO_NOTCANCELED。 要取消对某个给定文件描述符的所有请求,我们需要提供这个文件的描述符,以及一个对 aiocbp的 NULL 引用。如果所有的请求都取消了,这个函数就会返回 AIO_CANCELED;如果至少有一个请求没有被取消,那么这 个函数就会返回 AIO_NOT_CANCELED;如果没有一个请求可以被取消,那么这个函数就会返回 AIO_ALLDONE。 我们然后可以使用 aio_error 来验证每个 AIO 请求。如果这个请求已经被取消了,那么 aio_error 就会返 回-1,并且errno 会被设置为 ECANCELED。 (7)lio_listio 最后,AIO 提供了一种方法使用 lio_listio API 函数同时发起多个传输。这个函数非常重要,因为这意 味着我们可以在一个系统调用(一次内核上下文切换)中启动大量的 I/O 操作。从性能的角度来看,这非常重 要,因此值得我们花点时间探索一下。lio_listio API 函数的原型如下: int lio_listio( int mode, struct aiocb *list[], int nent,struct sigevent *sig ); mode 参数可以是 LIO_WAIT 或 LIO_NOWAIT。LIO_WAIT 会阻塞这个调用,直到所有的 I/O 都完成为 止。在操作进行排队之后,LIO_NOWAIT 就会返回。list 是一个 aiocb 引用的列表,最大元素的个数是由 nent定义的。注意 list 的元素可以为 NULL,lio_listio 会将其忽略。sigevent 引用定义了在所有 I/O 操作都完成时产生信号的方法。示例:用户空间异步I/O lio_listio()的使用
struct aiocb aiocb1,aiocb2 ; struct aiocb *list[MAX_LIST] ; ... /*准备第一个aiocb*/ aiocb1.aio_fildes = fd ; aiocb1.aio_buf = malloc(BUFSIZE + 1) ; aiocb1.aio_nbytes = BUFSIZE ; aiocb1.aio_offset = next_offset ; /*LIO_READ读操作,LIO_WRITE写操作,LIO_NOP空操作*/ aiocb1.aio_lio_opcode = LIO_READ;/*异步读操作*/ ... /*准备多个aiocb*/ bzero((char *)list,sizeof(list)) ; /*将aiocb填入链表*/ list[0] = aiocb1 ; list[1] = aiocb2 ; ... ret = lio_listio(LIO_WAIT,list,MAX_LIST,NULL) ;/*发起大量I/O操作*/使用回调函数作为AIO的通知
除了信号之外,应用程序还可以提供一个回调(Callback)函数给内核,以便AIO的请求完成后内核调用这个函数。
示例:使用回调函数作为AIO异步I/O通知机制
/*设置异步I/O请求*/ void setup_io(...) { int fd ; struct aiocb my_aiocb ; ... /*设置AIO请求*/ bzero((char *)&my_aiocb,sizeof(struct aiocb)) ; aiocb.aio_fildes = fd ; aiocb.aio_buf = malloc(BUFSIZE + 1) ; aiocb.aio_nbytes = BUFSIZE ; aiocb.aio_offset = next_offset ; /*连接AIO请求和线程回调函数*/ my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD ; my_aiocb.aio_sigevent.notify_function = aio_completion_handler ; /*设置回调函数*/ my_aiocb.aio_sigevent.notify_attributes = NULL ; my_aiocb.aio_sigevent.sigev_value_sival_ptr = &my_aiocb ; ... ret = aio_read(&my_aiocb) ; } /*异步I/O完成回调函数*/ void aio_completion_handler(sigval_t sigval) { struct aiocb *req ; req = (struct aiocb *)sigval.sival_ptr ; /*AIO请求完成*/ if(aio_error(req) == 0) /*请求完成,获得返回值*/ ret = aio_return (req) ; }
上述程序在创建aiocb请求之后,使用了SIGEV_THREAD请求了一个线程回调函数作为通知方法。在回调函数中,通过(struct aiocb*)sigval.sival_ptr可以获得对应的aiocb指针,使用AIO函数可验证请求是否已经完成。
proc文件系统包含了两个虚拟文件,他们可以用来对异步I/O的性能进行优化。
(1)/proc/sys/fs/aio-nr 文件提供了系统范围异步I/O请求现在的数目。
(2)/proc/sys/fs/aio-max-nr 文件是允许的并发请求的最大个数,最大个数通常是64KB,这对于大部分应用
程序来说都已经足够了。AIO与设备驱动
在内核中,每个I/O请求都对应于一个kiocb结构体,其ki_filp成员指向对应的file指针,通过is_sync_kiocb()可以判断某kiocb是否为同步I/O请求,如果返回非真,表示为异步I/O请求。
块设备和网络设备本身是异步的,只有字符设备必须明确表明应支持AIO,AIO对于大多数字符设备而言都不是必须的,只有极少数设备需要,比如,对于磁带机,由于I/O操作很慢,这时候使用异步I/O可以改善性能。
字符设备驱动程序中,file_operations包含3个与AIO相关的成员函数:
ssize_t (*aio_read)(struct kiocb *iocb,char *buffer,size_t count,loff_t offset); ssize_t (*aio_write)(struct kiocb *iocb,char *buffer,size_t count,loff_t offset); ssize_t (*aio_fsync)(struct kiocb *iocb,int datasync) ;
aio_read()和aio_write()与filp_operations中的read()和write()中的offset参数不一样,它直接传值,而后者是传递的指针,这是因为AIO从来不需要改变文件的位置。
aio_read()和aio_write()函数本身不一定完成了读和想写操作,它只是发起,初始化读和写操作。示例:设备驱动中的I/O函数
struct async_work() { struct kiocb *iocb ;/*kiocb结构体指针*/ int result ;/*执行结果*/ struct work_struct work ;/*工作结构体*/ }; ... /*异步读*/ static ssize_t xxx_aio_read(struct kiocb *iocb,char *buf,size_t count,loff_t pos) { return xxx_defer_op(0,iocb,count,pos) ; } /*异步写*/ static ssize_t xxx_aio_write(struct kiocb *iocb,const char *buf,size_t count,loff_t pos) { return xxx_defer_op(1,iocb,count,pos) ; } /*初始化异步I/O*/ static int xxx_defer_op(int write,struct kiocb *iocb,char *buf,size_t count,loff_t pos) { struct async_work *async_wk ; int result ; /*当我们能访问buffer时进行copy*/ if(write) result = xxx_write(iocb->ki_filp,buf,count,&pos) ; else result = xxx_read(iocb->filp,buf,count,&pos) ; /*如果是同步IOCB,立即返回状态*/ if(is_sync_kiocb(iocb)) return result ; /*否则,推后几秒执行*/ async_wk = kmalloc(sizeof(*async_wk),GFP_KERNEL) ; if(async_wk == NULL) return result ; /*调度延迟的工作*/ async_wk->iocb = iocb ; async_wk->result = result ; INIT_WORK(&async_wk->work,xxx_do_deferred_op,async_wk) ; schedule_delay_work(&async_wk->work ,Hz/100) ; return -EIOCBQUEUED ;/*控制权返回用户空间*/ } /*延迟后执行*/ static void xxx_do_deferred_op(void *p) { struct async_work *async_wk = (struct async_work *)p ; ... /*执行I/O操作*/ aio_complete(async_wk->iocb,async_wk->result,0) ; kfree(async_wk) ; }
上述代码最核心的是使用work_struct机制通过schedule_delay_work()函数将I/O操作延迟执行,而在具体的I/O操作执行完成后,调用aio_complete()通知内核驱动程序已经完成了I/O操作。
通常而言,具体的字符设备驱动一般不许呀AIO支持,而内核中仅有fs/direct-io.c,driver/usb/gadget/inode.c,fs/nfs/direct.c等少量地方使用了AIO。
郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。