f2fs: introduce cp_control structure

This patch add a new data structure to control checkpoint parameters. Currently, it presents the reason of checkpoint such as is_umount and normal sync. Reviewed-by: Chao Yu <chao2.yu@samsung.com> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

f2fs: introduce cp_control structure
This patch add a new data structure to control checkpoint parameters. Currently, it presents the reason of checkpoint such as is_umount and normal sync. Reviewed-by: Chao Yu <chao2.yu@samsung.com> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Jaegeuk Kim
1 parent 95dd897301
Showing 6 changed files with 47 additions and 20 deletions Side-by-side Diff
fs/f2fs/checkpoint.c
fs/f2fs/f2fs.h
fs/f2fs/gc.c
fs/f2fs/recovery.c
fs/f2fs/super.c
include/trace/events/f2fs.h
@@ -826,7 +826,7 @@
 	finish_wait(&sbi->cp_wait, &wait);
 }
  
-static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
+static void do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 {
 	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
 	struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
@@ -894,7 +894,7 @@
 	ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
 			orphan_blocks);
  
-	if (is_umount) {
+	if (cpc->reason == CP_UMOUNT) {
 		set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
 		ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+
 				cp_payload_blks + data_sum_blocks +
@@ -948,7 +948,7 @@
  
 	write_data_summaries(sbi, start_blk);
 	start_blk += data_sum_blocks;
-	if (is_umount) {
+	if (cpc->reason == CP_UMOUNT) {
 		write_node_summaries(sbi, start_blk);
 		start_blk += NR_CURSEG_NODE_TYPE;
 	}
  
@@ -988,12 +988,12 @@
 /*
  * We guarantee that this checkpoint procedure will not fail.
  */
-void write_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
+void write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 {
 	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
 	unsigned long long ckpt_ver;
  
-	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "start block_ops");
+	trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
  
 	mutex_lock(&sbi->cp_mutex);
  
@@ -1004,7 +1004,7 @@
 	if (block_operations(sbi))
 		goto out;
  
-	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish block_ops");
+	trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
  
 	f2fs_submit_merged_bio(sbi, DATA, WRITE);
 	f2fs_submit_merged_bio(sbi, NODE, WRITE);
  
@@ -1023,13 +1023,13 @@
 	flush_sit_entries(sbi);
  
 	/* unlock all the fs_lock[] in do_checkpoint() */
-	do_checkpoint(sbi, is_umount);
+	do_checkpoint(sbi, cpc);
  
 	unblock_operations(sbi);
 	stat_inc_cp_count(sbi->stat_info);
 out:
 	mutex_unlock(&sbi->cp_mutex);
-	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish checkpoint");
+	trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
 }
  
 void init_ino_entry_info(struct f2fs_sb_info *sbi)
@@ -96,6 +96,15 @@
 	SIT_BITMAP
 };
  
+enum {
+	CP_UMOUNT,
+	CP_SYNC,
+};
+
+struct cp_control {
+	int reason;
+};
+
 /*
  * For CP/NAT/SIT/SSA readahead
  */
@@ -1314,7 +1323,7 @@
 void add_dirty_dir_inode(struct inode *);
 void remove_dirty_dir_inode(struct inode *);
 void sync_dirty_dir_inodes(struct f2fs_sb_info *);
-void write_checkpoint(struct f2fs_sb_info *, bool);
+void write_checkpoint(struct f2fs_sb_info *, struct cp_control *);
 void init_ino_entry_info(struct f2fs_sb_info *);
 int __init create_checkpoint_caches(void);
 void destroy_checkpoint_caches(void);
@@ -694,6 +694,9 @@
 	int gc_type = BG_GC;
 	int nfree = 0;
 	int ret = -1;
+	struct cp_control cpc = {
+		.reason = CP_SYNC,
+	};
  
 	INIT_LIST_HEAD(&ilist);
 gc_more:
@@ -704,7 +707,7 @@
  
 	if (gc_type == BG_GC && has_not_enough_free_secs(sbi, nfree)) {
 		gc_type = FG_GC;
-		write_checkpoint(sbi, false);
+		write_checkpoint(sbi, &cpc);
 	}
  
 	if (!__get_victim(sbi, &segno, gc_type, NO_CHECK_TYPE))
@@ -729,7 +732,7 @@
 		goto gc_more;
  
 	if (gc_type == FG_GC)
-		write_checkpoint(sbi, false);
+		write_checkpoint(sbi, &cpc);
 stop:
 	mutex_unlock(&sbi->gc_mutex);
  
@@ -542,8 +542,11 @@
 		set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
 		mutex_unlock(&sbi->cp_mutex);
 	} else if (need_writecp) {
+		struct cp_control cpc = {
+			.reason = CP_SYNC,
+		};
 		mutex_unlock(&sbi->cp_mutex);
-		write_checkpoint(sbi, false);
+		write_checkpoint(sbi, &cpc);
 	} else {
 		mutex_unlock(&sbi->cp_mutex);
 	}
@@ -434,8 +434,12 @@
 	stop_gc_thread(sbi);
  
 	/* We don't need to do checkpoint when it's clean */
-	if (sbi->s_dirty)
-		write_checkpoint(sbi, true);
+	if (sbi->s_dirty) {
+		struct cp_control cpc = {
+			.reason = CP_UMOUNT,
+		};
+		write_checkpoint(sbi, &cpc);
+	}
  
 	/*
 	 * normally superblock is clean, so we need to release this.
  
@@ -466,8 +470,11 @@
 	trace_f2fs_sync_fs(sb, sync);
  
 	if (sync) {
+		struct cp_control cpc = {
+			.reason = CP_SYNC,
+		};
 		mutex_lock(&sbi->gc_mutex);
-		write_checkpoint(sbi, false);
+		write_checkpoint(sbi, &cpc);
 		mutex_unlock(&sbi->gc_mutex);
 	} else {
 		f2fs_balance_fs(sbi);
@@ -69,6 +69,11 @@
 		{ GC_GREEDY,	"Greedy" },				\
 		{ GC_CB,	"Cost-Benefit" })
  
+#define show_cpreason(type)						\
+	__print_symbolic(type,						\
+		{ CP_UMOUNT,	"Umount" },				\
+		{ CP_SYNC,	"Sync" })
+
 struct victim_sel_policy;
  
 DECLARE_EVENT_CLASS(f2fs__inode,
  
  
  
  
@@ -944,25 +949,25 @@
  
 TRACE_EVENT(f2fs_write_checkpoint,
  
-	TP_PROTO(struct super_block *sb, bool is_umount, char *msg),
+	TP_PROTO(struct super_block *sb, int reason, char *msg),
  
-	TP_ARGS(sb, is_umount, msg),
+	TP_ARGS(sb, reason, msg),
  
 	TP_STRUCT__entry(
 		__field(dev_t,	dev)
-		__field(bool,	is_umount)
+		__field(int,	reason)
 		__field(char *,	msg)
 	),
  
 	TP_fast_assign(
 		__entry->dev		= sb->s_dev;
-		__entry->is_umount	= is_umount;
+		__entry->reason		= reason;
 		__entry->msg		= msg;
 	),
  
 	TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
 		show_dev(__entry),
-		__entry->is_umount ? "clean umount" : "consistency",
+		show_cpreason(__entry->reason),
 		__entry->msg)
 );
...	...	@@ -826,7 +826,7 @@
826	826	finish_wait(&sbi->cp_wait, &wait);
827	827	}
828	828
829		-static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
	829	+static void do_checkpoint(struct f2fs_sb_info sbi, struct cp_control cpc)
830	830	{
831	831	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
832	832	struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
...	...	@@ -894,7 +894,7 @@
894	894	ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
895	895	orphan_blocks);
896	896
897		- if (is_umount) {
	897	+ if (cpc->reason == CP_UMOUNT) {
898	898	set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
899	899	ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+
900	900	cp_payload_blks + data_sum_blocks +
...	...	@@ -948,7 +948,7 @@
948	948
949	949	write_data_summaries(sbi, start_blk);
950	950	start_blk += data_sum_blocks;
951		- if (is_umount) {
	951	+ if (cpc->reason == CP_UMOUNT) {
952	952	write_node_summaries(sbi, start_blk);
953	953	start_blk += NR_CURSEG_NODE_TYPE;
954	954	}
955	955
...	...	@@ -988,12 +988,12 @@
988	988	/*
989	989	* We guarantee that this checkpoint procedure will not fail.
990	990	*/
991		-void write_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
	991	+void write_checkpoint(struct f2fs_sb_info sbi, struct cp_control cpc)
992	992	{
993	993	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
994	994	unsigned long long ckpt_ver;
995	995
996		- trace_f2fs_write_checkpoint(sbi->sb, is_umount, "start block_ops");
	996	+ trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
997	997
998	998	mutex_lock(&sbi->cp_mutex);
999	999
...	...	@@ -1004,7 +1004,7 @@
1004	1004	if (block_operations(sbi))
1005	1005	goto out;
1006	1006
1007		- trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish block_ops");
	1007	+ trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
1008	1008
1009	1009	f2fs_submit_merged_bio(sbi, DATA, WRITE);
1010	1010	f2fs_submit_merged_bio(sbi, NODE, WRITE);
1011	1011
...	...	@@ -1023,13 +1023,13 @@
1023	1023	flush_sit_entries(sbi);
1024	1024
1025	1025	/* unlock all the fs_lock[] in do_checkpoint() */
1026		- do_checkpoint(sbi, is_umount);
	1026	+ do_checkpoint(sbi, cpc);
1027	1027
1028	1028	unblock_operations(sbi);
1029	1029	stat_inc_cp_count(sbi->stat_info);
1030	1030	out:
1031	1031	mutex_unlock(&sbi->cp_mutex);
1032		- trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish checkpoint");
	1032	+ trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
1033	1033	}
1034	1034
1035	1035	void init_ino_entry_info(struct f2fs_sb_info *sbi)
...	...	@@ -96,6 +96,15 @@
96	96	SIT_BITMAP
97	97	};
98	98
	99	+enum {
	100	+ CP_UMOUNT,
	101	+ CP_SYNC,
	102	+};
	103	+
	104	+struct cp_control {
	105	+ int reason;
	106	+};
	107	+
99	108	/*
100	109	* For CP/NAT/SIT/SSA readahead
101	110	*/
...	...	@@ -1314,7 +1323,7 @@
1314	1323	void add_dirty_dir_inode(struct inode *);
1315	1324	void remove_dirty_dir_inode(struct inode *);
1316	1325	void sync_dirty_dir_inodes(struct f2fs_sb_info *);
1317		-void write_checkpoint(struct f2fs_sb_info *, bool);
	1326	+void write_checkpoint(struct f2fs_sb_info , struct cp_control );
1318	1327	void init_ino_entry_info(struct f2fs_sb_info *);
1319	1328	int __init create_checkpoint_caches(void);
1320	1329	void destroy_checkpoint_caches(void);
...	...	@@ -694,6 +694,9 @@
694	694	int gc_type = BG_GC;
695	695	int nfree = 0;
696	696	int ret = -1;
	697	+ struct cp_control cpc = {
	698	+ .reason = CP_SYNC,
	699	+ };
697	700
698	701	INIT_LIST_HEAD(&ilist);
699	702	gc_more:
...	...	@@ -704,7 +707,7 @@
704	707
705	708	if (gc_type == BG_GC && has_not_enough_free_secs(sbi, nfree)) {
706	709	gc_type = FG_GC;
707		- write_checkpoint(sbi, false);
	710	+ write_checkpoint(sbi, &cpc);
708	711	}
709	712
710	713	if (!__get_victim(sbi, &segno, gc_type, NO_CHECK_TYPE))
...	...	@@ -729,7 +732,7 @@
729	732	goto gc_more;
730	733
731	734	if (gc_type == FG_GC)
732		- write_checkpoint(sbi, false);
	735	+ write_checkpoint(sbi, &cpc);
733	736	stop:
734	737	mutex_unlock(&sbi->gc_mutex);
735	738
...	...	@@ -542,8 +542,11 @@
542	542	set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
543	543	mutex_unlock(&sbi->cp_mutex);
544	544	} else if (need_writecp) {
	545	+ struct cp_control cpc = {
	546	+ .reason = CP_SYNC,
	547	+ };
545	548	mutex_unlock(&sbi->cp_mutex);
546		- write_checkpoint(sbi, false);
	549	+ write_checkpoint(sbi, &cpc);
547	550	} else {
548	551	mutex_unlock(&sbi->cp_mutex);
549	552	}
...	...	@@ -434,8 +434,12 @@
434	434	stop_gc_thread(sbi);
435	435
436	436	/* We don't need to do checkpoint when it's clean */
437		- if (sbi->s_dirty)
438		- write_checkpoint(sbi, true);
	437	+ if (sbi->s_dirty) {
	438	+ struct cp_control cpc = {
	439	+ .reason = CP_UMOUNT,
	440	+ };
	441	+ write_checkpoint(sbi, &cpc);
	442	+ }
439	443
440	444	/*
441	445	* normally superblock is clean, so we need to release this.
442	446
...	...	@@ -466,8 +470,11 @@
466	470	trace_f2fs_sync_fs(sb, sync);
467	471
468	472	if (sync) {
	473	+ struct cp_control cpc = {
	474	+ .reason = CP_SYNC,
	475	+ };
469	476	mutex_lock(&sbi->gc_mutex);
470		- write_checkpoint(sbi, false);
	477	+ write_checkpoint(sbi, &cpc);
471	478	mutex_unlock(&sbi->gc_mutex);
472	479	} else {
473	480	f2fs_balance_fs(sbi);
...	...	@@ -69,6 +69,11 @@
69	69	{ GC_GREEDY, "Greedy" }, \
70	70	{ GC_CB, "Cost-Benefit" })
71	71
	72	+#define show_cpreason(type) \
	73	+ __print_symbolic(type, \
	74	+ { CP_UMOUNT, "Umount" }, \
	75	+ { CP_SYNC, "Sync" })
	76	+
72	77	struct victim_sel_policy;
73	78
74	79	DECLARE_EVENT_CLASS(f2fs__inode,
75	80
76	81
77	82
78	83
...	...	@@ -944,25 +949,25 @@
944	949
945	950	TRACE_EVENT(f2fs_write_checkpoint,
946	951
947		- TP_PROTO(struct super_block sb, bool is_umount, char msg),
	952	+ TP_PROTO(struct super_block sb, int reason, char msg),
948	953
949		- TP_ARGS(sb, is_umount, msg),
	954	+ TP_ARGS(sb, reason, msg),
950	955
951	956	TP_STRUCT__entry(
952	957	__field(dev_t, dev)
953		- __field(bool, is_umount)
	958	+ __field(int, reason)
954	959	__field(char *, msg)
955	960	),
956	961
957	962	TP_fast_assign(
958	963	__entry->dev = sb->s_dev;
959		- __entry->is_umount = is_umount;
	964	+ __entry->reason = reason;
960	965	__entry->msg = msg;
961	966	),
962	967
963	968	TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
964	969	show_dev(__entry),
965		- __entry->is_umount ? "clean umount" : "consistency",
	970	+ show_cpreason(__entry->reason),
966	971	__entry->msg)
967	972	);
968	973