Linux设备驱动开发详解-Note(19)---Linux 设备驱动中的异步通知与异步 I/O(2)

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

成于坚持,败于止步

Linux 2.6 异步 I/O

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)获得返回值。

1 #include <aio.h>
2 …
3 int fd, ret;
4 struct aiocb my_aiocb;
5
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
13 /* 为 aiocb 请求分配数据缓冲区 /
14 my_aiocb.aio_buf = malloc(BUFSIZE + 1);
15 if (!my_aiocb.aio_buf)
16 perror(“malloc”);
17
18 /
初始化 aiocb 的成员 /
19 my_aiocb.aio_fildes = fd;
20 my_aiocb.aio_nbytes = BUFSIZE;
21 my_aiocb.aio_offset = 0;
22
23 ret = aio_read(&my_aiocb);
24 if (ret < 0)
25 perror(“aio_read”);
26
27 while (aio_error(&my_aiocb) == EINPROGRESS)
28 ;
29
30 if ((ret = aio_return(&my_iocb)) > 0)
31 {
32 /
获得异步读的返回值 /
33 }
34 else
35 {
36 /
读失败,分析 errorno */
37 }
用户可以使用 aio_suspend()函数来挂起(或阻塞)调用进程,直到异步请求完成为止,此时会产生一个信号,或者发生其他超时操作。调用者提供了一个 aiocb 引用列表,其中任何一个完成都会导致 aio_suspend()返回。aio_suspend 的函数原型如下: 
int aio_suspend( const struct aiocb *const cblist[], int n, const struct timespec *timeout );

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

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 );
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()函数的例子。

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 aiocb1.aio_lio_opcode = LIO_READ; /异步读操作/
10 … /*准备多个 aiocb */
11 bzero( (char *)list, sizeof(list) );
12
13 /将 aiocb 填入链表/
14 list[0] = &aiocb1;
15 list[1] = &aiocb2;
16 …
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 通知机制的例子。

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

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

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

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

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 my_aiocb.aio_fildes = fd;
10 my_aiocb.aio_buf = malloc(BUF_SIZE + 1);
11 my_aiocb.aio_nbytes = BUF_SIZE;
12 my_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 … ret = aio_read(&my_aiocb); //发起 AIO 请求
21 }
22
23 /
异步 I/O 完成回调函数 /
24 void aio_completion_handler(sigval_t sigval)
25 {
26 struct aiocb req;
27 req = (struct aiocb
)sigval.sival_ptr;
28
29 /
AIO 请求完成? /
30 if (aio_error(req) == 0)
31 {
32 /
请求完成,获得返回值 /
33 ret = aio_return(req);
34 }
35
36 return ;
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()函数的实现例子。

1 /异步读/
2 static ssize_t xxx_aio_read(struct kiocb *iocb, char *buf, size_t count, loff_t
3 pos)
4 {
5 return xxx_defer_op(0, iocb, buf, count, pos);
6 }
7
8 /异步写/
9 static ssize_t xxx_aio_write(struct kiocb *iocb, const char buf, size_t count,
10 loff_t pos)
11 {
12 return xxx_defer_op(1, iocb, (char
)buf, count, pos);
13 }
14
15 /初始化异步 I/O/
16 static int xxx_defer_op(int write, struct kiocb iocb, char buf, size_t count,
17 loff_t pos)
18 {
19 struct async_work async_wk;
20 int result;
21 /
当可以访问 buffer 时进行复制
/
22 if (write)
23 result = xxx_write(iocb->ki_filp, buf, count, &pos);
24 else
25 result = xxx_read(iocb->ki_filp, buf, count, &pos);
26 /
如果是同步 IOCB,立即返回状态 /
27 if (is_sync_kiocb(iocb))
28 return result;
29
30 /
否则,推后几μ s 执行 */
31 async_wk = kmalloc(sizeof(*async_wk), GFP_KERNEL);
32 if (async_wk == NULL)
33 return result;
34 /调度延迟的工作/
35 async_wk->iocb = iocb;
36 async_wk->result = result;
37 INIT_WORK(&async_wk->work, xxx_do_deferred_op, async_wk);
38 schedule_delayed_work(&async_wk->work, HZ / 100);
39 return - EIOCBQUEUED; /控制权返回用户空间/
40 }
41
42 /延迟后执行/
43 static void xxx_do_deferred_op(void *p)
44 {
45 struct async_work async_wk = (struct async_work)p;
46 aio_complete(async_wk->iocb, async_wk->result, 0);
47 kfree(async_wk);
48 }
上述代码中最核心的是使用 aync_work(异步工作)结构体将操作延后执行,aync_work 结构体定义如代码清单所示,通过 schedule_delayed_work()函数可以调度其执行。第 46 行对 aio_complete()的调用用于通知内核驱动程序已经完成了操作。
1 struct async_work
2 {
3 struct kiocb *iocb; //kiocb 结构体指针
4 int result; //执行结果
5 struct work_struct work; //工作结构体
6 };
就到这里了,O(∩_∩)O~

我的专栏地址:http://blog.csdn.net/column/details/linux-driver-note.html

待续。。。。

作者:Ela–学海无涯
来源:CSDN
原文:https://blog.csdn.net/xinyuwuxian/article/details/9359685
版权声明:本文为博主原创文章,转载请附上博文链接!

上一篇:mysql


下一篇:JAVA 中BIO,NIO,AIO的理解