Commit 4354994f authored by Daniel Rosenberg's avatar Daniel Rosenberg Committed by Jaegeuk Kim
Browse files

f2fs: checkpoint disabling 



Note that, it requires "f2fs: return correct errno in f2fs_gc".

This adds a lightweight non-persistent snapshotting scheme to f2fs.

To use, mount with the option checkpoint=disable, and to return to
normal operation, remount with checkpoint=enable. If the filesystem
is shut down before remounting with checkpoint=enable, it will revert
back to its apparent state when it was first mounted with
checkpoint=disable. This is useful for situations where you wish to be
able to roll back the state of the disk in case of some critical
failure.

Signed-off-by: default avatarDaniel Rosenberg <drosen@google.com>
[Jaegeuk Kim: use SB_RDONLY instead of MS_RDONLY]
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent fb7d70db

Documentation/filesystems/f2fs.txt

+5 −0
Original line number Diff line number Diff line
@@ -212,6 +212,11 @@ fsync_mode=%s Control the policy of fsync. Currently supports "posix", 
                       non-atomic files likewise "nobarrier" mount option.

test_dummy_encryption  Enable dummy encryption, which provides a fake fscrypt

                       context. The fake fscrypt context is used by xfstests.

checkpoint=%s          Set to "disable" to turn off checkpointing. Set to "enable"

                       to reenable checkpointing. Is enabled by default. While

                       disabled, any unmounting or unexpected shutdowns will cause

                       the filesystem contents to appear as they did when the

                       filesystem was mounted with that option.



================================================================================

DEBUGFS ENTRIES

fs/f2fs/checkpoint.c

+12 −0
Original line number Diff line number Diff line
@@ -1210,6 +1210,11 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))

		__set_ckpt_flags(ckpt, CP_FSCK_FLAG);



	if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))

		__set_ckpt_flags(ckpt, CP_DISABLED_FLAG);

	else

		__clear_ckpt_flags(ckpt, CP_DISABLED_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);
@@ -1417,6 +1422,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);

	sbi->unusable_block_count = 0;

	__set_cp_next_pack(sbi);



	/*
@@ -1441,6 +1447,12 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	unsigned long long ckpt_ver;

	int err = 0;



	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {

		if (cpc->reason != CP_PAUSE)

			return 0;

		f2fs_msg(sbi->sb, KERN_WARNING,

				"Start checkpoint disabled!");

	}

	mutex_lock(&sbi->cp_mutex);



	if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&

fs/f2fs/data.c

+13 −1
Original line number Diff line number Diff line
@@ -537,7 +537,8 @@ skip: 
	if (fio->in_list)

		goto next;

out:

	if (is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN))

	if (is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN) ||

				f2fs_is_checkpoint_ready(sbi))

		__submit_merged_bio(io);

	up_write(&io->io_rwsem);

}
@@ -1703,6 +1704,10 @@ static inline bool check_inplace_update_policy(struct inode *inode, 
			is_inode_flag_set(inode, FI_NEED_IPU))

		return true;



	if (unlikely(fio && is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&

			!f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))

		return true;



	return false;

}
@@ -1733,6 +1738,9 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio) 
			return true;

		if (IS_ATOMIC_WRITTEN_PAGE(fio->page))

			return true;

		if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&

			f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))

			return true;

	}

	return false;

}
@@ -2353,6 +2361,10 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 


	trace_f2fs_write_begin(inode, pos, len, flags);



	err = f2fs_is_checkpoint_ready(sbi);

	if (err)

		goto fail;



	if ((f2fs_is_atomic_file(inode) &&

			!f2fs_available_free_memory(sbi, INMEM_PAGES)) ||

			is_inode_flag_set(inode, FI_ATOMIC_REVOKE_REQUEST)) {

fs/f2fs/debug.c

+2 −1
Original line number Diff line number Diff line
@@ -272,7 +272,8 @@ static int stat_show(struct seq_file *s, void *v) 
		seq_printf(s, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",

			si->sbi->sb->s_bdev, i++,

			f2fs_readonly(si->sbi->sb) ? "RO": "RW",

			f2fs_cp_error(si->sbi) ? "Error": "Good");

			is_set_ckpt_flags(si->sbi, CP_DISABLED_FLAG) ?

			"Disabled": (f2fs_cp_error(si->sbi) ? "Error": "Good"));

		seq_printf(s, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",

			   si->sit_area_segs, si->nat_area_segs);

		seq_printf(s, "[SSA: %d] [MAIN: %d",

fs/f2fs/f2fs.h

+17 −1
Original line number Diff line number Diff line
@@ -99,6 +99,7 @@ extern char *f2fs_fault_name[FAULT_MAX]; 
#define F2FS_MOUNT_QUOTA		0x00400000

#define F2FS_MOUNT_INLINE_XATTR_SIZE	0x00800000

#define F2FS_MOUNT_RESERVE_ROOT		0x01000000

#define F2FS_MOUNT_DISABLE_CHECKPOINT	0x02000000



#define F2FS_OPTION(sbi)	((sbi)->mount_opt)

#define clear_opt(sbi, option)	(F2FS_OPTION(sbi).opt &= ~F2FS_MOUNT_##option)
@@ -178,6 +179,7 @@ enum { 
#define	CP_RECOVERY	0x00000008

#define	CP_DISCARD	0x00000010

#define CP_TRIMMED	0x00000020

#define CP_PAUSE	0x00000040



#define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)

#define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
@@ -187,6 +189,7 @@ enum { 
#define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */

#define DEF_CP_INTERVAL			60	/* 60 secs */

#define DEF_IDLE_INTERVAL		5	/* 5 secs */

#define DEF_DISABLE_INTERVAL		5	/* 5 secs */



struct cp_control {

	int reason;
@@ -1092,6 +1095,7 @@ enum { 
	SBI_NEED_CP,				/* need to checkpoint */

	SBI_IS_SHUTDOWN,			/* shutdown by ioctl */

	SBI_IS_RECOVERED,			/* recovered orphan/data */

	SBI_CP_DISABLED,			/* CP was disabled last mount */

};



enum {
@@ -1099,6 +1103,7 @@ enum { 
	REQ_TIME,

	DISCARD_TIME,

	GC_TIME,

	DISABLE_TIME,

	MAX_TIME,

};
@@ -1225,6 +1230,9 @@ struct f2fs_sb_info { 
	block_t reserved_blocks;		/* configurable reserved blocks */

	block_t current_reserved_blocks;	/* current reserved blocks */



	/* Additional tracking for no checkpoint mode */

	block_t unusable_block_count;		/* # of blocks saved by last cp */



	unsigned int nquota_files;		/* # of quota sysfile */



	u32 s_next_generation;			/* for NFS support */
@@ -1735,7 +1743,8 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi, 


	if (!__allow_reserved_blocks(sbi, inode, true))

		avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;



	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))

		avail_user_block_count -= sbi->unusable_block_count;

	if (unlikely(sbi->total_valid_block_count > avail_user_block_count)) {

		diff = sbi->total_valid_block_count - avail_user_block_count;

		if (diff > *count)
@@ -1942,6 +1951,8 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi, 


	if (!__allow_reserved_blocks(sbi, inode, false))

		valid_block_count += F2FS_OPTION(sbi).root_reserved_blocks;

	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))

		valid_block_count += sbi->unusable_block_count;



	if (unlikely(valid_block_count > sbi->user_block_count)) {

		spin_unlock(&sbi->stat_lock);
@@ -2945,6 +2956,8 @@ void f2fs_stop_discard_thread(struct f2fs_sb_info *sbi); 
bool f2fs_wait_discard_bios(struct f2fs_sb_info *sbi);

void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,

					struct cp_control *cpc);

void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi);

int f2fs_disable_cp_again(struct f2fs_sb_info *sbi);

void f2fs_release_discard_addrs(struct f2fs_sb_info *sbi);

int f2fs_npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);

void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi);
@@ -3532,6 +3545,9 @@ static inline bool f2fs_force_buffered_io(struct inode *inode, 
	if (test_opt(sbi, LFS) && (rw == WRITE) &&

				block_unaligned_IO(inode, iocb, iter))

		return true;

	if (is_sbi_flag_set(F2FS_I_SB(inode), SBI_CP_DISABLED))

		return true;



	return false;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE