~hc/RK356X_SDK_RELEASE.git

..	..	@@ -24,13 +24,15 @@
24	24	#include <linux/sysfs.h>
25	25	#include <linux/quota.h>
26	26	#include <linux/unicode.h>
	27	+#include <linux/part_stat.h>
	28	+#include <linux/zstd.h>
	29	+#include <linux/lz4.h>
27	30
28	31	#include "f2fs.h"
29	32	#include "node.h"
30	33	#include "segment.h"
31	34	#include "xattr.h"
32	35	#include "gc.h"
33		-#include "trace.h"
34	36
35	37	#define CREATE_TRACE_POINTS
36	38	#include <trace/events/f2fs.h>
..	..	@@ -44,7 +46,6 @@
44	46	[FAULT_KVMALLOC] = "kvmalloc",
45	47	[FAULT_PAGE_ALLOC] = "page alloc",
46	48	[FAULT_PAGE_GET] = "page get",
47		- [FAULT_ALLOC_BIO] = "alloc bio",
48	49	[FAULT_ALLOC_NID] = "alloc nid",
49	50	[FAULT_ORPHAN] = "orphan",
50	51	[FAULT_BLOCK] = "no more block",
..	..	@@ -142,9 +143,19 @@
142	143	Opt_checkpoint_disable_cap,
143	144	Opt_checkpoint_disable_cap_perc,
144	145	Opt_checkpoint_enable,
	146	+ Opt_checkpoint_merge,
	147	+ Opt_nocheckpoint_merge,
145	148	Opt_compress_algorithm,
146	149	Opt_compress_log_size,
147	150	Opt_compress_extension,
	151	+ Opt_compress_chksum,
	152	+ Opt_compress_mode,
	153	+ Opt_compress_cache,
	154	+ Opt_atgc,
	155	+ Opt_gc_merge,
	156	+ Opt_nogc_merge,
	157	+ Opt_memory_mode,
	158	+ Opt_age_extent_cache,
148	159	Opt_err,
149	160	};
150	161
..	..	@@ -209,9 +220,19 @@
209	220	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
210	221	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
211	222	{Opt_checkpoint_enable, "checkpoint=enable"},
	223	+ {Opt_checkpoint_merge, "checkpoint_merge"},
	224	+ {Opt_nocheckpoint_merge, "nocheckpoint_merge"},
212	225	{Opt_compress_algorithm, "compress_algorithm=%s"},
213	226	{Opt_compress_log_size, "compress_log_size=%u"},
214	227	{Opt_compress_extension, "compress_extension=%s"},
	228	+ {Opt_compress_chksum, "compress_chksum"},
	229	+ {Opt_compress_mode, "compress_mode=%s"},
	230	+ {Opt_compress_cache, "compress_cache"},
	231	+ {Opt_atgc, "atgc"},
	232	+ {Opt_gc_merge, "gc_merge"},
	233	+ {Opt_nogc_merge, "nogc_merge"},
	234	+ {Opt_memory_mode, "memory=%s"},
	235	+ {Opt_age_extent_cache, "age_extent_cache"},
215	236	{Opt_err, NULL},
216	237	};
217	238
..	..	@@ -260,17 +281,35 @@
260	281
261	282	return 0;
262	283	}
	284	+
	285	+struct kmem_cache *f2fs_cf_name_slab;
	286	+static int __init f2fs_create_casefold_cache(void)
	287	+{
	288	+ f2fs_cf_name_slab = f2fs_kmem_cache_create("f2fs_casefolded_name",
	289	+ F2FS_NAME_LEN);
	290	+ if (!f2fs_cf_name_slab)
	291	+ return -ENOMEM;
	292	+ return 0;
	293	+}
	294	+
	295	+static void f2fs_destroy_casefold_cache(void)
	296	+{
	297	+ kmem_cache_destroy(f2fs_cf_name_slab);
	298	+}
	299	+#else
	300	+static int __init f2fs_create_casefold_cache(void) { return 0; }
	301	+static void f2fs_destroy_casefold_cache(void) { }
263	302	#endif
264	303
265	304	static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
266	305	{
267		- block_t limit = min((sbi->user_block_count << 1) / 1000,
	306	+ block_t limit = min((sbi->user_block_count >> 3),
268	307	sbi->user_block_count - sbi->reserved_blocks);
269	308
270		- /* limit is 0.2%, and cannot be too small */
271		- limit = max(limit, MIN_ROOT_RESERVED_BLOCKS);
	309	+ /* limit is 12.5% */
272	310	if (test_opt(sbi, RESERVE_ROOT) &&
273		- F2FS_OPTION(sbi).root_reserved_blocks > limit) {
	311	+ F2FS_OPTION(sbi).root_reserved_blocks > limit &&
	312	+ F2FS_OPTION(sbi).root_reserved_blocks > MIN_ROOT_RESERVED_BLOCKS) {
274	313	F2FS_OPTION(sbi).root_reserved_blocks = limit;
275	314	f2fs_info(sbi, "Reduce reserved blocks for root = %u",
276	315	F2FS_OPTION(sbi).root_reserved_blocks);
..	..	@@ -285,6 +324,46 @@
285	324	F2FS_OPTION(sbi).s_resuid),
286	325	from_kgid_munged(&init_user_ns,
287	326	F2FS_OPTION(sbi).s_resgid));
	327	+}
	328	+
	329	+static inline int adjust_reserved_segment(struct f2fs_sb_info *sbi)
	330	+{
	331	+ unsigned int sec_blks = sbi->blocks_per_seg * sbi->segs_per_sec;
	332	+ unsigned int avg_vblocks;
	333	+ unsigned int wanted_reserved_segments;
	334	+ block_t avail_user_block_count;
	335	+
	336	+ if (!F2FS_IO_ALIGNED(sbi))
	337	+ return 0;
	338	+
	339	+ /* average valid block count in section in worst case */
	340	+ avg_vblocks = sec_blks / F2FS_IO_SIZE(sbi);
	341	+
	342	+ /*
	343	+ * we need enough free space when migrating one section in worst case
	344	+ */
	345	+ wanted_reserved_segments = (F2FS_IO_SIZE(sbi) / avg_vblocks) *
	346	+ reserved_segments(sbi);
	347	+ wanted_reserved_segments -= reserved_segments(sbi);
	348	+
	349	+ avail_user_block_count = sbi->user_block_count -
	350	+ sbi->current_reserved_blocks -
	351	+ F2FS_OPTION(sbi).root_reserved_blocks;
	352	+
	353	+ if (wanted_reserved_segments * sbi->blocks_per_seg >
	354	+ avail_user_block_count) {
	355	+ f2fs_err(sbi, "IO align feature can't grab additional reserved segment: %u, available segments: %u",
	356	+ wanted_reserved_segments,
	357	+ avail_user_block_count >> sbi->log_blocks_per_seg);
	358	+ return -ENOSPC;
	359	+ }
	360	+
	361	+ SM_I(sbi)->additional_reserved_segments = wanted_reserved_segments;
	362	+
	363	+ f2fs_info(sbi, "IO align feature needs additional reserved segment: %u",
	364	+ wanted_reserved_segments);
	365	+
	366	+ return 0;
288	367	}
289	368
290	369	static inline void adjust_unusable_cap_perc(struct f2fs_sb_info *sbi)
..	..	@@ -350,7 +429,7 @@
350	429	set_opt(sbi, QUOTA);
351	430	return 0;
352	431	errout:
353		- kvfree(qname);
	432	+ kfree(qname);
354	433	return ret;
355	434	}
356	435
..	..	@@ -362,7 +441,7 @@
362	441	f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
363	442	return -EINVAL;
364	443	}
365		- kvfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
	444	+ kfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
366	445	F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;
367	446	return 0;
368	447	}
..	..	@@ -433,12 +512,12 @@
433	512	* needed to allow it to be set or changed during remount. We do allow
434	513	* it to be specified during remount, but only if there is no change.
435	514	*/
436		- if (is_remount && !F2FS_OPTION(sbi).dummy_enc_ctx.ctx) {
	515	+ if (is_remount && !F2FS_OPTION(sbi).dummy_enc_policy.policy) {
437	516	f2fs_warn(sbi, "Can't set test_dummy_encryption on remount");
438	517	return -EINVAL;
439	518	}
440	519	err = fscrypt_set_test_dummy_encryption(
441		- sb, arg, &F2FS_OPTION(sbi).dummy_enc_ctx);
	520	+ sb, arg->from, &F2FS_OPTION(sbi).dummy_enc_policy);
442	521	if (err) {
443	522	if (err == -EEXIST)
444	523	f2fs_warn(sbi,
..	..	@@ -458,22 +537,94 @@
458	537	return 0;
459	538	}
460	539
	540	+#ifdef CONFIG_F2FS_FS_COMPRESSION
	541	+#ifdef CONFIG_F2FS_FS_LZ4
	542	+static int f2fs_set_lz4hc_level(struct f2fs_sb_info sbi, const char str)
	543	+{
	544	+#ifdef CONFIG_F2FS_FS_LZ4HC
	545	+ unsigned int level;
	546	+#endif
	547	+
	548	+ if (strlen(str) == 3) {
	549	+ F2FS_OPTION(sbi).compress_level = 0;
	550	+ return 0;
	551	+ }
	552	+
	553	+#ifdef CONFIG_F2FS_FS_LZ4HC
	554	+ str += 3;
	555	+
	556	+ if (str[0] != ':') {
	557	+ f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");
	558	+ return -EINVAL;
	559	+ }
	560	+ if (kstrtouint(str + 1, 10, &level))
	561	+ return -EINVAL;
	562	+
	563	+ if (level < LZ4HC_MIN_CLEVEL \|\| level > LZ4HC_MAX_CLEVEL) {
	564	+ f2fs_info(sbi, "invalid lz4hc compress level: %d", level);
	565	+ return -EINVAL;
	566	+ }
	567	+
	568	+ F2FS_OPTION(sbi).compress_level = level;
	569	+ return 0;
	570	+#else
	571	+ f2fs_info(sbi, "kernel doesn't support lz4hc compression");
	572	+ return -EINVAL;
	573	+#endif
	574	+}
	575	+#endif
	576	+
	577	+#ifdef CONFIG_F2FS_FS_ZSTD
	578	+static int f2fs_set_zstd_level(struct f2fs_sb_info sbi, const char str)
	579	+{
	580	+ unsigned int level;
	581	+ int len = 4;
	582	+
	583	+ if (strlen(str) == len) {
	584	+ F2FS_OPTION(sbi).compress_level = 0;
	585	+ return 0;
	586	+ }
	587	+
	588	+ str += len;
	589	+
	590	+ if (str[0] != ':') {
	591	+ f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");
	592	+ return -EINVAL;
	593	+ }
	594	+ if (kstrtouint(str + 1, 10, &level))
	595	+ return -EINVAL;
	596	+
	597	+ if (!level \|\| level > ZSTD_maxCLevel()) {
	598	+ f2fs_info(sbi, "invalid zstd compress level: %d", level);
	599	+ return -EINVAL;
	600	+ }
	601	+
	602	+ F2FS_OPTION(sbi).compress_level = level;
	603	+ return 0;
	604	+}
	605	+#endif
	606	+#endif
	607	+
461	608	static int parse_options(struct super_block sb, char options, bool is_remount)
462	609	{
463	610	struct f2fs_sb_info *sbi = F2FS_SB(sb);
464	611	substring_t args[MAX_OPT_ARGS];
	612	+#ifdef CONFIG_F2FS_FS_COMPRESSION
465	613	unsigned char (*ext)[F2FS_EXTENSION_LEN];
	614	+ int ext_cnt;
	615	+#endif
466	616	char p, name;
467		- int arg = 0, ext_cnt;
	617	+ int arg = 0;
468	618	kuid_t uid;
469	619	kgid_t gid;
470	620	int ret;
471	621
472	622	if (!options)
473		- return 0;
	623	+ goto default_check;
474	624
475	625	while ((p = strsep(&options, ",")) != NULL) {
476	626	int token;
	627	+
477	628	if (!*p)
478	629	continue;
479	630	/*
..	..	@@ -496,10 +647,10 @@
496	647	} else if (!strcmp(name, "sync")) {
497	648	F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
498	649	} else {
499		- kvfree(name);
	650	+ kfree(name);
500	651	return -EINVAL;
501	652	}
502		- kvfree(name);
	653	+ kfree(name);
503	654	break;
504	655	case Opt_disable_roll_forward:
505	656	set_opt(sbi, DISABLE_ROLL_FORWARD);
..	..	@@ -577,7 +728,8 @@
577	728	case Opt_active_logs:
578	729	if (args->from && match_int(args, &arg))
579	730	return -EINVAL;
580		- if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
	731	+ if (arg != 2 && arg != 4 &&
	732	+ arg != NR_CURSEG_PERSIST_TYPE)
581	733	return -EINVAL;
582	734	F2FS_OPTION(sbi).active_logs = arg;
583	735	break;
..	..	@@ -606,10 +758,10 @@
606	758	set_opt(sbi, FASTBOOT);
607	759	break;
608	760	case Opt_extent_cache:
609		- set_opt(sbi, EXTENT_CACHE);
	761	+ set_opt(sbi, READ_EXTENT_CACHE);
610	762	break;
611	763	case Opt_noextent_cache:
612		- clear_opt(sbi, EXTENT_CACHE);
	764	+ clear_opt(sbi, READ_EXTENT_CACHE);
613	765	break;
614	766	case Opt_noinline_data:
615	767	clear_opt(sbi, INLINE_DATA);
..	..	@@ -656,17 +808,17 @@
656	808	if (!strcmp(name, "adaptive")) {
657	809	if (f2fs_sb_has_blkzoned(sbi)) {
658	810	f2fs_warn(sbi, "adaptive mode is not allowed with zoned block device feature");
659		- kvfree(name);
	811	+ kfree(name);
660	812	return -EINVAL;
661	813	}
662	814	F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
663	815	} else if (!strcmp(name, "lfs")) {
664	816	F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
665	817	} else {
666		- kvfree(name);
	818	+ kfree(name);
667	819	return -EINVAL;
668	820	}
669		- kvfree(name);
	821	+ kfree(name);
670	822	break;
671	823	case Opt_io_size_bits:
672	824	if (args->from && match_int(args, &arg))
..	..	@@ -792,10 +944,10 @@
792	944	} else if (!strcmp(name, "fs-based")) {
793	945	F2FS_OPTION(sbi).whint_mode = WHINT_MODE_FS;
794	946	} else {
795		- kvfree(name);
	947	+ kfree(name);
796	948	return -EINVAL;
797	949	}
798		- kvfree(name);
	950	+ kfree(name);
799	951	break;
800	952	case Opt_alloc:
801	953	name = match_strdup(&args[0]);
..	..	@@ -807,10 +959,10 @@
807	959	} else if (!strcmp(name, "reuse")) {
808	960	F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
809	961	} else {
810		- kvfree(name);
	962	+ kfree(name);
811	963	return -EINVAL;
812	964	}
813		- kvfree(name);
	965	+ kfree(name);
814	966	break;
815	967	case Opt_fsync:
816	968	name = match_strdup(&args[0]);
..	..	@@ -824,10 +976,10 @@
824	976	F2FS_OPTION(sbi).fsync_mode =
825	977	FSYNC_MODE_NOBARRIER;
826	978	} else {
827		- kvfree(name);
	979	+ kfree(name);
828	980	return -EINVAL;
829	981	}
830		- kvfree(name);
	982	+ kfree(name);
831	983	break;
832	984	case Opt_test_dummy_encryption:
833	985	ret = f2fs_set_test_dummy_encryption(sb, p, &args[0],
..	..	@@ -837,7 +989,7 @@
837	989	break;
838	990	case Opt_inlinecrypt:
839	991	#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
840		- F2FS_OPTION(sbi).inlinecrypt = true;
	992	+ sb->s_flags \|= SB_INLINECRYPT;
841	993	#else
842	994	f2fs_info(sbi, "inline encryption not supported");
843	995	#endif
..	..	@@ -862,23 +1014,61 @@
862	1014	case Opt_checkpoint_enable:
863	1015	clear_opt(sbi, DISABLE_CHECKPOINT);
864	1016	break;
	1017	+ case Opt_checkpoint_merge:
	1018	+ set_opt(sbi, MERGE_CHECKPOINT);
	1019	+ break;
	1020	+ case Opt_nocheckpoint_merge:
	1021	+ clear_opt(sbi, MERGE_CHECKPOINT);
	1022	+ break;
	1023	+#ifdef CONFIG_F2FS_FS_COMPRESSION
865	1024	case Opt_compress_algorithm:
866	1025	if (!f2fs_sb_has_compression(sbi)) {
867		- f2fs_err(sbi, "Compression feature if off");
868		- return -EINVAL;
	1026	+ f2fs_info(sbi, "Image doesn't support compression");
	1027	+ break;
869	1028	}
870	1029	name = match_strdup(&args[0]);
871	1030	if (!name)
872	1031	return -ENOMEM;
873	1032	if (!strcmp(name, "lzo")) {
	1033	+#ifdef CONFIG_F2FS_FS_LZO
	1034	+ F2FS_OPTION(sbi).compress_level = 0;
874	1035	F2FS_OPTION(sbi).compress_algorithm =
875	1036	COMPRESS_LZO;
876		- } else if (!strcmp(name, "lz4")) {
	1037	+#else
	1038	+ f2fs_info(sbi, "kernel doesn't support lzo compression");
	1039	+#endif
	1040	+ } else if (!strncmp(name, "lz4", 3)) {
	1041	+#ifdef CONFIG_F2FS_FS_LZ4
	1042	+ ret = f2fs_set_lz4hc_level(sbi, name);
	1043	+ if (ret) {
	1044	+ kfree(name);
	1045	+ return -EINVAL;
	1046	+ }
877	1047	F2FS_OPTION(sbi).compress_algorithm =
878	1048	COMPRESS_LZ4;
879		- } else if (!strcmp(name, "zstd")) {
	1049	+#else
	1050	+ f2fs_info(sbi, "kernel doesn't support lz4 compression");
	1051	+#endif
	1052	+ } else if (!strncmp(name, "zstd", 4)) {
	1053	+#ifdef CONFIG_F2FS_FS_ZSTD
	1054	+ ret = f2fs_set_zstd_level(sbi, name);
	1055	+ if (ret) {
	1056	+ kfree(name);
	1057	+ return -EINVAL;
	1058	+ }
880	1059	F2FS_OPTION(sbi).compress_algorithm =
881	1060	COMPRESS_ZSTD;
	1061	+#else
	1062	+ f2fs_info(sbi, "kernel doesn't support zstd compression");
	1063	+#endif
	1064	+ } else if (!strcmp(name, "lzo-rle")) {
	1065	+#ifdef CONFIG_F2FS_FS_LZORLE
	1066	+ F2FS_OPTION(sbi).compress_level = 0;
	1067	+ F2FS_OPTION(sbi).compress_algorithm =
	1068	+ COMPRESS_LZORLE;
	1069	+#else
	1070	+ f2fs_info(sbi, "kernel doesn't support lzorle compression");
	1071	+#endif
882	1072	} else {
883	1073	kfree(name);
884	1074	return -EINVAL;
..	..	@@ -887,8 +1077,8 @@
887	1077	break;
888	1078	case Opt_compress_log_size:
889	1079	if (!f2fs_sb_has_compression(sbi)) {
890		- f2fs_err(sbi, "Compression feature is off");
891		- return -EINVAL;
	1080	+ f2fs_info(sbi, "Image doesn't support compression");
	1081	+ break;
892	1082	}
893	1083	if (args->from && match_int(args, &arg))
894	1084	return -EINVAL;
..	..	@@ -902,8 +1092,8 @@
902	1092	break;
903	1093	case Opt_compress_extension:
904	1094	if (!f2fs_sb_has_compression(sbi)) {
905		- f2fs_err(sbi, "Compression feature is off");
906		- return -EINVAL;
	1095	+ f2fs_info(sbi, "Image doesn't support compression");
	1096	+ break;
907	1097	}
908	1098	name = match_strdup(&args[0]);
909	1099	if (!name)
..	..	@@ -924,12 +1114,71 @@
924	1114	F2FS_OPTION(sbi).compress_ext_cnt++;
925	1115	kfree(name);
926	1116	break;
	1117	+ case Opt_compress_chksum:
	1118	+ F2FS_OPTION(sbi).compress_chksum = true;
	1119	+ break;
	1120	+ case Opt_compress_mode:
	1121	+ name = match_strdup(&args[0]);
	1122	+ if (!name)
	1123	+ return -ENOMEM;
	1124	+ if (!strcmp(name, "fs")) {
	1125	+ F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
	1126	+ } else if (!strcmp(name, "user")) {
	1127	+ F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
	1128	+ } else {
	1129	+ kfree(name);
	1130	+ return -EINVAL;
	1131	+ }
	1132	+ kfree(name);
	1133	+ break;
	1134	+ case Opt_compress_cache:
	1135	+ set_opt(sbi, COMPRESS_CACHE);
	1136	+ break;
	1137	+#else
	1138	+ case Opt_compress_algorithm:
	1139	+ case Opt_compress_log_size:
	1140	+ case Opt_compress_extension:
	1141	+ case Opt_compress_chksum:
	1142	+ case Opt_compress_mode:
	1143	+ case Opt_compress_cache:
	1144	+ f2fs_info(sbi, "compression options not supported");
	1145	+ break;
	1146	+#endif
	1147	+ case Opt_atgc:
	1148	+ set_opt(sbi, ATGC);
	1149	+ break;
	1150	+ case Opt_gc_merge:
	1151	+ set_opt(sbi, GC_MERGE);
	1152	+ break;
	1153	+ case Opt_nogc_merge:
	1154	+ clear_opt(sbi, GC_MERGE);
	1155	+ break;
	1156	+ case Opt_age_extent_cache:
	1157	+ set_opt(sbi, AGE_EXTENT_CACHE);
	1158	+ break;
	1159	+ case Opt_memory_mode:
	1160	+ name = match_strdup(&args[0]);
	1161	+ if (!name)
	1162	+ return -ENOMEM;
	1163	+ if (!strcmp(name, "normal")) {
	1164	+ F2FS_OPTION(sbi).memory_mode =
	1165	+ MEMORY_MODE_NORMAL;
	1166	+ } else if (!strcmp(name, "low")) {
	1167	+ F2FS_OPTION(sbi).memory_mode =
	1168	+ MEMORY_MODE_LOW;
	1169	+ } else {
	1170	+ kfree(name);
	1171	+ return -EINVAL;
	1172	+ }
	1173	+ kfree(name);
	1174	+ break;
927	1175	default:
928	1176	f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
929	1177	p);
930	1178	return -EINVAL;
931	1179	}
932	1180	}
	1181	+default_check:
933	1182	#ifdef CONFIG_QUOTA
934	1183	if (f2fs_check_quota_options(sbi))
935	1184	return -EINVAL;
..	..	@@ -947,6 +1196,17 @@
947	1196	if (f2fs_sb_has_casefold(sbi)) {
948	1197	f2fs_err(sbi,
949	1198	"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
	1199	+ return -EINVAL;
	1200	+ }
	1201	+#endif
	1202	+ /*
	1203	+ * The BLKZONED feature indicates that the drive was formatted with
	1204	+ * zone alignment optimization. This is optional for host-aware
	1205	+ * devices, but mandatory for host-managed zoned block devices.
	1206	+ */
	1207	+#ifndef CONFIG_BLK_DEV_ZONED
	1208	+ if (f2fs_sb_has_blkzoned(sbi)) {
	1209	+ f2fs_err(sbi, "Zoned block device support is not enabled");
950	1210	return -EINVAL;
951	1211	}
952	1212	#endif
..	..	@@ -982,15 +1242,20 @@
982	1242	}
983	1243
984	1244	if (test_opt(sbi, DISABLE_CHECKPOINT) && f2fs_lfs_mode(sbi)) {
985		- f2fs_err(sbi, "LFS not compatible with checkpoint=disable\n");
	1245	+ f2fs_err(sbi, "LFS not compatible with checkpoint=disable");
986	1246	return -EINVAL;
987	1247	}
988	1248
989	1249	/* Not pass down write hints if the number of active logs is lesser
990		- * than NR_CURSEG_TYPE.
	1250	+ * than NR_CURSEG_PERSIST_TYPE.
991	1251	*/
992		- if (F2FS_OPTION(sbi).active_logs != NR_CURSEG_TYPE)
	1252	+ if (F2FS_OPTION(sbi).active_logs != NR_CURSEG_PERSIST_TYPE)
993	1253	F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
	1254	+
	1255	+ if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
	1256	+ f2fs_err(sbi, "Allow to mount readonly mode only");
	1257	+ return -EROFS;
	1258	+ }
994	1259	return 0;
995	1260	}
996	1261
..	..	@@ -1006,17 +1271,18 @@
1006	1271
1007	1272	/* Initialize f2fs-specific inode info */
1008	1273	atomic_set(&fi->dirty_pages, 0);
1009		- init_rwsem(&fi->i_sem);
	1274	+ atomic_set(&fi->i_compr_blocks, 0);
	1275	+ init_f2fs_rwsem(&fi->i_sem);
1010	1276	spin_lock_init(&fi->i_size_lock);
1011	1277	INIT_LIST_HEAD(&fi->dirty_list);
1012	1278	INIT_LIST_HEAD(&fi->gdirty_list);
1013	1279	INIT_LIST_HEAD(&fi->inmem_ilist);
1014	1280	INIT_LIST_HEAD(&fi->inmem_pages);
1015	1281	mutex_init(&fi->inmem_lock);
1016		- init_rwsem(&fi->i_gc_rwsem[READ]);
1017		- init_rwsem(&fi->i_gc_rwsem[WRITE]);
1018		- init_rwsem(&fi->i_mmap_sem);
1019		- init_rwsem(&fi->i_xattr_sem);
	1282	+ init_f2fs_rwsem(&fi->i_gc_rwsem[READ]);
	1283	+ init_f2fs_rwsem(&fi->i_gc_rwsem[WRITE]);
	1284	+ init_f2fs_rwsem(&fi->i_mmap_sem);
	1285	+ init_f2fs_rwsem(&fi->i_xattr_sem);
1020	1286
1021	1287	/* Will be used by directory only */
1022	1288	fi->i_dir_level = F2FS_SB(sb)->dir_level;
..	..	@@ -1148,18 +1414,10 @@
1148	1414	f2fs_inode_dirtied(inode, false);
1149	1415	}
1150	1416
1151		-static void f2fs_i_callback(struct rcu_head *head)
	1417	+static void f2fs_free_inode(struct inode *inode)
1152	1418	{
1153		- struct inode *inode = container_of(head, struct inode, i_rcu);
1154		-
1155	1419	fscrypt_free_inode(inode);
1156		-
1157	1420	kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
1158		-}
1159		-
1160		-static void f2fs_destroy_inode(struct inode *inode)
1161		-{
1162		- call_rcu(&inode->i_rcu, f2fs_i_callback);
1163	1421	}
1164	1422
1165	1423	static void destroy_percpu_info(struct f2fs_sb_info *sbi)
..	..	@@ -1176,6 +1434,7 @@
1176	1434	blkdev_put(FDEV(i).bdev, FMODE_EXCL);
1177	1435	#ifdef CONFIG_BLK_DEV_ZONED
1178	1436	kvfree(FDEV(i).blkz_seq);
	1437	+ kfree(FDEV(i).zone_capacity_blocks);
1179	1438	#endif
1180	1439	}
1181	1440	kvfree(sbi->devs);
..	..	@@ -1194,6 +1453,12 @@
1194	1453
1195	1454	/* prevent remaining shrinker jobs */
1196	1455	mutex_lock(&sbi->umount_mutex);
	1456	+
	1457	+ /*
	1458	+ * flush all issued checkpoints and stop checkpoint issue thread.
	1459	+ * after then, all checkpoints should be done by each process context.
	1460	+ */
	1461	+ f2fs_stop_ckpt_thread(sbi);
1197	1462
1198	1463	/*
1199	1464	* We don't need to do checkpoint when superblock is clean.
..	..	@@ -1235,6 +1500,8 @@
1235	1500
1236	1501	f2fs_bug_on(sbi, sbi->fsync_node_num);
1237	1502
	1503	+ f2fs_destroy_compress_inode(sbi);
	1504	+
1238	1505	iput(sbi->node_inode);
1239	1506	sbi->node_inode = NULL;
1240	1507
..	..	@@ -1258,23 +1525,24 @@
1258	1525	sb->s_fs_info = NULL;
1259	1526	if (sbi->s_chksum_driver)
1260	1527	crypto_free_shash(sbi->s_chksum_driver);
1261		- kvfree(sbi->raw_super);
	1528	+ kfree(sbi->raw_super);
1262	1529
1263	1530	destroy_device_list(sbi);
	1531	+ f2fs_destroy_page_array_cache(sbi);
1264	1532	f2fs_destroy_xattr_caches(sbi);
1265	1533	mempool_destroy(sbi->write_io_dummy);
1266	1534	#ifdef CONFIG_QUOTA
1267	1535	for (i = 0; i < MAXQUOTAS; i++)
1268		- kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
	1536	+ kfree(F2FS_OPTION(sbi).s_qf_names[i]);
1269	1537	#endif
1270		- fscrypt_free_dummy_context(&F2FS_OPTION(sbi).dummy_enc_ctx);
	1538	+ fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
1271	1539	destroy_percpu_info(sbi);
1272	1540	for (i = 0; i < NR_PAGE_TYPE; i++)
1273	1541	kvfree(sbi->write_io[i]);
1274	1542	#ifdef CONFIG_UNICODE
1275	1543	utf8_unload(sb->s_encoding);
1276	1544	#endif
1277		- kvfree(sbi);
	1545	+ kfree(sbi);
1278	1546	}
1279	1547
1280	1548	int f2fs_sync_fs(struct super_block *sb, int sync)
..	..	@@ -1293,16 +1561,9 @@
1293	1561	return -EAGAIN;
1294	1562
1295	1563	if (sync) {
1296		- struct cp_control cpc;
1297		-
1298		- cpc.reason = __get_cp_reason(sbi);
1299		-
	1564	+ err = f2fs_issue_checkpoint(sbi);
1300	1565	atomic_set(&sbi->no_cp_fsync_pages, 0);
1301		- down_write(&sbi->gc_lock);
1302		- err = f2fs_write_checkpoint(sbi, &cpc);
1303		- up_write(&sbi->gc_lock);
1304	1566	}
1305		- f2fs_trace_ios(NULL, 1);
1306	1567
1307	1568	return err;
1308	1569	}
..	..	@@ -1319,11 +1580,18 @@
1319	1580	/* must be clean, since sync_filesystem() was already called */
1320	1581	if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))
1321	1582	return -EINVAL;
	1583	+
	1584	+ /* Let's flush checkpoints and stop the thread. */
	1585	+ f2fs_flush_ckpt_thread(F2FS_SB(sb));
	1586	+
	1587	+ /* to avoid deadlock on f2fs_evict_inode->SB_FREEZE_FS */
	1588	+ set_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING);
1322	1589	return 0;
1323	1590	}
1324	1591
1325	1592	static int f2fs_unfreeze(struct super_block *sb)
1326	1593	{
	1594	+ clear_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING);
1327	1595	return 0;
1328	1596	}
1329	1597
..	..	@@ -1416,8 +1684,7 @@
1416	1684	}
1417	1685
1418	1686	buf->f_namelen = F2FS_NAME_LEN;
1419		- buf->f_fsid.val[0] = (u32)id;
1420		- buf->f_fsid.val[1] = (u32)(id >> 32);
	1687	+ buf->f_fsid = u64_to_fsid(id);
1421	1688
1422	1689	#ifdef CONFIG_QUOTA
1423	1690	if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
..	..	@@ -1465,6 +1732,7 @@
1465	1732	#endif
1466	1733	}
1467	1734
	1735	+#ifdef CONFIG_F2FS_FS_COMPRESSION
1468	1736	static inline void f2fs_show_compress_options(struct seq_file *seq,
1469	1737	struct super_block *sb)
1470	1738	{
..	..	@@ -1485,8 +1753,14 @@
1485	1753	case COMPRESS_ZSTD:
1486	1754	algtype = "zstd";
1487	1755	break;
	1756	+ case COMPRESS_LZORLE:
	1757	+ algtype = "lzo-rle";
	1758	+ break;
1488	1759	}
1489	1760	seq_printf(seq, ",compress_algorithm=%s", algtype);
	1761	+
	1762	+ if (F2FS_OPTION(sbi).compress_level)
	1763	+ seq_printf(seq, ":%d", F2FS_OPTION(sbi).compress_level);
1490	1764
1491	1765	seq_printf(seq, ",compress_log_size=%u",
1492	1766	F2FS_OPTION(sbi).compress_log_size);
..	..	@@ -1495,7 +1769,19 @@
1495	1769	seq_printf(seq, ",compress_extension=%s",
1496	1770	F2FS_OPTION(sbi).extensions[i]);
1497	1771	}
	1772	+
	1773	+ if (F2FS_OPTION(sbi).compress_chksum)
	1774	+ seq_puts(seq, ",compress_chksum");
	1775	+
	1776	+ if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_FS)
	1777	+ seq_printf(seq, ",compress_mode=%s", "fs");
	1778	+ else if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_USER)
	1779	+ seq_printf(seq, ",compress_mode=%s", "user");
	1780	+
	1781	+ if (test_opt(sbi, COMPRESS_CACHE))
	1782	+ seq_puts(seq, ",compress_cache");
1498	1783	}
	1784	+#endif
1499	1785
1500	1786	static int f2fs_show_options(struct seq_file seq, struct dentry root)
1501	1787	{
..	..	@@ -1507,6 +1793,9 @@
1507	1793	seq_printf(seq, ",background_gc=%s", "on");
1508	1794	else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF)
1509	1795	seq_printf(seq, ",background_gc=%s", "off");
	1796	+
	1797	+ if (test_opt(sbi, GC_MERGE))
	1798	+ seq_puts(seq, ",gc_merge");
1510	1799
1511	1800	if (test_opt(sbi, DISABLE_ROLL_FORWARD))
1512	1801	seq_puts(seq, ",disable_roll_forward");
..	..	@@ -1555,10 +1844,12 @@
1555	1844	seq_puts(seq, ",nobarrier");
1556	1845	if (test_opt(sbi, FASTBOOT))
1557	1846	seq_puts(seq, ",fastboot");
1558		- if (test_opt(sbi, EXTENT_CACHE))
	1847	+ if (test_opt(sbi, READ_EXTENT_CACHE))
1559	1848	seq_puts(seq, ",extent_cache");
1560	1849	else
1561	1850	seq_puts(seq, ",noextent_cache");
	1851	+ if (test_opt(sbi, AGE_EXTENT_CACHE))
	1852	+ seq_puts(seq, ",age_extent_cache");
1562	1853	if (test_opt(sbi, DATA_FLUSH))
1563	1854	seq_puts(seq, ",data_flush");
1564	1855
..	..	@@ -1604,10 +1895,8 @@
1604	1895
1605	1896	fscrypt_show_test_dummy_encryption(seq, ',', sbi->sb);
1606	1897
1607		-#ifdef CONFIG_FS_ENCRYPTION
1608		- if (F2FS_OPTION(sbi).inlinecrypt)
	1898	+ if (sbi->sb->s_flags & SB_INLINECRYPT)
1609	1899	seq_puts(seq, ",inlinecrypt");
1610		-#endif
1611	1900
1612	1901	if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_DEFAULT)
1613	1902	seq_printf(seq, ",alloc_mode=%s", "default");
..	..	@@ -1617,6 +1906,10 @@
1617	1906	if (test_opt(sbi, DISABLE_CHECKPOINT))
1618	1907	seq_printf(seq, ",checkpoint=disable:%u",
1619	1908	F2FS_OPTION(sbi).unusable_cap);
	1909	+ if (test_opt(sbi, MERGE_CHECKPOINT))
	1910	+ seq_puts(seq, ",checkpoint_merge");
	1911	+ else
	1912	+ seq_puts(seq, ",nocheckpoint_merge");
1620	1913	if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)
1621	1914	seq_printf(seq, ",fsync_mode=%s", "posix");
1622	1915	else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)
..	..	@@ -1624,34 +1917,51 @@
1624	1917	else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)
1625	1918	seq_printf(seq, ",fsync_mode=%s", "nobarrier");
1626	1919
	1920	+#ifdef CONFIG_F2FS_FS_COMPRESSION
1627	1921	f2fs_show_compress_options(seq, sbi->sb);
	1922	+#endif
	1923	+
	1924	+ if (test_opt(sbi, ATGC))
	1925	+ seq_puts(seq, ",atgc");
	1926	+
	1927	+ if (F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_NORMAL)
	1928	+ seq_printf(seq, ",memory=%s", "normal");
	1929	+ else if (F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_LOW)
	1930	+ seq_printf(seq, ",memory=%s", "low");
	1931	+
1628	1932	return 0;
1629	1933	}
1630	1934
1631	1935	static void default_options(struct f2fs_sb_info *sbi)
1632	1936	{
1633	1937	/* init some FS parameters */
1634		- F2FS_OPTION(sbi).active_logs = NR_CURSEG_TYPE;
	1938	+ if (f2fs_sb_has_readonly(sbi))
	1939	+ F2FS_OPTION(sbi).active_logs = NR_CURSEG_RO_TYPE;
	1940	+ else
	1941	+ F2FS_OPTION(sbi).active_logs = NR_CURSEG_PERSIST_TYPE;
	1942	+
1635	1943	F2FS_OPTION(sbi).inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
1636	1944	F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
1637	1945	F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
1638	1946	F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
1639		-#ifdef CONFIG_FS_ENCRYPTION
1640		- F2FS_OPTION(sbi).inlinecrypt = false;
1641		-#endif
1642	1947	F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
1643	1948	F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);
1644	1949	F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
1645	1950	F2FS_OPTION(sbi).compress_log_size = MIN_COMPRESS_LOG_SIZE;
1646	1951	F2FS_OPTION(sbi).compress_ext_cnt = 0;
	1952	+ F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
1647	1953	F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
	1954	+ F2FS_OPTION(sbi).memory_mode = MEMORY_MODE_NORMAL;
	1955	+
	1956	+ sbi->sb->s_flags &= ~SB_INLINECRYPT;
1648	1957
1649	1958	set_opt(sbi, INLINE_XATTR);
1650	1959	set_opt(sbi, INLINE_DATA);
1651	1960	set_opt(sbi, INLINE_DENTRY);
1652		- set_opt(sbi, EXTENT_CACHE);
	1961	+ set_opt(sbi, READ_EXTENT_CACHE);
1653	1962	set_opt(sbi, NOHEAP);
1654	1963	clear_opt(sbi, DISABLE_CHECKPOINT);
	1964	+ set_opt(sbi, MERGE_CHECKPOINT);
1655	1965	F2FS_OPTION(sbi).unusable_cap = 0;
1656	1966	sbi->sb->s_flags \|= SB_LAZYTIME;
1657	1967	set_opt(sbi, FLUSH_MERGE);
..	..	@@ -1692,8 +2002,8 @@
1692	2002	f2fs_update_time(sbi, DISABLE_TIME);
1693	2003
1694	2004	while (!f2fs_time_over(sbi, DISABLE_TIME)) {
1695		- down_write(&sbi->gc_lock);
1696		- err = f2fs_gc(sbi, true, false, NULL_SEGNO);
	2005	+ f2fs_down_write(&sbi->gc_lock);
	2006	+ err = f2fs_gc(sbi, true, false, false, NULL_SEGNO);
1697	2007	if (err == -ENODATA) {
1698	2008	err = 0;
1699	2009	break;
..	..	@@ -1704,7 +2014,7 @@
1704	2014
1705	2015	ret = sync_filesystem(sbi->sb);
1706	2016	if (ret \|\| err) {
1707		- err = ret ? ret: err;
	2017	+ err = ret ? ret : err;
1708	2018	goto restore_flag;
1709	2019	}
1710	2020
..	..	@@ -1714,7 +2024,7 @@
1714	2024	goto restore_flag;
1715	2025	}
1716	2026
1717		- down_write(&sbi->gc_lock);
	2027	+ f2fs_down_write(&sbi->gc_lock);
1718	2028	cpc.reason = CP_PAUSE;
1719	2029	set_sbi_flag(sbi, SBI_CP_DISABLED);
1720	2030	err = f2fs_write_checkpoint(sbi, &cpc);
..	..	@@ -1726,7 +2036,7 @@
1726	2036	spin_unlock(&sbi->stat_lock);
1727	2037
1728	2038	out_unlock:
1729		- up_write(&sbi->gc_lock);
	2039	+ f2fs_up_write(&sbi->gc_lock);
1730	2040	restore_flag:
1731	2041	sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
1732	2042	return err;
..	..	@@ -1734,17 +2044,29 @@
1734	2044
1735	2045	static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
1736	2046	{
1737		- /* we should flush all the data to keep data consistency */
1738		- sync_inodes_sb(sbi->sb);
	2047	+ int retry = DEFAULT_RETRY_IO_COUNT;
1739	2048
1740		- down_write(&sbi->gc_lock);
	2049	+ /* we should flush all the data to keep data consistency */
	2050	+ do {
	2051	+ sync_inodes_sb(sbi->sb);
	2052	+ cond_resched();
	2053	+ congestion_wait(BLK_RW_ASYNC, DEFAULT_IO_TIMEOUT);
	2054	+ } while (get_pages(sbi, F2FS_DIRTY_DATA) && retry--);
	2055	+
	2056	+ if (unlikely(retry < 0))
	2057	+ f2fs_warn(sbi, "checkpoint=enable has some unwritten data.");
	2058	+
	2059	+ f2fs_down_write(&sbi->gc_lock);
1741	2060	f2fs_dirty_to_prefree(sbi);
1742	2061
1743	2062	clear_sbi_flag(sbi, SBI_CP_DISABLED);
1744	2063	set_sbi_flag(sbi, SBI_IS_DIRTY);
1745		- up_write(&sbi->gc_lock);
	2064	+ f2fs_up_write(&sbi->gc_lock);
1746	2065
1747	2066	f2fs_sync_fs(sbi->sb, 1);
	2067	+
	2068	+ /* Let's ensure there's no pending checkpoint anymore */
	2069	+ f2fs_flush_ckpt_thread(sbi);
1748	2070	}
1749	2071
1750	2072	static int f2fs_remount(struct super_block sb, int flags, char *data)
..	..	@@ -1753,11 +2075,15 @@
1753	2075	struct f2fs_mount_info org_mount_opt;
1754	2076	unsigned long old_sb_flags;
1755	2077	int err;
1756		- bool need_restart_gc = false;
1757		- bool need_stop_gc = false;
1758		- bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
	2078	+ bool need_restart_gc = false, need_stop_gc = false;
	2079	+ bool need_restart_ckpt = false, need_stop_ckpt = false;
	2080	+ bool need_restart_flush = false, need_stop_flush = false;
	2081	+ bool no_read_extent_cache = !test_opt(sbi, READ_EXTENT_CACHE);
	2082	+ bool no_age_extent_cache = !test_opt(sbi, AGE_EXTENT_CACHE);
1759	2083	bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
1760	2084	bool no_io_align = !F2FS_IO_ALIGNED(sbi);
	2085	+ bool no_atgc = !test_opt(sbi, ATGC);
	2086	+ bool no_compress_cache = !test_opt(sbi, COMPRESS_CACHE);
1761	2087	bool checkpoint_changed;
1762	2088	#ifdef CONFIG_QUOTA
1763	2089	int i, j;
..	..	@@ -1779,7 +2105,7 @@
1779	2105	GFP_KERNEL);
1780	2106	if (!org_mount_opt.s_qf_names[i]) {
1781	2107	for (j = 0; j < i; j++)
1782		- kvfree(org_mount_opt.s_qf_names[j]);
	2108	+ kfree(org_mount_opt.s_qf_names[j]);
1783	2109	return -ENOMEM;
1784	2110	}
1785	2111	} else {
..	..	@@ -1813,6 +2139,11 @@
1813	2139	if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
1814	2140	goto skip;
1815	2141
	2142	+ if (f2fs_sb_has_readonly(sbi) && !(*flags & SB_RDONLY)) {
	2143	+ err = -EROFS;
	2144	+ goto restore_opts;
	2145	+ }
	2146	+
1816	2147	#ifdef CONFIG_QUOTA
1817	2148	if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
1818	2149	err = dquot_suspend(sb, -1);
..	..	@@ -1830,16 +2161,35 @@
1830	2161	}
1831	2162	}
1832	2163	#endif
	2164	+ /* disallow enable atgc dynamically */
	2165	+ if (no_atgc == !!test_opt(sbi, ATGC)) {
	2166	+ err = -EINVAL;
	2167	+ f2fs_warn(sbi, "switch atgc option is not allowed");
	2168	+ goto restore_opts;
	2169	+ }
	2170	+
1833	2171	/* disallow enable/disable extent_cache dynamically */
1834		- if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) {
	2172	+ if (no_read_extent_cache == !!test_opt(sbi, READ_EXTENT_CACHE)) {
1835	2173	err = -EINVAL;
1836	2174	f2fs_warn(sbi, "switch extent_cache option is not allowed");
	2175	+ goto restore_opts;
	2176	+ }
	2177	+ /* disallow enable/disable age extent_cache dynamically */
	2178	+ if (no_age_extent_cache == !!test_opt(sbi, AGE_EXTENT_CACHE)) {
	2179	+ err = -EINVAL;
	2180	+ f2fs_warn(sbi, "switch age_extent_cache option is not allowed");
1837	2181	goto restore_opts;
1838	2182	}
1839	2183
1840	2184	if (no_io_align == !!F2FS_IO_ALIGNED(sbi)) {
1841	2185	err = -EINVAL;
1842	2186	f2fs_warn(sbi, "switch io_bits option is not allowed");
	2187	+ goto restore_opts;
	2188	+ }
	2189	+
	2190	+ if (no_compress_cache == !!test_opt(sbi, COMPRESS_CACHE)) {
	2191	+ err = -EINVAL;
	2192	+ f2fs_warn(sbi, "switch compress_cache option is not allowed");
1843	2193	goto restore_opts;
1844	2194	}
1845	2195
..	..	@@ -1855,7 +2205,8 @@
1855	2205	* option. Also sync the filesystem.
1856	2206	*/
1857	2207	if ((*flags & SB_RDONLY) \|\|
1858		- F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF) {
	2208	+ (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF &&
	2209	+ !test_opt(sbi, GC_MERGE))) {
1859	2210	if (sbi->gc_thread) {
1860	2211	f2fs_stop_gc_thread(sbi);
1861	2212	need_restart_gc = true;
..	..	@@ -1869,7 +2220,6 @@
1869	2220
1870	2221	if (*flags & SB_RDONLY \|\|
1871	2222	F2FS_OPTION(sbi).whint_mode != org_mount_opt.whint_mode) {
1872		- writeback_inodes_sb(sb, WB_REASON_SYNC);
1873	2223	sync_inodes_sb(sb);
1874	2224
1875	2225	set_sbi_flag(sbi, SBI_IS_DIRTY);
..	..	@@ -1878,14 +2228,22 @@
1878	2228	clear_sbi_flag(sbi, SBI_IS_CLOSE);
1879	2229	}
1880	2230
1881		- if (checkpoint_changed) {
1882		- if (test_opt(sbi, DISABLE_CHECKPOINT)) {
1883		- err = f2fs_disable_checkpoint(sbi);
1884		- if (err)
1885		- goto restore_gc;
1886		- } else {
1887		- f2fs_enable_checkpoint(sbi);
	2231	+ if ((*flags & SB_RDONLY) \|\| test_opt(sbi, DISABLE_CHECKPOINT) \|\|
	2232	+ !test_opt(sbi, MERGE_CHECKPOINT)) {
	2233	+ f2fs_stop_ckpt_thread(sbi);
	2234	+ need_restart_ckpt = true;
	2235	+ } else {
	2236	+ /* Flush if the prevous checkpoint, if exists. */
	2237	+ f2fs_flush_ckpt_thread(sbi);
	2238	+
	2239	+ err = f2fs_start_ckpt_thread(sbi);
	2240	+ if (err) {
	2241	+ f2fs_err(sbi,
	2242	+ "Failed to start F2FS issue_checkpoint_thread (%d)",
	2243	+ err);
	2244	+ goto restore_gc;
1888	2245	}
	2246	+ need_stop_ckpt = true;
1889	2247	}
1890	2248
1891	2249	/*
..	..	@@ -1895,16 +2253,29 @@
1895	2253	if ((*flags & SB_RDONLY) \|\| !test_opt(sbi, FLUSH_MERGE)) {
1896	2254	clear_opt(sbi, FLUSH_MERGE);
1897	2255	f2fs_destroy_flush_cmd_control(sbi, false);
	2256	+ need_restart_flush = true;
1898	2257	} else {
1899	2258	err = f2fs_create_flush_cmd_control(sbi);
1900	2259	if (err)
1901		- goto restore_gc;
	2260	+ goto restore_ckpt;
	2261	+ need_stop_flush = true;
1902	2262	}
	2263	+
	2264	+ if (checkpoint_changed) {
	2265	+ if (test_opt(sbi, DISABLE_CHECKPOINT)) {
	2266	+ err = f2fs_disable_checkpoint(sbi);
	2267	+ if (err)
	2268	+ goto restore_flush;
	2269	+ } else {
	2270	+ f2fs_enable_checkpoint(sbi);
	2271	+ }
	2272	+ }
	2273	+
1903	2274	skip:
1904	2275	#ifdef CONFIG_QUOTA
1905	2276	/* Release old quota file names */
1906	2277	for (i = 0; i < MAXQUOTAS; i++)
1907		- kvfree(org_mount_opt.s_qf_names[i]);
	2278	+ kfree(org_mount_opt.s_qf_names[i]);
1908	2279	#endif
1909	2280	/* Update the POSIXACL Flag */
1910	2281	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) \|
..	..	@@ -1914,6 +2285,21 @@
1914	2285	adjust_unusable_cap_perc(sbi);
1915	2286	flags = (flags & ~SB_LAZYTIME) \| (sb->s_flags & SB_LAZYTIME);
1916	2287	return 0;
	2288	+restore_flush:
	2289	+ if (need_restart_flush) {
	2290	+ if (f2fs_create_flush_cmd_control(sbi))
	2291	+ f2fs_warn(sbi, "background flush thread has stopped");
	2292	+ } else if (need_stop_flush) {
	2293	+ clear_opt(sbi, FLUSH_MERGE);
	2294	+ f2fs_destroy_flush_cmd_control(sbi, false);
	2295	+ }
	2296	+restore_ckpt:
	2297	+ if (need_restart_ckpt) {
	2298	+ if (f2fs_start_ckpt_thread(sbi))
	2299	+ f2fs_warn(sbi, "background ckpt thread has stopped");
	2300	+ } else if (need_stop_ckpt) {
	2301	+ f2fs_stop_ckpt_thread(sbi);
	2302	+ }
1917	2303	restore_gc:
1918	2304	if (need_restart_gc) {
1919	2305	if (f2fs_start_gc_thread(sbi))
..	..	@@ -1925,7 +2311,7 @@
1925	2311	#ifdef CONFIG_QUOTA
1926	2312	F2FS_OPTION(sbi).s_jquota_fmt = org_mount_opt.s_jquota_fmt;
1927	2313	for (i = 0; i < MAXQUOTAS; i++) {
1928		- kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
	2314	+ kfree(F2FS_OPTION(sbi).s_qf_names[i]);
1929	2315	F2FS_OPTION(sbi).s_qf_names[i] = org_mount_opt.s_qf_names[i];
1930	2316	}
1931	2317	#endif
..	..	@@ -2116,7 +2502,7 @@
2116	2502
2117	2503	/* Don't account quota for quota files to avoid recursion */
2118	2504	qf_inode->i_flags \|= S_NOQUOTA;
2119		- err = dquot_enable(qf_inode, type, format_id, flags);
	2505	+ err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
2120	2506	iput(qf_inode);
2121	2507	return err;
2122	2508	}
..	..	@@ -2159,64 +2545,78 @@
2159	2545	return 0;
2160	2546	}
2161	2547
	2548	+static int f2fs_quota_sync_file(struct f2fs_sb_info *sbi, int type)
	2549	+{
	2550	+ struct quota_info *dqopt = sb_dqopt(sbi->sb);
	2551	+ struct address_space *mapping = dqopt->files[type]->i_mapping;
	2552	+ int ret = 0;
	2553	+
	2554	+ ret = dquot_writeback_dquots(sbi->sb, type);
	2555	+ if (ret)
	2556	+ goto out;
	2557	+
	2558	+ ret = filemap_fdatawrite(mapping);
	2559	+ if (ret)
	2560	+ goto out;
	2561	+
	2562	+ /* if we are using journalled quota */
	2563	+ if (is_journalled_quota(sbi))
	2564	+ goto out;
	2565	+
	2566	+ ret = filemap_fdatawait(mapping);
	2567	+
	2568	+ truncate_inode_pages(&dqopt->files[type]->i_data, 0);
	2569	+out:
	2570	+ if (ret)
	2571	+ set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
	2572	+ return ret;
	2573	+}
	2574	+
2162	2575	int f2fs_quota_sync(struct super_block *sb, int type)
2163	2576	{
2164	2577	struct f2fs_sb_info *sbi = F2FS_SB(sb);
2165	2578	struct quota_info *dqopt = sb_dqopt(sb);
2166	2579	int cnt;
2167		- int ret;
2168		-
2169		- /*
2170		- * do_quotactl
2171		- * f2fs_quota_sync
2172		- * down_read(quota_sem)
2173		- * dquot_writeback_dquots()
2174		- * f2fs_dquot_commit
2175		- * block_operation
2176		- * down_read(quota_sem)
2177		- */
2178		- f2fs_lock_op(sbi);
2179		-
2180		- down_read(&sbi->quota_sem);
2181		- ret = dquot_writeback_dquots(sb, type);
2182		- if (ret)
2183		- goto out;
	2580	+ int ret = 0;
2184	2581
2185	2582	/*
2186	2583	* Now when everything is written we can discard the pagecache so
2187	2584	* that userspace sees the changes.
2188	2585	*/
2189	2586	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2190		- struct address_space *mapping;
2191	2587
2192	2588	if (type != -1 && cnt != type)
2193	2589	continue;
	2590	+
2194	2591	if (!sb_has_quota_active(sb, cnt))
2195	2592	continue;
2196	2593
2197		- mapping = dqopt->files[cnt]->i_mapping;
	2594	+ if (!f2fs_sb_has_quota_ino(sbi))
	2595	+ inode_lock(dqopt->files[cnt]);
2198	2596
2199		- ret = filemap_fdatawrite(mapping);
	2597	+ /*
	2598	+ * do_quotactl
	2599	+ * f2fs_quota_sync
	2600	+ * f2fs_down_read(quota_sem)
	2601	+ * dquot_writeback_dquots()
	2602	+ * f2fs_dquot_commit
	2603	+ * block_operation
	2604	+ * f2fs_down_read(quota_sem)
	2605	+ */
	2606	+ f2fs_lock_op(sbi);
	2607	+ f2fs_down_read(&sbi->quota_sem);
	2608	+
	2609	+ ret = f2fs_quota_sync_file(sbi, cnt);
	2610	+
	2611	+ f2fs_up_read(&sbi->quota_sem);
	2612	+ f2fs_unlock_op(sbi);
	2613	+
	2614	+ if (!f2fs_sb_has_quota_ino(sbi))
	2615	+ inode_unlock(dqopt->files[cnt]);
	2616	+
2200	2617	if (ret)
2201		- goto out;
2202		-
2203		- /* if we are using journalled quota */
2204		- if (is_journalled_quota(sbi))
2205		- continue;
2206		-
2207		- ret = filemap_fdatawait(mapping);
2208		- if (ret)
2209		- set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2210		-
2211		- inode_lock(dqopt->files[cnt]);
2212		- truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
2213		- inode_unlock(dqopt->files[cnt]);
	2618	+ break;
2214	2619	}
2215		-out:
2216		- if (ret)
2217		- set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2218		- up_read(&sbi->quota_sem);
2219		- f2fs_unlock_op(sbi);
2220	2620	return ret;
2221	2621	}
2222	2622
..	..	@@ -2334,11 +2734,11 @@
2334	2734	struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
2335	2735	int ret;
2336	2736
2337		- down_read_nested(&sbi->quota_sem, SINGLE_DEPTH_NESTING);
	2737	+ f2fs_down_read_nested(&sbi->quota_sem, SINGLE_DEPTH_NESTING);
2338	2738	ret = dquot_commit(dquot);
2339	2739	if (ret < 0)
2340	2740	set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2341		- up_read(&sbi->quota_sem);
	2741	+ f2fs_up_read(&sbi->quota_sem);
2342	2742	return ret;
2343	2743	}
2344	2744
..	..	@@ -2347,11 +2747,11 @@
2347	2747	struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
2348	2748	int ret;
2349	2749
2350		- down_read(&sbi->quota_sem);
	2750	+ f2fs_down_read(&sbi->quota_sem);
2351	2751	ret = dquot_acquire(dquot);
2352	2752	if (ret < 0)
2353	2753	set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2354		- up_read(&sbi->quota_sem);
	2754	+ f2fs_up_read(&sbi->quota_sem);
2355	2755	return ret;
2356	2756	}
2357	2757
..	..	@@ -2430,8 +2830,8 @@
2430	2830
2431	2831	static const struct super_operations f2fs_sops = {
2432	2832	.alloc_inode = f2fs_alloc_inode,
	2833	+ .free_inode = f2fs_free_inode,
2433	2834	.drop_inode = f2fs_drop_inode,
2434		- .destroy_inode = f2fs_destroy_inode,
2435	2835	.write_inode = f2fs_write_inode,
2436	2836	.dirty_inode = f2fs_dirty_inode,
2437	2837	.show_options = f2fs_show_options,
..	..	@@ -2477,10 +2877,9 @@
2477	2877	ctx, len, fs_data, XATTR_CREATE);
2478	2878	}
2479	2879
2480		-static const union fscrypt_context *
2481		-f2fs_get_dummy_context(struct super_block *sb)
	2880	+static const union fscrypt_policy f2fs_get_dummy_policy(struct super_block sb)
2482	2881	{
2483		- return F2FS_OPTION(F2FS_SB(sb)).dummy_enc_ctx.ctx;
	2882	+ return F2FS_OPTION(F2FS_SB(sb)).dummy_enc_policy.policy;
2484	2883	}
2485	2884
2486	2885	static bool f2fs_has_stable_inodes(struct super_block *sb)
..	..	@@ -2493,11 +2892,6 @@
2493	2892	{
2494	2893	ino_bits_ret = 8 sizeof(nid_t);
2495	2894	lblk_bits_ret = 8 sizeof(block_t);
2496		-}
2497		-
2498		-static bool f2fs_inline_crypt_enabled(struct super_block *sb)
2499		-{
2500		- return F2FS_OPTION(F2FS_SB(sb)).inlinecrypt;
2501	2895	}
2502	2896
2503	2897	static int f2fs_get_num_devices(struct super_block *sb)
..	..	@@ -2523,12 +2917,11 @@
2523	2917	.key_prefix = "f2fs:",
2524	2918	.get_context = f2fs_get_context,
2525	2919	.set_context = f2fs_set_context,
2526		- .get_dummy_context = f2fs_get_dummy_context,
	2920	+ .get_dummy_policy = f2fs_get_dummy_policy,
2527	2921	.empty_dir = f2fs_empty_dir,
2528	2922	.max_namelen = F2FS_NAME_LEN,
2529	2923	.has_stable_inodes = f2fs_has_stable_inodes,
2530	2924	.get_ino_and_lblk_bits = f2fs_get_ino_and_lblk_bits,
2531		- .inline_crypt_enabled = f2fs_inline_crypt_enabled,
2532	2925	.get_num_devices = f2fs_get_num_devices,
2533	2926	.get_devices = f2fs_get_devices,
2534	2927	};
..	..	@@ -2579,10 +2972,10 @@
2579	2972	.get_parent = f2fs_get_parent,
2580	2973	};
2581	2974
2582		-static loff_t max_file_blocks(void)
	2975	+loff_t max_file_blocks(struct inode *inode)
2583	2976	{
2584	2977	loff_t result = 0;
2585		- loff_t leaf_count = DEF_ADDRS_PER_BLOCK;
	2978	+ loff_t leaf_count;
2586	2979
2587	2980	/*
2588	2981	* note: previously, result is equal to (DEF_ADDRS_PER_INODE -
..	..	@@ -2590,6 +2983,11 @@
2590	2983	* space in inode.i_addr, it will be more safe to reassign
2591	2984	* result as zero.
2592	2985	*/
	2986	+
	2987	+ if (inode && f2fs_compressed_file(inode))
	2988	+ leaf_count = ADDRS_PER_BLOCK(inode);
	2989	+ else
	2990	+ leaf_count = DEF_ADDRS_PER_BLOCK;
2593	2991
2594	2992	/* two direct node blocks */
2595	2993	result += (leaf_count * 2);
..	..	@@ -2681,10 +3079,8 @@
2681	3079	}
2682	3080
2683	3081	if (main_end_blkaddr > seg_end_blkaddr) {
2684		- f2fs_info(sbi, "Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)",
2685		- main_blkaddr,
2686		- segment0_blkaddr +
2687		- (segment_count << log_blocks_per_seg),
	3082	+ f2fs_info(sbi, "Wrong MAIN_AREA boundary, start(%u) end(%llu) block(%u)",
	3083	+ main_blkaddr, seg_end_blkaddr,
2688	3084	segment_count_main << log_blocks_per_seg);
2689	3085	return true;
2690	3086	} else if (main_end_blkaddr < seg_end_blkaddr) {
..	..	@@ -2702,10 +3098,8 @@
2702	3098	err = __f2fs_commit_super(bh, NULL);
2703	3099	res = err ? "failed" : "done";
2704	3100	}
2705		- f2fs_info(sbi, "Fix alignment : %s, start(%u) end(%u) block(%u)",
2706		- res, main_blkaddr,
2707		- segment0_blkaddr +
2708		- (segment_count << log_blocks_per_seg),
	3101	+ f2fs_info(sbi, "Fix alignment : %s, start(%u) end(%llu) block(%u)",
	3102	+ res, main_blkaddr, seg_end_blkaddr,
2709	3103	segment_count_main << log_blocks_per_seg);
2710	3104	if (err)
2711	3105	return true;
..	..	@@ -2716,11 +3110,10 @@
2716	3110	static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
2717	3111	struct buffer_head *bh)
2718	3112	{
2719		- block_t segment_count, segs_per_sec, secs_per_zone;
	3113	+ block_t segment_count, segs_per_sec, secs_per_zone, segment_count_main;
2720	3114	block_t total_sections, blocks_per_seg;
2721	3115	struct f2fs_super_block raw_super = (struct f2fs_super_block )
2722	3116	(bh->b_data + F2FS_SUPER_OFFSET);
2723		- unsigned int blocksize;
2724	3117	size_t crc_offset = 0;
2725	3118	__u32 crc = 0;
2726	3119
..	..	@@ -2746,18 +3139,11 @@
2746	3139	}
2747	3140	}
2748	3141
2749		- /* Currently, support only 4KB page cache size */
2750		- if (F2FS_BLKSIZE != PAGE_SIZE) {
2751		- f2fs_info(sbi, "Invalid page_cache_size (%lu), supports only 4KB",
2752		- PAGE_SIZE);
2753		- return -EFSCORRUPTED;
2754		- }
2755		-
2756	3142	/* Currently, support only 4KB block size */
2757		- blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
2758		- if (blocksize != F2FS_BLKSIZE) {
2759		- f2fs_info(sbi, "Invalid blocksize (%u), supports only 4KB",
2760		- blocksize);
	3143	+ if (le32_to_cpu(raw_super->log_blocksize) != F2FS_BLKSIZE_BITS) {
	3144	+ f2fs_info(sbi, "Invalid log_blocksize (%u), supports only %u",
	3145	+ le32_to_cpu(raw_super->log_blocksize),
	3146	+ F2FS_BLKSIZE_BITS);
2761	3147	return -EFSCORRUPTED;
2762	3148	}
2763	3149
..	..	@@ -2787,6 +3173,7 @@
2787	3173	}
2788	3174
2789	3175	segment_count = le32_to_cpu(raw_super->segment_count);
	3176	+ segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2790	3177	segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2791	3178	secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2792	3179	total_sections = le32_to_cpu(raw_super->section_count);
..	..	@@ -2800,11 +3187,16 @@
2800	3187	return -EFSCORRUPTED;
2801	3188	}
2802	3189
2803		- if (total_sections > segment_count \|\|
2804		- total_sections < F2FS_MIN_SEGMENTS \|\|
	3190	+ if (total_sections > segment_count_main \|\| total_sections < 1 \|\|
2805	3191	segs_per_sec > segment_count \|\| !segs_per_sec) {
2806	3192	f2fs_info(sbi, "Invalid segment/section count (%u, %u x %u)",
2807	3193	segment_count, total_sections, segs_per_sec);
	3194	+ return -EFSCORRUPTED;
	3195	+ }
	3196	+
	3197	+ if (segment_count_main != total_sections * segs_per_sec) {
	3198	+ f2fs_info(sbi, "Invalid segment/section count (%u != %u * %u)",
	3199	+ segment_count_main, total_sections, segs_per_sec);
2808	3200	return -EFSCORRUPTED;
2809	3201	}
2810	3202
..	..	@@ -2833,6 +3225,12 @@
2833	3225	segment_count, dev_seg_count);
2834	3226	return -EFSCORRUPTED;
2835	3227	}
	3228	+ } else {
	3229	+ if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_BLKZONED) &&
	3230	+ !bdev_is_zoned(sbi->sb->s_bdev)) {
	3231	+ f2fs_info(sbi, "Zoned block device path is missing");
	3232	+ return -EFSCORRUPTED;
	3233	+ }
2836	3234	}
2837	3235
2838	3236	if (secs_per_zone > total_sections \|\| !secs_per_zone) {
..	..	@@ -2851,11 +3249,13 @@
2851	3249	return -EFSCORRUPTED;
2852	3250	}
2853	3251
2854		- if (le32_to_cpu(raw_super->cp_payload) >
2855		- (blocks_per_seg - F2FS_CP_PACKS)) {
2856		- f2fs_info(sbi, "Insane cp_payload (%u > %u)",
	3252	+ if (le32_to_cpu(raw_super->cp_payload) >=
	3253	+ (blocks_per_seg - F2FS_CP_PACKS -
	3254	+ NR_CURSEG_PERSIST_TYPE)) {
	3255	+ f2fs_info(sbi, "Insane cp_payload (%u >= %u)",
2857	3256	le32_to_cpu(raw_super->cp_payload),
2858		- blocks_per_seg - F2FS_CP_PACKS);
	3257	+ blocks_per_seg - F2FS_CP_PACKS -
	3258	+ NR_CURSEG_PERSIST_TYPE);
2859	3259	return -EFSCORRUPTED;
2860	3260	}
2861	3261
..	..	@@ -2891,6 +3291,7 @@
2891	3291	unsigned int cp_pack_start_sum, cp_payload;
2892	3292	block_t user_block_count, valid_user_blocks;
2893	3293	block_t avail_node_count, valid_node_count;
	3294	+ unsigned int nat_blocks, nat_bits_bytes, nat_bits_blocks;
2894	3295	int i, j;
2895	3296
2896	3297	total = le32_to_cpu(raw_super->segment_count);
..	..	@@ -2908,14 +3309,15 @@
2908	3309	ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
2909	3310	reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
2910	3311
2911		- if (unlikely(fsmeta < F2FS_MIN_SEGMENTS \|\|
	3312	+ if (!f2fs_sb_has_readonly(sbi) &&
	3313	+ unlikely(fsmeta < F2FS_MIN_META_SEGMENTS \|\|
2912	3314	ovp_segments == 0 \|\| reserved_segments == 0)) {
2913	3315	f2fs_err(sbi, "Wrong layout: check mkfs.f2fs version");
2914	3316	return 1;
2915	3317	}
2916		-
2917	3318	user_block_count = le64_to_cpu(ckpt->user_block_count);
2918		- segment_count_main = le32_to_cpu(raw_super->segment_count_main);
	3319	+ segment_count_main = le32_to_cpu(raw_super->segment_count_main) +
	3320	+ (f2fs_sb_has_readonly(sbi) ? 1 : 0);
2919	3321	log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2920	3322	if (!user_block_count \|\| user_block_count >=
2921	3323	segment_count_main << log_blocks_per_seg) {
..	..	@@ -2946,6 +3348,10 @@
2946	3348	if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs \|\|
2947	3349	le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)
2948	3350	return 1;
	3351	+
	3352	+ if (f2fs_sb_has_readonly(sbi))
	3353	+ goto check_data;
	3354	+
2949	3355	for (j = i + 1; j < NR_CURSEG_NODE_TYPE; j++) {
2950	3356	if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2951	3357	le32_to_cpu(ckpt->cur_node_segno[j])) {
..	..	@@ -2956,10 +3362,15 @@
2956	3362	}
2957	3363	}
2958	3364	}
	3365	+check_data:
2959	3366	for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
2960	3367	if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs \|\|
2961	3368	le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)
2962	3369	return 1;
	3370	+
	3371	+ if (f2fs_sb_has_readonly(sbi))
	3372	+ goto skip_cross;
	3373	+
2963	3374	for (j = i + 1; j < NR_CURSEG_DATA_TYPE; j++) {
2964	3375	if (le32_to_cpu(ckpt->cur_data_segno[i]) ==
2965	3376	le32_to_cpu(ckpt->cur_data_segno[j])) {
..	..	@@ -2981,7 +3392,7 @@
2981	3392	}
2982	3393	}
2983	3394	}
2984		-
	3395	+skip_cross:
2985	3396	sit_bitmap_size = le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
2986	3397	nat_bitmap_size = le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
2987	3398
..	..	@@ -2996,7 +3407,7 @@
2996	3407	cp_payload = __cp_payload(sbi);
2997	3408	if (cp_pack_start_sum < cp_payload + 1 \|\|
2998	3409	cp_pack_start_sum > blocks_per_seg - 1 -
2999		- NR_CURSEG_TYPE) {
	3410	+ NR_CURSEG_PERSIST_TYPE) {
3000	3411	f2fs_err(sbi, "Wrong cp_pack_start_sum: %u",
3001	3412	cp_pack_start_sum);
3002	3413	return 1;
..	..	@@ -3008,6 +3419,17 @@
3008	3419	"please run fsck v1.13.0 or higher to repair, chksum_offset: %u, "
3009	3420	"fixed with patch: \"f2fs-tools: relocate chksum_offset for large_nat_bitmap feature\"",
3010	3421	le32_to_cpu(ckpt->checksum_offset));
	3422	+ return 1;
	3423	+ }
	3424	+
	3425	+ nat_blocks = nat_segs << log_blocks_per_seg;
	3426	+ nat_bits_bytes = nat_blocks / BITS_PER_BYTE;
	3427	+ nat_bits_blocks = F2FS_BLK_ALIGN((nat_bits_bytes << 1) + 8);
	3428	+ if (__is_set_ckpt_flags(ckpt, CP_NAT_BITS_FLAG) &&
	3429	+ (cp_payload + F2FS_CP_PACKS +
	3430	+ NR_CURSEG_PERSIST_TYPE + nat_bits_blocks >= blocks_per_seg)) {
	3431	+ f2fs_warn(sbi, "Insane cp_payload: %u, nat_bits_blocks: %u)",
	3432	+ cp_payload, nat_bits_blocks);
3011	3433	return 1;
3012	3434	}
3013	3435
..	..	@@ -3035,9 +3457,9 @@
3035	3457	sbi->total_node_count =
3036	3458	(le32_to_cpu(raw_super->segment_count_nat) / 2)
3037	3459	* sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
3038		- sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
3039		- sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
3040		- sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
	3460	+ F2FS_ROOT_INO(sbi) = le32_to_cpu(raw_super->root_ino);
	3461	+ F2FS_NODE_INO(sbi) = le32_to_cpu(raw_super->node_ino);
	3462	+ F2FS_META_INO(sbi) = le32_to_cpu(raw_super->meta_ino);
3041	3463	sbi->cur_victim_sec = NULL_SECNO;
3042	3464	sbi->next_victim_seg[BG_GC] = NULL_SEGNO;
3043	3465	sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
..	..	@@ -3062,14 +3484,14 @@
3062	3484
3063	3485	INIT_LIST_HEAD(&sbi->s_list);
3064	3486	mutex_init(&sbi->umount_mutex);
3065		- init_rwsem(&sbi->io_order_lock);
	3487	+ init_f2fs_rwsem(&sbi->io_order_lock);
3066	3488	spin_lock_init(&sbi->cp_lock);
3067	3489
3068	3490	sbi->dirty_device = 0;
3069	3491	spin_lock_init(&sbi->dev_lock);
3070	3492
3071		- init_rwsem(&sbi->sb_lock);
3072		- init_rwsem(&sbi->pin_sem);
	3493	+ init_f2fs_rwsem(&sbi->sb_lock);
	3494	+ init_f2fs_rwsem(&sbi->pin_sem);
3073	3495	}
3074	3496
3075	3497	static int init_percpu_info(struct f2fs_sb_info *sbi)
..	..	@@ -3089,15 +3511,35 @@
3089	3511	}
3090	3512
3091	3513	#ifdef CONFIG_BLK_DEV_ZONED
	3514	+
	3515	+struct f2fs_report_zones_args {
	3516	+ struct f2fs_dev_info *dev;
	3517	+ bool zone_cap_mismatch;
	3518	+};
	3519	+
	3520	+static int f2fs_report_zone_cb(struct blk_zone *zone, unsigned int idx,
	3521	+ void *data)
	3522	+{
	3523	+ struct f2fs_report_zones_args *rz_args = data;
	3524	+
	3525	+ if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
	3526	+ return 0;
	3527	+
	3528	+ set_bit(idx, rz_args->dev->blkz_seq);
	3529	+ rz_args->dev->zone_capacity_blocks[idx] = zone->capacity >>
	3530	+ F2FS_LOG_SECTORS_PER_BLOCK;
	3531	+ if (zone->len != zone->capacity && !rz_args->zone_cap_mismatch)
	3532	+ rz_args->zone_cap_mismatch = true;
	3533	+
	3534	+ return 0;
	3535	+}
	3536	+
3092	3537	static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
3093	3538	{
3094	3539	struct block_device *bdev = FDEV(devi).bdev;
3095	3540	sector_t nr_sectors = bdev->bd_part->nr_sects;
3096		- sector_t sector = 0;
3097		- struct blk_zone *zones;
3098		- unsigned int i, nr_zones;
3099		- unsigned int n = 0;
3100		- int err = -EIO;
	3541	+ struct f2fs_report_zones_args rep_zone_arg;
	3542	+ int ret;
3101	3543
3102	3544	if (!f2fs_sb_has_blkzoned(sbi))
3103	3545	return 0;
..	..	@@ -3122,40 +3564,27 @@
3122	3564	if (!FDEV(devi).blkz_seq)
3123	3565	return -ENOMEM;
3124	3566
3125		-#define F2FS_REPORT_NR_ZONES 4096
3126		-
3127		- zones = f2fs_kzalloc(sbi,
3128		- array_size(F2FS_REPORT_NR_ZONES,
3129		- sizeof(struct blk_zone)),
3130		- GFP_KERNEL);
3131		- if (!zones)
	3567	+ /* Get block zones type and zone-capacity */
	3568	+ FDEV(devi).zone_capacity_blocks = f2fs_kzalloc(sbi,
	3569	+ FDEV(devi).nr_blkz * sizeof(block_t),
	3570	+ GFP_KERNEL);
	3571	+ if (!FDEV(devi).zone_capacity_blocks)
3132	3572	return -ENOMEM;
3133	3573
3134		- /* Get block zones type */
3135		- while (zones && sector < nr_sectors) {
	3574	+ rep_zone_arg.dev = &FDEV(devi);
	3575	+ rep_zone_arg.zone_cap_mismatch = false;
3136	3576
3137		- nr_zones = F2FS_REPORT_NR_ZONES;
3138		- err = blkdev_report_zones(bdev, sector,
3139		- zones, &nr_zones,
3140		- GFP_KERNEL);
3141		- if (err)
3142		- break;
3143		- if (!nr_zones) {
3144		- err = -EIO;
3145		- break;
3146		- }
	3577	+ ret = blkdev_report_zones(bdev, 0, BLK_ALL_ZONES, f2fs_report_zone_cb,
	3578	+ &rep_zone_arg);
	3579	+ if (ret < 0)
	3580	+ return ret;
3147	3581
3148		- for (i = 0; i < nr_zones; i++) {
3149		- if (zones[i].type != BLK_ZONE_TYPE_CONVENTIONAL)
3150		- set_bit(n, FDEV(devi).blkz_seq);
3151		- sector += zones[i].len;
3152		- n++;
3153		- }
	3582	+ if (!rep_zone_arg.zone_cap_mismatch) {
	3583	+ kfree(FDEV(devi).zone_capacity_blocks);
	3584	+ FDEV(devi).zone_capacity_blocks = NULL;
3154	3585	}
3155	3586
3156		- kvfree(zones);
3157		-
3158		- return err;
	3587	+ return 0;
3159	3588	}
3160	3589	#endif
3161	3590
..	..	@@ -3210,7 +3639,7 @@
3210	3639
3211	3640	/* No valid superblock */
3212	3641	if (!*raw_super)
3213		- kvfree(super);
	3642	+ kfree(super);
3214	3643	else
3215	3644	err = 0;
3216	3645
..	..	@@ -3254,6 +3683,26 @@
3254	3683	err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
3255	3684	brelse(bh);
3256	3685	return err;
	3686	+}
	3687	+
	3688	+void f2fs_handle_stop(struct f2fs_sb_info *sbi, unsigned char reason)
	3689	+{
	3690	+ struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	3691	+ int err;
	3692	+
	3693	+ f2fs_bug_on(sbi, reason >= MAX_STOP_REASON);
	3694	+
	3695	+ f2fs_down_write(&sbi->sb_lock);
	3696	+
	3697	+ if (raw_super->s_stop_reason[reason] < ((1 << BITS_PER_BYTE) - 1))
	3698	+ raw_super->s_stop_reason[reason]++;
	3699	+
	3700	+ err = f2fs_commit_super(sbi, false);
	3701	+ if (err)
	3702	+ f2fs_err(sbi, "f2fs_commit_super fails to record reason:%u err:%d",
	3703	+ reason, err);
	3704	+
	3705	+ f2fs_up_write(&sbi->sb_lock);
3257	3706	}
3258	3707
3259	3708	static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
..	..	@@ -3319,7 +3768,7 @@
3319	3768	#ifdef CONFIG_BLK_DEV_ZONED
3320	3769	if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM &&
3321	3770	!f2fs_sb_has_blkzoned(sbi)) {
3322		- f2fs_err(sbi, "Zoned block device feature not enabled\n");
	3771	+ f2fs_err(sbi, "Zoned block device feature not enabled");
3323	3772	return -EINVAL;
3324	3773	}
3325	3774	if (bdev_zoned_model(FDEV(i).bdev) != BLK_ZONED_NONE) {
..	..	@@ -3396,7 +3845,8 @@
3396	3845	if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
3397	3846	F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
3398	3847	sm_i->dcc_info->discard_granularity = 1;
3399		- sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
	3848	+ sm_i->ipu_policy = 1 << F2FS_IPU_FORCE \|
	3849	+ 1 << F2FS_IPU_HONOR_OPU_WRITE;
3400	3850	}
3401	3851
3402	3852	sbi->readdir_ra = 1;
..	..	@@ -3455,18 +3905,6 @@
3455	3905	sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,
3456	3906	sizeof(raw_super->uuid));
3457	3907
3458		- /*
3459		- * The BLKZONED feature indicates that the drive was formatted with
3460		- * zone alignment optimization. This is optional for host-aware
3461		- * devices, but mandatory for host-managed zoned block devices.
3462		- */
3463		-#ifndef CONFIG_BLK_DEV_ZONED
3464		- if (f2fs_sb_has_blkzoned(sbi)) {
3465		- f2fs_err(sbi, "Zoned block device support is not enabled");
3466		- err = -EOPNOTSUPP;
3467		- goto free_sb_buf;
3468		- }
3469		-#endif
3470	3908	default_options(sbi);
3471	3909	/* parse mount options */
3472	3910	options = kstrdup((const char *)data, GFP_KERNEL);
..	..	@@ -3479,8 +3917,7 @@
3479	3917	if (err)
3480	3918	goto free_options;
3481	3919
3482		- sbi->max_file_blocks = max_file_blocks();
3483		- sb->s_maxbytes = sbi->max_file_blocks <<
	3920	+ sb->s_maxbytes = max_file_blocks(NULL) <<
3484	3921	le32_to_cpu(raw_super->log_blocksize);
3485	3922	sb->s_max_links = F2FS_LINK_MAX;
3486	3923
..	..	@@ -3519,11 +3956,11 @@
3519	3956
3520	3957	/* init f2fs-specific super block info */
3521	3958	sbi->valid_super_block = valid_super_block;
3522		- init_rwsem(&sbi->gc_lock);
	3959	+ init_f2fs_rwsem(&sbi->gc_lock);
3523	3960	mutex_init(&sbi->writepages);
3524		- mutex_init(&sbi->cp_mutex);
3525		- init_rwsem(&sbi->node_write);
3526		- init_rwsem(&sbi->node_change);
	3961	+ init_f2fs_rwsem(&sbi->cp_global_sem);
	3962	+ init_f2fs_rwsem(&sbi->node_write);
	3963	+ init_f2fs_rwsem(&sbi->node_change);
3527	3964
3528	3965	/* disallow all the data/node/meta page writes */
3529	3966	set_sbi_flag(sbi, SBI_POR_DOING);
..	..	@@ -3535,7 +3972,7 @@
3535	3972	sbi->iostat_period_ms = DEFAULT_IOSTAT_PERIOD_MS;
3536	3973
3537	3974	for (i = 0; i < NR_PAGE_TYPE; i++) {
3538		- int n = (i == META) ? 1: NR_TEMP_TYPE;
	3975	+ int n = (i == META) ? 1 : NR_TEMP_TYPE;
3539	3976	int j;
3540	3977
3541	3978	sbi->write_io[i] =
..	..	@@ -3549,18 +3986,18 @@
3549	3986	}
3550	3987
3551	3988	for (j = HOT; j < n; j++) {
3552		- init_rwsem(&sbi->write_io[i][j].io_rwsem);
	3989	+ init_f2fs_rwsem(&sbi->write_io[i][j].io_rwsem);
3553	3990	sbi->write_io[i][j].sbi = sbi;
3554	3991	sbi->write_io[i][j].bio = NULL;
3555	3992	spin_lock_init(&sbi->write_io[i][j].io_lock);
3556	3993	INIT_LIST_HEAD(&sbi->write_io[i][j].io_list);
3557	3994	INIT_LIST_HEAD(&sbi->write_io[i][j].bio_list);
3558		- init_rwsem(&sbi->write_io[i][j].bio_list_lock);
	3995	+ init_f2fs_rwsem(&sbi->write_io[i][j].bio_list_lock);
3559	3996	}
3560	3997	}
3561	3998
3562		- init_rwsem(&sbi->cp_rwsem);
3563		- init_rwsem(&sbi->quota_sem);
	3999	+ init_f2fs_rwsem(&sbi->cp_rwsem);
	4000	+ init_f2fs_rwsem(&sbi->quota_sem);
3564	4001	init_waitqueue_head(&sbi->cp_wait);
3565	4002	init_sb_info(sbi);
3566	4003
..	..	@@ -3581,13 +4018,16 @@
3581	4018	err = f2fs_init_xattr_caches(sbi);
3582	4019	if (err)
3583	4020	goto free_io_dummy;
	4021	+ err = f2fs_init_page_array_cache(sbi);
	4022	+ if (err)
	4023	+ goto free_xattr_cache;
3584	4024
3585	4025	/* get an inode for meta space */
3586	4026	sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
3587	4027	if (IS_ERR(sbi->meta_inode)) {
3588	4028	f2fs_err(sbi, "Failed to read F2FS meta data inode");
3589	4029	err = PTR_ERR(sbi->meta_inode);
3590		- goto free_xattr_cache;
	4030	+ goto free_page_array_cache;
3591	4031	}
3592	4032
3593	4033	err = f2fs_get_valid_checkpoint(sbi);
..	..	@@ -3644,6 +4084,19 @@
3644	4084
3645	4085	f2fs_init_fsync_node_info(sbi);
3646	4086
	4087	+ /* setup checkpoint request control and start checkpoint issue thread */
	4088	+ f2fs_init_ckpt_req_control(sbi);
	4089	+ if (!f2fs_readonly(sb) && !test_opt(sbi, DISABLE_CHECKPOINT) &&
	4090	+ test_opt(sbi, MERGE_CHECKPOINT)) {
	4091	+ err = f2fs_start_ckpt_thread(sbi);
	4092	+ if (err) {
	4093	+ f2fs_err(sbi,
	4094	+ "Failed to start F2FS issue_checkpoint_thread (%d)",
	4095	+ err);
	4096	+ goto stop_ckpt_thread;
	4097	+ }
	4098	+ }
	4099	+
3647	4100	/* setup f2fs internal modules */
3648	4101	err = f2fs_build_segment_manager(sbi);
3649	4102	if (err) {
..	..	@@ -3658,11 +4111,12 @@
3658	4111	goto free_nm;
3659	4112	}
3660	4113
	4114	+ err = adjust_reserved_segment(sbi);
	4115	+ if (err)
	4116	+ goto free_nm;
	4117	+
3661	4118	/* For write statistics */
3662		- if (sb->s_bdev->bd_part)
3663		- sbi->sectors_written_start =
3664		- (u64)part_stat_read(sb->s_bdev->bd_part,
3665		- sectors[STAT_WRITE]);
	4119	+ sbi->sectors_written_start = f2fs_get_sectors_written(sbi);
3666	4120
3667	4121	/* Read accumulated write IO statistics if exists */
3668	4122	seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
..	..	@@ -3706,9 +4160,13 @@
3706	4160	goto free_node_inode;
3707	4161	}
3708	4162
3709		- err = f2fs_register_sysfs(sbi);
	4163	+ err = f2fs_init_compress_inode(sbi);
3710	4164	if (err)
3711	4165	goto free_root_inode;
	4166	+
	4167	+ err = f2fs_register_sysfs(sbi);
	4168	+ if (err)
	4169	+ goto free_compress_inode;
3712	4170
3713	4171	#ifdef CONFIG_QUOTA
3714	4172	/* Enable quota usage during mount */
..	..	@@ -3735,9 +4193,15 @@
3735	4193	*/
3736	4194	if (f2fs_hw_is_readonly(sbi)) {
3737	4195	if (!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
3738		- err = -EROFS;
3739		- f2fs_err(sbi, "Need to recover fsync data, but write access unavailable");
3740		- goto free_meta;
	4196	+ err = f2fs_recover_fsync_data(sbi, true);
	4197	+ if (err > 0) {
	4198	+ err = -EROFS;
	4199	+ f2fs_err(sbi, "Need to recover fsync data, but "
	4200	+ "write access unavailable, please try "
	4201	+ "mount w/ disable_roll_forward or norecovery");
	4202	+ }
	4203	+ if (err < 0)
	4204	+ goto free_meta;
3741	4205	}
3742	4206	f2fs_info(sbi, "write access unavailable, skipping recovery");
3743	4207	goto reset_checkpoint;
..	..	@@ -3767,7 +4231,20 @@
3767	4231	goto free_meta;
3768	4232	}
3769	4233	}
	4234	+
	4235	+ /*
	4236	+ * If the f2fs is not readonly and fsync data recovery succeeds,
	4237	+ * check zoned block devices' write pointer consistency.
	4238	+ */
	4239	+ if (!err && !f2fs_readonly(sb) && f2fs_sb_has_blkzoned(sbi)) {
	4240	+ err = f2fs_check_write_pointer(sbi);
	4241	+ if (err)
	4242	+ goto free_meta;
	4243	+ }
	4244	+
3770	4245	reset_checkpoint:
	4246	+ f2fs_init_inmem_curseg(sbi);
	4247	+
3771	4248	/* f2fs_recover_fsync_data() cleared this already */
3772	4249	clear_sbi_flag(sbi, SBI_POR_DOING);
3773	4250
..	..	@@ -3783,7 +4260,8 @@
3783	4260	* If filesystem is not mounted as read-only then
3784	4261	* do start the gc_thread.
3785	4262	*/
3786		- if (F2FS_OPTION(sbi).bggc_mode != BGGC_MODE_OFF && !f2fs_readonly(sb)) {
	4263	+ if ((F2FS_OPTION(sbi).bggc_mode != BGGC_MODE_OFF \|\|
	4264	+ test_opt(sbi, GC_MERGE)) && !f2fs_readonly(sb)) {
3787	4265	/* After POR, we can run background GC thread.*/
3788	4266	err = f2fs_start_gc_thread(sbi);
3789	4267	if (err)
..	..	@@ -3830,6 +4308,8 @@
3830	4308	/* evict some inodes being cached by GC */
3831	4309	evict_inodes(sb);
3832	4310	f2fs_unregister_sysfs(sbi);
	4311	+free_compress_inode:
	4312	+ f2fs_destroy_compress_inode(sbi);
3833	4313	free_root_inode:
3834	4314	dput(sb->s_root);
3835	4315	sb->s_root = NULL;
..	..	@@ -3841,10 +4321,14 @@
3841	4321	free_stats:
3842	4322	f2fs_destroy_stats(sbi);
3843	4323	free_nm:
	4324	+ /* stop discard thread before destroying node manager */
	4325	+ f2fs_stop_discard_thread(sbi);
3844	4326	f2fs_destroy_node_manager(sbi);
3845	4327	free_sm:
3846	4328	f2fs_destroy_segment_manager(sbi);
3847	4329	f2fs_destroy_post_read_wq(sbi);
	4330	+stop_ckpt_thread:
	4331	+ f2fs_stop_ckpt_thread(sbi);
3848	4332	free_devices:
3849	4333	destroy_device_list(sbi);
3850	4334	kvfree(sbi->ckpt);
..	..	@@ -3852,6 +4336,8 @@
3852	4336	make_bad_inode(sbi->meta_inode);
3853	4337	iput(sbi->meta_inode);
3854	4338	sbi->meta_inode = NULL;
	4339	+free_page_array_cache:
	4340	+ f2fs_destroy_page_array_cache(sbi);
3855	4341	free_xattr_cache:
3856	4342	f2fs_destroy_xattr_caches(sbi);
3857	4343	free_io_dummy:
..	..	@@ -3864,20 +4350,21 @@
3864	4350
3865	4351	#ifdef CONFIG_UNICODE
3866	4352	utf8_unload(sb->s_encoding);
	4353	+ sb->s_encoding = NULL;
3867	4354	#endif
3868	4355	free_options:
3869	4356	#ifdef CONFIG_QUOTA
3870	4357	for (i = 0; i < MAXQUOTAS; i++)
3871		- kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
	4358	+ kfree(F2FS_OPTION(sbi).s_qf_names[i]);
3872	4359	#endif
3873		- fscrypt_free_dummy_context(&F2FS_OPTION(sbi).dummy_enc_ctx);
	4360	+ fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
3874	4361	kvfree(options);
3875	4362	free_sb_buf:
3876		- kvfree(raw_super);
	4363	+ kfree(raw_super);
3877	4364	free_sbi:
3878	4365	if (sbi->s_chksum_driver)
3879	4366	crypto_free_shash(sbi->s_chksum_driver);
3880		- kvfree(sbi);
	4367	+ kfree(sbi);
3881	4368
3882	4369	/* give only one another chance */
3883	4370	if (retry_cnt > 0 && skip_recovery) {
..	..	@@ -3902,6 +4389,15 @@
3902	4389	set_sbi_flag(sbi, SBI_IS_CLOSE);
3903	4390	f2fs_stop_gc_thread(sbi);
3904	4391	f2fs_stop_discard_thread(sbi);
	4392	+
	4393	+#ifdef CONFIG_F2FS_FS_COMPRESSION
	4394	+ /*
	4395	+ * latter evict_inode() can bypass checking and invalidating
	4396	+ * compress inode cache.
	4397	+ */
	4398	+ if (test_opt(sbi, COMPRESS_CACHE))
	4399	+ truncate_inode_pages_final(COMPRESS_MAPPING(sbi));
	4400	+#endif
3905	4401
3906	4402	if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) \|\|
3907	4403	!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
..	..	@@ -3956,8 +4452,6 @@
3956	4452	return -EINVAL;
3957	4453	}
3958	4454
3959		- f2fs_build_trace_ios();
3960		-
3961	4455	err = init_inodecache();
3962	4456	if (err)
3963	4457	goto fail;
..	..	@@ -3970,12 +4464,18 @@
3970	4464	err = f2fs_create_checkpoint_caches();
3971	4465	if (err)
3972	4466	goto free_segment_manager_caches;
3973		- err = f2fs_create_extent_cache();
	4467	+ err = f2fs_create_recovery_cache();
3974	4468	if (err)
3975	4469	goto free_checkpoint_caches;
3976		- err = f2fs_init_sysfs();
	4470	+ err = f2fs_create_extent_cache();
	4471	+ if (err)
	4472	+ goto free_recovery_cache;
	4473	+ err = f2fs_create_garbage_collection_cache();
3977	4474	if (err)
3978	4475	goto free_extent_cache;
	4476	+ err = f2fs_init_sysfs();
	4477	+ if (err)
	4478	+ goto free_garbage_collection_cache;
3979	4479	err = register_shrinker(&f2fs_shrinker_info);
3980	4480	if (err)
3981	4481	goto free_sysfs;
..	..	@@ -3995,7 +4495,17 @@
3995	4495	err = f2fs_init_compress_mempool();
3996	4496	if (err)
3997	4497	goto free_bioset;
	4498	+ err = f2fs_init_compress_cache();
	4499	+ if (err)
	4500	+ goto free_compress_mempool;
	4501	+ err = f2fs_create_casefold_cache();
	4502	+ if (err)
	4503	+ goto free_compress_cache;
3998	4504	return 0;
	4505	+free_compress_cache:
	4506	+ f2fs_destroy_compress_cache();
	4507	+free_compress_mempool:
	4508	+ f2fs_destroy_compress_mempool();
3999	4509	free_bioset:
4000	4510	f2fs_destroy_bioset();
4001	4511	free_bio_enrty_cache:
..	..	@@ -4009,8 +4519,12 @@
4009	4519	unregister_shrinker(&f2fs_shrinker_info);
4010	4520	free_sysfs:
4011	4521	f2fs_exit_sysfs();
	4522	+free_garbage_collection_cache:
	4523	+ f2fs_destroy_garbage_collection_cache();
4012	4524	free_extent_cache:
4013	4525	f2fs_destroy_extent_cache();
	4526	+free_recovery_cache:
	4527	+ f2fs_destroy_recovery_cache();
4014	4528	free_checkpoint_caches:
4015	4529	f2fs_destroy_checkpoint_caches();
4016	4530	free_segment_manager_caches:
..	..	@@ -4025,6 +4539,8 @@
4025	4539
4026	4540	static void __exit exit_f2fs_fs(void)
4027	4541	{
	4542	+ f2fs_destroy_casefold_cache();
	4543	+ f2fs_destroy_compress_cache();
4028	4544	f2fs_destroy_compress_mempool();
4029	4545	f2fs_destroy_bioset();
4030	4546	f2fs_destroy_bio_entry_cache();
..	..	@@ -4033,12 +4549,13 @@
4033	4549	unregister_filesystem(&f2fs_fs_type);
4034	4550	unregister_shrinker(&f2fs_shrinker_info);
4035	4551	f2fs_exit_sysfs();
	4552	+ f2fs_destroy_garbage_collection_cache();
4036	4553	f2fs_destroy_extent_cache();
	4554	+ f2fs_destroy_recovery_cache();
4037	4555	f2fs_destroy_checkpoint_caches();
4038	4556	f2fs_destroy_segment_manager_caches();
4039	4557	f2fs_destroy_node_manager_caches();
4040	4558	destroy_inodecache();
4041		- f2fs_destroy_trace_ios();
4042	4559	}
4043	4560
4044	4561	module_init(init_f2fs_fs)
..	..	@@ -4047,5 +4564,6 @@
4047	4564	MODULE_AUTHOR("Samsung Electronics's Praesto Team");
4048	4565	MODULE_DESCRIPTION("Flash Friendly File System");
4049	4566	MODULE_LICENSE("GPL");
	4567	+MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
4050	4568	MODULE_SOFTDEP("pre: crc32");
4051	4569