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

f2fs: check skipped write in f2fs_enable_checkpoint() 



This patch introduces sbi->nr_pages[F2FS_SKIPPED_WRITE] to record any
skipped write during data flush in f2fs_enable_checkpoint().

So in the loop of data flush, if there is any skipped write in previous
flush, let's retry sync_inode_sb(), otherwise, all dirty data written
before f2fs_enable_checkpoint() should have been persisted, then break
the retry loop.

Signed-off-by: default avatarChao Yu <chao@kernel.org>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 99366387

fs/f2fs/data.c

+19 −0
Original line number Diff line number Diff line
@@ -3495,6 +3495,16 @@ static inline void account_writeback(struct inode *inode, bool inc) 
	f2fs_up_read(&F2FS_I(inode)->i_sem);

}



static inline void update_skipped_write(struct f2fs_sb_info *sbi,

						struct writeback_control *wbc)

{

	long skipped = wbc->pages_skipped;



	if (is_sbi_flag_set(sbi, SBI_ENABLE_CHECKPOINT) && skipped &&

		wbc->sync_mode == WB_SYNC_ALL)

		atomic_add(skipped, &sbi->nr_pages[F2FS_SKIPPED_WRITE]);

}



static int __f2fs_write_data_pages(struct address_space *mapping,

						struct writeback_control *wbc,

						enum iostat_type io_type)
@@ -3559,10 +3569,19 @@ static int __f2fs_write_data_pages(struct address_space *mapping, 
	 */



	f2fs_remove_dirty_inode(inode);



	/*

	 * f2fs_write_cache_pages() has retry logic for EAGAIN case which is

	 * common when racing w/ checkpoint, so only update skipped write

	 * when ret is non-zero.

	 */

	if (ret)

		update_skipped_write(sbi, wbc);

	return ret;



skip_write:

	wbc->pages_skipped += get_dirty_pages(inode);

	update_skipped_write(sbi, wbc);

	trace_f2fs_writepages(mapping->host, wbc, DATA);

	return 0;

}

fs/f2fs/debug.c

+1 −0
Original line number Diff line number Diff line
@@ -423,6 +423,7 @@ static const char *s_flag[MAX_SBI_FLAG] = { 
	[SBI_IS_RESIZEFS]	= "resizefs",

	[SBI_IS_FREEZING]	= "freezefs",

	[SBI_IS_WRITABLE]	= "writable",

	[SBI_ENABLE_CHECKPOINT]	= "enable_checkpoint",

};



static const char *ipu_mode_names[F2FS_IPU_MAX] = {

fs/f2fs/f2fs.h

+2 −0
Original line number Diff line number Diff line
@@ -1238,6 +1238,7 @@ enum count_type { 
	F2FS_RD_META,

	F2FS_DIO_WRITE,

	F2FS_DIO_READ,

	F2FS_SKIPPED_WRITE,	/* skip or fail during f2fs_enable_checkpoint() */

	NR_COUNT_TYPE,

};
@@ -1476,6 +1477,7 @@ enum { 
	SBI_IS_RESIZEFS,			/* resizefs is in process */

	SBI_IS_FREEZING,			/* freezefs is in process */

	SBI_IS_WRITABLE,			/* remove ro mountoption transiently */

	SBI_ENABLE_CHECKPOINT,			/* indicate it's during f2fs_enable_checkpoint() */

	MAX_SBI_FLAG,

};

fs/f2fs/super.c

+33 −4
Original line number Diff line number Diff line
@@ -2690,6 +2690,7 @@ static int f2fs_enable_checkpoint(struct f2fs_sb_info *sbi) 
	long long start, writeback, end;

	int ret;

	struct f2fs_lock_context lc;

	long long skipped_write, dirty_data;



	f2fs_info(sbi, "f2fs_enable_checkpoint() starts, meta: %lld, node: %lld, data: %lld",

					get_pages(sbi, F2FS_DIRTY_META),
@@ -2698,17 +2699,45 @@ static int f2fs_enable_checkpoint(struct f2fs_sb_info *sbi) 


	start = ktime_get();



	set_sbi_flag(sbi, SBI_ENABLE_CHECKPOINT);



	/* we should flush all the data to keep data consistency */

	do {

		skipped_write = get_pages(sbi, F2FS_SKIPPED_WRITE);

		dirty_data = get_pages(sbi, F2FS_DIRTY_DATA);



		sync_inodes_sb(sbi->sb);

		f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);

	} while (get_pages(sbi, F2FS_DIRTY_DATA) && retry--);



		f2fs_info(sbi, "sync_inode_sb done, dirty_data: %lld, %lld, "

				"skipped write: %lld, %lld, retry: %d",

				get_pages(sbi, F2FS_DIRTY_DATA),

				dirty_data,

				get_pages(sbi, F2FS_SKIPPED_WRITE),

				skipped_write, retry);



		/*

		 * sync_inodes_sb() has retry logic, so let's check dirty_data

		 * in prior to skipped_write in case there is no dirty data.

		 */

		if (!get_pages(sbi, F2FS_DIRTY_DATA))

			break;

		if (get_pages(sbi, F2FS_SKIPPED_WRITE) == skipped_write)

			break;

	} while (retry--);



	clear_sbi_flag(sbi, SBI_ENABLE_CHECKPOINT);



	writeback = ktime_get();



	if (unlikely(get_pages(sbi, F2FS_DIRTY_DATA)))

		f2fs_warn(sbi, "checkpoint=enable has some unwritten data: %lld",

					get_pages(sbi, F2FS_DIRTY_DATA));

	if (unlikely(get_pages(sbi, F2FS_DIRTY_DATA) ||

			get_pages(sbi, F2FS_SKIPPED_WRITE)))

		f2fs_warn(sbi, "checkpoint=enable unwritten data: %lld, skipped data: %lld, retry: %d",

				get_pages(sbi, F2FS_DIRTY_DATA),

				get_pages(sbi, F2FS_SKIPPED_WRITE), retry);



	if (get_pages(sbi, F2FS_SKIPPED_WRITE))

		atomic_set(&sbi->nr_pages[F2FS_SKIPPED_WRITE], 0);



	f2fs_down_write_trace(&sbi->gc_lock, &lc);

	f2fs_dirty_to_prefree(sbi);