本文代码基于Linux5.10。
当上层调用read函数读取一个文件时， Linux 内核究竟如何处理？ 本文主要介绍这个问题
数据结构
address_space
linux 的文件在磁盘上可能是不连续的， 但文件读取又需要将文件当成一个连续的字节流， 为了解决这个矛盾， 就引入了address_space。
address_space的作用就是将文件在磁盘上的数据也page的方式连续地呈现出来， 这样读取文件的操作便转换成了先将不连续的磁盘上的内容读取的page中， 再从连续的page中去读取连续的数据。
address_spage的定义如下
include/linux/fs.h
struct address_space {
struct inode *host;
struct xarray i_pages;
gfp_t gfp_mask;
atomic_t i_mmap_writable;
#ifdef CONFIG_READ_ONLY_THP_FOR_FS
/* number of thp, only for non-shmem files */
atomic_t nr_thps;
#endif
struct rb_root_cached i_mmap;
struct rw_semaphore i_mmap_rwsem;
unsigned long nrpages;
unsigned long nrexceptional;
pgoff_t writeback_index;
const struct address_space_operations *a_ops;
unsigned long flags;
errseq_t wb_err;
spinlock_t private_lock;
struct list_head private_list;
void *private_data;
} __attribute__((aligned(sizeof(long)))) __randomize_layout;host: 该结构体对应的文件的inode
i_pages: pages对应的数组
nrpages： 页面总数
a_ops： 地址空间的操作函数
整体流程
由于page cache的存在， read 并不是直接文件中读取， 而是从page cache中读，那么整体流程大概是： 如果page cache存在， 则直接从page cache中读取， 如果不存在， 则将文件内容先读到page cache中， 再copy给用户。
入口函数
read 系统调用的定义如下：
fs/read_write.c
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
return ksys_read(fd, buf, count);
}ksys_read的定义如下：
fs/read_write.c
ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count)
{
struct fd f = fdget_pos(fd);
ssize_t ret = -EBADF;
if (f.file) {
loff_t pos, *ppos = file_ppos(f.file); /* 1 */
if (ppos) {
pos = *ppos;
ppos = &pos;
}
ret = vfs_read(f.file, buf, count, ppos); /* 2 */
if (ret >= 0 && ppos)
f.file->f_pos = pos; /* 3 */
fdput_pos(f);
}
return ret;
}(1) 获取当前文件的偏移
(2) 调用vfs_read执行具体的read流程
(3) 如果读取成功， 更新当前文件的偏移
vfs_read 的定义如下：
fs/read_write.c
ksys_read-> vfs_read
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
ssize_t ret;
if (!(file->f_mode & FMODE_READ))
return -EBADF;
if (!(file->f_mode & FMODE_CAN_READ))
return -EINVAL;
if (unlikely(!access_ok(buf, count))) /* 1 */
return -EFAULT;
ret = rw_verify_area(READ, file, pos, count); /* 2 */
if (ret)
return ret;
if (count > MAX_RW_COUNT)
count = MAX_RW_COUNT;
if (file->f_op->read)
ret = file->f_op->read(file, buf, count, pos);
else if (file->f_op->read_iter)
ret = new_sync_read(file, buf, count, pos); /* 3 */
else
ret = -EINVAL;
if (ret > 0) {
fsnotify_access(file);
add_rchar(current, ret);
}
inc_syscr(current);
return ret;
}（1） 对文件的模式及用户buf进行检测
（2） 校验用户读取的区域是否有效
（3） 调用new_sync_read进行读取。 由于目前大多数文件系统都是用的新的read_iter回调， 故一般都会走到这里来。 read_iter和read的区别是， read_iter一次性可以读取多个文件片段
new_sync_read的实现如下：
fs/read_write.c
ksys_read-> vfs_read->new_sync_read
static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
{
struct iovec iov = { .iov_base = buf, .iov_len = len };
struct kiocb kiocb;
struct iov_iter iter;
ssize_t ret;
init_sync_kiocb(&kiocb, filp);
kiocb.ki_pos = (ppos ? *ppos : 0);
iov_iter_init(&iter, READ, &iov, 1, len); /* 1 */
ret = call_read_iter(filp, &kiocb, &iter); /* 2 */
BUG_ON(ret == -EIOCBQUEUED);
if (ppos)
*ppos = kiocb.ki_pos;
return ret;
}(1) 初始化kiocb 和iov_iter 这两个结构体，他们用来控制read行为。 其定义如下：
include/linux/fs.h
struct kiocb {
struct file *ki_filp;
/* The 'ki_filp' pointer is shared in a union for aio */
randomized_struct_fields_start
loff_t ki_pos;
void (*ki_complete)(struct kiocb *iocb, long ret, long ret2);
void *private;
int ki_flags;
u16 ki_hint;
u16 ki_ioprio; /* See linux/ioprio.h */
union {
unsigned int ki_cookie; /* for ->iopoll */
struct wait_page_queue *ki_waitq; /* for async buffered IO */
};
randomized_struct_fields_end
};
include/linux/uio.h
struct iov_iter {
/*
* Bit 0 is the read/write bit, set if we're writing.
* Bit 1 is the BVEC_FLAG_NO_REF bit, set if type is a bvec and
* the caller isn't expecting to drop a page reference when done.
*/
unsigned int type;
size_t iov_offset;
size_t count;
union {
const struct iovec *iov;
const struct kvec *kvec;
const struct bio_vec *bvec;
struct pipe_inode_info *pipe;
};
union {
unsigned long nr_segs;
struct {
unsigned int head;
unsigned int start_head;
};
};
};kiocb 用来控制整个读取流程， kernel 每一次读写都会对应一个kiocb （kernel io control block）
iov_iter 记录了所有读取片段的信息。 由于kernel 支持readv这样的调用， 支持一次读取多个片段， iov_iter就是 用来记录所有的片段信息。其中：
iov 指向一个数组， 代表了所有的片段信息
nr_segs 代表iov的数组长度
count代表所有的iov的总长度，即一次读取的总的文件长度
（2） call_read_iter实际上就是调用了file->f_op->read_iter(kio, iter);
static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
struct iov_iter *iter)
{
return file->f_op->read_iter(kio, iter);
}以exfat文件系统为例， 其read_iter的实现为
fs/exfat/file.c
const struct file_operations exfat_file_operations = {
.llseek = generic_file_llseek,
.read_iter = generic_file_read_iter,
.write_iter = generic_file_write_iter,
.mmap = generic_file_mmap,
.fsync = exfat_file_fsync,
.splice_read = generic_file_splice_read,
.splice_write = iter_file_splice_write,
};
mm/filemap.c
ksys_read-> vfs_read->new_sync_read->generic_file_read_iter
ssize_t generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
size_t count = iov_iter_count(iter);
ssize_t retval = 0;
if (!count)
goto out; /* skip atime */
if (iocb->ki_flags & IOCB_DIRECT) {
struct file *file = iocb->ki_filp;
struct address_space *mapping = file->f_mapping;
struct inode *inode = mapping->host;
loff_t size;
size = i_size_read(inode);
if (iocb->ki_flags & IOCB_NOWAIT) {
if (filemap_range_has_page(mapping, iocb->ki_pos,
iocb->ki_pos + count - 1))
return -EAGAIN;
} else {
retval = filemap_write_and_wait_range(mapping,
iocb->ki_pos,
iocb->ki_pos + count - 1);
if (retval < 0)
goto out;
}
file_accessed(file);
retval = mapping->a_ops->direct_IO(iocb, iter);
if (retval >= 0) {
iocb->ki_pos += retval;
count -= retval;
}
iov_iter_revert(iter, count - iov_iter_count(iter));
/*
* Btrfs can have a short DIO read if we encounter
* compressed extents, so if there was an error, or if
* we've already read everything we wanted to, or if
* there was a short read because we hit EOF, go ahead
* and return. Otherwise fallthrough to buffered io for
* the rest of the read. Buffered reads will not work for
* DAX files, so don't bother trying.
*/
if (retval < 0 || !count || iocb->ki_pos >= size ||
IS_DAX(inode))
goto out;
}
retval = generic_file_buffered_read(iocb, iter, retval); /* 1 */
out:
return retval;
}
EXPORT_SYMBOL(generic_file_read_iter);可以看到， read_iter 的实现为generic_file_read_iter， 如果不是DIO, 则直接调用generic_file_buffered_read
mm/filemap.c
ksys_read-> vfs_read->new_sync_read->generic_file_read_iter->generic_file_buffered_read
ssize_t generic_file_buffered_read(struct kiocb *iocb,
struct iov_iter *iter, ssize_t written)
{
struct file *filp = iocb->ki_filp;
struct file_ra_state *ra = &filp->f_ra;
struct address_space *mapping = filp->f_mapping;
struct inode *inode = mapping->host;
struct page *pages_onstack[PAGEVEC_SIZE], **pages = NULL;
unsigned int nr_pages = min_t(unsigned int, 512,
((iocb->ki_pos + iter->count + PAGE_SIZE - 1) >> PAGE_SHIFT) -
(iocb->ki_pos >> PAGE_SHIFT));
int i, pg_nr, error = 0;
bool writably_mapped;
loff_t isize, end_offset;
if (unlikely(iocb->ki_pos >= inode->i_sb->s_maxbytes))
return 0;
iov_iter_truncate(iter, inode->i_sb->s_maxbytes);
if (nr_pages > ARRAY_SIZE(pages_onstack))
pages = kmalloc_array(nr_pages, sizeof(void *), GFP_KERNEL);
if (!pages) {
pages = pages_onstack;
nr_pages = min_t(unsigned int, nr_pages, ARRAY_SIZE(pages_onstack));
}
do {
cond_resched();
/*
* If we've already successfully copied some data, then we
* can no longer safely return -EIOCBQUEUED. Hence mark
* an async read NOWAIT at that point.
*/
if ((iocb->ki_flags & IOCB_WAITQ) && written)
iocb->ki_flags |= IOCB_NOWAIT;
i = 0;
pg_nr = generic_file_buffered_read_get_pages(iocb, iter,
pages, nr_pages); /* 1 */
if (pg_nr < 0) {
error = pg_nr;
break;
}
/*
* i_size must be checked after we know the pages are Uptodate.
*
* Checking i_size after the check allows us to calculate
* the correct value for "nr", which means the zero-filled
* part of the page is not copied back to userspace (unless
* another truncate extends the file - this is desired though).
*/
isize = i_size_read(inode);
if (unlikely(iocb->ki_pos >= isize))
goto put_pages;
end_offset = min_t(loff_t, isize, iocb->ki_pos + iter->count);
while ((iocb->ki_pos >> PAGE_SHIFT) + pg_nr >
(end_offset + PAGE_SIZE - 1) >> PAGE_SHIFT)
put_page(pages[--pg_nr]);
/*
* Once we start copying data, we don't want to be touching any
* cachelines that might be contended:
*/
writably_mapped = mapping_writably_mapped(mapping);
/*
* When a sequential read accesses a page several times, only
* mark it as accessed the first time.
*/
if (iocb->ki_pos >> PAGE_SHIFT !=
ra->prev_pos >> PAGE_SHIFT)
mark_page_accessed(pages[0]);
for (i = 1; i < pg_nr; i++)
mark_page_accessed(pages[i]);
for (i = 0; i < pg_nr; i++) { /* 2 */
unsigned int offset = iocb->ki_pos & ~PAGE_MASK;
unsigned int bytes = min_t(loff_t, end_offset - iocb->ki_pos,
PAGE_SIZE - offset);
unsigned int copied;
/*
* If users can be writing to this page using arbitrary
* virtual addresses, take care about potential aliasing
* before reading the page on the kernel side.
*/
if (writably_mapped)
flush_dcache_page(pages[i]);
copied = copy_page_to_iter(pages[i], offset, bytes, iter);
written += copied;
iocb->ki_pos += copied;
ra->prev_pos = iocb->ki_pos;
if (copied < bytes) {
error = -EFAULT;
break;
}
}
put_pages:
for (i = 0; i < pg_nr; i++)
put_page(pages[i]);
} while (iov_iter_count(iter) && iocb->ki_pos < isize && !error);
file_accessed(filp);
if (pages != pages_onstack)
kfree(pages);
return written ? written : error;
}
EXPORT_SYMBOL_GPL(generic_file_buffered_read);这个函数的整体逻辑应该是： 将文件内容读取到page中， 然后再拷贝到对应的iov上
（1） 找到对应的page， 如果不存在， 则新建， 并将文件内容读取到其中
（2） 遍历相关的page， 将其内容拷贝到iov_iter中
文件预读
在读取文件内容到page 的过程中， 存在预读的过程。
预读算法预测即将访问的页面，并提前将页面批量读入内存缓存。
这段逻辑可以参考https://mp.weixin.qq.com/s/8GIeK8C3bz8nbLcwmk1vcA?from=singlemessage&isappinstalled=0&scene=1&clicktime=1646449253&enterid=1646449253， 这里面说的很详细
读取磁盘内容到page
文件预读的最后一步， 是读取文件内容到page中。 这个会调用到address_space_operations的readpage 函数，在exFAT 文件系统中， 这个函数的实现为：
static const struct address_space_operations exfat_aops = {
.readpage = exfat_readpage,
.readahead = exfat_readahead,
.writepage = exfat_writepage,
.writepages = exfat_writepages,
.write_begin = exfat_write_begin,
.write_end = exfat_write_end,
.direct_IO = exfat_direct_IO,
.bmap = exfat_aop_bmap
};
static int exfat_readpage(struct file *file, struct page *page)
{
return mpage_readpage(page, exfat_get_block);
}可以看到， 这个函数会调用到， mpage_readpage
int mpage_readpage(struct page *page, get_block_t get_block)
{
struct mpage_readpage_args args = {
.page = page,
.nr_pages = 1,
.get_block = get_block,
};
args.bio = do_mpage_readpage(&args);
if (args.bio)
mpage_bio_submit(REQ_OP_READ, 0, args.bio);
return 0;
}
EXPORT_SYMBOL(mpage_readpage);最终调用到do_mpage_readpage。这个是读取文件内容到 page中的关键函数， 在理解这个函数之前， 需要先做几点说明， 否则无法理解其中的逻辑。
文件空洞
linux 中有些文件系统是允许文件空洞的。
例如一个文件只有1M , 但用户可以seek到2M的地方去写1M， 这中间的1M区域就成了空洞（hole） , 你查看文件大小， 显示的是3M, 但实际上在硬盘上只占用了2M的空间，中间1M的区域， 你读取会读到0。
fallocate、truncate 以及GNU dd的seek扩展命令都可以实现创建空洞文件的效果
fallocate -l 10G bigfile
truncate -s 10G bigfile
dd of=bigfile bs=1 seek=10G count=0bio 和buffer_head
linux 中， vfs 下发一个io 请求到block 层， 一般有两种方式， 一种是通过 bio , 一种是buffer_head。
buffer_head 代表的是一个sector（一般是512字节）， 你可以将磁盘上一个sector的内容读到一个buffer_head结构体中。
一个bio代表了物理连续的多个sector， 用于请求一大段连续的空间。
do_mpage_readpage
理解了上面两点， 下面可以来解释这个函数的具体逻辑。 一般来说，一个page 是4k， 一般包含多个 sector(512B)。 如果要读取一个page， 最理想的场景是， 这个page对应的sector在磁盘上是连续的， 那么我们只需要通过下发一个长度为4k的bio下去，就可以读取到所有的内容。 但是， 很有可能一个page对应的内容在磁盘上是不连续的， 甚至可能不存在（文件空洞）， 这种情况就没法通过下发一个bio去读取了， 因为文件内容是不连续的， 只能通过一个buffer_head一个sector一个sector去读。
linux 中， 如果要读取某个buffer_head， 需要指定它对应了物理磁盘上哪个sector。 流程一般如下
sector_t phys = x;
struct super_block *sb = ...
struct buffer_head *bh_result
map_bh(bh_result, sb, phys); // 设置buffer_head对应的物理sector
submit_bh(REQ_OP_READ, 0, bh_result); // 读取对应sector的内容到buffer_head中那么， 读取文件时， 怎么知道某个buffer_head对应的物理sector是哪个呢？
这个就需要用到mpage_readpage传进来的get_block的这个这个回调。
例如， 如果读文件的头4k的内容， 其在文件中的逻辑sector号分别是0，1，2....7, 那通过get_block这个回调， 就可以得到文件中第0个sector对应了物理上的那个sector。 知道了这个物理sector号， 就可以通过buffer_head或者bio 的方式去读取了。
do_mpage_readpage的整体逻辑就是， 尽量通过bio的方式去读取连续的sector， 如果不行， 就转而通过buffer_head的方式一个sector一个sector去读。 一个页面的逻辑块被映射到磁盘可能有以下几种情况(以下内容主要参考《存储技术原理分析， 敖青云》)
(1) 页面所有逻辑块映射到了磁盘上连续的逻辑块， 这种情况下会以bio方式提交。如果传入了bio，并和本页面在磁盘上连续， 那个尽可能合成一个bio
(2) 页面的逻辑块映射到了磁盘 上不连续的逻辑块。如果要作为bio的方式提交的话， 将不只一个请求， 会增加复杂性。所以采用buffer_head的方式处理， 如果传入了bio， 那么先将bio提交。
(3)页面的前面部分逻镇块未被映射到磁盘上 （标记为纯灰色的逻辑块）。尽管只有一个请求段，但它的起始位置不是从0开始，支持这种情况并非不可能，但代码会更复杂。所以也采用buffer_head的方式处理。如果调用时传入了一个bio，那么先把提交执行。
(4)页面的中间部分逻辑块未被映射到磁盘上，也就是说，中间部分为“空洞”。同第二种情况一样，因为有多个请求段，也只能采用缓冲页面的方式来处理。如果调用时传入了一个bio，那么先把提交执行。
(5)页面的后面部分逻强块末被映射到磁盘上，它会以bio 方式来提交。如果函数调用时传入了个bio， 并且和本页面在磁盘上连续，那么会将这个页面添加到传入的 bio 中，如果可行的话。
(6) 页面的所有逻镇块都未被映射到磁盘上，这时会跳过这个页面的处理。如果调用时传入了一个bio，则依旧将它返回，以期可以继续合并后面的页面。
理解了上面的情况， 下面就可理解do_mpage_readpage的逻辑
fs/mpage.c
static struct bio *do_mpage_readpage(struct mpage_readpage_args *args)
{
struct page *page = args->page;
struct inode *inode = page->mapping->host;
const unsigned blkbits = inode->i_blkbits;
const unsigned blocks_per_page = PAGE_SIZE >> blkbits;
const unsigned blocksize = 1 << blkbits;
struct buffer_head *map_bh = &args->map_bh;
sector_t block_in_file;
sector_t last_block;
sector_t last_block_in_file;
sector_t blocks[MAX_BUF_PER_PAGE];
unsigned page_block;
unsigned first_hole = blocks_per_page;
struct block_device *bdev = NULL;
int length;
int fully_mapped = 1;
int op_flags;
unsigned nblocks;
unsigned relative_block;
gfp_t gfp;
if (args->is_readahead) {
op_flags = REQ_RAHEAD;
gfp = readahead_gfp_mask(page->mapping);
} else {
op_flags = 0;
gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);
}
if (page_has_buffers(page))
goto confused;
block_in_file = (sector_t)page->index << (PAGE_SHIFT - blkbits);
last_block = block_in_file + args->nr_pages * blocks_per_page;
last_block_in_file = (i_size_read(inode) + blocksize - 1) >> blkbits;
if (last_block > last_block_in_file)
last_block = last_block_in_file;
page_block = 0;
/*
* Map blocks using the result from the previous get_blocks call first.
*/
nblocks = map_bh->b_size >> blkbits;
if (buffer_mapped(map_bh) &&
block_in_file > args->first_logical_block &&
block_in_file < (args->first_logical_block + nblocks)) {
unsigned map_offset = block_in_file - args->first_logical_block;
unsigned last = nblocks - map_offset;
for (relative_block = 0; ; relative_block++) {
if (relative_block == last) {
clear_buffer_mapped(map_bh);
break;
}
if (page_block == blocks_per_page)
break;
blocks[page_block] = map_bh->b_blocknr + map_offset +
relative_block;
page_block++;
block_in_file++;
}
bdev = map_bh->b_bdev;
} /* 1 */
/*
* Then do more get_blocks calls until we are done with this page.
*/
map_bh->b_page = page;
while (page_block < blocks_per_page) {
map_bh->b_state = 0;
map_bh->b_size = 0;
if (block_in_file < last_block) {
map_bh->b_size = (last_block-block_in_file) << blkbits;
if (args->get_block(inode, block_in_file, map_bh, 0)) /* 2 */
goto confused;
args->first_logical_block = block_in_file;
}
if (!buffer_mapped(map_bh)) { /* 3 */
fully_mapped = 0;
if (first_hole == blocks_per_page)
first_hole = page_block;
page_block++;
block_in_file++;
continue;
}
/* some filesystems will copy data into the page during
* the get_block call, in which case we don't want to
* read it again. map_buffer_to_page copies the data
* we just collected from get_block into the page's buffers
* so readpage doesn't have to repeat the get_block call
*/
if (buffer_uptodate(map_bh)) { /* 4 */
map_buffer_to_page(page, map_bh, page_block);
goto confused;
}
if (first_hole != blocks_per_page) /* 5 */
goto confused; /* hole -> non-hole */
/* Contiguous blocks? */
if (page_block && blocks[page_block-1] != map_bh->b_blocknr-1) /* 6 */
goto confused;
nblocks = map_bh->b_size >> blkbits;
for (relative_block = 0; ; relative_block++) { /* 7 */
if (relative_block == nblocks) {
clear_buffer_mapped(map_bh);
break;
} else if (page_block == blocks_per_page)
break;
blocks[page_block] = map_bh->b_blocknr+relative_block;
page_block++;
block_in_file++;
}
bdev = map_bh->b_bdev;
}
if (first_hole != blocks_per_page) { /* 8 */
zero_user_segment(page, first_hole << blkbits, PAGE_SIZE);
if (first_hole == 0) {
SetPageUptodate(page);
unlock_page(page);
goto out;
}
} else if (fully_mapped) {
SetPageMappedToDisk(page);
}
if (fully_mapped && blocks_per_page == 1 && !PageUptodate(page) &&
cleancache_get_page(page) == 0) {
SetPageUptodate(page);
goto confused;
}
/*
* This page will go to BIO. Do we need to send this BIO off first?
*/
if (args->bio && (args->last_block_in_bio != blocks[0] - 1)) /* 9 */
args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
alloc_new:
if (args->bio == NULL) { /* 10 */
if (first_hole == blocks_per_page) {
if (!bdev_read_page(bdev, blocks[0] << (blkbits - 9),
page))
goto out;
}
args->bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
min_t(int, args->nr_pages,
BIO_MAX_PAGES),
gfp);
if (args->bio == NULL)
goto confused;
}
length = first_hole << blkbits;
if (bio_add_page(args->bio, page, length, 0) < length) { /* 11 */
args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
goto alloc_new;
}
relative_block = block_in_file - args->first_logical_block;
nblocks = map_bh->b_size >> blkbits;
if ((buffer_boundary(map_bh) && relative_block == nblocks) ||
(first_hole != blocks_per_page))
args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
else
args->last_block_in_bio = blocks[blocks_per_page - 1];
out:
return args->bio;
confused: /* 12 */
if (args->bio)
args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
if (!PageUptodate(page))
block_read_full_page(page, args->get_block);
else
unlock_page(page);
goto out;
}先对这个函数中涉及到的变量做一些解释：
blocks_per_page： 一个page中包含的block数(一般来说是8， 因为一个page是4k， 一个block是512B)
blocksize: 一个block大小， 一般是512B
block_in_file: 文件中的逻辑sector号
blocks: 映射数组， 每个元素表示这个页面给定的逻辑sector对应的物理sector
page_block: page 中第几个sector
first_hole： 第一个文件空洞的位置（如果有空洞的话）
在这个函数调用之前， 可能已经有了其他page的bio(args->bio)， 可以和即将创建的bio合成一个更大的bio下发。
(1) 这段if逻辑处理调用这个函数之前， 对应page的内容已经被部分map的情况。 对于这种情况，把对应部门的内容记录来。赋值给blocks[page_block] (2) 接来下处理page中剩余的部分。调用get_block 映射block_in_file对应的文件sector, 结果存在map_bh中。 (3) 如果没有被映射， 说明对应的sector是一个文件洞。 这种情况下， 用first_hole 记录当前的位置， 然后继续循环。
(4）某些文件系统会在 get block 函数进行映射时复制数据到页面中，这就没必要再次从磁盘读取了。调用map_buffer_to_page复制我们收集的数据到页面缓冲区中，然后跳转到标号 confused 处继续执行，这样readpage 不需要重复调用 get block。
(5) 程序继续运行，那一定是缓冲头己经有映射的情况。如果这时 first hole 已经设置，说明这个页面在经过空洞后又重新被映射，没有办法用bio 方式来提交，跳转到 confused 标号处。
(6)如果这个逻镇块不是页面的第一个，判断它是否和前一个逻辑块在磁盘上也是连续的。如果不是，也没有办法用bio 方式来提交，跳转到 confused 标号处
(7) 根据缓冲头的映射信息，记录页面每个逻辑块在磁盘上对应的块编号。如果映射信息用光，清除缓冲头的 mapped 标志，退出循环；如果这个页面的所有sector都己经处理完，也退出循环，如果此时映射信息可能还没有用光，则留给下一个页面。
(8) 页面的所有逻辑块都经过上面的处理后，可以采用 bio 方式提交的情况就清楚了。只可能会是三种情况。页面的逻辑块被映射到磁盘上连续的逻辑块，这时设置页面的映射标志；页面只有前面一些逻辑块被映射到磁盘，这时清零没有被映射部分的数据：控个页面都没有被映射，清除整个页面，并设置最新标志。
(9) 如果传入了一个bio， 需要判断本页面第一个逻街块和传入bio 的最后一个逻辑块在磁盘上是否连续，也就是看是否可以将本页面作为一个请求段加入传入的 bio 中。如果不连续，那么mpage_bio_submit提交前面的bio， 这个函数恒返回 NULL
(10) 如果传入的bio 为 NULL， 或者传入的bio 已提交，那么，我们需要调用 mpage_alloc 重新分配一个bio。
(11) 设置该bio的参数， 并将该bio返回
(12) 对于无法用bio处理的情况， 先将已有的bio提交， 然后调用block_read_full_page 通过buffer_head的方式进行读取
从文件块编号推导物理块编号
下面以exFAT文件系统为例， 讲解一下get_block这个函数的具体实现。
fs/exfat/inode.c
static int exfat_get_block(struct inode *inode, sector_t iblock,
struct buffer_head *bh_result, int create)
{
struct exfat_inode_info *ei = EXFAT_I(inode);
struct super_block *sb = inode->i_sb;
struct exfat_sb_info *sbi = EXFAT_SB(sb);
unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
int err = 0;
unsigned long mapped_blocks = 0;
unsigned int cluster, sec_offset;
sector_t last_block;
sector_t phys = 0;
loff_t pos;
mutex_lock(&sbi->s_lock);
last_block = EXFAT_B_TO_BLK_ROUND_UP(i_size_read(inode), sb);
if (iblock >= last_block && !create)
goto done;
/* Is this block already allocated? */
err = exfat_map_cluster(inode, iblock >> sbi->sect_per_clus_bits, /* 1 */
&cluster, create);
if (err) {
if (err != -ENOSPC)
exfat_fs_error_ratelimit(sb,
"failed to bmap (inode : %p iblock : %llu, err : %d)",
inode, (unsigned long long)iblock, err);
goto unlock_ret;
}
if (cluster == EXFAT_EOF_CLUSTER)
goto done;
/* sector offset in cluster */
sec_offset = iblock & (sbi->sect_per_clus - 1);
phys = exfat_cluster_to_sector(sbi, cluster) + sec_offset;
mapped_blocks = sbi->sect_per_clus - sec_offset;
max_blocks = min(mapped_blocks, max_blocks);
/* Treat newly added block / cluster */
if (iblock < last_block)
create = 0;
if (create || buffer_delay(bh_result)) {
pos = EXFAT_BLK_TO_B((iblock + 1), sb);
if (ei->i_size_ondisk < pos)
ei->i_size_ondisk = pos;
}
if (create) {
err = exfat_map_new_buffer(ei, bh_result, pos);
if (err) {
exfat_fs_error(sb,
"requested for bmap out of range(pos : (%llu) > i_size_aligned(%llu)\n",
pos, ei->i_size_aligned);
goto unlock_ret;
}
}
if (buffer_delay(bh_result))
clear_buffer_delay(bh_result);
map_bh(bh_result, sb, phys); /* 2 */
done:
bh_result->b_size = EXFAT_BLK_TO_B(max_blocks, sb);
unlock_ret:
mutex_unlock(&sbi->s_lock);
return err;
}get_block 这个函数用于查找inode对应的文件中第iblock位置的sector在物理上对应那个sector， 并将结果保存在bh_result, create表示如果没有找到对应的sector， 是否进行创建。
(1) 调用exfat_map_cluster 去查找某个文件中的iblock 对应的实际的cluster。 这里面就涉及到文件系统的具体操作。
(2) 将bh_result映射到phys对应的位置
