Linux中直接IO机制的介绍

Linux 中直接 I/O 机制的介绍https://www.360docs.net/doc/1f7105881.html,/developerworks/cn/linux/l-cn-...

https://www.360docs.net/doc/1f7105881.html,/developerworks/cn/linux/l-cn-...

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

操作系统内核中处理 open() 系统调用的内核函数是 sys_open()，sys_open() 会调用 do_sys_open() 去处理主要的打开操作。它主要做了三件事情：首先，它调用 getname() 从进程地址空间中读取文件的路径名；接着，do_sys_open() 调用

get_unused_fd() 从进程的文件表中找到一个空闲的文件表指针，相应的新文件描述符就存放在本地变量 fd 中；之后，函数

do_?lp_open() 会根据传入的参数去执行相应的打开操作。清单 1 列出了操作系统内核中处理 open() 系统调用的一个主要函数关系图。

清单 1. 主要调用函数关系图

sys_open()

|-----do_sys_open()

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

|---------get_unused_fd()

|---------do_filp_open()

|--------nameidata_to_filp()

|----------__dentry_open()

函数 do_?ip_open() 在执行的过程中会调用函数 nameidata_to_?lp()，而 nameidata_to_?lp() 最终会调用 __dentry_open()函数，若进程指定了 O_DIRECT 标识符，则该函数会检查直接 I./O 操作是否可以作用于该文件。清单 2 列出了 __dentry_open()函数中与直接 I/O 操作相关的代码。

清单 2. 函数 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()，其主要的调用函数关系图如下清单 3 所示：

清单 3. 主调用函数关系图

sys_read()

|-----vfs_read()

|----generic_file_read()

|----generic_file_aio_read()

|--------- generic_file_direct_IO()

函数 sys_read() 从进程中获取文件描述符以及文件当前的操作位置后会调用 vfs_read() 函数去执行具体的操作过程，而

vfs_read() 函数最终是调用了 ?le 结构中的相关操作去完成文件的读操作，即调用了 generic_?le_read() 函数，其代码如下所示：

清单 4. 函数 generic_?le_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_?le_read() 初始化了 iovec 以及 kiocb 描述符。描述符 iovec 主要是用于存放两个内容：用来接收所读取数据的用户地址空间缓冲区的地址和缓冲区的大小；描述符 kiocb 用来跟踪 I/O 操作的完成状态。之后，函数 generic_?le_read() 凋用函数 __generic_?le_aio_read()。该函数检查 iovec 中描述的用户地址空间缓冲区是否可用，接着检查访问模式，若访问模式描述符设置了 O_DIRECT，则执行与直接 I/O 相关的代码。函数 __generic_?le_aio_read() 中与直接 I/O 有关的代码如下所示：

清单 5. 函数 __generic_?le_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_?le_direct_io()，并将操作类型 READ，描述符 iocb，描述符 iovec，当前文件指针的值以及在描述符 io_vec 中指定的用户地址空间缓冲区的个数等值作为参数传给它。当 generic_?le_direct_io() 函数执行完成，函数

__generic_?le_aio_read（）会继续执行去完成后续操作：更新文件指针，设置访问文件 i 节点的时间戳；这些操作全部执行完成以后，函数返回。函数 generic_?le_direct_IO() 会用到五个参数，各参数的含义如下所示：

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

iocb：指针，指向 kiocb 描述符　

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

o?set：?le 结构偏移量

nr_segs：iov 数组中 iovec 的个数

函数 generic_file_direct_IO() 代码如下所示：

清单 6. 函数 generic_?le_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_?le_direct_IO() 对 WRITE 操作类型进行了一些特殊处理，这在下边介绍 write() 系统调用的时候再做说明。除此之外，它主要是调用了 direct_IO 方法去执行直接 I/O 的读或者写操作。在进行直接 I/O 读操作之前，先将页缓存中的相关脏数据刷回到磁盘上去，这样做可以确保从磁盘上读到的是最新的数据。这里的 direct_IO 方法最终会对应到 __blockdev_direct_IO()函数上去。__blockdev_direct_IO() 函数的代码如下所示：

清单 7. 函数 __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() 系统调用返回，应用程序就可以访问用户地址空间中含有相应数据的缓冲区。但是，这种方法在应用程序读操作完成之前不能关闭应用程序，这将会导致关闭应用程序缓慢。

　

接下来我们看一下 write() 系统调用中与直接 I/O 相关的处理实现过程。函数 write() 的原型如下所示：

ssize_t write(int filedes, const void * buff, size_t nbytes) ;

操作系统中处理 write() 系统调用的入口函数是 sys_write()。其主要的调用函数关系如下所示：

清单 8. 主调用函数关系图

sys_write()

|-----vfs_write()

|----generic_file_write()

|----generic_file_aio_read()

|---- __generic_file_write_nolock()

|-- __generic_file_aio_write_nolock

|-- generic_file_direct_write()

|-- generic_file_direct_IO()

函数 sys_write() 几乎与 sys_read() 执行相同的步骤，它从进程中获取文件描述符以及文件当前的操作位置后即调用 vfs_write()函数去执行具体的操作过程，而 vfs_write() 函数最终是调用了 ?le 结构中的相关操作完成文件的写操作，即调用了

generic_?le_write() 函数。在函数 generic_?le_write() 中，函数 generic_?le_write_nolock() 最终调用

generic_?le_aio_write_nolock() 函数去检查 O_DIRECT 的设置，并且调用 generic_?le_direct_write() 函数去执行直接 I/O 写操作。

函数 generic_file_aio_write_nolock() 中与直接 I/O 相关的代码如下所示：

清单 9. 函数 generic_?le_aio_write_nolock() 中与直接 I/O 相关的代码

if (unlikely(file->f_flags & O_DIRECT)) {

written = generic_file_direct_write(iocb, iov,

&nr_segs, pos, ppos, count, ocount);

if (written < 0 || written == count)

goto out;

pos += written;

count -= written;

}

从上边代码可以看出， generic_?le_aio_write_nolock() 调用了 generic_?le_direct_write() 函数去执行直接 I/O 操作；而在generic_?le_direct_write() 函数中，跟读操作过程类似，它最终也是调用了 generic_?le_direct_IO() 函数去执行直接 I/O 写操作。与直接 I/O 读操作不同的是，这次需要将操作类型 WRITE 作为参数传给函数 generic_?le_direct_IO()。

前边介绍了 generic_?le_direct_IO() 的主体 direct_IO 方法：__blockdev_direct_IO()。函数 generic_?le_direct_IO() 对WRITE 操作类型进行了一些额外的处理。当操作类型是 WRITE 的时候，若发现该使用直接 I/O 的文件已经与其他一个或者多个进程存在关联的内存映射，那么就调用 unmap_mapping_range() 函数去取消建立在该文件上的所有的内存映射，并将页缓存中相关的所有 dirty 位被置位的脏页面刷回到磁盘上去。对于直接 I/O 写操作来说，这样做可以保证写到磁盘上的数据是最新的，否则，即将用直接 I/O 方式写入到磁盘上的数据很可能会因为页缓存中已经存在的脏数据而失效。在直接 I/O 写操作完成之后，在页缓存中相关的脏数据就都已经失效了，磁盘与页缓存中的数据内容必须保持同步。

如何在字符设备中执行直接 I/O

在字符设备中执行直接 I/O 可能是有害的，只有在确定了设置缓冲 I/O 的开销非常巨大的时候才建议使用直接 I/O。在 Linux 2.6的内核中，实现直接 I/O 的关键是函数 get_user_pages() 函数。其函数原型如下所示：

int get_user_pages(struct task_struct *tsk,

struct mm_struct *mm,

unsigned long start,

int len,

int write,

int force,

struct page **pages,

struct vm_area_struct **vmas);

该函数的参数含义如下所示：

tsk：指向执行映射的进程的指针；该参数的主要用途是用来告诉操作系统内核，映射页面所产生的页错误由谁来负责，该参数几乎总是 current。

mm：指向被映射的用户地址空间的内存管理结构的指针，该参数通常是 current->mm 。

start: 需要映射的用户地址空间的地址。

len：页内缓冲区的长度。

write：如果需要对所映射的页面有写权限，该参数的设置得是非零。

force：该参数的设置通知 get_user_pages() 函数无需考虑对指定内存页的保护，直接提供所请求的读或者写访问。

page：输出参数。调用成功后，该参数中包含一个描述用户空间页面的 page 结构的指针列表。

vmas：输出参数。若该参数非空，则该参数包含一个指向 vm_area_struct 结构的指针，该 vm_area_struct 结构包含了每一个所映射的页面。

在使用 get_user_pages() 函数的时候，往往还需要配合使用以下这些函数：

void down_read(struct rw_semaphore *sem);

void up_read(struct rw_semaphore *sem);

void SetPageDirty(struct page *page);

void page_cache_release(struct page *page);

首先，在使用 get_user_pages() 函数之前，需要先调用 down_read() 函数将 mmap 为获得用户地址空间的读取者 / 写入者信号量设置为读模式；在调用完 get_user_pages() 函数之后，再调用配对函数 up_read() 释放信号量 sem。若 get_user_pages()调用失败，则返回错误代码；若调用成功，则返回实际被映射的页面数，该数目有可能比请求的数量少。调用成功后所映射的用户页面被锁在内存中，调用者可以通过 page 结构的指针去访问这些用户页面。

直接 I/O 的调用者必须进行善后工作，一旦直接 I/O 操作完成，用户内存页面必须从页缓存中释放。在用户内存页被释放之前，如果这些页面中的内容改变了，那么调用者必须要通知操作系统内核，否则虚拟存储子系统会认为这些页面是干净的，从而导致这些数据被修改了的页面在被释放之前无法被写回到永久存储中去。因此，如果改变了页中的数据，那么就必须使用 SetPageDirty() 函数标记出每个被改变的页。对于 Linux 2.6.18.1，该宏定义在 /include/linux/page_?ags.h 中。执行该操作的代码一般需要先检查页，以确保该页不在内存映射的保留区域内，因为这个区的页是不会被交换出去的，其代码如下所示：

if (!PageReserved(page))

SetPageDirty(page);

但是，由于用户空间所映射的页面通常不会被标记为保留，所以上述代码中的检查并不是严格要求的。

最终，在直接 I/O 操作完成之后，不管页面是否被改变，它们都必须从页缓存中释放，否则那些页面永远都会存在在那里。函数page_cache_release() 就是用于释放这些页的。页面被释放之后，调用者就不能再次访问它们。

关于如何在字符设备驱动程序中加入对直接 I/O 的支持，Linux 2.6.18.1 源代码中 /drivers/scsi/st.c 给出了一个完整的例子。其中，函数 sgl_map_user_pages（）和 sgl_map_user_pages（）几乎涵盖了本节中介绍的所有内容。

直接 I/O 技术的特点

直接 I/O 的优点

直接 I/O 最主要的优点就是通过减少操作系统内核缓冲区和应用程序地址空间的数据拷贝次数，降低了对文件读取和写入时所带来的 CPU 的使用以及内存带宽的占用。这对于某些特殊的应用程序，比如自缓存应用程序来说，不失为一种好的选择。如果要传输的数据量很大，使用直接 I/O 的方式进行数据传输，而不需要操作系统内核地址空间拷贝数据操作的参与，这将会大大提高性能。

直接 I/O 潜在可能存在的问题

直接 I/O 并不一定总能提供令人满意的性能上的飞跃。设置直接 I/O 的开销非常大，而直接 I/O 又不能提供缓存 I/O 的优势。缓存I/O 的读操作可以从高速缓冲存储器中获取数据，而直接 I/O 的读数据操作会造成磁盘的同步读，这会带来性能上的差异 , 并且导致进程需要较长的时间才能执行完；对于写数据操作来说，使用直接 I/O 需要 write() 系统调用同步执行，否则应用程序将会不知道什么时候才能够再次使用它的 I/O 缓冲区。与直接 I/O 读操作类似的是，直接 I/O 写操作也会导致应用程序关闭缓慢。所以，应用程序使用直接 I/O 进行数据传输的时候通常会和使用异步 I/O 结合使用。

总结

Linux 中的直接 I/O 访问文件方式可以减少 CPU 的使用率以及内存带宽的占用，但是直接 I/O 有时候也会对性能产生负面影响。所以在使用直接 I/O 之前一定要对应用程序有一个很清醒的认识，只有在确定了设置缓冲 I/O 的开销非常巨大的情况下，才考虑使用直接 I/O。直接 I/O 经常需要跟异步 I/O 结合起来使用，本文对异步 I/O 没有作详细介绍，有兴趣的读者可以参看 Linux 2.6 中相