自学教程：C++ F2FS_INODE函数代码示例

static void recover_inode(struct inode *inode, struct page *page){	struct f2fs_inode *raw = F2FS_INODE(page);	char *name;	inode->i_mode = le16_to_cpu(raw->i_mode);	f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));	inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);	inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);	inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);	inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);	inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);	inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);	F2FS_I(inode)->i_advise = raw->i_advise;	recover_inline_flags(inode, raw);	if (file_enc_name(inode))		name = "<encrypted>";	else		name = F2FS_INODE(page)->i_name;	f2fs_msg(inode->i_sb, KERN_NOTICE,		"recover_inode: ino = %x, name = %s, inline = %x",			ino_of_node(page), name, raw->i_inline);}

int f2fs_inline_data_fiemap(struct inode *inode,		struct fiemap_extent_info *fieinfo, __u64 start, __u64 len){	__u64 byteaddr, ilen;	__u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |		FIEMAP_EXTENT_LAST;	struct node_info ni;	struct page *ipage;	int err = 0;	ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);	if (IS_ERR(ipage))		return PTR_ERR(ipage);	if (!f2fs_has_inline_data(inode)) {		err = -EAGAIN;		goto out;	}	ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));	if (start >= ilen)		goto out;	if (start + len < ilen)		ilen = start + len;	ilen -= start;	get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);	byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;	byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);	err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);out:	f2fs_put_page(ipage, 1);	return err;}

static void recover_inode(struct inode *inode, struct page *page){	struct f2fs_inode *raw = F2FS_INODE(page);	inode->i_mode = le16_to_cpu(raw->i_mode);	i_size_write(inode, le64_to_cpu(raw->i_size));	inode->i_atime.tv_sec = le64_to_cpu(raw->i_mtime);	inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);	inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);	inode->i_atime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);	inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);	inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);	f2fs_msg(inode->i_sb, KERN_NOTICE, "recover_inode: ino = %x, name = %s",			ino_of_node(page), F2FS_INODE(page)->i_name);}

static int recover_quota_data(struct inode *inode, struct page *page){	struct f2fs_inode *raw = F2FS_INODE(page);	struct iattr attr;	uid_t i_uid = le32_to_cpu(raw->i_uid);	gid_t i_gid = le32_to_cpu(raw->i_gid);	int err;	memset(&attr, 0, sizeof(attr));	attr.ia_uid = make_kuid(inode->i_sb->s_user_ns, i_uid);	attr.ia_gid = make_kgid(inode->i_sb->s_user_ns, i_gid);	if (!uid_eq(attr.ia_uid, inode->i_uid))		attr.ia_valid |= ATTR_UID;	if (!gid_eq(attr.ia_gid, inode->i_gid))		attr.ia_valid |= ATTR_GID;	if (!attr.ia_valid)		return 0;	err = dquot_transfer(inode, &attr);	if (err)		set_sbi_flag(F2FS_I_SB(inode), SBI_QUOTA_NEED_REPAIR);	return err;}

static bool is_same_inode(struct inode *inode, struct page *ipage){	struct f2fs_inode *ri = F2FS_INODE(ipage);	struct timespec disk;	if (!IS_INODE(ipage))		return true;	disk.tv_sec = le64_to_cpu(ri->i_ctime);	disk.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);	if (timespec_compare(&inode->i_ctime, &disk) > 0)		return false;	disk.tv_sec = le64_to_cpu(ri->i_atime);	disk.tv_nsec = le32_to_cpu(ri->i_atime_nsec);	if (timespec_compare(&inode->i_atime, &disk) > 0)		return false;	disk.tv_sec = le64_to_cpu(ri->i_mtime);	disk.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);	if (timespec_compare(&inode->i_mtime, &disk) > 0)		return false;	return true;}

static void init_dent_inode(const struct qstr *name, struct page *ipage){	struct f2fs_inode *ri;	/* copy name info. to this inode page */	ri = F2FS_INODE(ipage);	ri->i_namelen = cpu_to_le32(name->len);	memcpy(ri->i_name, name->name, name->len);	set_page_dirty(ipage);}

static int do_read_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	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;	}	node_page = get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page))		return PTR_ERR(node_page);	ri = F2FS_INODE(node_page);	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;	get_extent_info(&fi->ext, ri->i_ext);	get_inline_info(fi, ri);	/* get rdev by using inline_info */	__get_inode_rdev(inode, ri);	f2fs_put_page(node_page, 1);	return 0;}

bool recover_inline_data(struct inode *inode, struct page *npage){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct f2fs_inode *ri = NULL;	void *src_addr, *dst_addr;	struct page *ipage;	/*	 * The inline_data recovery policy is as follows.	 * [prev.] [next] of inline_data flag	 *    o       o  -> recover inline_data	 *    o       x  -> remove inline_data, and then recover data blocks	 *    x       o  -> remove inline_data, and then recover inline_data	 *    x       x  -> recover data blocks	 */	if (IS_INODE(npage))		ri = F2FS_INODE(npage);	if (f2fs_has_inline_data(inode) &&			ri && (ri->i_inline & F2FS_INLINE_DATA)) {process_inline:		ipage = get_node_page(sbi, inode->i_ino);		f2fs_bug_on(sbi, IS_ERR(ipage));		f2fs_wait_on_page_writeback(ipage, NODE, true);		src_addr = inline_data_addr(npage);		dst_addr = inline_data_addr(ipage);		memcpy(dst_addr, src_addr, MAX_INLINE_DATA);		set_inode_flag(inode, FI_INLINE_DATA);		set_inode_flag(inode, FI_DATA_EXIST);		set_page_dirty(ipage);		f2fs_put_page(ipage, 1);		return true;	}	if (f2fs_has_inline_data(inode)) {		ipage = get_node_page(sbi, inode->i_ino);		f2fs_bug_on(sbi, IS_ERR(ipage));		if (!truncate_inline_inode(ipage, 0))			return false;		f2fs_clear_inline_inode(inode);		f2fs_put_page(ipage, 1);	} else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {		if (truncate_blocks(inode, 0, false))			return false;		goto process_inline;	}	return false;}

int update_inode(struct inode *inode, struct page *node_page){	struct f2fs_inode *ri;	struct extent_tree *et = F2FS_I(inode)->extent_tree;	f2fs_inode_synced(inode);	f2fs_wait_on_page_writeback(node_page, NODE, true);	ri = F2FS_INODE(node_page);	ri->i_mode = cpu_to_le16(inode->i_mode);	ri->i_advise = F2FS_I(inode)->i_advise;	ri->i_uid = cpu_to_le32(i_uid_read(inode));	ri->i_gid = cpu_to_le32(i_gid_read(inode));	ri->i_links = cpu_to_le32(inode->i_nlink);	ri->i_size = cpu_to_le64(i_size_read(inode));	ri->i_blocks = cpu_to_le64(inode->i_blocks);	if (et) {		read_lock(&et->lock);		set_raw_extent(&et->largest, &ri->i_ext);		read_unlock(&et->lock);	} else {		memset(&ri->i_ext, 0, sizeof(ri->i_ext));	}	set_raw_inline(inode, ri);	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);	ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);	ri->i_generation = cpu_to_le32(inode->i_generation);	ri->i_dir_level = F2FS_I(inode)->i_dir_level;	__set_inode_rdev(inode, ri);	set_cold_node(inode, node_page);	/* deleted inode */	if (inode->i_nlink == 0)		clear_inline_node(node_page);	return set_page_dirty(node_page);}

int recover_inline_data(struct inode *inode, struct page *npage){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	struct f2fs_inode *ri = NULL;	void *src_addr, *dst_addr;	struct page *ipage;	/*	 * The inline_data recovery policy is as follows.	 * [prev.] [next] of inline_data flag	 *    o       o  -> recover inline_data	 *    o       x  -> remove inline_data, and then recover data blocks	 *    x       o  -> remove inline_data, and then recover inline_data	 *    x       x  -> recover data blocks	 */	if (IS_INODE(npage))		ri = F2FS_INODE(npage);	if (f2fs_has_inline_data(inode) &&			ri && ri->i_inline & F2FS_INLINE_DATA) {process_inline:		ipage = get_node_page(sbi, inode->i_ino);		f2fs_bug_on(IS_ERR(ipage));		src_addr = inline_data_addr(npage);		dst_addr = inline_data_addr(ipage);		memcpy(dst_addr, src_addr, MAX_INLINE_DATA);		update_inode(inode, ipage);		f2fs_put_page(ipage, 1);		return -1;	}	if (f2fs_has_inline_data(inode)) {		ipage = get_node_page(sbi, inode->i_ino);		f2fs_bug_on(IS_ERR(ipage));		zero_user_segment(ipage, INLINE_DATA_OFFSET,				 INLINE_DATA_OFFSET + MAX_INLINE_DATA);		clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);		update_inode(inode, ipage);		f2fs_put_page(ipage, 1);	} else if (ri && ri->i_inline & F2FS_INLINE_DATA) {		truncate_blocks(inode, 0);		set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);		goto process_inline;	}	return 0;}

static void __recover_inline_status(struct inode *inode, struct page *ipage){	void *inline_data = inline_data_addr(ipage);	__le32 *start = inline_data;	__le32 *end = start + MAX_INLINE_DATA / sizeof(__le32);	while (start < end) {		if (*start++) {			f2fs_wait_on_page_writeback(ipage, NODE, true);			set_inode_flag(inode, FI_DATA_EXIST);			set_raw_inline(inode, F2FS_INODE(ipage));			set_page_dirty(ipage);			return;		}	}	return;}

void update_inode(struct inode *inode, struct page *node_page){	struct f2fs_inode *ri;	f2fs_wait_on_page_writeback(node_page, NODE);	ri = F2FS_INODE(node_page);	ri->i_mode = cpu_to_le16(inode->i_mode);	ri->i_advise = F2FS_I(inode)->i_advise;	ri->i_uid = cpu_to_le32(inode->i_uid);	ri->i_gid = cpu_to_le32(inode->i_gid);	ri->i_links = cpu_to_le32(inode->i_nlink);	ri->i_size = cpu_to_le64(i_size_read(inode));	ri->i_blocks = cpu_to_le64(inode->i_blocks);	if (F2FS_I(inode)->extent_tree)		set_raw_extent(&F2FS_I(inode)->extent_tree->largest,							&ri->i_ext);	else		memset(&ri->i_ext, 0, sizeof(ri->i_ext));	set_raw_inline(F2FS_I(inode), ri);	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);	ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);	ri->i_generation = cpu_to_le32(inode->i_generation);	ri->i_dir_level = F2FS_I(inode)->i_dir_level;	__set_inode_rdev(inode, ri);	set_cold_node(inode, node_page);	set_page_dirty(node_page);	clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);}

static int recover_inode(struct inode *inode, struct page *node_page){	struct f2fs_inode *raw_inode = F2FS_INODE(node_page);	if (!IS_INODE(node_page))		return 0;	inode->i_mode = le16_to_cpu(raw_inode->i_mode);	i_size_write(inode, le64_to_cpu(raw_inode->i_size));	inode->i_atime.tv_sec = le64_to_cpu(raw_inode->i_mtime);	inode->i_ctime.tv_sec = le64_to_cpu(raw_inode->i_ctime);	inode->i_mtime.tv_sec = le64_to_cpu(raw_inode->i_mtime);	inode->i_atime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec);	inode->i_ctime.tv_nsec = le32_to_cpu(raw_inode->i_ctime_nsec);	inode->i_mtime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec);	if (is_dent_dnode(node_page))		return recover_dentry(node_page, inode);	f2fs_msg(inode->i_sb, KERN_DEBUG, "recover_inode: ino = %x, name = %s",			ino_of_node(node_page), raw_inode->i_name);	return 0;}

static int recover_dentry(struct inode *inode, struct page *ipage){	struct f2fs_inode *raw_inode = F2FS_INODE(ipage);	nid_t pino = le32_to_cpu(raw_inode->i_pino);	struct f2fs_dir_entry *de;	struct qstr name;	struct page *page;	struct inode *dir, *einode;	int err = 0;	dir = f2fs_iget(inode->i_sb, pino);	if (IS_ERR(dir)) {		err = PTR_ERR(dir);		goto out;	}	if (file_enc_name(inode)) {		iput(dir);		return 0;	}	name.len = le32_to_cpu(raw_inode->i_namelen);	name.name = raw_inode->i_name;	if (unlikely(name.len > F2FS_NAME_LEN)) {		WARN_ON(1);		err = -ENAMETOOLONG;		goto out_err;	}retry:	de = f2fs_find_entry(dir, &name, &page);	if (de && inode->i_ino == le32_to_cpu(de->ino))		goto out_unmap_put;	if (de) {		einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino));		if (IS_ERR(einode)) {			WARN_ON(1);			err = PTR_ERR(einode);			if (err == -ENOENT)				err = -EEXIST;			goto out_unmap_put;		}		err = acquire_orphan_inode(F2FS_I_SB(inode));		if (err) {			iput(einode);			goto out_unmap_put;		}		f2fs_delete_entry(de, page, dir, einode);		iput(einode);		goto retry;	}	err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);	if (err)		goto out_err;	if (is_inode_flag_set(F2FS_I(dir), FI_DELAY_IPUT)) {		iput(dir);	} else {		add_dirty_dir_inode(dir);		set_inode_flag(F2FS_I(dir), FI_DELAY_IPUT);	}	goto out;out_unmap_put:	f2fs_dentry_kunmap(dir, page);	f2fs_put_page(page, 0);out_err:	iput(dir);out:	f2fs_msg(inode->i_sb, KERN_NOTICE,			"%s: ino = %x, name = %s, dir = %lx, err = %d",			__func__, ino_of_node(ipage), raw_inode->i_name,			IS_ERR(dir) ? 0 : dir->i_ino, err);	return err;}

static int recover_inode(struct inode *inode, struct page *page){	struct f2fs_inode *raw = F2FS_INODE(page);	char *name;	int err;	inode->i_mode = le16_to_cpu(raw->i_mode);	err = recover_quota_data(inode, page);	if (err)		return err;	i_uid_write(inode, le32_to_cpu(raw->i_uid));	i_gid_write(inode, le32_to_cpu(raw->i_gid));	if (raw->i_inline & F2FS_EXTRA_ATTR) {		if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&			F2FS_FITS_IN_INODE(raw, le16_to_cpu(raw->i_extra_isize),								i_projid)) {			projid_t i_projid;			kprojid_t kprojid;			i_projid = (projid_t)le32_to_cpu(raw->i_projid);			kprojid = make_kprojid(&init_user_ns, i_projid);			if (!projid_eq(kprojid, F2FS_I(inode)->i_projid)) {				err = f2fs_transfer_project_quota(inode,								kprojid);				if (err)					return err;				F2FS_I(inode)->i_projid = kprojid;			}		}	}	f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));	inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);	inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);	inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);	inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);	inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);	inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);	F2FS_I(inode)->i_advise = raw->i_advise;	F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags);	f2fs_set_inode_flags(inode);	F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] =				le16_to_cpu(raw->i_gc_failures);	recover_inline_flags(inode, raw);	f2fs_mark_inode_dirty_sync(inode, true);	if (file_enc_name(inode))		name = "<encrypted>";	else		name = F2FS_INODE(page)->i_name;	f2fs_msg(inode->i_sb, KERN_NOTICE,		"recover_inode: ino = %x, name = %s, inline = %x",			ino_of_node(page), name, raw->i_inline);	return 0;}

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;	projid_t i_projid;	int err;	/* Check if ino is within scope */	if (f2fs_check_nid_range(sbi, inode->i_ino))		return -EINVAL;	node_page = f2fs_get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page))		return PTR_ERR(node_page);	ri = F2FS_INODE(node_page);	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 = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1);	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);	if (S_ISDIR(inode->i_mode))		fi->i_current_depth = le32_to_cpu(ri->i_current_depth);	else if (S_ISREG(inode->i_mode))		fi->i_gc_failures[GC_FAILURE_PIN] =					le16_to_cpu(ri->i_gc_failures);	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(inode, ri);	fi->i_extra_isize = f2fs_has_extra_attr(inode) ?					le16_to_cpu(ri->i_extra_isize) : 0;	if (f2fs_sb_has_flexible_inline_xattr(sbi->sb)) {		fi->i_inline_xattr_size = le16_to_cpu(ri->i_inline_xattr_size);	} else if (f2fs_has_inline_xattr(inode) ||				f2fs_has_inline_dentry(inode)) {		fi->i_inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;	} else {		/*		 * Previous inline data or directory always reserved 200 bytes		 * in inode layout, even if inline_xattr is disabled. In order		 * to keep inline_dentry's structure for backward compatibility,		 * we get the space back only from inline_data.		 */		fi->i_inline_xattr_size = 0;	}	if (!sanity_check_inode(inode, node_page)) {		f2fs_put_page(node_page, 1);		return -EINVAL;	}	/* 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 (S_ISREG(inode->i_mode)) {		err = __written_first_block(sbi, ri);		if (err < 0) {			f2fs_put_page(node_page, 1);			return err;		}		if (!err)			set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);	}	if (!f2fs_need_inode_block_update(sbi, inode->i_ino))		fi->last_disk_size = inode->i_size;	if (fi->i_flags & F2FS_PROJINHERIT_FL)		set_inode_flag(inode, FI_PROJ_INHERIT);	if (f2fs_has_extra_attr(inode) && f2fs_sb_has_project_quota(sbi->sb) &&			F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid))		i_projid = (projid_t)le32_to_cpu(ri->i_projid);//.........这里部分代码省略.........

static int recover_dentry(struct inode *inode, struct page *ipage,						struct list_head *dir_list){	struct f2fs_inode *raw_inode = F2FS_INODE(ipage);	nid_t pino = le32_to_cpu(raw_inode->i_pino);	struct f2fs_dir_entry *de;	struct fscrypt_name fname;	struct page *page;	struct inode *dir, *einode;	struct fsync_inode_entry *entry;	int err = 0;	char *name;	entry = get_fsync_inode(dir_list, pino);	if (!entry) {		entry = add_fsync_inode(F2FS_I_SB(inode), dir_list,							pino, false);		if (IS_ERR(entry)) {			dir = ERR_CAST(entry);			err = PTR_ERR(entry);			goto out;		}	}	dir = entry->inode;	memset(&fname, 0, sizeof(struct fscrypt_name));	fname.disk_name.len = le32_to_cpu(raw_inode->i_namelen);	fname.disk_name.name = raw_inode->i_name;	if (unlikely(fname.disk_name.len > F2FS_NAME_LEN)) {		WARN_ON(1);		err = -ENAMETOOLONG;		goto out;	}retry:	de = __f2fs_find_entry(dir, &fname, &page);	if (de && inode->i_ino == le32_to_cpu(de->ino))		goto out_put;	if (de) {		einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));		if (IS_ERR(einode)) {			WARN_ON(1);			err = PTR_ERR(einode);			if (err == -ENOENT)				err = -EEXIST;			goto out_put;		}		err = dquot_initialize(einode);		if (err) {			iput(einode);			goto out_put;		}		err = f2fs_acquire_orphan_inode(F2FS_I_SB(inode));		if (err) {			iput(einode);			goto out_put;		}		f2fs_delete_entry(de, page, dir, einode);		iput(einode);		goto retry;	} else if (IS_ERR(page)) {		err = PTR_ERR(page);	} else {		err = f2fs_add_dentry(dir, &fname, inode,					inode->i_ino, inode->i_mode);	}	if (err == -ENOMEM)		goto retry;	goto out;out_put:	f2fs_put_page(page, 0);out:	if (file_enc_name(inode))		name = "<encrypted>";	else		name = raw_inode->i_name;	f2fs_msg(inode->i_sb, KERN_NOTICE,			"%s: ino = %x, name = %s, dir = %lx, err = %d",			__func__, ino_of_node(ipage), name,			IS_ERR(dir) ? 0 : dir->i_ino, err);	return err;}

void f2fs_update_inode(struct inode *inode, struct page *node_page){	struct f2fs_inode *ri;	struct extent_tree *et = F2FS_I(inode)->extent_tree;	f2fs_wait_on_page_writeback(node_page, NODE, true);	set_page_dirty(node_page);	f2fs_inode_synced(inode);	ri = F2FS_INODE(node_page);	ri->i_mode = cpu_to_le16(inode->i_mode);	ri->i_advise = F2FS_I(inode)->i_advise;	ri->i_uid = cpu_to_le32(i_uid_read(inode));	ri->i_gid = cpu_to_le32(i_gid_read(inode));	ri->i_links = cpu_to_le32(inode->i_nlink);	ri->i_size = cpu_to_le64(i_size_read(inode));	ri->i_blocks = cpu_to_le64(SECTOR_TO_BLOCK(inode->i_blocks) + 1);	if (et) {		read_lock(&et->lock);		set_raw_extent(&et->largest, &ri->i_ext);		read_unlock(&et->lock);	} else {		memset(&ri->i_ext, 0, sizeof(ri->i_ext));	}	set_raw_inline(inode, ri);	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);	if (S_ISDIR(inode->i_mode))		ri->i_current_depth =			cpu_to_le32(F2FS_I(inode)->i_current_depth);	else if (S_ISREG(inode->i_mode))		ri->i_gc_failures =			cpu_to_le16(F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN]);	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);	ri->i_generation = cpu_to_le32(inode->i_generation);	ri->i_dir_level = F2FS_I(inode)->i_dir_level;	if (f2fs_has_extra_attr(inode)) {		ri->i_extra_isize = cpu_to_le16(F2FS_I(inode)->i_extra_isize);		if (f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(inode)->sb))			ri->i_inline_xattr_size =				cpu_to_le16(F2FS_I(inode)->i_inline_xattr_size);		if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)->sb) &&			F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,								i_projid)) {			projid_t i_projid;			i_projid = from_kprojid(&init_user_ns,						F2FS_I(inode)->i_projid);			ri->i_projid = cpu_to_le32(i_projid);		}		if (f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)->sb) &&			F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,								i_crtime)) {			ri->i_crtime =				cpu_to_le64(F2FS_I(inode)->i_crtime.tv_sec);			ri->i_crtime_nsec =				cpu_to_le32(F2FS_I(inode)->i_crtime.tv_nsec);		}	}	__set_inode_rdev(inode, ri);	/* deleted inode */	if (inode->i_nlink == 0)		clear_inline_node(node_page);	F2FS_I(inode)->i_disk_time[0] = inode->i_atime;	F2FS_I(inode)->i_disk_time[1] = inode->i_ctime;	F2FS_I(inode)->i_disk_time[2] = inode->i_mtime;	F2FS_I(inode)->i_disk_time[3] = F2FS_I(inode)->i_crtime;#ifdef CONFIG_F2FS_CHECK_FS	f2fs_inode_chksum_set(F2FS_I_SB(inode), node_page);#endif}

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;	}	node_page = get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page))		return PTR_ERR(node_page);	ri = F2FS_INODE(node_page);	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(inode, 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(inode, FI_FIRST_BLOCK_WRITTEN);	if (!need_inode_block_update(sbi, inode->i_ino))		fi->last_disk_size = inode->i_size;	f2fs_put_page(node_page, 1);	stat_inc_inline_xattr(inode);	stat_inc_inline_inode(inode);	stat_inc_inline_dir(inode);	return 0;}

static bool sanity_check_inode(struct inode *inode, struct page *node_page){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct f2fs_inode_info *fi = F2FS_I(inode);	unsigned long long iblocks;	iblocks = le64_to_cpu(F2FS_INODE(node_page)->i_blocks);	if (!iblocks) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, "			"run fsck to fix.",			__func__, inode->i_ino, iblocks);		return false;	}	if (ino_of_node(node_page) != nid_of_node(node_page)) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: corrupted inode footer i_ino=%lx, ino,nid: "			"[%u, %u] run fsck to fix.",			__func__, inode->i_ino,			ino_of_node(node_page), nid_of_node(node_page));		return false;	}	if (f2fs_sb_has_flexible_inline_xattr(sbi->sb)			&& !f2fs_has_extra_attr(inode)) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: corrupted inode ino=%lx, run fsck to fix.",			__func__, inode->i_ino);		return false;	}	if (f2fs_has_extra_attr(inode) &&			!f2fs_sb_has_extra_attr(sbi->sb)) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: inode (ino=%lx) is with extra_attr, "			"but extra_attr feature is off",			__func__, inode->i_ino);		return false;	}	if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||			fi->i_extra_isize % sizeof(__le32)) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: inode (ino=%lx) has corrupted i_extra_isize: %d, "			"max: %zu",			__func__, inode->i_ino, fi->i_extra_isize,			F2FS_TOTAL_EXTRA_ATTR_SIZE);		return false;	}	if (F2FS_I(inode)->extent_tree) {		struct extent_info *ei = &F2FS_I(inode)->extent_tree->largest;		if (ei->len &&			(!f2fs_is_valid_blkaddr(sbi, ei->blk, DATA_GENERIC) ||			!f2fs_is_valid_blkaddr(sbi, ei->blk + ei->len - 1,							DATA_GENERIC))) {			set_sbi_flag(sbi, SBI_NEED_FSCK);			f2fs_msg(sbi->sb, KERN_WARNING,				"%s: inode (ino=%lx) extent info [%u, %u, %u] "				"is incorrect, run fsck to fix",				__func__, inode->i_ino,				ei->blk, ei->fofs, ei->len);			return false;		}	}	if (f2fs_has_inline_data(inode) &&			(!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: inode (ino=%lx, mode=%u) should not have "			"inline_data, run fsck to fix",			__func__, inode->i_ino, inode->i_mode);		return false;	}	if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {		set_sbi_flag(sbi, SBI_NEED_FSCK);		f2fs_msg(sbi->sb, KERN_WARNING,			"%s: inode (ino=%lx, mode=%u) should not have "			"inline_dentry, run fsck to fix",			__func__, inode->i_ino, inode->i_mode);		return false;	}	return true;}