linux设备驱动开发学习之旅--异步I/O

[cpp]  view plain copy

1. /** 
2.  * Author:hasen 
3.  * 参考 ：《linux设备驱动开发详解》 
4.  * 简介：android小菜鸟的linux 
5.  *           设备驱动开发学习之旅 
6.  * 主题：异步I/O 
7.  * Date:2014-11-11 
8.  */  

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所要求，主要有以下的函数：

[cpp]  view plain copy

1. (1)aio_read  
2.     int aio_read(struct aiocb *aiocbp) ;/*对一个有效的文件描述符进行异步操作*/  
3.     文件描述符可以表示文件，套接字，管道,aio_read()在请求进行排队后立即返回，执行成功返回0，  
4.     出现错误返回-1，并设置errno的值。  
5. (2)aio_write     
6.     int aio_write(struct aiocb *aiocbp) ;/*用来请求一个异步写操作*/  
7.     aio_write()函数会立即返回，说明请求已经进行排队，成功返回0，失败返回-1，并相应地设置errno。  
8. (3)aio_error  
9.     aio_error(struct aiocb *aiocbp) ;/*用来确定请求的状态*/  
10.     这个函数可以返回以下内容。  
11.         EINPROGRESS:说明请求尚未完成。  
12.         ECANCELLED：说明请求被应用程序取消了。  
13.         -1：说明发生了错误，具体错误原因由errno记录。  
14. (4)aio_return  
15.     /*异步I/O和标准I/O方式之间的另一个区别是不能立即访问这个函数的返回状态，因为异步I/O并没有阻塞 
16.     在read()调用上。在标准的read()调用中，返回状态是在该函数返回时提供的。但是在异步I/O中，使用 
17.     aio_return()函数*/  
18.     ssize_t aio_return(struct aiocb *aiocbp) ;  
19.     只有在aio_error()调用确定请求已经完成(可能成功，或者发生错误)之后，才会调用这个函数，  
20.     aio_return()函数的返回值就等价于同步情况中read()和write()的返回值，成功返回字节数，  
21.     错误返回负值。  

        下面的代码示例给出了用户空间进行异步读操作，它首先打开文档，然后准备aiocb结构体，之后调用aio_read(&my_aiocb)进行提出异步读请求，当aio_error(&my_aiocb)==EINPROGRESS，即操作还在进行中，一直等待，结束后通过aio_return(&my_aiocb)获得返回值。

[cpp]  view plain copy

1. #include <aio.h>  
2. ...  
3.   
4. int fd ,ret ;  
5. struct aiocb my_aiocb ;  
6. fd = open("file.txt",O_RDONLY) ;  
7. if(fd<0)  
8.     perror("open") ;  
9.   
10. /*清零aiocb结构体*/  
11. bzero((char *)&my_aiocb,sizeof(struct aiocb)) ;  
12. /*为aiocb结构体请求分配数据缓冲区*/  
13. my_aiocb.aio_buf = malloc(BUFSIZE + 1) ;  
14. if(!my_aiocb.aio_buf)  
15.     perror("malloc") ;  
16.   
17. /*初始化aiocb的成员*/  
18. my_aiocb.aio_fildes = fd ;  
19. my_aiocb.aio_nbytes = BUFSIZE ;  
20. my_aiocb.aio_offset = 0 ;  
21.   
22. ret = aio_read(&my_aiocb) ;  
23. if(ret < 0)  
24.     perror("aio_read") ;  
25.   
26. while(aio_error(&my_aiocb) == EINPROGRESS)  
27.     continue ;  
28.   
29. if((ret = aio_return(&my_aiocb)) > 0){  
30.     /*获得异步读的返回值*/  
31. }else{  
32.     /*读失败，分析errno*/  
33. }  

[cpp]  view plain copy

1. (5)aio_suspend  
2.     用户可以使用aio_suspend()函数来挂起(或阻塞)调用进程，直到异步请求完成为止，此时会产生一个信号，  
3.     或者发生其他超时操作。调用者提供了一个aiocb引用列表，其中任何一个完成都会导致aio_suspend()返回。  
4.     int aio_suspend(const struct aiocb cblist[] ,int n,const struct timespec *timeout) ;  
5.     注意，aio_suspend 的第二个参数是 cblist 中元素的个数，而不是 aiocb 引用的个数。cblist中任何  
6.     NULL元素都会被 aio_suspend 忽略。如果为 aio_suspend 提供了超时，而超时情况的确发生了，那么它  
7.     就会返回 -1，errno 中会包含 EAGAIN。  

示例：用户空间异步I/O aio_suspend()函数使用

[cpp]  view plain copy

1. struct aioct *cblist[MAX_LIST]  
2. /*清零aioct结构体链表*/  
3. bzero((char *)cblist,sizeof(cblist)) ;  
4. /*将一个或更多的aiocb放入aioct结构体链表*/  
5. cblist[0] = &my_aiocb ;  
6. ret = aio_read(&my_aiocb) ;  
7. ret = aio_suspend(cblist,MAX_LIST,NULL) ;  

[cpp]  view plain copy

1. (6)aio_cancel  
2.         aio_cancel()函数允许用户取消对某个文件描述符执行的一个或者所有的I/O请求，原型如下：  
3.           
4.         int aio_cancel(int fd ,struct aiocb *aiocbp) ;  
5.   
6.         要取消一个请求，我们需要提供文件描述符和 aiocb 引用。如果这个请求被成功取消了，那么这个函数  
7.     就会返回AIO_CANCELED。如果请求完成了，这个函数就会返回 AIO_NOTCANCELED。  
8.         要取消对某个给定文件描述符的所有请求，我们需要提供这个文件的描述符，以及一个对 aiocbp的 NULL  
9.     引用。如果所有的请求都取消了，这个函数就会返回 AIO_CANCELED；如果至少有一个请求没有被取消，那么这  
10.     个函数就会返回 AIO_NOT_CANCELED；如果没有一个请求可以被取消，那么这个函数就会返回 AIO_ALLDONE。  
11.     我们然后可以使用 aio_error 来验证每个 AIO 请求。如果这个请求已经被取消了，那么 aio_error 就会返  
12.     回-1，并且errno 会被设置为 ECANCELED。  
13. (7)lio_listio  
14.         最后，AIO 提供了一种方法使用 lio_listio API 函数同时发起多个传输。这个函数非常重要，因为这意  
15.     味着我们可以在一个系统调用（一次内核上下文切换）中启动大量的 I/O 操作。从性能的角度来看，这非常重  
16.     要，因此值得我们花点时间探索一下。lio_listio API 函数的原型如下：  
17.       
18.         int lio_listio( int mode, struct aiocb *list[], int nent,struct sigevent *sig );  
19.           
20.         mode 参数可以是 LIO_WAIT 或 LIO_NOWAIT。LIO_WAIT 会阻塞这个调用，直到所有的 I/O 都完成为  
21.     止。在操作进行排队之后，LIO_NOWAIT 就会返回。list 是一个 aiocb 引用的列表，最大元素的个数是由  
22.     nent定义的。注意 list 的元素可以为 NULL，lio_listio 会将其忽略。sigevent 引用定义了在所有 I/O  
23.     操作都完成时产生信号的方法。  

示例：用户空间异步I/O lio_listio()的使用

[cpp]  view plain copy

1. struct aiocb aiocb1,aiocb2 ;  
2. struct aiocb *list[MAX_LIST] ;  
3. ...  
4. /*准备第一个aiocb*/  
5. aiocb1.aio_fildes = fd ;  
6. aiocb1.aio_buf = malloc(BUFSIZE + 1) ;  
7. aiocb1.aio_nbytes = BUFSIZE ;  
8. aiocb1.aio_offset = next_offset ;  
9. /*LIO_READ读操作，LIO_WRITE写操作，LIO_NOP空操作*/  
10. aiocb1.aio_lio_opcode = LIO_READ;/*异步读操作*/  
11. ... /*准备多个aiocb*/  
12. bzero((char *)list,sizeof(list)) ;  
13.   
14. /*将aiocb填入链表*/  
15. list[0] = aiocb1 ;  
16. list[1] = aiocb2 ;  
17. ...  
18. ret = lio_listio(LIO_WAIT,list,MAX_LIST,NULL) ;/*发起大量I/O操作*/  

使用回调函数作为AIO的通知
除了信号之外，应用程序还可以提供一个回调(Callback)函数给内核，以便AIO的请求完成后内核调用这个函数。
示例：使用回调函数作为AIO异步I/O通知机制

[cpp]  view plain copy

1. /*设置异步I/O请求*/  
2. void setup_io(...)  
3. {  
4.     int fd ;  
5.     struct aiocb my_aiocb ;  
6.     ...  
7.     /*设置AIO请求*/  
8.     bzero((char *)&my_aiocb,sizeof(struct aiocb)) ;  
9.     aiocb.aio_fildes = fd ;  
10.     aiocb.aio_buf = malloc(BUFSIZE + 1) ;  
11.     aiocb.aio_nbytes = BUFSIZE ;  
12.     aiocb.aio_offset = next_offset ;  
13.       
14.     /*连接AIO请求和线程回调函数*/  
15.     my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD ;  
16.     my_aiocb.aio_sigevent.notify_function = aio_completion_handler ;  
17.     /*设置回调函数*/  
18.     my_aiocb.aio_sigevent.notify_attributes = NULL ;  
19.     my_aiocb.aio_sigevent.sigev_value_sival_ptr = &my_aiocb ;  
20.     ...  
21.     ret = aio_read(&my_aiocb) ;  
22. }  
23.   
24. /*异步I/O完成回调函数*/  
25. void aio_completion_handler(sigval_t sigval)  
26. {  
27.     struct aiocb *req ;  
28.     req = (struct aiocb *)sigval.sival_ptr ;  
29.       
30.     /*AIO请求完成*/  
31.     if(aio_error(req) == 0)  
32.         /*请求完成，获得返回值*/  
33.         ret = aio_return (req) ;  
34. }  

上述程序在创建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相关的成员函数：

[cpp]  view plain copy

1. ssize_t (*aio_read)(struct kiocb *iocb,char *buffer,size_t count,loff_t offset);  
2. ssize_t (*aio_write)(struct kiocb *iocb,char *buffer,size_t count,loff_t offset);  
3. 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函数

[cpp]  view plain copy

1. struct async_work()  
2. {  
3.     struct kiocb *iocb ;/*kiocb结构体指针*/  
4.     int result  ;/*执行结果*/  
5.     struct work_struct work ;/*工作结构体*/  
6. };  
7. ...  
8. /*异步读*/  
9. static ssize_t xxx_aio_read(struct kiocb *iocb,char *buf,size_t count,loff_t pos)  
10. {  
11.     return xxx_defer_op(0,iocb,count,pos) ;  
12. }  
13.   
14. /*异步写*/  
15. static ssize_t xxx_aio_write(struct kiocb *iocb,const char *buf,size_t count,loff_t pos)  
16. {  
17.     return xxx_defer_op(1,iocb,count,pos) ;  
18. }  
19.   
20. /*初始化异步I/O*/  
21. static int xxx_defer_op(int write,struct kiocb *iocb,char *buf,size_t count,loff_t pos)  
22. {  
23.     struct async_work *async_wk ;  
24.     int result ;  
25.     /*当我们能访问buffer时进行copy*/  
26.     if(write)  
27.         result = xxx_write(iocb->ki_filp,buf,count,&pos) ;  
28.     else  
29.         result = xxx_read(iocb->filp,buf,count,&pos) ;  
30.     /*如果是同步IOCB，立即返回状态*/  
31.     if(is_sync_kiocb(iocb))  
32.         return result ;  
33.       
34.     /*否则，推后几秒执行*/  
35.     async_wk = kmalloc(sizeof(*async_wk),GFP_KERNEL) ;  
36.     if(async_wk == NULL)  
37.         return result ;  
38.     /*调度延迟的工作*/  
39.     async_wk->iocb = iocb ;  
40.     async_wk->result = result ;  
41.     INIT_WORK(&async_wk->work,xxx_do_deferred_op,async_wk) ;  
42.     schedule_delay_work(&async_wk->work ,Hz/100) ;  
43.     return -EIOCBQUEUED ;/*控制权返回用户空间*/  
44. }  
45.   
46. /*延迟后执行*/  
47. static void xxx_do_deferred_op(void *p)  
48. {  
49.     struct async_work *async_wk = (struct async_work *)p ;  
50.     ... /*执行I/O操作*/  
51.     aio_complete(async_wk->iocb,async_wk->result,0) ;  
52.     kfree(async_wk) ;  
53. }  

上述代码最核心的是使用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。