f2fs读取磁盘block过程：do_read_inode

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/jasonLee_lijiaqi/article/details/82970775

f2fs：依据inode的节点号，将inode对应的block读到页缓存
f2fs_iget依据索引节点号，查找对应的inode，若没有，则创建一个新的inode，读取磁盘上的inode所在的block，生成f2f2_inode对象去初始化这个新inode。

其中，当inode不存在时，需要创建新的inode，同时还要从磁盘上读取inode所在的block；
因此，这次主要针对f2fs读取磁盘block过程进行分析，do_read_inode是主要函数。

/* 
	依据节点号ino，获得对应的inode；
	若没有，则创建一个新的inode，读取磁盘上的inode所在的block，生成f2f2_inode对象去初始化这个新inode
*/
struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
	struct inode *inode;
	int ret = 0;

	//依据索引节点号ino，获得对应的inode；若没有，则创建一个新的inode
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);

	/* 该inode不是新inode，直接返回该inode */
	if (!(inode->i_state & I_NEW)) {
		trace_f2fs_iget(inode);
		return inode;
	}

	/* 如果索引节点号是NODE节点或者META节点，调到make_now */
	if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
		goto make_now;

	/* 索引节点是DATA节点：依据inode的节点号，将inode对应的block读到页缓存，此时磁盘上的f2fs_node节点就位于页缓存中。
		使用f2fs_node 对inode初始化 */
	ret = do_read_inode(inode);
	if (ret)
		goto bad_inode;
make_now:

	/* 依据ino对应的节点类型或者文件类型，赋予inode不同的操作方法 */
	if (ino == F2FS_NODE_INO(sbi)) {   //ino是NODE节点
		inode->i_mapping->a_ops = &f2fs_node_aops;
		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
	} else if (ino == F2FS_META_INO(sbi)) {  //ino是META节点
		inode->i_mapping->a_ops = &f2fs_meta_aops;
		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
	} else if (S_ISREG(inode->i_mode)) {    //inode代表普通文件
		inode->i_op = &f2fs_file_inode_operations;
		inode->i_fop = &f2fs_file_operations;
		inode->i_mapping->a_ops = &f2fs_dblock_aops;
	} else if (S_ISDIR(inode->i_mode)) {   //inode代表目录文件
		inode->i_op = &f2fs_dir_inode_operations;
		inode->i_fop = &f2fs_dir_operations;
		inode->i_mapping->a_ops = &f2fs_dblock_aops;
		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO);
	} else if (S_ISLNK(inode->i_mode)) {   //inode代表符号链接
		if (f2fs_encrypted_inode(inode))
			inode->i_op = &f2fs_encrypted_symlink_inode_operations;
		else
			inode->i_op = &f2fs_symlink_inode_operations;
		inode_nohighmem(inode);
		inode->i_mapping->a_ops = &f2fs_dblock_aops;
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
			S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {  //inode代表字符设备、块设备、管道或者套接字文件
		inode->i_op = &f2fs_special_inode_operations;
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
	} else {
		ret = -EIO;
		goto bad_inode;
	}
	unlock_new_inode(inode);
	trace_f2fs_iget(inode);
	return inode;

bad_inode:
	iget_failed(inode);
	trace_f2fs_iget_exit(inode, ret);
	return ERR_PTR(ret);
}

do_read_inode依据inode节点号，将inode所在的磁盘block读到页缓存，该block恰好对应着页缓存中的一个page，对page进行F2FS_INODE转换，转换成f2fs_inode结构。最后使用f2fs_inode 对inode初始化。
我们接着深入get_node_page函数，看看f2fs是如何读取磁盘block的。

/* 依据inode的节点号，将inode所在的磁盘block读到页缓存，此时磁盘上的f2fs_node节点就位于页缓存中。
		使用f2fs_node 对inode初始化 */
static int do_read_inode(struct inode *inode)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct f2fs_inode_info *fi = F2FS_I(inode);
	struct page *node_page;
	struct f2fs_inode *ri;

	/* Check if ino is within scope */
	if (check_nid_range(sbi, inode->i_ino)) {
		f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",
			 (unsigned long) inode->i_ino);
		WARN_ON(1);
		return -EINVAL;
	}

	/* 依据inode节点号，将inode所在的磁盘block读到页缓存，返回页缓存中的page */
	node_page = get_node_page(sbi, inode->i_ino);
	if (IS_ERR(node_page))
		return PTR_ERR(node_page);

	/* 获取到page中的f2fs_inode结构（该结构本来是位于磁盘上的，后来被读到内存中） */
	ri = F2FS_INODE(node_page);

	/* 使用f2fs_inode的磁盘信息初始化inode和f2fs_inode_info */
	inode->i_mode = le16_to_cpu(ri->i_mode);
	i_uid_write(inode, le32_to_cpu(ri->i_uid));
	i_gid_write(inode, le32_to_cpu(ri->i_gid));
	set_nlink(inode, le32_to_cpu(ri->i_links));
	inode->i_size = le64_to_cpu(ri->i_size);
	inode->i_blocks = le64_to_cpu(ri->i_blocks);

	inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
	inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
	inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
	inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
	inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
	inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
	inode->i_generation = le32_to_cpu(ri->i_generation);

	fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
	fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
	fi->i_flags = le32_to_cpu(ri->i_flags);
	fi->flags = 0;
	fi->i_advise = ri->i_advise;
	fi->i_pino = le32_to_cpu(ri->i_pino);
	fi->i_dir_level = ri->i_dir_level;

	if (f2fs_init_extent_tree(inode, &ri->i_ext))
		set_page_dirty(node_page);

	get_inline_info(fi, ri);

	/* check data exist */
	if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
		__recover_inline_status(inode, node_page);

	/* get rdev by using inline_info */
	__get_inode_rdev(inode, ri);

	if (__written_first_block(ri))
		set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);

	f2fs_put_page(node_page, 1);

	stat_inc_inline_xattr(inode);
	stat_inc_inline_inode(inode);
	stat_inc_inline_dir(inode);

	return 0;
}

get_node_page是__get_node_page函数的封装；

/* 依据inode节点号，将inode所在的磁盘block读到页缓存，返回页缓存中的page */
struct page *get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid)
{
	return __get_node_page(sbi, nid, NULL, 0);
}

进入__get_node_page函数。
该函数首先调用grab_cache_page查找address_space中是否有inode索引节点号对应的page，如果没有则创建一个新的page插入到页缓存中。紧接着调用read_node_page从磁盘中读取inode对应的block，将block数据放到刚刚创建的page中，最后返回读取到的page。

/* 依据inode节点号，将inode所在的磁盘block读到页缓存，返回页缓存中的page */
static struct page *__get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid,
					struct page *parent, int start)
{
	struct page *page;
	int err;

	if (!nid)
		return ERR_PTR(-ENOENT);
	f2fs_bug_on(sbi, check_nid_range(sbi, nid));
repeat:
	/* 首先查找address_space中是否有inode索引号对应的page，如果没有则创建新的page*/
	page = grab_cache_page(NODE_MAPPING(sbi), nid);
	if (!page)
		return ERR_PTR(-ENOMEM);

	/* 提交bio请求，从磁盘读取inode对应的block，放到page中
	   如果inode对应的block读取到page中了，直接返回该page
	*/
	err = read_node_page(page, READ_SYNC);
	if (err < 0) {
		f2fs_put_page(page, 1);
		return ERR_PTR(err);
	} else if (err == LOCKED_PAGE) {
		goto page_hit;
	}

	if (parent)
		ra_node_pages(parent, start + 1);

	lock_page(page);

	if (unlikely(!PageUptodate(page))) {
		f2fs_put_page(page, 1);
		return ERR_PTR(-EIO);
	}
	if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
		f2fs_put_page(page, 1);
		goto repeat;
	}
page_hit:
	f2fs_bug_on(sbi, nid != nid_of_node(page));
	return page;
}

进入read_node_page。
该函数首先构造bio所需的信息，将信息填充在f2fs_io_info中，并调用get_node_info获得node信息，放到node_info中。最后调用f2fs_submit_page_bio提交bio请求，从磁盘中读取block到page中。

/*
	提交bio请求，从磁盘读取inode对应的block，放到page中
 * Caller should do after getting the following values.
 * 0: f2fs_put_page(page, 0)
 * LOCKED_PAGE or error: f2fs_put_page(page, 1)
 */
static int read_node_page(struct page *page, int rw)
{
	struct f2fs_sb_info *sbi = F2FS_P_SB(page);
	struct node_info ni;

	/* 构造bio所需的信息 */
	struct f2fs_io_info fio = {
		.sbi = sbi,
		.type = NODE,
		.rw = rw,
		.page = page,
		.encrypted_page = NULL,
	};

	/* 获得node信息，存放在ni中 */
	get_node_info(sbi, page->index, &ni);

	if (unlikely(ni.blk_addr == NULL_ADDR)) {
		ClearPageUptodate(page);
		return -ENOENT;
	}

	if (PageUptodate(page))
		return LOCKED_PAGE;

	fio.new_blkaddr = fio.old_blkaddr = ni.blk_addr;
	/* 提交bio请求 */
	return f2fs_submit_page_bio(&fio);
}

f2fs_submit_page_bio 主要是申请一个新的bio结构，进行bio合并，最后提交bio请求。
submit_bio之后的操作位于通用块层，不再具体的深入了。

/*
 * Fill the locked page with data located in the block address.
 * Return unlocked page.
 */
int f2fs_submit_page_bio(struct f2fs_io_info *fio)
{
	struct bio *bio;
	struct page *page = fio->encrypted_page ?
			fio->encrypted_page : fio->page;

	trace_f2fs_submit_page_bio(page, fio);
	f2fs_trace_ios(fio, 0);

	/* Allocate a new bio
	*/
	bio = __bio_alloc(fio->sbi, fio->new_blkaddr, 1, is_read_io(fio->rw));

	/* 进行bio合并 */
	if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
		bio_put(bio);
		return -EFAULT;
	}

	/* 提交bio请求 */
	submit_bio(fio->rw, bio);
	return 0;
}