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;
}