Linux 设备驱动中的异步通知与异步 I/O(2)

AIO 概念与 GNU C 库函数 

Linux 系统中最常用的输入/输出（I/O）模型是同步 I/O。在这个模型中，当请求发出之后，应用程序就会阻塞，直到请求满足为止。这是很好的一种解决方案，因为调用应用程序在等待 I/O 请求完成时不需要使用任何中央处理单元（CPU）。但是在某
些情况下，I/O 请求可能需要与其他进程产生交叠。可移植操作系统接口（POSIX）异步 I/O（AIO）应用程序接口（API）就提供了这种功能。 

Linux 异步 I/O 是 2.6 版本内核的一个标准特性，但是我们在 2.4 版本内核的补丁中也可以找到它。AIO 基本思想是允许进程发起很多 I/O 操作，而不用阻塞或等待任何操作完成。稍后或在接收到 I/O 操作完成的通知时，进程就可以检索 I/O 操作的结
果。 

select()函数所提供的功能（异步阻塞 I/O）与 AIO 类似，它对通知事件进行阻塞，而不是对 I/O 调用进行阻塞。 

在异步非阻塞 I/O 中，我们可以同时发起多个传输操作。这需要每个传输操作都有惟一的上下文，这样才能在它们完成时区分到底是哪个传输操作完成了。在 AIO 中，通过 aiocb（AIO I/O Control Block）结构体进行区分。这个结构体包含了有关传输的所有信息，包括为数据准备的用户缓冲区。在产生 I/O（称为完成）通知时，aiocb 结构就被用来惟一标识所完成的 I/O 操作。 

AIO 系列 API 被 GNU C 库函数所包含，它被 POSIX.1b 所要求，主要包括如下函数。 

1．aio_read 

aio_read()函数请求对一个有效的文件描述符进行异步读操作。这个文件描述符可以表示一个文件、套接字甚至管道

aio_read 函数的原型如下： 

int aio_read( struct aiocb *aiocbp ); 

aio_read()函数在请求进行排队之后会立即返回。如果执行成功，返回值就为 0；如果出现错误，返回值就为−1，并设置 errno 的值。 

2．aio_write 

aio_write()函数用来请求一个异步写操作，其函数原型如下： 

int aio_write( struct aiocb *aiocbp ); 

aio_write()函数会立即返回，说明请求已经进行排队（成功时返回值为 0，失败时返回值为−1，并相应地设置 errno。 

3．aio_error 

aio_error 函数被用来确定请求的状态，其原型如下： 

int aio_error( struct aiocb *aiocbp ); 

这个函数可以返回以下内容。 

EINPROGRESS：说明请求尚未完成。 

ECANCELLED：说明请求被应用程序取消了。 

-1：说明发生了错误，具体错误原因由 errno 记录。 

4．aio_return 

异步 I/O 和标准块 I/O 之间的另外一个区别是不能立即访问这个函数的返回状态，因为并没有阻塞在 read()调用上。在标准的 read()调用中，返回状态是在该函数返回时提供的。但是在异步 I/O 中，我们要使用 aio_return()函数。这个函数的原型如下：

ssize_t aio_return( struct aiocb *aiocbp ); 

只有在 aio_error()调用确定请求已经完成（可能成功，也可能发生了错误）之后，才会调用这个函数。aio_return()的返回值就等价于同步情况中 read 或 write 系统调用的返回值（所传输的字节数，如果发生错误，返回值就为−1）。 

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

[html]  view plain  copy

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

用户可以使用 aio_suspend()函数来挂起（或阻塞）调用进程，直到异步请求完成为止，此时会产生一个信号，或者发生其他超时操作。调用者提供了一个 aiocb 引用列表，其中任何一个完成都会导致 aio_suspend()返回。aio_suspend 的函数原型如下： 

int aio_suspend( const struct aiocb *const cblist[], int n, const struct timespec *timeout ); 

下面代码清单给出了用户空间异步读操作时使用 aio_suspend()函数的例子。

[html]  view plain  copy

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

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。 lio_listio()函数可用于同时发起多个传输。这个函数非常重要，它使得用户可以在一个系统调用（一次内核上下文切换）中启动大量的 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()会将其忽略。 

代码清单给出了用户空间异步 I/O 操作时使用 lio_listio()函数的例子。

[html]  view plain  copy

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

上述代码第 9 行中，因为是进行异步读操作，所以操作码为 LIO_READ，对于写操作来说，应该使用 LIO_WRITE 作为操作码，而 LIO_NOP 意味着空操作。 

使用信号作为 AIO 的通知 

上面讲述的信号作为异步通知的机制在 AIO 中仍然是适用的，为使用信号，使用 AIO 的应用程序同样需要定义信号处理程序，在指定的信号被产生时会触发调用这个处理程序。作为信号上下文的一部分，特定的 aiocb 请求被提供给信号处理函数用来区分 AIO 请求。 

下面代码清单给出了使用信号作为 AIO 异步 I/O 通知机制的例子。

[html]  view plain  copy

1. 1  /*设置异步 I/O 请求*/   
2. 2  void setup_io(...)   
3. 3  {   
4. 4    int fd;   
5. 5    struct sigaction sig_act;   
6. 6    struct aiocb my_aiocb;   
7. 7    ...   
8. 8    /* 设置信号处理函数 */   
9. 9    sigemptyset(&sig_act.sa_mask);   
10. 10   sig_act.sa_flags = SA_SIGINFO;   
11. 11   sig_act.sa_sigaction = aio_completion_handler;   
12. 12    
13. 13   /* 设置 AIO 请求 */   
14. 14   bzero((char*) &my_aiocb, sizeof(struct aiocb));   
15. 15   my_aiocb.aio_fildes = fd;   
16. 16   my_aiocb.aio_buf = malloc(BUF_SIZE + 1);   
17. 17   my_aiocb.aio_nbytes = BUF_SIZE;   
18. 18   my_aiocb.aio_offset = next_offset;   
19. 19    
20. 20   /* 连接 AIO 请求和信号处理函数 */   
21. 21   my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;   
22. 22   my_aiocb.aio_sigevent.sigev_signo = SIGIO;   
23. 23   my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;   
24. 24    
25. 25   /* 将信号与信号处理函数绑定 */   
26. 26   ret = sigaction(SIGIO, &sig_act, NULL);   
27. 27   ...   
28. 28   ret = aio_read(&my_aiocb); /*发出异步读请求*/   
29. 29 }   
30. 30    
31. 31 /*信号处理函数*/   
32. 32  void  aio_completion_handler(int  signo,  siginfo_t  *info,  void *context)   
33. 33 {   
34. 34   struct aiocb *req;   
35. 35    
36. 36   /* 确定是我们需要的信号*/   
37. 37   if (info->si_signo == SIGIO)   
38. 38   {   
39. 39     req = (struct aiocb*)info->si_value.sival_ptr; /*获得 aiocb*/   
40. 40    
41. 41     /* 请求的操作完成了吗? */   
42. 42     if (aio_error(req) == 0)   
43. 43     {   
44. 44       /* 请求的操作完成，获取返回值 */   
45. 45       ret = aio_return(req);   
46. 46     }   
47. 47   }   
48. 48   return ;   
49. 49 }   

特别要注意上述代码的第 39 行通过(struct aiocb*)info->si_value.sival_ptr 获得了信号对应的 aiocb。 

使用回调函数作为 AIO 的通知 

除了信号之外，应用程序还可提供一个回调（Callback）函数给内核，以便 AIO 的请求完成后内核调用这个函数。 

一般来说，下层对上层（如内核对应用）的调用都称为“回调”，而上层对下层（如进行 Linux 系统调用）的调用称为“调用”，如图 9.3 所示。

 

代码清单给出了使用回调函数作为 AIO 异步 I/O 请求完成的通知机制的例子。 

[html]  view plain  copy

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

上述程序在创建 aiocb 请求之后，使用 SIGEV_THREAD 请求了一个线程回调函数来作为通知方法。在回调函数中，通过(struct aiocb*)sigval.sival_ptr 可以获得对应的aiocb 指针，使用 AIO 函数可验证请求是否已经完成。 

proc 文件系统包含了两个虚拟文件，它们可以用来对异步 I/O 的性能进行优化。 

/proc/sys/fs/aio-nr 文件提供了系统范围异步 I/O 请求的数目。 

/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, const char *buffer, size_t count, loff_t offset); 

int (*aio_fsync) (struct kiocb *iocb, int datasync); 

aio_read()和 aio_write()与 file_operations 中的 read()和 write()中的 offset 参数不同，它直接传递值，而后者传递的是指针，这是因为 AIO 从来不需要改变文件的位置。 

aio_read()和 aio_write()函数本身不一定完成了读和写操作，它只是发起、初始化读和写操作，下面代码清单给出了驱动程序中aio_read()和aio_write()函数的实现例子。

[html]  view plain  copy

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

上述代码中最核心的是使用 aync_work（异步工作）结构体将操作延后执行，aync_work 结构体定义如代码清单所示，通过 schedule_delayed_work()函数可以调度其执行。第 46 行对 aio_complete()的调用用于通知内核驱动程序已经完成了操作。

[html]  view plain  copy

1. 1 struct async_work   
2. 2 {   
3. 3     struct kiocb *iocb;  //kiocb 结构体指针   
4. 4     int result;  //执行结果   
5. 5     struct work_struct work; //工作结构体   
6. 6 };