Commit af033b2a authored by Chao Yu's avatar Chao Yu Committed by Jaegeuk Kim
Browse files

f2fs: guarantee journalled quota data by checkpoint 



For journalled quota mode, let checkpoint to flush dquot dirty data
and quota file data to guarntee persistence of all quota sysfile in
last checkpoint, by this way, we can avoid corrupting quota sysfile
when encountering SPO.

The implementation is as below:

1. add a global state SBI_QUOTA_NEED_FLUSH to indicate that there is
cached dquot metadata changes in quota subsystem, and later checkpoint
should:
 a) flush dquot metadata into quota file.
 b) flush quota file to storage to keep file usage be consistent.

2. add a global state SBI_QUOTA_NEED_REPAIR to indicate that quota
operation failed due to -EIO or -ENOSPC, so later,
 a) checkpoint will skip syncing dquot metadata.
 b) CP_QUOTA_NEED_FSCK_FLAG will be set in last cp pack to give a
    hint for fsck repairing.

3. add a global state SBI_QUOTA_SKIP_FLUSH, in checkpoint, if quota
data updating is very heavy, it may cause hungtask in block_operation().
To avoid this, if our retry time exceed threshold, let's just skip
flushing and retry in next checkpoint().

Signed-off-by: default avatarWeichao Guo <guoweichao@huawei.com>
Signed-off-by: default avatarChao Yu <yuchao0@huawei.com>
[Jaegeuk Kim: avoid warnings and set fsck flag]
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 26b5a079

fs/f2fs/checkpoint.c

+58 −4
Original line number Diff line number Diff line
@@ -1079,6 +1079,21 @@ static void __prepare_cp_block(struct f2fs_sb_info *sbi) 
	ckpt->next_free_nid = cpu_to_le32(last_nid);

}



static bool __need_flush_quota(struct f2fs_sb_info *sbi)

{

	if (!is_journalled_quota(sbi))

		return false;

	if (is_sbi_flag_set(sbi, SBI_QUOTA_SKIP_FLUSH))

		return false;

	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR))

		return false;

	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_FLUSH))

		return true;

	if (get_pages(sbi, F2FS_DIRTY_QDATA))

		return true;

	return false;

}



/*

 * Freeze all the FS-operations for checkpoint.

 */
@@ -1090,12 +1105,36 @@ static int block_operations(struct f2fs_sb_info *sbi) 
		.for_reclaim = 0,

	};

	struct blk_plug plug;

	int err = 0;

	int err = 0, cnt = 0;



	blk_start_plug(&plug);



retry_flush_dents:

retry_flush_quotas:

	if (__need_flush_quota(sbi)) {

		int locked;



		if (++cnt > DEFAULT_RETRY_QUOTA_FLUSH_COUNT) {

			set_sbi_flag(sbi, SBI_QUOTA_SKIP_FLUSH);

			f2fs_lock_all(sbi);

			goto retry_flush_dents;

		}

		clear_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);



		/* only failed during mount/umount/freeze/quotactl */

		locked = down_read_trylock(&sbi->sb->s_umount);

		f2fs_quota_sync(sbi->sb, -1);

		if (locked)

			up_read(&sbi->sb->s_umount);

	}



	f2fs_lock_all(sbi);

	if (__need_flush_quota(sbi)) {

		f2fs_unlock_all(sbi);

		cond_resched();

		goto retry_flush_quotas;

	}



retry_flush_dents:

	/* write all the dirty dentry pages */

	if (get_pages(sbi, F2FS_DIRTY_DENTS)) {

		f2fs_unlock_all(sbi);
@@ -1103,7 +1142,7 @@ retry_flush_dents: 
		if (err)

			goto out;

		cond_resched();

		goto retry_flush_dents;

		goto retry_flush_quotas;

	}



	/*
@@ -1112,6 +1151,12 @@ retry_flush_dents: 
	 */

	down_write(&sbi->node_change);



	if (__need_flush_quota(sbi)) {

		up_write(&sbi->node_change);

		f2fs_unlock_all(sbi);

		goto retry_flush_quotas;

	}



	if (get_pages(sbi, F2FS_DIRTY_IMETA)) {

		up_write(&sbi->node_change);

		f2fs_unlock_all(sbi);
@@ -1119,7 +1164,7 @@ retry_flush_dents: 
		if (err)

			goto out;

		cond_resched();

		goto retry_flush_dents;

		goto retry_flush_quotas;

	}



retry_flush_nodes:
@@ -1215,6 +1260,14 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	else

		__clear_ckpt_flags(ckpt, CP_DISABLED_FLAG);



	if (is_sbi_flag_set(sbi, SBI_QUOTA_SKIP_FLUSH))

		__set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);



	if (is_sbi_flag_set(sbi, SBI_QUOTA_NEED_REPAIR))

		__set_ckpt_flags(ckpt, CP_QUOTA_NEED_FSCK_FLAG);



	/* set this flag to activate crc|cp_ver for recovery */

	__set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);

	__clear_ckpt_flags(ckpt, CP_NOCRC_RECOVERY_FLAG);
@@ -1422,6 +1475,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	clear_sbi_flag(sbi, SBI_IS_DIRTY);

	clear_sbi_flag(sbi, SBI_NEED_CP);

	clear_sbi_flag(sbi, SBI_QUOTA_SKIP_FLUSH);

	sbi->unusable_block_count = 0;

	__set_cp_next_pack(sbi);

fs/f2fs/data.c

+11 −5
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ static bool __is_cp_guaranteed(struct page *page) 
			inode->i_ino ==  F2FS_NODE_INO(sbi) ||

			S_ISDIR(inode->i_mode) ||

			(S_ISREG(inode->i_mode) &&

			is_inode_flag_set(inode, FI_ATOMIC_FILE)) ||

			(f2fs_is_atomic_file(inode) || IS_NOQUOTA(inode))) ||

			is_cold_data(page))

		return true;

	return false;
@@ -1766,6 +1766,8 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio) 
		return true;

	if (S_ISDIR(inode->i_mode))

		return true;

	if (IS_NOQUOTA(inode))

		return true;

	if (f2fs_is_atomic_file(inode))

		return true;

	if (fio) {
@@ -2016,7 +2018,7 @@ out: 
	}



	unlock_page(page);

	if (!S_ISDIR(inode->i_mode))

	if (!S_ISDIR(inode->i_mode) && !IS_NOQUOTA(inode))

		f2fs_balance_fs(sbi, need_balance_fs);



	if (unlikely(f2fs_cp_error(sbi))) {
@@ -2207,6 +2209,8 @@ static inline bool __should_serialize_io(struct inode *inode, 
{

	if (!S_ISREG(inode->i_mode))

		return false;

	if (IS_NOQUOTA(inode))

		return false;

	if (wbc->sync_mode != WB_SYNC_ALL)

		return true;

	if (get_dirty_pages(inode) >= SM_I(F2FS_I_SB(inode))->min_seq_blocks)
@@ -2236,7 +2240,8 @@ static int __f2fs_write_data_pages(struct address_space *mapping, 
	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))

		goto skip_write;



	if (S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_NONE &&

	if ((S_ISDIR(inode->i_mode) || IS_NOQUOTA(inode)) &&

			wbc->sync_mode == WB_SYNC_NONE &&

			get_dirty_pages(inode) < nr_pages_to_skip(sbi, DATA) &&

			f2fs_available_free_memory(sbi, DIRTY_DENTS))

		goto skip_write;
@@ -2301,7 +2306,7 @@ static void f2fs_write_failed(struct address_space *mapping, loff_t to) 
		down_write(&F2FS_I(inode)->i_mmap_sem);



		truncate_pagecache(inode, i_size);

		f2fs_truncate_blocks(inode, i_size, true);

		f2fs_truncate_blocks(inode, i_size, true, true);



		up_write(&F2FS_I(inode)->i_mmap_sem);

		up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -2440,7 +2445,8 @@ repeat: 
	if (err)

		goto fail;



	if (need_balance && has_not_enough_free_secs(sbi, 0, 0)) {

	if (need_balance && !IS_NOQUOTA(inode) &&

			has_not_enough_free_secs(sbi, 0, 0)) {

		unlock_page(page);

		f2fs_balance_fs(sbi, true);

		lock_page(page);

fs/f2fs/f2fs.h

+41 −8
Original line number Diff line number Diff line
@@ -531,6 +531,9 @@ enum { 


#define DEFAULT_RETRY_IO_COUNT	8	/* maximum retry read IO count */



/* maximum retry quota flush count */

#define DEFAULT_RETRY_QUOTA_FLUSH_COUNT		8



#define F2FS_LINK_MAX	0xffffffff	/* maximum link count per file */



#define MAX_DIR_RA_PAGES	4	/* maximum ra pages of dir */
@@ -1099,6 +1102,9 @@ enum { 
	SBI_IS_SHUTDOWN,			/* shutdown by ioctl */

	SBI_IS_RECOVERED,			/* recovered orphan/data */

	SBI_CP_DISABLED,			/* CP was disabled last mount */

	SBI_QUOTA_NEED_FLUSH,			/* need to flush quota info in CP */

	SBI_QUOTA_SKIP_FLUSH,			/* skip flushing quota in current CP */

	SBI_QUOTA_NEED_REPAIR,			/* quota file may be corrupted */

};



enum {
@@ -1923,12 +1929,18 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi, 
{

	block_t	valid_block_count;

	unsigned int valid_node_count;

	bool quota = inode && !is_inode;

	int err;



	if (quota) {

		int ret = dquot_reserve_block(inode, 1);

		if (ret)

			return ret;

	if (is_inode) {

		if (inode) {

			err = dquot_alloc_inode(inode);

			if (err)

				return err;

		}

	} else {

		err = dquot_reserve_block(inode, 1);

		if (err)

			return err;

	}



	if (time_to_inject(sbi, FAULT_BLOCK)) {
@@ -1972,8 +1984,12 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi, 
	return 0;



enospc:

	if (quota)

	if (is_inode) {

		if (inode)

			dquot_free_inode(inode);

	} else {

		dquot_release_reservation_block(inode, 1);

	}

	return -ENOSPC;

}
@@ -1994,7 +2010,9 @@ static inline void dec_valid_node_count(struct f2fs_sb_info *sbi, 


	spin_unlock(&sbi->stat_lock);



	if (!is_inode)

	if (is_inode)

		dquot_free_inode(inode);

	else

		f2fs_i_blocks_write(inode, 1, false, true);

}
@@ -2782,7 +2800,8 @@ static inline bool is_valid_data_blkaddr(struct f2fs_sb_info *sbi, 
 */

int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);

void f2fs_truncate_data_blocks(struct dnode_of_data *dn);

int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock);

int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock,

							bool buf_write);

int f2fs_truncate(struct inode *inode);

int f2fs_getattr(const struct path *path, struct kstat *stat,

			u32 request_mask, unsigned int flags);
@@ -2870,6 +2889,7 @@ static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode) 
int f2fs_inode_dirtied(struct inode *inode, bool sync);

void f2fs_inode_synced(struct inode *inode);

int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly);

int f2fs_quota_sync(struct super_block *sb, int type);

void f2fs_quota_off_umount(struct super_block *sb);

int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);

int f2fs_sync_fs(struct super_block *sb, int sync);
@@ -3564,3 +3584,16 @@ extern void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned int rate, 
#endif



#endif



static inline bool is_journalled_quota(struct f2fs_sb_info *sbi)

{

#ifdef CONFIG_QUOTA

	if (f2fs_sb_has_quota_ino(sbi->sb))

		return true;

	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||

		F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||

		F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])

		return true;

#endif

	return false;

}

fs/f2fs/file.c

+24 −7
Original line number Diff line number Diff line
@@ -586,7 +586,8 @@ truncate_out: 
	return 0;

}



int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock)

int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock,

							bool buf_write)

{

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct dnode_of_data dn;
@@ -594,6 +595,7 @@ int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock) 
	int count = 0, err = 0;

	struct page *ipage;

	bool truncate_page = false;

	int flag = buf_write ? F2FS_GET_BLOCK_PRE_AIO : F2FS_GET_BLOCK_PRE_DIO;



	trace_f2fs_truncate_blocks_enter(inode, from);
@@ -603,7 +605,7 @@ int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock) 
		goto free_partial;



	if (lock)

		f2fs_lock_op(sbi);

		__do_map_lock(sbi, flag, true);



	ipage = f2fs_get_node_page(sbi, inode->i_ino);

	if (IS_ERR(ipage)) {
@@ -641,7 +643,7 @@ free_next: 
	err = f2fs_truncate_inode_blocks(inode, free_from);

out:

	if (lock)

		f2fs_unlock_op(sbi);

		__do_map_lock(sbi, flag, false);

free_partial:

	/* lastly zero out the first data page */

	if (!err)
@@ -676,7 +678,7 @@ int f2fs_truncate(struct inode *inode) 
			return err;

	}



	err = f2fs_truncate_blocks(inode, i_size_read(inode), true);

	err = f2fs_truncate_blocks(inode, i_size_read(inode), true, false);

	if (err)

		return err;
@@ -785,10 +787,25 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 
		!uid_eq(attr->ia_uid, inode->i_uid)) ||

		(attr->ia_valid & ATTR_GID &&

		!gid_eq(attr->ia_gid, inode->i_gid))) {

		f2fs_lock_op(F2FS_I_SB(inode));

		err = dquot_transfer(inode, attr);

		if (err)

		if (err) {

			set_sbi_flag(F2FS_I_SB(inode),

					SBI_QUOTA_NEED_REPAIR);

			f2fs_unlock_op(F2FS_I_SB(inode));

			return err;

		}

		/*

		 * update uid/gid under lock_op(), so that dquot and inode can

		 * be updated atomically.

		 */

		if (attr->ia_valid & ATTR_UID)

			inode->i_uid = attr->ia_uid;

		if (attr->ia_valid & ATTR_GID)

			inode->i_gid = attr->ia_gid;

		f2fs_mark_inode_dirty_sync(inode, true);

		f2fs_unlock_op(F2FS_I_SB(inode));

	}



	if (attr->ia_valid & ATTR_SIZE) {

		bool to_smaller = (attr->ia_size <= i_size_read(inode));
@@ -1242,7 +1259,7 @@ static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len) 
	new_size = i_size_read(inode) - len;

	truncate_pagecache(inode, new_size);



	ret = f2fs_truncate_blocks(inode, new_size, true);

	ret = f2fs_truncate_blocks(inode, new_size, true, false);

	up_write(&F2FS_I(inode)->i_mmap_sem);

	if (!ret)

		f2fs_i_size_write(inode, new_size);
@@ -1427,7 +1444,7 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len) 
	f2fs_balance_fs(sbi, true);



	down_write(&F2FS_I(inode)->i_mmap_sem);

	ret = f2fs_truncate_blocks(inode, i_size_read(inode), true);

	ret = f2fs_truncate_blocks(inode, i_size_read(inode), true, false);

	up_write(&F2FS_I(inode)->i_mmap_sem);

	if (ret)

		return ret;

fs/f2fs/inline.c

+2 −2
Original line number Diff line number Diff line
@@ -298,7 +298,7 @@ process_inline: 
		clear_inode_flag(inode, FI_INLINE_DATA);

		f2fs_put_page(ipage, 1);

	} else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {

		if (f2fs_truncate_blocks(inode, 0, false))

		if (f2fs_truncate_blocks(inode, 0, false, false))

			return false;

		goto process_inline;

	}
@@ -470,7 +470,7 @@ static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry) 
	return 0;

punch_dentry_pages:

	truncate_inode_pages(&dir->i_data, 0);

	f2fs_truncate_blocks(dir, 0, false);

	f2fs_truncate_blocks(dir, 0, false, false);

	f2fs_remove_dirty_inode(dir);

	return err;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE