Linux文件系统（四）文件缓存

小咪咪 2023-06-08 06:13 51阅读 0赞

**Linux文件系统**

[Linux文件系统（一）文件系统概述][Linux]

[Linux文件系统（二）磁盘文件系统][Linux 1]

[Linux文件系统（三）虚拟文件系统][Linux 2]

[Linux文件系统（四）文件缓存][Linux 3]

# Linux文件系统（四）文件缓存 #

### 文章目录 ###

*  Linux文件系统（四）文件缓存
 *   *  一、系统调用层和虚拟文件系统层
     *  二、ext4 文件系统层
     *   *  2.1 直接读写
         *  2.2 带缓存的读写
     *  三、总结

前几篇文章讲解了文件系统的挂载和文件的打开，这篇文章讲解文件的读写

## 一、系统调用层和虚拟文件系统层 ##

文件的读写就是通过调用 read、write 系统调用来实现的，由于读写的实现过程很多逻辑都是相似的，所以两部分放在一起讨论

read、write 系统调用的定义如下

SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
    {
        
    	struct fd f = fdget_pos(fd);
    ......
    	loff_t pos = file_pos_read(f.file);
    	ret = vfs_read(f.file, buf, count, &pos);
    ......
    }
    
    
    SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
    		size_t, count)
    {
        
    	struct fd f = fdget_pos(fd);
    ......
    	loff_t pos = file_pos_read(f.file);
        ret = vfs_write(f.file, buf, count, &pos);
    ......
    }

对于 read 来讲，调用了 vfs\_read -> \_\_vfs\_read，对于 write 来讲，调用了 vfs\_write -> \_\_vfs\_write

下面看以下 \_\_vfs\_read 和 \_\_vfs\_write 的代码

ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
    		   loff_t *pos)
    {
        
    	if (file->f_op->read)
    		return file->f_op->read(file, buf, count, pos);
    	else if (file->f_op->read_iter)
    		return new_sync_read(file, buf, count, pos);
    	else
    		return -EINVAL;
    }
    
    
    ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
    		    loff_t *pos)
    {
        
    	if (file->f_op->write)
    		return file->f_op->write(file, p, count, pos);
    	else if (file->f_op->write_iter)
    		return new_sync_write(file, p, count, pos);
    	else
    		return -EINVAL;
    }

上一篇文章讲了，进程打开的文件都对应有一个 struct file，里面有相应的文件操作集 file\_operation，具体的文件操作集有文件系统决定

对于 read，最终会调用 file->f\_op->read 或者 file->f\_op->read\_iter，对于 write，最终会调用 file->f\_op->write 或者 file->f\_op->write\_iter

下面来讲解具体文件系统的实现，以 ext4 文件系统为例

## 二、ext4 文件系统层 ##

### 2.1 直接读写 ###

对于 ext4 文件系统，定义了一个文件操作集 file\_operations，如下

const struct file_operations ext4_file_operations = {
        
    ......
    	.read_iter	= ext4_file_read_iter,
    	.write_iter	= ext4_file_write_iter,
    ......
    }

对于 ext4 文件系统，没有定义 read 和 write，所以会调用 ext4\_file\_read\_iter 和 ext4\_file\_write\_iter

ext4\_file\_read\_iter 会调用 generic\_file\_read\_iter，ext4\_file\_write\_iter 会调用 \_\_generic\_file\_write\_iter

ssize_t
    generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
    {
        
    ......
        if (iocb->ki_flags & IOCB_DIRECT) {
        
    ......
            struct address_space *mapping = file->f_mapping;
    ......
            retval = mapping->a_ops->direct_IO(iocb, iter);
        }
    ......
        retval = generic_file_buffered_read(iocb, iter, retval);
    }
    
    
    ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
    {
        
    ......
        if (iocb->ki_flags & IOCB_DIRECT) {
        
    ......
            written = generic_file_direct_write(iocb, from);
    ......
        } else {
        
    ......
    		written = generic_perform_write(file, from, iocb->ki_pos);
    ......
        }
    }

generic\_file\_read\_iter 和 \_\_generic\_file\_write\_iter 有相似的逻辑，就是是否使用缓存

缓存其实就是一块内存空间，因为内存的访问速度比硬盘快许多，所以Linux为了提高读写性能，会准备一块缓存，不直接操作硬盘，而是直接操作内存，然后批量读取或者写入磁盘

因此根据是否使用缓存，可以把文件的 I/O 操作分为两类

第一种类型是**缓存 I/O**。大多数文件系统都是缓存I/O。对于读操作来讲，操作系统会先检测，内存的缓存区是否已存在需要的数据。如果存在，那么直接从缓存中返回；如果不存在，则从硬盘中读取数据，然后缓存到操作系统的缓存中。对于写操作，操作系统会将用户空间的数组拷贝到内核的缓存中，对于用户进程，这已经算是写完成了，至于什么时候将数据写到硬盘中，由操作系统决定，除非显示调用 sync 同步命令马上将缓存写入硬盘

第二种类型是**直接I/O**，就是应用直接访问磁盘，而不使用缓存

从上面的程序中可以看到，如果设置了 IOCB\_DIRECT 标志，那么就使用直接I/O，否则使用缓存I/O

对于**读操作**，如果是**直接I/O**，会调用 address\_space 的 direct\_IO 函数，直接从磁盘读取数据，address\_space 的作用主要是内存映射的时候，将文件和内存页产生关联

address\_space 的相关操作根据文件系统的不同而不同，对于 ext4 文件系统，定义如下

static const struct address_space_operations ext4_aops = {
        
    ......
    	.direct_IO		= ext4_direct_IO,
    ......
    };

对于**写操作**，如果是**直接I/O**，会调用 generic\_file\_direct\_write，同样也会调用 address\_space 的 direct\_IO 函数

ext4\_direct\_IO 最终会调用 \_\_blockdev\_direct\_IO -> do\_\_blockdev\_direct\_IO，这就跨过了缓存层，直接到了文件系统的设备驱动层

下面我们再来看带缓存的读写操作

### 2.2 带缓存的读写 ###

**带缓存的写**

首先看带缓存的写函数 generic\_perform\_write

ssize_t generic_perform_write(struct file *file,
    				struct iov_iter *i, loff_t pos)
    {
        
    	struct address_space *mapping = file->f_mapping;
    	const struct address_space_operations *a_ops = mapping->a_ops;
    	do {
        
    		struct page *page;
    		unsigned long offset;	/* Offset into pagecache page */
    		unsigned long bytes;	/* Bytes to write to page */
    		status = a_ops->write_begin(file, mapping, pos, bytes, flags,
    						&page, &fsdata);
    		copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);
    		flush_dcache_page(page);
    		status = a_ops->write_end(file, mapping, pos, bytes, copied,
    						page, fsdata);
    		pos += copied;
    		written += copied;
    
    
    		balance_dirty_pages_ratelimited(mapping);
    	} while (iov_iter_count(i));
    }

这个函数中是一个 while 循环，我们需要找到这次写入影响的所有页，然后依次写入，对于每一个循环，主要做下面几件事

*  对每一页，先调用 address\_space 的 write\_begin 准备
 *  调用 iov\_iter\_copy\_from\_user\_atomic，将写入的内容从用户空间拷贝到内核空间
 *  调用 address\_space 的 write\_end 完成写操作
 *  调用 balance\_dirty\_pages\_ratelimited，看脏页是否太多，需要写入硬盘中。脏页的意思是文件内容已写入缓存中，但还没写入硬盘中的页面

下面我们依次来看这四个步骤

static const struct address_space_operations ext4_aops = {
        
    ......
    	.write_begin	= ext4_write_begin,
    	.write_end		= ext4_write_end,
    ......
    }

第一步，对于 ext4 文件系统来讲，调用的是 ext4\_write\_begin

ext4 是一个日志系统，为了防止突然掉电的时候的数据丢失，引入了**日志（journal）模式**。日志文件系统比非日志文件系统多了一个 journal 区域。文件在 ext4 文件系统中分两部分存储，一部分是文件的元数据，另一部是数据。元数据和数据的操作日志 journal 也是分开管理。可以在挂载 ext4 文件系统的时候，使用 journal 模式。这种模式必须在将数据写入文件系统中，必须等待元数据和数据的日志已经落盘才能发挥作用。这样的性能比较差，但是是最安全的

另一种模式是 **order模式**。这种模式不记录数据的日志，只记录元数据的日志，但是在写元数据日志前，必须先确保数据已经落盘。这个是折中的方式，也是默认的模式

还有一种模式是 **writeback模式**，不记录数据的日志，只记录元数据的日志，但是不确保数据比元数据的日志先落盘。这个性能是最好的，但是也是最不安全的

在 ext4\_write\_begin 中，可以看到对于 ext4\_journal\_strat 的调用，就是做日志相关的工作

在 ext4\_write\_begin 中还做了另一件重要的事，就是调用 grab\_cache\_page\_write\_begin，来得到应该写入的缓存页，其定义如下

struct page *grab_cache_page_write_begin(struct address_space *mapping,
    					pgoff_t index, unsigned flags)
    {
        
    	struct page *page;
    	int fgp_flags = FGP_LOCK|FGP_WRITE|FGP_CREAT;
    	page = pagecache_get_page(mapping, index, fgp_flags,
    			mapping_gfp_mask(mapping));
    	if (page)
    		wait_for_stable_page(page);
    	return page;
    }

在内核中，缓存以页为单位存放在内存中，那我们如何知道，一个文件哪些数据被存放在缓存中呢？每一个打开的文件都有一个 struct file 结构，每一个 struct file 结构中都有一个 struct address\_space 用于关联文件和内存，就是在这个结构中，有一棵树，用于保存所有于这个文件相关的缓存页

我们查找的时候，往往根据文件中的偏移值找到相应的缓存页，而基数树 radix tree 这种数据结构能快速根据长整型找到其相应的对象，因而这里缓存页就放在 radix 基数树里面

struct address_space {
        
    	struct inode		*host;		/* owner: inode, block_device */
    	struct radix_tree_root	page_tree;	/* radix tree of all pages */
    	spinlock_t		tree_lock;	/* and lock protecting it */
    ......
    }

pagecache\_get\_page 根据 pgoff\_t index 这个长整型，在这棵树里面找到缓存页，如果找不到就创建一个缓存页

第二步，调用 iov\_iter\_copy\_from\_user\_atomic，其定义如下

size_t iov_iter_copy_from_user_atomic(struct page *page,
    		struct iov_iter *i, unsigned long offset, size_t bytes)
    {
        
    	char *kaddr = kmap_atomic(page), *p = kaddr + offset;
    	iterate_all_kinds(i, bytes, v,
    		copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len),
    		memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page,
    				 v.bv_offset, v.bv_len),
    		memcpy((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
    	)
    	kunmap_atomic(kaddr);
    	return bytes;
    }

先将分配好的物理页面通过 kmap\_atomic 临时映射到内核虚拟地址空间，然后将用户空间的数据拷贝到内核空间，之后再使用 kunmap\_atomic 取消临时映射

第三步，调用 ext4\_write\_end 完成写入。这里会调用 ext4\_journal\_stop 完成日志的写入，会调用 block\_write\_end -> \_\_block\_commit\_write -> mark\_buffer\_dirty，将修改过的缓存标记为脏页。可见，这里的写入并不是真正的写入硬盘，而是写入缓存中，然后标记相应的缓存页为脏页

第四步，调用 balance\_dirty\_pages\_ratelimited，是回写脏页的一个时机

/**
     * balance_dirty_pages_ratelimited - balance dirty memory state
     * @mapping: address_space which was dirtied
     *
     * Processes which are dirtying memory should call in here once for each page
     * which was newly dirtied.  The function will periodically check the system's
     * dirty state and will initiate writeback if needed.
      */
    void balance_dirty_pages_ratelimited(struct address_space *mapping)
    {
        
    	struct inode *inode = mapping->host;
    	struct backing_dev_info *bdi = inode_to_bdi(inode);
    	struct bdi_writeback *wb = NULL;
    	int ratelimit;
    ......
    	if (unlikely(current->nr_dirtied >= ratelimit))
    		balance_dirty_pages(mapping, wb, current->nr_dirtied);
    ......
    }

balance\_dirty\_pages\_ratelimited 发现脏页数量大于限制值，就调用 balance\_dirty\_pages -> wb\_start\_background\_writeback，启动一个背后线程开始回写，这只是回写的一种场景，下面几种场景也会触发回写

*  用户主动调用 sync，将缓存刷到硬盘中，最终会调用 wakeup\_flusher\_threads，同步脏页
 *  当内存十分紧张时，以至于无法分配页面的时候，会调用 free\_more\_memory，最终会调用 wakeup\_flusher\_threads，释放脏页
 *  脏页已经更新一定时间了，时间超过了 timer，需要及时回写脏页，保持缓存于硬盘上的内容一致

**带缓存的读操作**

带缓存的读相对来说简单一些，其对应的函数为 generic\_file\_buffered\_read，定义如下

static ssize_t generic_file_buffered_read(struct kiocb *iocb,
    		struct iov_iter *iter, ssize_t written)
    {
        
    	struct file *filp = iocb->ki_filp;
    	struct address_space *mapping = filp->f_mapping;
    	struct inode *inode = mapping->host;
    	for (;;) {
        
    		struct page *page;
    		pgoff_t end_index;
    		loff_t isize;
    		page = find_get_page(mapping, index);
    		if (!page) {
        
    			if (iocb->ki_flags & IOCB_NOWAIT)
    				goto would_block;
    			page_cache_sync_readahead(mapping,
    					ra, filp,
    					index, last_index - index);
    			page = find_get_page(mapping, index);
    			if (unlikely(page == NULL))
    				goto no_cached_page;
    		}
    		if (PageReadahead(page)) {
        
    			page_cache_async_readahead(mapping,
    					ra, filp, page,
    					index, last_index - index);
    		}
    		/*
    		 * Ok, we have the page, and it's up-to-date, so
    		 * now we can copy it to user space...
    		 */
    		ret = copy_page_to_iter(page, offset, nr, iter);
        }
    }

在 generic\_file\_buffered\_read 中，首先查找缓存中是否存在相应的缓存页，如果没有找到，不但需要读取这一页的内容，还需要进行预读，这些在 page\_cache\_sync\_readahead 中实现。然后再查找一篇相应的缓存页，这是应该可以找到了

如果缓存中可以找到相应的缓存页，这时候还需要判断是否需要进行预读

最后调用 copy\_page\_to\_iter，将缓存页的内容拷贝回用户内存空间

## 三、总结 ##

read 和 write 系统调用分别调用 vfs\_read 和 vfs\_write，然后再调用 f\_op 中 的 read 和 write，对于 ext4 文件系统，调用的就是 ext4\_file\_read\_iter 和 ext4\_file\_write\_iter

读和写都分为直接I/O和缓存I/O

对于直接I/O，读和写都是调用 address\_apace 中的 direct\_IO，对于 ext4 文件系统，对应的就是 ext4\_direct\_IO，然后直接访问块设备驱动

对于缓存I/O，如果是读，那么就在缓存中查找相应的页，然后拷贝回用户空间。如果是写，那么就将数据写到相应的缓存页，然后标记页为脏，等待适当的时机内核线程进行回写

![img][]

[Linux]: https://blog.csdn.net/weixin_42462202/article/details/102529686
[Linux 1]: https://blog.csdn.net/weixin_42462202/article/details/102531706
[Linux 2]: https://blog.csdn.net/weixin_42462202/article/details/102571238
[Linux 3]: https://blog.csdn.net/weixin_42462202/article/details/102592948
[img]: /images/20230531/940b52aca3bb4532abf4e145078e2fd1.png