Linux中直接I/O的机制原理

曾经终败给现在 2024-03-26 14:12 70阅读 0赞

在介绍直接 I/O 之前，先来介绍下直接I/O这种机制产生的原因。毕竟已经有了缓存I/O（Buffered I/O），那肯定能够像到缓存I/O有缺陷吧，就按照这个思路来。

什么是缓存 I/O (Buffered I/O)

缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操作系统会将 I/O 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。写的过程就是数据流反方向。缓存 I/O 有以下这些优点：

缓存 I/O 使用了操作系统内核缓冲区，在一定程度上分离了应用程序空间和实际的物理设备。

缓存 I/O 可以减少读盘的次数，从而提高性能。

对于读操作：当应用程序要去读取某块数据的时候，如果这块数据已经在页缓存中，那就返回之。而不需要经过硬盘的读取操作了。如果这块数据不在页缓存中，就需要从硬盘中读取数据到页缓存。

对于写操作：应用程序会将数据先写到页缓存中，数据是否会被立即写到磁盘，这取决于所采用的写操作机制：

同步机制，数据会立即被写到磁盘中，直到数据写完，写接口才返回；

延迟机制：写接口立即返回，操作系统会定期地将页缓存中的数据刷到硬盘。所以这个机制会存在丢失数据的风险。想象下写接口返回的时候，页缓存的数据还没刷到硬盘，正好断电。对于应用程序来说，认为数据已经在硬盘中。

缓存I/O的写操作

缓存 I/O 的缺点

在缓存I/O的机制中，以写操作为例，数据先从用户态拷贝到内核态中的页缓存中，然后又会从页缓存中写到磁盘中，这些拷贝操作带来的CPU以及内存的开销是非常大的。

对于某些特殊的应用程序来说，能够绕开内核缓冲区能够获取更好的性能，这就是直接I/O出现的意义。

直接I/O写操作

直接I/O 介绍

凡是通过直接I/O方式进行数据传输，数据直接从用户态地址空间写入到磁盘中，直接跳过内核缓冲区。对于一些应用程序，例如：数据库。他们更倾向于自己的缓存机制，这样可以提供更好的缓冲机制提高数据库的读写性能。直接I/O写操作如上图所示。

直接I/O 设计与实现

要在块设备中执行直接 I/O，进程必须在打开文件的时候设置对文件的访问模式为 O\_DIRECT，这样就等于告诉操作系统进程在接下来使用 read() 或者 write() 系统调用去读写文件的时候使用的是直接 I/O 方式，所传输的数据均不经过操作系统内核缓存空间。使用直接 I/O 读写数据必须要注意缓冲区对齐（ buffer alignment ）以及缓冲区的大小的问题，即对应 read() 以及 write() 系统调用的第二个和第三个参数。这里边说的对齐指的是文件系统块大小的对齐，缓冲区的大小也必须是该块大小的整数倍。

下面主要介绍三个函数：open()，read() 以及 write()。Linux 中访问文件具有多样性，所以这三个函数对于处理不同的文件访问方式定义了不同的处理方法，本文主要介绍其与直接 I/O 方式相关的函数与功能．首先，先来看 open() 系统调用，其函数原型如下所示：

int open(const char \*pathname, int oflag, … /\*, mode\_t mode \* / ) ;

当应用程序需要直接访问文件而不经过操作系统页高速缓冲存储器的时候，它打开文件的时候需要指定 O\_DIRECT 标识符。

操作系统内核中处理 open() 系统调用的内核函数是 sys\_open()，sys\_open() 会调用 do\_sys\_open() 去处理主要的打开操作。它主要做了三件事情：

调用 getname() 从进程地址空间中读取文件的路径名；

do\_sys\_open() 调用 get\_unused\_fd() 从进程的文件表中找到一个空闲的文件表指针，相应的新文件描述符就存放在本地变量 fd 中；微点阅读（[www.weidianyuedu.com][]）

函数 do\_filp\_open() 会根据传入的参数去执行相应的打开操作。

下面列出了操作系统内核中处理 open() 系统调用的一个主要函数关系图。

sys\_open()

|-----do\_sys\_open()

|---------getname()

|---------get\_unused\_fd()

|---------do\_filp\_open()

|--------nameidata\_to\_filp()

|----------\_\_dentry\_open()

函数 do\_flip\_open() 在执行的过程中会调用函数 nameidata\_to\_filp()，而 nameidata\_to\_filp() 最终会调用 \_\_dentry\_open() 函数，若进程指定了 O\_DIRECT 标识符，则该函数会检查直接 I./O 操作是否可以作用于该文件。下面列出了 \_\_dentry\_open() 函数中与直接 I/O 操作相关的代码。

if (f->f\_flags & O\_DIRECT) \{

if (!f->f\_mapping->a\_ops ||

((!f->f\_mapping->a\_ops->direct\_IO) &&

(!f->f\_mapping->a\_ops->get\_xip\_page))) \{

fput(f);

f = ERR\_PTR(-EINVAL);

当文件打开时指定了 O\_DIRECT 标识符，那么操作系统就会知道接下来对文件的读或者写操作都是要使用直接 I/O 方式的。

下边我们来看一下当进程通过 read() 系统调用读取一个已经设置了 O\_DIRECT 标识符的文件的时候，系统都做了哪些处理。 函数 read() 的原型如下所示：

ssize\_t read(int feledes, void \*buff, size\_t nbytes) ;

操作系统中处理 read() 函数的入口函数是 sys\_read()，其主要的调用函数关系图如下：

sys\_read()

|-----vfs\_read()

|----generic\_file\_read()

|----generic\_file\_aio\_read()

|--------- generic\_file\_direct\_IO()

函数 sys\_read() 从进程中获取文件描述符以及文件当前的操作位置后会调用 vfs\_read() 函数去执行具体的操作过程，而 vfs\_read() 函数最终是调用了 file 结构中的相关操作去完成文件的读操作，即调用了 generic\_file\_read() 函数，其代码如下所示：

ssize\_t

generic\_file\_read(struct file \*filp,

char \_\_user \*buf, size\_t count, loff\_t \*ppos)

struct iovec local\_iov = \{ .iov\_base = buf, .iov\_len = count \};

struct kiocb kiocb;

ssize\_t ret;

init\_sync\_kiocb(&kiocb, filp);

ret = \_\_generic\_file\_aio\_read(&kiocb, &local\_iov, 1, ppos);

if (-EIOCBQUEUED == ret)

ret = wait\_on\_sync\_kiocb(&kiocb);

return ret;

函数 generic\_file\_read() 初始化了 iovec 以及 kiocb 描述符。描述符 iovec 主要是用于存放两个内容：用来接收所读取数据的用户地址空间缓冲区的地址和缓冲区的大小；描述符 kiocb 用来跟踪 I/O 操作的完成状态。之后，函数 generic\_file\_read() 凋用函数 \_\_generic\_file\_aio\_read()。该函数检查 iovec 中描述的用户地址空间缓冲区是否可用，接着检查访问模式，若访问模式描述符设置了 O\_DIRECT，则执行与直接 I/O 相关的代码。函数 \_\_generic\_file\_aio\_read() 中与直接 I/O 有关的代码如下所示：

if (filp->f\_flags & O\_DIRECT) \{

loff\_t pos = \*ppos, size;

struct address\_space \*mapping;

struct inode \*inode;

mapping = filp->f\_mapping;

inode = mapping->host;

retval = 0;

if (!count)

goto out;

size = i\_size\_read(inode);

if (pos < size) \{

retval = generic\_file\_direct\_IO(READ, iocb,

iov, pos, nr\_segs);

if (retval > 0 && !is\_sync\_kiocb(iocb))

retval = -EIOCBQUEUED;

if (retval > 0)

\*ppos = pos + retval;

file\_accessed(filp);

goto out;

上边的代码段主要是检查了文件指针的值，文件的大小以及所请求读取的字节数目等，之后，该函数调用 generic\_file\_direct\_io()，并将操作类型 READ，描述符 iocb，描述符 iovec，当前文件指针的值以及在描述符 io\_vec 　中指定的用户地址空间缓冲区的个数等值作为参数传给它。当 generic\_file\_direct\_io() 函数执行完成，函数 \_\_generic\_file\_aio\_read（）会继续执行去完成后续操作：更新文件指针，设置访问文件 i 节点的时间戳；这些操作全部执行完成以后，函数返回。 函数 generic\_file\_direct\_IO() 会用到五个参数，各参数的含义如下所示：

rw：操作类型，可以是 READ 或者 WRITE

iocb：指针，指向 kiocb 描述符

iov：指针，指向 iovec 描述符数组

offset：file 结构偏移量

nr\_segs：iov 数组中 iovec 的个数

函数 generic\_file\_direct\_IO() 代码如下所示：

static ssize\_t

generic\_file\_direct\_IO(int rw, struct kiocb \*iocb, const struct iovec \*iov,

loff\_t offset, unsigned long nr\_segs)

struct file \*file = iocb->ki\_filp;

struct address\_space \*mapping = file->f\_mapping;

ssize\_t retval;

size\_t write\_len = 0;

if (rw == WRITE) \{

write\_len = iov\_length(iov, nr\_segs);

if (mapping\_mapped(mapping))

unmap\_mapping\_range(mapping, offset, write\_len, 0);

retval = filemap\_write\_and\_wait(mapping);

if (retval == 0) \{

retval = mapping->a\_ops->direct\_IO(rw, iocb, iov,

offset, nr\_segs);

if (rw == WRITE && mapping->nrpages) \{

pgoff\_t end = (offset + write\_len - 1)

>> PAGE\_CACHE\_SHIFT;

int err = invalidate\_inode\_pages2\_range(mapping,

offset >> PAGE\_CACHE\_SHIFT, end);

if (err)

retval = err;

return retval;

函数 generic\_file\_direct\_IO() 对 WRITE 操作类型进行了一些特殊处理。除此之外，它主要是调用了 direct\_IO 方法去执行直接 I/O 的读或者写操作。在进行直接　 I/O 　读操作之前，先将页缓存中的相关脏数据刷回到磁盘上去，这样做可以确保从磁盘上读到的是最新的数据。这里的 direct\_IO 方法最终会对应到 \_\_blockdev\_direct\_IO() 函数上去。\_\_blockdev\_direct\_IO() 函数的代码如下所示：

ssize\_t

\_\_blockdev\_direct\_IO(int rw, struct kiocb \*iocb, struct inode \*inode,

struct block\_device \*bdev, const struct iovec \*iov, loff\_t offset,

unsigned long nr\_segs, get\_block\_t get\_block, dio\_iodone\_t end\_io,

int dio\_lock\_type)

int seg;

size\_t size;

unsigned long addr;

unsigned blkbits = inode->i\_blkbits;

unsigned bdev\_blkbits = 0;

unsigned blocksize\_mask = (1 << blkbits) - 1;

ssize\_t retval = -EINVAL;

loff\_t end = offset;

struct dio \*dio;

int release\_i\_mutex = 0;

int acquire\_i\_mutex = 0;

if (rw & WRITE)

rw = WRITE\_SYNC;

if (bdev)

bdev\_blkbits = blksize\_bits(bdev\_hardsect\_size(bdev));

if (offset & blocksize\_mask) \{

if (bdev)

blkbits = bdev\_blkbits;

blocksize\_mask = (1 << blkbits) - 1;

if (offset & blocksize\_mask)

goto out;

for (seg = 0; seg < nr\_segs; seg++) \{

addr = (unsigned long)iov\[seg\].iov\_base;

size = iov\[seg\].iov\_len;

end += size;

if ((addr & blocksize\_mask) || (size & blocksize\_mask)) \{

if (bdev)

blkbits = bdev\_blkbits;

blocksize\_mask = (1 << blkbits) - 1;

if ((addr & blocksize\_mask) || (size & blocksize\_mask))

goto out;

dio = kmalloc(sizeof(\*dio), GFP\_KERNEL);

retval = -ENOMEM;

if (!dio)

goto out;

dio->lock\_type = dio\_lock\_type;

if (dio\_lock\_type != DIO\_NO\_LOCKING) \{

if (rw == READ && end > offset) \{

struct address\_space \*mapping;

mapping = iocb->ki\_filp->f\_mapping;

if (dio\_lock\_type != DIO\_OWN\_LOCKING) \{

mutex\_lock(&inode->i\_mutex);

release\_i\_mutex = 1;

retval = filemap\_write\_and\_wait\_range(mapping, offset,

end - 1);

if (retval) \{

kfree(dio);

goto out;

if (dio\_lock\_type == DIO\_OWN\_LOCKING) \{

mutex\_unlock(&inode->i\_mutex);

acquire\_i\_mutex = 1;

if (dio\_lock\_type == DIO\_LOCKING)

down\_read\_non\_owner(&inode->i\_alloc\_sem);

dio->is\_async = !is\_sync\_kiocb(iocb) && !((rw & WRITE) &&

(end > i\_size\_read(inode)));

retval = direct\_io\_worker(rw, iocb, inode, iov, offset,

nr\_segs, blkbits, get\_block, end\_io, dio);

if (rw == READ && dio\_lock\_type == DIO\_LOCKING)

release\_i\_mutex = 0;

out:

if (release\_i\_mutex)

mutex\_unlock(&inode->i\_mutex);

else if (acquire\_i\_mutex)

mutex\_lock(&inode->i\_mutex);

return retval;

该函数将要读或者要写的数据进行拆分，并检查缓冲区对齐的情况。本文在前边介绍 open() 函数的时候指出，使用直接 I/O 读写数据的时候必须要注意缓冲区对齐的问题，从上边的代码可以看出，缓冲区对齐的检查是在 \_\_blockdev\_direct\_IO() 函数里边进行的。用户地址空间的缓冲区可以通过 iov 数组中的 iovec 描述符确定。直接 I/O 的读操作或者写操作都是同步进行的，也就是说，函数 \_\_blockdev\_direct\_IO() 会一直等到所有的 I/O 操作都结束才会返回，因此，一旦应用程序 read() 系统调用返回，应用程序就可以访问用户地址空间中含有相应数据的缓冲区。但是，这种方法在应用程序读操作完成之前不能关闭应用程序，这将会导致关闭应用程序缓慢。

直接I/O 优点

最大的优点就是减少操作系统缓冲区和用户地址空间的拷贝次数。降低了CPU的开销，和内存带宽。对于某些应用程序来说简直是福音，将会大大提高性能。

直接I/O 缺点

直接IO并不总能让人如意。直接IO的开销也很大，应用程序没有控制好读写，将会导致磁盘读写的效率低下。磁盘的读写是通过磁头的切换到不同的磁道上读取和写入数据，如果需要写入数据在磁盘位置相隔比较远，就会导致寻道的时间大大增加，写入读取的效率大大降低。

总结

直接IO方式确实能够减少CPU的使用率以及内存带宽的占用，但是有时候也会造成性能的影响。所以在使用直接IO之前一定要清楚它的原理，只有在各项都清晰的情况下，才考虑使用。本人只是介绍了原理，如想深入，建议参考内核相关文档。

来源：[https://www.weidianyuedu.com][www.weidianyuedu.com]

[www.weidianyuedu.com]: https://www.weidianyuedu.com