[PATCH v4 0/7] f2fs: new mount API conversion

[PATCH v4 0/7] f2fs: new mount API conversion

[Hongbo Li]

In this version, we have finished the issues pointed in v3.
First, I'd like to express my sincere thanks to Jaegeuk and Chao
for reviewing this patch series and providing corrections. I also
appreciate Eric for rebasing the patches onto the latest branch to
ensure forward compatibility.

The latest patch series has addressed all the issues mentioned in
the previous set. For modified patches, I've re-added Signed-off-by
tags (SOB) and uniformly removed all Reviewed-by tags.

v4:
  - Change is_remount as bool type in patch 2.
  - Remove the warning reported by Dan for patch 5.
  - Enhance sanity check and fix some coding style suggested by
    Jaegeuk in patch 5.
  - Change the log info when compression option conflicts in patch 5.
  - Fix the issues reported by code-reviewing in patch 5.
  - Context modified in patch 7.

V3: https://lore.kernel.org/all/20250423170926.76007-1-sandeen@redhat.com/
- Rebase onto git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
  dev branch
- Fix up some 0day robot warnings

(Here is the origianl cover letter:)

Since many filesystems have done the new mount API conversion,
we introduce the new mount API conversion in f2fs.

The series can be applied on top of the current mainline tree
and the work is based on the patches from Lukas Czerner (has
done this in ext4[1]). His patch give me a lot of ideas.

Here is a high level description of the patchset:

1. Prepare the f2fs mount parameters required by the new mount
API and use it for parsing, while still using the old API to
get mount options string. Split the parameter parsing and
validation of the parse_options helper into two separate
helpers.

  f2fs: Add fs parameter specifications for mount options
  f2fs: move the option parser into handle_mount_opt

2. Remove the use of sb/sbi structure of f2fs from all the
parsing code, because with the new mount API the parsing is
going to be done before we even get the super block. In this
part, we introduce f2fs_fs_context to hold the temporary
options when parsing. For the simple options check, it has
to be done during parsing by using f2fs_fs_context structure.
For the check which needs sb/sbi, we do this during super
block filling.

  f2fs: Allow sbi to be NULL in f2fs_printk
  f2fs: Add f2fs_fs_context to record the mount options
  f2fs: separate the options parsing and options checking

3. Switch the f2fs to use the new mount API for mount and
remount.

  f2fs: introduce fs_context_operation structure
  f2fs: switch to the new mount api

[1] https://lore.kernel.org/all/20211021114508.21407-1-lczerner@redhat.com/

Hongbo Li (7):
  f2fs: Add fs parameter specifications for mount options
  f2fs: move the option parser into handle_mount_opt
  f2fs: Allow sbi to be NULL in f2fs_printk
  f2fs: Add f2fs_fs_context to record the mount options
  f2fs: separate the options parsing and options checking
  f2fs: introduce fs_context_operation structure
  f2fs: switch to the new mount api

 fs/f2fs/super.c | 2108 +++++++++++++++++++++++++++--------------------
 1 file changed, 1197 insertions(+), 911 deletions(-)

-- 
2.33.0

[PATCH v4 1/7] f2fs: Add fs parameter specifications for mount options

[Hongbo Li]

Use an array of `fs_parameter_spec` called f2fs_param_specs to
hold the mount option specifications for the new mount api.

Add constant_table structures for several options to facilitate
parsing.

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port, minor fixes and updates, more fsparam_enum]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
---
 fs/f2fs/super.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index b71156900892..996633b8379e 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -27,6 +27,7 @@
 #include <linux/part_stat.h>
 #include <linux/zstd.h>
 #include <linux/lz4.h>
+#include <linux/fs_parser.h>
 
 #include "f2fs.h"
 #include "node.h"
@@ -196,9 +197,130 @@ enum {
 	Opt_age_extent_cache,
 	Opt_errors,
 	Opt_nat_bits,
+	Opt_jqfmt,
+	Opt_checkpoint,
 	Opt_err,
 };
 
+static const struct constant_table f2fs_param_background_gc[] = {
+	{"on",		BGGC_MODE_ON},
+	{"off",		BGGC_MODE_OFF},
+	{"sync",	BGGC_MODE_SYNC},
+	{}
+};
+
+static const struct constant_table f2fs_param_mode[] = {
+	{"adaptive",		FS_MODE_ADAPTIVE},
+	{"lfs",			FS_MODE_LFS},
+	{"fragment:segment",	FS_MODE_FRAGMENT_SEG},
+	{"fragment:block",	FS_MODE_FRAGMENT_BLK},
+	{}
+};
+
+static const struct constant_table f2fs_param_jqfmt[] = {
+	{"vfsold",	QFMT_VFS_OLD},
+	{"vfsv0",	QFMT_VFS_V0},
+	{"vfsv1",	QFMT_VFS_V1},
+	{}
+};
+
+static const struct constant_table f2fs_param_alloc_mode[] = {
+	{"default",	ALLOC_MODE_DEFAULT},
+	{"reuse",	ALLOC_MODE_REUSE},
+	{}
+};
+static const struct constant_table f2fs_param_fsync_mode[] = {
+	{"posix",	FSYNC_MODE_POSIX},
+	{"strict",	FSYNC_MODE_STRICT},
+	{"nobarrier",	FSYNC_MODE_NOBARRIER},
+	{}
+};
+
+static const struct constant_table f2fs_param_compress_mode[] = {
+	{"fs",		COMPR_MODE_FS},
+	{"user",	COMPR_MODE_USER},
+	{}
+};
+
+static const struct constant_table f2fs_param_discard_unit[] = {
+	{"block",	DISCARD_UNIT_BLOCK},
+	{"segment",	DISCARD_UNIT_SEGMENT},
+	{"section",	DISCARD_UNIT_SECTION},
+	{}
+};
+
+static const struct constant_table f2fs_param_memory_mode[] = {
+	{"normal",	MEMORY_MODE_NORMAL},
+	{"low",		MEMORY_MODE_LOW},
+	{}
+};
+
+static const struct constant_table f2fs_param_errors[] = {
+	{"remount-ro",	MOUNT_ERRORS_READONLY},
+	{"continue",	MOUNT_ERRORS_CONTINUE},
+	{"panic",	MOUNT_ERRORS_PANIC},
+	{}
+};
+
+static const struct fs_parameter_spec f2fs_param_specs[] = {
+	fsparam_enum("background_gc", Opt_gc_background, f2fs_param_background_gc),
+	fsparam_flag("disable_roll_forward", Opt_disable_roll_forward),
+	fsparam_flag("norecovery", Opt_norecovery),
+	fsparam_flag_no("discard", Opt_discard),
+	fsparam_flag("no_heap", Opt_noheap),
+	fsparam_flag("heap", Opt_heap),
+	fsparam_flag_no("user_xattr", Opt_user_xattr),
+	fsparam_flag_no("acl", Opt_acl),
+	fsparam_s32("active_logs", Opt_active_logs),
+	fsparam_flag("disable_ext_identify", Opt_disable_ext_identify),
+	fsparam_flag_no("inline_xattr", Opt_inline_xattr),
+	fsparam_s32("inline_xattr_size", Opt_inline_xattr_size),
+	fsparam_flag_no("inline_data", Opt_inline_data),
+	fsparam_flag_no("inline_dentry", Opt_inline_dentry),
+	fsparam_flag_no("flush_merge", Opt_flush_merge),
+	fsparam_flag_no("barrier", Opt_barrier),
+	fsparam_flag("fastboot", Opt_fastboot),
+	fsparam_flag_no("extent_cache", Opt_extent_cache),
+	fsparam_flag("data_flush", Opt_data_flush),
+	fsparam_u32("reserve_root", Opt_reserve_root),
+	fsparam_gid("resgid", Opt_resgid),
+	fsparam_uid("resuid", Opt_resuid),
+	fsparam_enum("mode", Opt_mode, f2fs_param_mode),
+	fsparam_s32("fault_injection", Opt_fault_injection),
+	fsparam_u32("fault_type", Opt_fault_type),
+	fsparam_flag_no("lazytime", Opt_lazytime),
+	fsparam_flag_no("quota", Opt_quota),
+	fsparam_flag("usrquota", Opt_usrquota),
+	fsparam_flag("grpquota", Opt_grpquota),
+	fsparam_flag("prjquota", Opt_prjquota),
+	fsparam_string_empty("usrjquota", Opt_usrjquota),
+	fsparam_string_empty("grpjquota", Opt_grpjquota),
+	fsparam_string_empty("prjjquota", Opt_prjjquota),
+	fsparam_flag("nat_bits", Opt_nat_bits),
+	fsparam_enum("jqfmt", Opt_jqfmt, f2fs_param_jqfmt),
+	fsparam_enum("alloc_mode", Opt_alloc, f2fs_param_alloc_mode),
+	fsparam_enum("fsync_mode", Opt_fsync, f2fs_param_fsync_mode),
+	fsparam_string("test_dummy_encryption", Opt_test_dummy_encryption),
+	fsparam_flag("test_dummy_encryption", Opt_test_dummy_encryption),
+	fsparam_flag("inlinecrypt", Opt_inlinecrypt),
+	fsparam_string("checkpoint", Opt_checkpoint),
+	fsparam_flag_no("checkpoint_merge", Opt_checkpoint_merge),
+	fsparam_string("compress_algorithm", Opt_compress_algorithm),
+	fsparam_u32("compress_log_size", Opt_compress_log_size),
+	fsparam_string("compress_extension", Opt_compress_extension),
+	fsparam_string("nocompress_extension", Opt_nocompress_extension),
+	fsparam_flag("compress_chksum", Opt_compress_chksum),
+	fsparam_enum("compress_mode", Opt_compress_mode, f2fs_param_compress_mode),
+	fsparam_flag("compress_cache", Opt_compress_cache),
+	fsparam_flag("atgc", Opt_atgc),
+	fsparam_flag_no("gc_merge", Opt_gc_merge),
+	fsparam_enum("discard_unit", Opt_discard_unit, f2fs_param_discard_unit),
+	fsparam_enum("memory", Opt_memory_mode, f2fs_param_memory_mode),
+	fsparam_flag("age_extent_cache", Opt_age_extent_cache),
+	fsparam_enum("errors", Opt_errors, f2fs_param_errors),
+	{}
+};
+
 static match_table_t f2fs_tokens = {
 	{Opt_gc_background, "background_gc=%s"},
 	{Opt_disable_roll_forward, "disable_roll_forward"},
-- 
2.33.0

[PATCH v4 2/7] f2fs: move the option parser into handle_mount_opt

[Hongbo Li]

In handle_mount_opt, we use fs_parameter to parse each option.
However we're still using the old API to get the options string.
Using fsparams parse_options allows us to remove many of the Opt_
enums, so remove them.

The checkpoint disable cap (or percent) involves rather complex
parsing; we retain the old match_table mechanism for this, which
handles it well.

There are some changes about parsing options:
  1. For `active_logs`, `inline_xattr_size` and `fault_injection`,
     we use s32 type according the internal structure to record the
     option's value.

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port, minor fixes and updates]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
[hongbo: minor cleanup]
Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
---
 fs/f2fs/super.c | 1068 ++++++++++++++++++-----------------------------
 1 file changed, 413 insertions(+), 655 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 996633b8379e..dff2419ba905 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -27,6 +27,7 @@
 #include <linux/part_stat.h>
 #include <linux/zstd.h>
 #include <linux/lz4.h>
+#include <linux/ctype.h>
 #include <linux/fs_parser.h>
 
 #include "f2fs.h"
@@ -126,29 +127,20 @@ enum {
 	Opt_disable_roll_forward,
 	Opt_norecovery,
 	Opt_discard,
-	Opt_nodiscard,
 	Opt_noheap,
 	Opt_heap,
 	Opt_user_xattr,
-	Opt_nouser_xattr,
 	Opt_acl,
-	Opt_noacl,
 	Opt_active_logs,
 	Opt_disable_ext_identify,
 	Opt_inline_xattr,
-	Opt_noinline_xattr,
 	Opt_inline_xattr_size,
 	Opt_inline_data,
 	Opt_inline_dentry,
-	Opt_noinline_dentry,
 	Opt_flush_merge,
-	Opt_noflush_merge,
 	Opt_barrier,
-	Opt_nobarrier,
 	Opt_fastboot,
 	Opt_extent_cache,
-	Opt_noextent_cache,
-	Opt_noinline_data,
 	Opt_data_flush,
 	Opt_reserve_root,
 	Opt_resgid,
@@ -157,21 +149,13 @@ enum {
 	Opt_fault_injection,
 	Opt_fault_type,
 	Opt_lazytime,
-	Opt_nolazytime,
 	Opt_quota,
-	Opt_noquota,
 	Opt_usrquota,
 	Opt_grpquota,
 	Opt_prjquota,
 	Opt_usrjquota,
 	Opt_grpjquota,
 	Opt_prjjquota,
-	Opt_offusrjquota,
-	Opt_offgrpjquota,
-	Opt_offprjjquota,
-	Opt_jqfmt_vfsold,
-	Opt_jqfmt_vfsv0,
-	Opt_jqfmt_vfsv1,
 	Opt_alloc,
 	Opt_fsync,
 	Opt_test_dummy_encryption,
@@ -181,17 +165,15 @@ enum {
 	Opt_checkpoint_disable_cap_perc,
 	Opt_checkpoint_enable,
 	Opt_checkpoint_merge,
-	Opt_nocheckpoint_merge,
 	Opt_compress_algorithm,
 	Opt_compress_log_size,
-	Opt_compress_extension,
 	Opt_nocompress_extension,
+	Opt_compress_extension,
 	Opt_compress_chksum,
 	Opt_compress_mode,
 	Opt_compress_cache,
 	Opt_atgc,
 	Opt_gc_merge,
-	Opt_nogc_merge,
 	Opt_discard_unit,
 	Opt_memory_mode,
 	Opt_age_extent_cache,
@@ -321,83 +303,12 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
 	{}
 };
 
-static match_table_t f2fs_tokens = {
-	{Opt_gc_background, "background_gc=%s"},
-	{Opt_disable_roll_forward, "disable_roll_forward"},
-	{Opt_norecovery, "norecovery"},
-	{Opt_discard, "discard"},
-	{Opt_nodiscard, "nodiscard"},
-	{Opt_noheap, "no_heap"},
-	{Opt_heap, "heap"},
-	{Opt_user_xattr, "user_xattr"},
-	{Opt_nouser_xattr, "nouser_xattr"},
-	{Opt_acl, "acl"},
-	{Opt_noacl, "noacl"},
-	{Opt_active_logs, "active_logs=%u"},
-	{Opt_disable_ext_identify, "disable_ext_identify"},
-	{Opt_inline_xattr, "inline_xattr"},
-	{Opt_noinline_xattr, "noinline_xattr"},
-	{Opt_inline_xattr_size, "inline_xattr_size=%u"},
-	{Opt_inline_data, "inline_data"},
-	{Opt_inline_dentry, "inline_dentry"},
-	{Opt_noinline_dentry, "noinline_dentry"},
-	{Opt_flush_merge, "flush_merge"},
-	{Opt_noflush_merge, "noflush_merge"},
-	{Opt_barrier, "barrier"},
-	{Opt_nobarrier, "nobarrier"},
-	{Opt_fastboot, "fastboot"},
-	{Opt_extent_cache, "extent_cache"},
-	{Opt_noextent_cache, "noextent_cache"},
-	{Opt_noinline_data, "noinline_data"},
-	{Opt_data_flush, "data_flush"},
-	{Opt_reserve_root, "reserve_root=%u"},
-	{Opt_resgid, "resgid=%u"},
-	{Opt_resuid, "resuid=%u"},
-	{Opt_mode, "mode=%s"},
-	{Opt_fault_injection, "fault_injection=%u"},
-	{Opt_fault_type, "fault_type=%u"},
-	{Opt_lazytime, "lazytime"},
-	{Opt_nolazytime, "nolazytime"},
-	{Opt_quota, "quota"},
-	{Opt_noquota, "noquota"},
-	{Opt_usrquota, "usrquota"},
-	{Opt_grpquota, "grpquota"},
-	{Opt_prjquota, "prjquota"},
-	{Opt_usrjquota, "usrjquota=%s"},
-	{Opt_grpjquota, "grpjquota=%s"},
-	{Opt_prjjquota, "prjjquota=%s"},
-	{Opt_offusrjquota, "usrjquota="},
-	{Opt_offgrpjquota, "grpjquota="},
-	{Opt_offprjjquota, "prjjquota="},
-	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
-	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
-	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
-	{Opt_alloc, "alloc_mode=%s"},
-	{Opt_fsync, "fsync_mode=%s"},
-	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
-	{Opt_test_dummy_encryption, "test_dummy_encryption"},
-	{Opt_inlinecrypt, "inlinecrypt"},
-	{Opt_checkpoint_disable, "checkpoint=disable"},
-	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
-	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
-	{Opt_checkpoint_enable, "checkpoint=enable"},
-	{Opt_checkpoint_merge, "checkpoint_merge"},
-	{Opt_nocheckpoint_merge, "nocheckpoint_merge"},
-	{Opt_compress_algorithm, "compress_algorithm=%s"},
-	{Opt_compress_log_size, "compress_log_size=%u"},
-	{Opt_compress_extension, "compress_extension=%s"},
-	{Opt_nocompress_extension, "nocompress_extension=%s"},
-	{Opt_compress_chksum, "compress_chksum"},
-	{Opt_compress_mode, "compress_mode=%s"},
-	{Opt_compress_cache, "compress_cache"},
-	{Opt_atgc, "atgc"},
-	{Opt_gc_merge, "gc_merge"},
-	{Opt_nogc_merge, "nogc_merge"},
-	{Opt_discard_unit, "discard_unit=%s"},
-	{Opt_memory_mode, "memory=%s"},
-	{Opt_age_extent_cache, "age_extent_cache"},
-	{Opt_errors, "errors=%s"},
-	{Opt_nat_bits, "nat_bits"},
+/* Resort to a match_table for this interestingly formatted option */
+static match_table_t f2fs_checkpoint_tokens = {
+	{Opt_checkpoint_disable, "disable"},
+	{Opt_checkpoint_disable_cap, "disable:%u"},
+	{Opt_checkpoint_disable_cap_perc, "disable:%u%%"},
+	{Opt_checkpoint_enable, "enable"},
 	{Opt_err, NULL},
 };
 
@@ -513,7 +424,7 @@ static void init_once(void *foo)
 static const char * const quotatypes[] = INITQFNAMES;
 #define QTYPE2NAME(t) (quotatypes[t])
 static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
-							substring_t *args)
+			    struct fs_parameter *param)
 {
 	struct super_block *sb = sbi->sb;
 	char *qname;
@@ -528,7 +439,7 @@ static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
 		return 0;
 	}
 
-	qname = match_strdup(args);
+	qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
 	if (!qname) {
 		f2fs_err(sbi, "Not enough memory for storing quotafile name");
 		return -ENOMEM;
@@ -613,14 +524,9 @@ static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
 #endif
 
 static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
-					  const char *opt,
-					  const substring_t *arg,
+					  const struct fs_parameter *param,
 					  bool is_remount)
 {
-	struct fs_parameter param = {
-		.type = fs_value_is_string,
-		.string = arg->from ? arg->from : "",
-	};
 	struct fscrypt_dummy_policy *policy =
 		&F2FS_OPTION(sbi).dummy_enc_policy;
 	int err;
@@ -646,17 +552,17 @@ static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
 		return -EINVAL;
 	}
 
-	err = fscrypt_parse_test_dummy_encryption(&param, policy);
+	err = fscrypt_parse_test_dummy_encryption(param, policy);
 	if (err) {
 		if (err == -EEXIST)
 			f2fs_warn(sbi,
 				  "Can't change test_dummy_encryption on remount");
 		else if (err == -EINVAL)
 			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
-				  opt);
+				  param->key);
 		else
 			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
-				  opt, err);
+				  param->key, err);
 		return -EINVAL;
 	}
 	f2fs_warn(sbi, "Test dummy encryption mode enabled");
@@ -799,372 +705,269 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
 #endif
 #endif
 
-static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
+static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 {
-	substring_t args[MAX_OPT_ARGS];
+	struct f2fs_sb_info *sbi = fc->s_fs_info;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	unsigned char (*ext)[F2FS_EXTENSION_LEN];
 	unsigned char (*noext)[F2FS_EXTENSION_LEN];
 	int ext_cnt, noext_cnt;
+	char *name;
 #endif
-	char *p, *name;
-	int arg = 0;
-	kuid_t uid;
-	kgid_t gid;
-	int ret;
+	substring_t args[MAX_OPT_ARGS];
+	struct fs_parse_result result;
+	bool is_remount;
+	int token, ret, arg;
 
-	if (!options)
-		return 0;
+	token = fs_parse(fc, f2fs_param_specs, param, &result);
+	if (token < 0)
+		return token;
 
-	while ((p = strsep(&options, ",")) != NULL) {
-		int token;
+	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
 
-		if (!*p)
-			continue;
-		/*
-		 * Initialize args struct so we know whether arg was
-		 * found; some options take optional arguments.
-		 */
-		args[0].to = args[0].from = NULL;
-		token = match_token(p, f2fs_tokens, args);
-
-		switch (token) {
-		case Opt_gc_background:
-			name = match_strdup(&args[0]);
-
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "on")) {
-				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
-			} else if (!strcmp(name, "off")) {
-				if (f2fs_sb_has_blkzoned(sbi)) {
-					f2fs_warn(sbi, "zoned devices need bggc");
-					kfree(name);
-					return -EINVAL;
-				}
-				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
-			} else if (!strcmp(name, "sync")) {
-				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
-			} else {
-				kfree(name);
+	switch (token) {
+	case Opt_gc_background:
+		F2FS_OPTION(sbi).bggc_mode = result.uint_32;
+		break;
+	case Opt_disable_roll_forward:
+		set_opt(sbi, DISABLE_ROLL_FORWARD);
+		break;
+	case Opt_norecovery:
+		/* requires ro mount, checked in f2fs_validate_options */
+		set_opt(sbi, NORECOVERY);
+		break;
+	case Opt_discard:
+		if (result.negated) {
+			if (f2fs_hw_should_discard(sbi)) {
+				f2fs_warn(sbi, "discard is required for zoned block devices");
 				return -EINVAL;
 			}
-			kfree(name);
-			break;
-		case Opt_disable_roll_forward:
-			set_opt(sbi, DISABLE_ROLL_FORWARD);
-			break;
-		case Opt_norecovery:
-			/* requires ro mount, checked in f2fs_default_check */
-			set_opt(sbi, NORECOVERY);
-			break;
-		case Opt_discard:
+			clear_opt(sbi, DISCARD);
+		} else {
 			if (!f2fs_hw_support_discard(sbi)) {
 				f2fs_warn(sbi, "device does not support discard");
 				break;
 			}
 			set_opt(sbi, DISCARD);
-			break;
-		case Opt_nodiscard:
-			if (f2fs_hw_should_discard(sbi)) {
-				f2fs_warn(sbi, "discard is required for zoned block devices");
-				return -EINVAL;
-			}
-			clear_opt(sbi, DISCARD);
-			break;
-		case Opt_noheap:
-		case Opt_heap:
-			f2fs_warn(sbi, "heap/no_heap options were deprecated");
-			break;
+		}
+		break;
+	case Opt_noheap:
+	case Opt_heap:
+		f2fs_warn(sbi, "heap/no_heap options were deprecated");
+		break;
 #ifdef CONFIG_F2FS_FS_XATTR
-		case Opt_user_xattr:
-			set_opt(sbi, XATTR_USER);
-			break;
-		case Opt_nouser_xattr:
+	case Opt_user_xattr:
+		if (result.negated)
 			clear_opt(sbi, XATTR_USER);
-			break;
-		case Opt_inline_xattr:
-			set_opt(sbi, INLINE_XATTR);
-			break;
-		case Opt_noinline_xattr:
+		else
+			set_opt(sbi, XATTR_USER);
+		break;
+	case Opt_inline_xattr:
+		if (result.negated)
 			clear_opt(sbi, INLINE_XATTR);
-			break;
-		case Opt_inline_xattr_size:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			set_opt(sbi, INLINE_XATTR_SIZE);
-			F2FS_OPTION(sbi).inline_xattr_size = arg;
-			break;
+		else
+			set_opt(sbi, INLINE_XATTR);
+		break;
+	case Opt_inline_xattr_size:
+		set_opt(sbi, INLINE_XATTR_SIZE);
+		F2FS_OPTION(sbi).inline_xattr_size = result.int_32;
+		break;
 #else
-		case Opt_user_xattr:
-		case Opt_nouser_xattr:
-		case Opt_inline_xattr:
-		case Opt_noinline_xattr:
-		case Opt_inline_xattr_size:
-			f2fs_info(sbi, "xattr options not supported");
-			break;
+	case Opt_user_xattr:
+	case Opt_inline_xattr:
+	case Opt_inline_xattr_size:
+		f2fs_info(sbi, "%s options not supported", param->key);
+		break;
 #endif
 #ifdef CONFIG_F2FS_FS_POSIX_ACL
-		case Opt_acl:
-			set_opt(sbi, POSIX_ACL);
-			break;
-		case Opt_noacl:
+	case Opt_acl:
+		if (result.negated)
 			clear_opt(sbi, POSIX_ACL);
-			break;
+		else
+			set_opt(sbi, POSIX_ACL);
+		break;
 #else
-		case Opt_acl:
-		case Opt_noacl:
-			f2fs_info(sbi, "acl options not supported");
-			break;
+	case Opt_acl:
+		f2fs_info(sbi, "%s options not supported", param->key);
+		break;
 #endif
-		case Opt_active_logs:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			if (arg != 2 && arg != 4 &&
-				arg != NR_CURSEG_PERSIST_TYPE)
-				return -EINVAL;
-			F2FS_OPTION(sbi).active_logs = arg;
-			break;
-		case Opt_disable_ext_identify:
-			set_opt(sbi, DISABLE_EXT_IDENTIFY);
-			break;
-		case Opt_inline_data:
+	case Opt_active_logs:
+		if (result.int_32 != 2 && result.int_32 != 4 &&
+			result.int_32 != NR_CURSEG_PERSIST_TYPE)
+			return -EINVAL;
+		F2FS_OPTION(sbi).active_logs = result.int_32;
+		break;
+	case Opt_disable_ext_identify:
+		set_opt(sbi, DISABLE_EXT_IDENTIFY);
+		break;
+	case Opt_inline_data:
+		if (result.negated)
+			clear_opt(sbi, INLINE_DATA);
+		else
 			set_opt(sbi, INLINE_DATA);
-			break;
-		case Opt_inline_dentry:
-			set_opt(sbi, INLINE_DENTRY);
-			break;
-		case Opt_noinline_dentry:
+		break;
+	case Opt_inline_dentry:
+		if (result.negated)
 			clear_opt(sbi, INLINE_DENTRY);
-			break;
-		case Opt_flush_merge:
-			set_opt(sbi, FLUSH_MERGE);
-			break;
-		case Opt_noflush_merge:
+		else
+			set_opt(sbi, INLINE_DENTRY);
+		break;
+	case Opt_flush_merge:
+		if (result.negated)
 			clear_opt(sbi, FLUSH_MERGE);
-			break;
-		case Opt_nobarrier:
+		else
+			set_opt(sbi, FLUSH_MERGE);
+		break;
+	case Opt_barrier:
+		if (result.negated)
 			set_opt(sbi, NOBARRIER);
-			break;
-		case Opt_barrier:
+		else
 			clear_opt(sbi, NOBARRIER);
-			break;
-		case Opt_fastboot:
-			set_opt(sbi, FASTBOOT);
-			break;
-		case Opt_extent_cache:
-			set_opt(sbi, READ_EXTENT_CACHE);
-			break;
-		case Opt_noextent_cache:
+		break;
+	case Opt_fastboot:
+		set_opt(sbi, FASTBOOT);
+		break;
+	case Opt_extent_cache:
+		if (result.negated) {
 			if (f2fs_sb_has_device_alias(sbi)) {
 				f2fs_err(sbi, "device aliasing requires extent cache");
 				return -EINVAL;
 			}
 			clear_opt(sbi, READ_EXTENT_CACHE);
-			break;
-		case Opt_noinline_data:
-			clear_opt(sbi, INLINE_DATA);
-			break;
-		case Opt_data_flush:
-			set_opt(sbi, DATA_FLUSH);
-			break;
-		case Opt_reserve_root:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			if (test_opt(sbi, RESERVE_ROOT)) {
-				f2fs_info(sbi, "Preserve previous reserve_root=%u",
-					  F2FS_OPTION(sbi).root_reserved_blocks);
-			} else {
-				F2FS_OPTION(sbi).root_reserved_blocks = arg;
-				set_opt(sbi, RESERVE_ROOT);
-			}
-			break;
-		case Opt_resuid:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			uid = make_kuid(current_user_ns(), arg);
-			if (!uid_valid(uid)) {
-				f2fs_err(sbi, "Invalid uid value %d", arg);
-				return -EINVAL;
-			}
-			F2FS_OPTION(sbi).s_resuid = uid;
-			break;
-		case Opt_resgid:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			gid = make_kgid(current_user_ns(), arg);
-			if (!gid_valid(gid)) {
-				f2fs_err(sbi, "Invalid gid value %d", arg);
-				return -EINVAL;
-			}
-			F2FS_OPTION(sbi).s_resgid = gid;
-			break;
-		case Opt_mode:
-			name = match_strdup(&args[0]);
-
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "adaptive")) {
-				F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
-			} else if (!strcmp(name, "lfs")) {
-				F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
-			} else if (!strcmp(name, "fragment:segment")) {
-				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;
-			} else if (!strcmp(name, "fragment:block")) {
-				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
-			break;
+		} else
+			set_opt(sbi, READ_EXTENT_CACHE);
+		break;
+	case Opt_data_flush:
+		set_opt(sbi, DATA_FLUSH);
+		break;
+	case Opt_reserve_root:
+		if (test_opt(sbi, RESERVE_ROOT)) {
+			f2fs_info(sbi, "Preserve previous reserve_root=%u",
+				  F2FS_OPTION(sbi).root_reserved_blocks);
+		} else {
+			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
+			set_opt(sbi, RESERVE_ROOT);
+		}
+		break;
+	case Opt_resuid:
+		F2FS_OPTION(sbi).s_resuid = result.uid;
+		break;
+	case Opt_resgid:
+		F2FS_OPTION(sbi).s_resgid = result.gid;
+		break;
+	case Opt_mode:
+		F2FS_OPTION(sbi).fs_mode = result.uint_32;
+		break;
 #ifdef CONFIG_F2FS_FAULT_INJECTION
-		case Opt_fault_injection:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			if (f2fs_build_fault_attr(sbi, arg, 0, FAULT_RATE))
-				return -EINVAL;
-			set_opt(sbi, FAULT_INJECTION);
-			break;
+	case Opt_fault_injection:
+		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
+			return -EINVAL;
+		set_opt(sbi, FAULT_INJECTION);
+		break;
 
-		case Opt_fault_type:
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			if (f2fs_build_fault_attr(sbi, 0, arg, FAULT_TYPE))
-				return -EINVAL;
-			set_opt(sbi, FAULT_INJECTION);
-			break;
+	case Opt_fault_type:
+		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
+			return -EINVAL;
+		set_opt(sbi, FAULT_INJECTION);
+		break;
 #else
-		case Opt_fault_injection:
-		case Opt_fault_type:
-			f2fs_info(sbi, "fault injection options not supported");
-			break;
+	case Opt_fault_injection:
+	case Opt_fault_type:
+		f2fs_info(sbi, "%s options not supported", param->key);
+		break;
 #endif
-		case Opt_lazytime:
-			set_opt(sbi, LAZYTIME);
-			break;
-		case Opt_nolazytime:
+	case Opt_lazytime:
+		if (result.negated)
 			clear_opt(sbi, LAZYTIME);
-			break;
+		else
+			set_opt(sbi, LAZYTIME);
+		break;
 #ifdef CONFIG_QUOTA
-		case Opt_quota:
-		case Opt_usrquota:
-			set_opt(sbi, USRQUOTA);
-			break;
-		case Opt_grpquota:
-			set_opt(sbi, GRPQUOTA);
-			break;
-		case Opt_prjquota:
-			set_opt(sbi, PRJQUOTA);
-			break;
-		case Opt_usrjquota:
-			ret = f2fs_set_qf_name(sbi, USRQUOTA, &args[0]);
-			if (ret)
-				return ret;
-			break;
-		case Opt_grpjquota:
-			ret = f2fs_set_qf_name(sbi, GRPQUOTA, &args[0]);
-			if (ret)
-				return ret;
-			break;
-		case Opt_prjjquota:
-			ret = f2fs_set_qf_name(sbi, PRJQUOTA, &args[0]);
-			if (ret)
-				return ret;
-			break;
-		case Opt_offusrjquota:
-			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
-			if (ret)
-				return ret;
-			break;
-		case Opt_offgrpjquota:
-			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
-			if (ret)
-				return ret;
-			break;
-		case Opt_offprjjquota:
-			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
-			if (ret)
-				return ret;
-			break;
-		case Opt_jqfmt_vfsold:
-			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
-			break;
-		case Opt_jqfmt_vfsv0:
-			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
-			break;
-		case Opt_jqfmt_vfsv1:
-			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
-			break;
-		case Opt_noquota:
+	case Opt_quota:
+		if (result.negated) {
 			clear_opt(sbi, QUOTA);
 			clear_opt(sbi, USRQUOTA);
 			clear_opt(sbi, GRPQUOTA);
 			clear_opt(sbi, PRJQUOTA);
-			break;
+		} else
+			set_opt(sbi, USRQUOTA);
+		break;
+	case Opt_usrquota:
+		set_opt(sbi, USRQUOTA);
+		break;
+	case Opt_grpquota:
+		set_opt(sbi, GRPQUOTA);
+		break;
+	case Opt_prjquota:
+		set_opt(sbi, PRJQUOTA);
+		break;
+	case Opt_usrjquota:
+		if (!*param->string)
+			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
+		else
+			ret = f2fs_set_qf_name(sbi, USRQUOTA, param);
+		if (ret)
+			return ret;
+		break;
+	case Opt_grpjquota:
+		if (!*param->string)
+			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
+		else
+			ret = f2fs_set_qf_name(sbi, GRPQUOTA, param);
+		if (ret)
+			return ret;
+		break;
+	case Opt_prjjquota:
+		if (!*param->string)
+			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
+		else
+			ret = f2fs_set_qf_name(sbi, PRJQUOTA, param);
+		if (ret)
+			return ret;
+		break;
+	case Opt_jqfmt:
+		F2FS_OPTION(sbi).s_jquota_fmt = result.uint_32;
+		break;
 #else
-		case Opt_quota:
-		case Opt_usrquota:
-		case Opt_grpquota:
-		case Opt_prjquota:
-		case Opt_usrjquota:
-		case Opt_grpjquota:
-		case Opt_prjjquota:
-		case Opt_offusrjquota:
-		case Opt_offgrpjquota:
-		case Opt_offprjjquota:
-		case Opt_jqfmt_vfsold:
-		case Opt_jqfmt_vfsv0:
-		case Opt_jqfmt_vfsv1:
-		case Opt_noquota:
-			f2fs_info(sbi, "quota operations not supported");
-			break;
+	case Opt_quota:
+	case Opt_usrquota:
+	case Opt_grpquota:
+	case Opt_prjquota:
+	case Opt_usrjquota:
+	case Opt_grpjquota:
+	case Opt_prjjquota:
+		f2fs_info(sbi, "quota operations not supported");
+		break;
 #endif
-		case Opt_alloc:
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-
-			if (!strcmp(name, "default")) {
-				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
-			} else if (!strcmp(name, "reuse")) {
-				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
-			break;
-		case Opt_fsync:
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "posix")) {
-				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
-			} else if (!strcmp(name, "strict")) {
-				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
-			} else if (!strcmp(name, "nobarrier")) {
-				F2FS_OPTION(sbi).fsync_mode =
-							FSYNC_MODE_NOBARRIER;
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
-			break;
-		case Opt_test_dummy_encryption:
-			ret = f2fs_set_test_dummy_encryption(sbi, p, &args[0],
-							     is_remount);
-			if (ret)
-				return ret;
-			break;
-		case Opt_inlinecrypt:
+	case Opt_alloc:
+		F2FS_OPTION(sbi).alloc_mode = result.uint_32;
+		break;
+	case Opt_fsync:
+		F2FS_OPTION(sbi).fsync_mode = result.uint_32;
+		break;
+	case Opt_test_dummy_encryption:
+		ret = f2fs_set_test_dummy_encryption(sbi, param, is_remount);
+		if (ret)
+			return ret;
+		break;
+	case Opt_inlinecrypt:
 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
-			set_opt(sbi, INLINECRYPT);
+		set_opt(sbi, INLINECRYPT);
 #else
-			f2fs_info(sbi, "inline encryption not supported");
+		f2fs_info(sbi, "inline encryption not supported");
 #endif
-			break;
+		break;
+	case Opt_checkpoint:
+		/*
+		 * Initialize args struct so we know whether arg was
+		 * found; some options take optional arguments.
+		 */
+		args[0].from = args[0].to = NULL;
+		arg = 0;
+
+		/* revert to match_table for checkpoint= options */
+		token = match_token(param->string, f2fs_checkpoint_tokens, args);
+		switch (token) {
 		case Opt_checkpoint_disable_cap_perc:
 			if (args->from && match_int(args, &arg))
 				return -EINVAL;
@@ -1185,270 +988,225 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
 		case Opt_checkpoint_enable:
 			clear_opt(sbi, DISABLE_CHECKPOINT);
 			break;
-		case Opt_checkpoint_merge:
-			set_opt(sbi, MERGE_CHECKPOINT);
-			break;
-		case Opt_nocheckpoint_merge:
+		default:
+			return -EINVAL;
+		}
+		break;
+	case Opt_checkpoint_merge:
+		if (result.negated)
 			clear_opt(sbi, MERGE_CHECKPOINT);
-			break;
+		else
+			set_opt(sbi, MERGE_CHECKPOINT);
+		break;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
-		case Opt_compress_algorithm:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "lzo")) {
+	case Opt_compress_algorithm:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
+			break;
+		}
+		name = param->string;
+		if (!strcmp(name, "lzo")) {
 #ifdef CONFIG_F2FS_FS_LZO
-				F2FS_OPTION(sbi).compress_level = 0;
-				F2FS_OPTION(sbi).compress_algorithm =
-								COMPRESS_LZO;
+			F2FS_OPTION(sbi).compress_level = 0;
+			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
 #else
-				f2fs_info(sbi, "kernel doesn't support lzo compression");
+			f2fs_info(sbi, "kernel doesn't support lzo compression");
 #endif
-			} else if (!strncmp(name, "lz4", 3)) {
+		} else if (!strncmp(name, "lz4", 3)) {
 #ifdef CONFIG_F2FS_FS_LZ4
-				ret = f2fs_set_lz4hc_level(sbi, name);
-				if (ret) {
-					kfree(name);
-					return -EINVAL;
-				}
-				F2FS_OPTION(sbi).compress_algorithm =
-								COMPRESS_LZ4;
+			ret = f2fs_set_lz4hc_level(sbi, name);
+			if (ret)
+				return -EINVAL;
+			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
 #else
-				f2fs_info(sbi, "kernel doesn't support lz4 compression");
+			f2fs_info(sbi, "kernel doesn't support lz4 compression");
 #endif
-			} else if (!strncmp(name, "zstd", 4)) {
+		} else if (!strncmp(name, "zstd", 4)) {
 #ifdef CONFIG_F2FS_FS_ZSTD
-				ret = f2fs_set_zstd_level(sbi, name);
-				if (ret) {
-					kfree(name);
-					return -EINVAL;
-				}
-				F2FS_OPTION(sbi).compress_algorithm =
-								COMPRESS_ZSTD;
+			ret = f2fs_set_zstd_level(sbi, name);
+			if (ret)
+				return -EINVAL;
+			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
 #else
-				f2fs_info(sbi, "kernel doesn't support zstd compression");
+			f2fs_info(sbi, "kernel doesn't support zstd compression");
 #endif
-			} else if (!strcmp(name, "lzo-rle")) {
+		} else if (!strcmp(name, "lzo-rle")) {
 #ifdef CONFIG_F2FS_FS_LZORLE
-				F2FS_OPTION(sbi).compress_level = 0;
-				F2FS_OPTION(sbi).compress_algorithm =
-								COMPRESS_LZORLE;
+			F2FS_OPTION(sbi).compress_level = 0;
+			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
 #else
-				f2fs_info(sbi, "kernel doesn't support lzorle compression");
+			f2fs_info(sbi, "kernel doesn't support lzorle compression");
 #endif
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
+		} else
+			return -EINVAL;
+		break;
+	case Opt_compress_log_size:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
 			break;
-		case Opt_compress_log_size:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			if (args->from && match_int(args, &arg))
-				return -EINVAL;
-			if (arg < MIN_COMPRESS_LOG_SIZE ||
-				arg > MAX_COMPRESS_LOG_SIZE) {
-				f2fs_err(sbi,
-					"Compress cluster log size is out of range");
-				return -EINVAL;
-			}
-			F2FS_OPTION(sbi).compress_log_size = arg;
+		}
+		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
+		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
+			f2fs_err(sbi,
+				"Compress cluster log size is out of range");
+			return -EINVAL;
+		}
+		F2FS_OPTION(sbi).compress_log_size = result.uint_32;
+		break;
+	case Opt_compress_extension:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
 			break;
-		case Opt_compress_extension:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-
-			ext = F2FS_OPTION(sbi).extensions;
-			ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
-
-			if (strlen(name) >= F2FS_EXTENSION_LEN ||
-				ext_cnt >= COMPRESS_EXT_NUM) {
-				f2fs_err(sbi,
-					"invalid extension length/number");
-				kfree(name);
-				return -EINVAL;
-			}
+		}
+		name = param->string;
+		ext = F2FS_OPTION(sbi).extensions;
+		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
 
-			if (is_compress_extension_exist(sbi, name, true)) {
-				kfree(name);
-				break;
-			}
+		if (strlen(name) >= F2FS_EXTENSION_LEN ||
+		    ext_cnt >= COMPRESS_EXT_NUM) {
+			f2fs_err(sbi, "invalid extension length/number");
+			return -EINVAL;
+		}
 
-			ret = strscpy(ext[ext_cnt], name);
-			if (ret < 0) {
-				kfree(name);
-				return ret;
-			}
-			F2FS_OPTION(sbi).compress_ext_cnt++;
-			kfree(name);
+		if (is_compress_extension_exist(sbi, name, true))
 			break;
-		case Opt_nocompress_extension:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-
-			noext = F2FS_OPTION(sbi).noextensions;
-			noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
 
-			if (strlen(name) >= F2FS_EXTENSION_LEN ||
-				noext_cnt >= COMPRESS_EXT_NUM) {
-				f2fs_err(sbi,
-					"invalid extension length/number");
-				kfree(name);
-				return -EINVAL;
-			}
+		ret = strscpy(ext[ext_cnt], name, F2FS_EXTENSION_LEN);
+		if (ret < 0)
+			return ret;
+		F2FS_OPTION(sbi).compress_ext_cnt++;
+		break;
+	case Opt_nocompress_extension:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
+			break;
+		}
+		name = param->string;
+		noext = F2FS_OPTION(sbi).noextensions;
+		noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
 
-			if (is_compress_extension_exist(sbi, name, false)) {
-				kfree(name);
-				break;
-			}
+		if (strlen(name) >= F2FS_EXTENSION_LEN ||
+			noext_cnt >= COMPRESS_EXT_NUM) {
+			f2fs_err(sbi, "invalid extension length/number");
+			return -EINVAL;
+		}
 
-			ret = strscpy(noext[noext_cnt], name);
-			if (ret < 0) {
-				kfree(name);
-				return ret;
-			}
-			F2FS_OPTION(sbi).nocompress_ext_cnt++;
-			kfree(name);
+		if (is_compress_extension_exist(sbi, name, false))
 			break;
-		case Opt_compress_chksum:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			F2FS_OPTION(sbi).compress_chksum = true;
+
+		ret = strscpy(noext[noext_cnt], name, F2FS_EXTENSION_LEN);
+		if (ret < 0)
+			return ret;
+		F2FS_OPTION(sbi).nocompress_ext_cnt++;
+		break;
+	case Opt_compress_chksum:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
 			break;
-		case Opt_compress_mode:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "fs")) {
-				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
-			} else if (!strcmp(name, "user")) {
-				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
+		}
+		F2FS_OPTION(sbi).compress_chksum = true;
+		break;
+	case Opt_compress_mode:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
 			break;
-		case Opt_compress_cache:
-			if (!f2fs_sb_has_compression(sbi)) {
-				f2fs_info(sbi, "Image doesn't support compression");
-				break;
-			}
-			set_opt(sbi, COMPRESS_CACHE);
+		}
+		F2FS_OPTION(sbi).compress_mode = result.uint_32;
+		break;
+	case Opt_compress_cache:
+		if (!f2fs_sb_has_compression(sbi)) {
+			f2fs_info(sbi, "Image doesn't support compression");
 			break;
+		}
+		set_opt(sbi, COMPRESS_CACHE);
+		break;
 #else
-		case Opt_compress_algorithm:
-		case Opt_compress_log_size:
-		case Opt_compress_extension:
-		case Opt_nocompress_extension:
-		case Opt_compress_chksum:
-		case Opt_compress_mode:
-		case Opt_compress_cache:
-			f2fs_info(sbi, "compression options not supported");
-			break;
+	case Opt_compress_algorithm:
+	case Opt_compress_log_size:
+	case Opt_compress_extension:
+	case Opt_nocompress_extension:
+	case Opt_compress_chksum:
+	case Opt_compress_mode:
+	case Opt_compress_cache:
+		f2fs_info(sbi, "compression options not supported");
+		break;
 #endif
-		case Opt_atgc:
-			set_opt(sbi, ATGC);
-			break;
-		case Opt_gc_merge:
-			set_opt(sbi, GC_MERGE);
-			break;
-		case Opt_nogc_merge:
+	case Opt_atgc:
+		set_opt(sbi, ATGC);
+		break;
+	case Opt_gc_merge:
+		if (result.negated)
 			clear_opt(sbi, GC_MERGE);
-			break;
-		case Opt_discard_unit:
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "block")) {
-				F2FS_OPTION(sbi).discard_unit =
-						DISCARD_UNIT_BLOCK;
-			} else if (!strcmp(name, "segment")) {
-				F2FS_OPTION(sbi).discard_unit =
-						DISCARD_UNIT_SEGMENT;
-			} else if (!strcmp(name, "section")) {
-				F2FS_OPTION(sbi).discard_unit =
-						DISCARD_UNIT_SECTION;
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
-			break;
-		case Opt_memory_mode:
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "normal")) {
-				F2FS_OPTION(sbi).memory_mode =
-						MEMORY_MODE_NORMAL;
-			} else if (!strcmp(name, "low")) {
-				F2FS_OPTION(sbi).memory_mode =
-						MEMORY_MODE_LOW;
-			} else {
-				kfree(name);
-				return -EINVAL;
-			}
-			kfree(name);
-			break;
-		case Opt_age_extent_cache:
-			set_opt(sbi, AGE_EXTENT_CACHE);
-			break;
-		case Opt_errors:
-			name = match_strdup(&args[0]);
-			if (!name)
-				return -ENOMEM;
-			if (!strcmp(name, "remount-ro")) {
-				F2FS_OPTION(sbi).errors =
-						MOUNT_ERRORS_READONLY;
-			} else if (!strcmp(name, "continue")) {
-				F2FS_OPTION(sbi).errors =
-						MOUNT_ERRORS_CONTINUE;
-			} else if (!strcmp(name, "panic")) {
-				F2FS_OPTION(sbi).errors =
-						MOUNT_ERRORS_PANIC;
-			} else {
-				kfree(name);
-				return -EINVAL;
+		else
+			set_opt(sbi, GC_MERGE);
+		break;
+	case Opt_discard_unit:
+		F2FS_OPTION(sbi).discard_unit = result.uint_32;
+		break;
+	case Opt_memory_mode:
+		F2FS_OPTION(sbi).memory_mode = result.uint_32;
+		break;
+	case Opt_age_extent_cache:
+		set_opt(sbi, AGE_EXTENT_CACHE);
+		break;
+	case Opt_errors:
+		F2FS_OPTION(sbi).errors = result.uint_32;
+		break;
+	case Opt_nat_bits:
+		set_opt(sbi, NAT_BITS);
+		break;
+	}
+	return 0;
+}
+
+static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
+{
+	struct fs_parameter param;
+	struct fs_context fc;
+	char *key;
+	int ret;
+
+	if (!options)
+		return 0;
+
+	memset(&fc, 0, sizeof(fc));
+	fc.s_fs_info = sbi;
+	if (is_remount)
+		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
+
+	while ((key = strsep(&options, ",")) != NULL) {
+		if (*key) {
+			size_t v_len = 0;
+			char *value = strchr(key, '=');
+
+			param.type = fs_value_is_flag;
+			param.string = NULL;
+
+			if (value) {
+				if (value == key)
+					continue;
+
+				*value++ = 0;
+				v_len = strlen(value);
+				param.string = kmemdup_nul(value, v_len, GFP_KERNEL);
+				if (!param.string)
+					return -ENOMEM;
+				param.type = fs_value_is_string;
 			}
-			kfree(name);
-			break;
-		case Opt_nat_bits:
-			set_opt(sbi, NAT_BITS);
-			break;
-		default:
-			f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
-				 p);
-			return -EINVAL;
+
+			param.key = key;
+			param.size = v_len;
+
+			ret = handle_mount_opt(&fc, &param);
+			kfree(param.string);
+			if (ret < 0)
+				return ret;
 		}
 	}
 	return 0;
 }
 
-static int f2fs_default_check(struct f2fs_sb_info *sbi)
+static int f2fs_validate_options(struct f2fs_sb_info *sbi)
 {
 #ifdef CONFIG_QUOTA
 	if (f2fs_check_quota_options(sbi))
@@ -2527,7 +2285,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	}
 #endif
 
-	err = f2fs_default_check(sbi);
+	err = f2fs_validate_options(sbi);
 	if (err)
 		goto restore_opts;
 
@@ -4725,7 +4483,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 	if (err)
 		goto free_options;
 
-	err = f2fs_default_check(sbi);
+	err = f2fs_validate_options(sbi);
 	if (err)
 		goto free_options;
 
-- 
2.33.0

Re: [PATCH v4 2/7] f2fs: move the option parser into handle_mount_opt

[Chao Yu]

On 6/2/25 17:02, Hongbo Li wrote:
> In handle_mount_opt, we use fs_parameter to parse each option.
> However we're still using the old API to get the options string.
> Using fsparams parse_options allows us to remove many of the Opt_
> enums, so remove them.
> 
> The checkpoint disable cap (or percent) involves rather complex
> parsing; we retain the old match_table mechanism for this, which
> handles it well.
> 
> There are some changes about parsing options:
>   1. For `active_logs`, `inline_xattr_size` and `fault_injection`,
>      we use s32 type according the internal structure to record the
>      option's value.
> 
> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
> [sandeen: forward port, minor fixes and updates]
> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
> [hongbo: minor cleanup]
> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
> ---
>  fs/f2fs/super.c | 1068 ++++++++++++++++++-----------------------------
>  1 file changed, 413 insertions(+), 655 deletions(-)
> 
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 996633b8379e..dff2419ba905 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -27,6 +27,7 @@
>  #include <linux/part_stat.h>
>  #include <linux/zstd.h>
>  #include <linux/lz4.h>
> +#include <linux/ctype.h>
>  #include <linux/fs_parser.h>
>  
>  #include "f2fs.h"
> @@ -126,29 +127,20 @@ enum {
>  	Opt_disable_roll_forward,
>  	Opt_norecovery,
>  	Opt_discard,
> -	Opt_nodiscard,
>  	Opt_noheap,
>  	Opt_heap,
>  	Opt_user_xattr,
> -	Opt_nouser_xattr,
>  	Opt_acl,
> -	Opt_noacl,
>  	Opt_active_logs,
>  	Opt_disable_ext_identify,
>  	Opt_inline_xattr,
> -	Opt_noinline_xattr,
>  	Opt_inline_xattr_size,
>  	Opt_inline_data,
>  	Opt_inline_dentry,
> -	Opt_noinline_dentry,
>  	Opt_flush_merge,
> -	Opt_noflush_merge,
>  	Opt_barrier,
> -	Opt_nobarrier,
>  	Opt_fastboot,
>  	Opt_extent_cache,
> -	Opt_noextent_cache,
> -	Opt_noinline_data,
>  	Opt_data_flush,
>  	Opt_reserve_root,
>  	Opt_resgid,
> @@ -157,21 +149,13 @@ enum {
>  	Opt_fault_injection,
>  	Opt_fault_type,
>  	Opt_lazytime,
> -	Opt_nolazytime,
>  	Opt_quota,
> -	Opt_noquota,
>  	Opt_usrquota,
>  	Opt_grpquota,
>  	Opt_prjquota,
>  	Opt_usrjquota,
>  	Opt_grpjquota,
>  	Opt_prjjquota,
> -	Opt_offusrjquota,
> -	Opt_offgrpjquota,
> -	Opt_offprjjquota,
> -	Opt_jqfmt_vfsold,
> -	Opt_jqfmt_vfsv0,
> -	Opt_jqfmt_vfsv1,
>  	Opt_alloc,
>  	Opt_fsync,
>  	Opt_test_dummy_encryption,
> @@ -181,17 +165,15 @@ enum {
>  	Opt_checkpoint_disable_cap_perc,
>  	Opt_checkpoint_enable,
>  	Opt_checkpoint_merge,
> -	Opt_nocheckpoint_merge,
>  	Opt_compress_algorithm,
>  	Opt_compress_log_size,
> -	Opt_compress_extension,
>  	Opt_nocompress_extension,
> +	Opt_compress_extension,
>  	Opt_compress_chksum,
>  	Opt_compress_mode,
>  	Opt_compress_cache,
>  	Opt_atgc,
>  	Opt_gc_merge,
> -	Opt_nogc_merge,
>  	Opt_discard_unit,
>  	Opt_memory_mode,
>  	Opt_age_extent_cache,
> @@ -321,83 +303,12 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
>  	{}
>  };
>  
> -static match_table_t f2fs_tokens = {
> -	{Opt_gc_background, "background_gc=%s"},
> -	{Opt_disable_roll_forward, "disable_roll_forward"},
> -	{Opt_norecovery, "norecovery"},
> -	{Opt_discard, "discard"},
> -	{Opt_nodiscard, "nodiscard"},
> -	{Opt_noheap, "no_heap"},
> -	{Opt_heap, "heap"},
> -	{Opt_user_xattr, "user_xattr"},
> -	{Opt_nouser_xattr, "nouser_xattr"},
> -	{Opt_acl, "acl"},
> -	{Opt_noacl, "noacl"},
> -	{Opt_active_logs, "active_logs=%u"},
> -	{Opt_disable_ext_identify, "disable_ext_identify"},
> -	{Opt_inline_xattr, "inline_xattr"},
> -	{Opt_noinline_xattr, "noinline_xattr"},
> -	{Opt_inline_xattr_size, "inline_xattr_size=%u"},
> -	{Opt_inline_data, "inline_data"},
> -	{Opt_inline_dentry, "inline_dentry"},
> -	{Opt_noinline_dentry, "noinline_dentry"},
> -	{Opt_flush_merge, "flush_merge"},
> -	{Opt_noflush_merge, "noflush_merge"},
> -	{Opt_barrier, "barrier"},
> -	{Opt_nobarrier, "nobarrier"},
> -	{Opt_fastboot, "fastboot"},
> -	{Opt_extent_cache, "extent_cache"},
> -	{Opt_noextent_cache, "noextent_cache"},
> -	{Opt_noinline_data, "noinline_data"},
> -	{Opt_data_flush, "data_flush"},
> -	{Opt_reserve_root, "reserve_root=%u"},
> -	{Opt_resgid, "resgid=%u"},
> -	{Opt_resuid, "resuid=%u"},
> -	{Opt_mode, "mode=%s"},
> -	{Opt_fault_injection, "fault_injection=%u"},
> -	{Opt_fault_type, "fault_type=%u"},
> -	{Opt_lazytime, "lazytime"},
> -	{Opt_nolazytime, "nolazytime"},
> -	{Opt_quota, "quota"},
> -	{Opt_noquota, "noquota"},
> -	{Opt_usrquota, "usrquota"},
> -	{Opt_grpquota, "grpquota"},
> -	{Opt_prjquota, "prjquota"},
> -	{Opt_usrjquota, "usrjquota=%s"},
> -	{Opt_grpjquota, "grpjquota=%s"},
> -	{Opt_prjjquota, "prjjquota=%s"},
> -	{Opt_offusrjquota, "usrjquota="},
> -	{Opt_offgrpjquota, "grpjquota="},
> -	{Opt_offprjjquota, "prjjquota="},
> -	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
> -	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
> -	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
> -	{Opt_alloc, "alloc_mode=%s"},
> -	{Opt_fsync, "fsync_mode=%s"},
> -	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
> -	{Opt_test_dummy_encryption, "test_dummy_encryption"},
> -	{Opt_inlinecrypt, "inlinecrypt"},
> -	{Opt_checkpoint_disable, "checkpoint=disable"},
> -	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
> -	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
> -	{Opt_checkpoint_enable, "checkpoint=enable"},
> -	{Opt_checkpoint_merge, "checkpoint_merge"},
> -	{Opt_nocheckpoint_merge, "nocheckpoint_merge"},
> -	{Opt_compress_algorithm, "compress_algorithm=%s"},
> -	{Opt_compress_log_size, "compress_log_size=%u"},
> -	{Opt_compress_extension, "compress_extension=%s"},
> -	{Opt_nocompress_extension, "nocompress_extension=%s"},
> -	{Opt_compress_chksum, "compress_chksum"},
> -	{Opt_compress_mode, "compress_mode=%s"},
> -	{Opt_compress_cache, "compress_cache"},
> -	{Opt_atgc, "atgc"},
> -	{Opt_gc_merge, "gc_merge"},
> -	{Opt_nogc_merge, "nogc_merge"},
> -	{Opt_discard_unit, "discard_unit=%s"},
> -	{Opt_memory_mode, "memory=%s"},
> -	{Opt_age_extent_cache, "age_extent_cache"},
> -	{Opt_errors, "errors=%s"},
> -	{Opt_nat_bits, "nat_bits"},
> +/* Resort to a match_table for this interestingly formatted option */
> +static match_table_t f2fs_checkpoint_tokens = {
> +	{Opt_checkpoint_disable, "disable"},
> +	{Opt_checkpoint_disable_cap, "disable:%u"},
> +	{Opt_checkpoint_disable_cap_perc, "disable:%u%%"},
> +	{Opt_checkpoint_enable, "enable"},
>  	{Opt_err, NULL},
>  };
>  
> @@ -513,7 +424,7 @@ static void init_once(void *foo)
>  static const char * const quotatypes[] = INITQFNAMES;
>  #define QTYPE2NAME(t) (quotatypes[t])
>  static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
> -							substring_t *args)
> +			    struct fs_parameter *param)
>  {
>  	struct super_block *sb = sbi->sb;
>  	char *qname;
> @@ -528,7 +439,7 @@ static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
>  		return 0;
>  	}
>  
> -	qname = match_strdup(args);
> +	qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
>  	if (!qname) {
>  		f2fs_err(sbi, "Not enough memory for storing quotafile name");
>  		return -ENOMEM;
> @@ -613,14 +524,9 @@ static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
>  #endif
>  
>  static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
> -					  const char *opt,
> -					  const substring_t *arg,
> +					  const struct fs_parameter *param,
>  					  bool is_remount)
>  {
> -	struct fs_parameter param = {
> -		.type = fs_value_is_string,
> -		.string = arg->from ? arg->from : "",
> -	};
>  	struct fscrypt_dummy_policy *policy =
>  		&F2FS_OPTION(sbi).dummy_enc_policy;
>  	int err;
> @@ -646,17 +552,17 @@ static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
>  		return -EINVAL;
>  	}
>  
> -	err = fscrypt_parse_test_dummy_encryption(&param, policy);
> +	err = fscrypt_parse_test_dummy_encryption(param, policy);
>  	if (err) {
>  		if (err == -EEXIST)
>  			f2fs_warn(sbi,
>  				  "Can't change test_dummy_encryption on remount");
>  		else if (err == -EINVAL)
>  			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
> -				  opt);
> +				  param->key);
>  		else
>  			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
> -				  opt, err);
> +				  param->key, err);
>  		return -EINVAL;
>  	}
>  	f2fs_warn(sbi, "Test dummy encryption mode enabled");
> @@ -799,372 +705,269 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
>  #endif
>  #endif
>  
> -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
> +static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  {
> -	substring_t args[MAX_OPT_ARGS];
> +	struct f2fs_sb_info *sbi = fc->s_fs_info;
>  #ifdef CONFIG_F2FS_FS_COMPRESSION
>  	unsigned char (*ext)[F2FS_EXTENSION_LEN];
>  	unsigned char (*noext)[F2FS_EXTENSION_LEN];
>  	int ext_cnt, noext_cnt;
> +	char *name;
>  #endif
> -	char *p, *name;
> -	int arg = 0;
> -	kuid_t uid;
> -	kgid_t gid;
> -	int ret;
> +	substring_t args[MAX_OPT_ARGS];
> +	struct fs_parse_result result;
> +	bool is_remount;
> +	int token, ret, arg;
>  
> -	if (!options)
> -		return 0;
> +	token = fs_parse(fc, f2fs_param_specs, param, &result);
> +	if (token < 0)
> +		return token;
>  
> -	while ((p = strsep(&options, ",")) != NULL) {
> -		int token;
> +	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
>  
> -		if (!*p)
> -			continue;
> -		/*
> -		 * Initialize args struct so we know whether arg was
> -		 * found; some options take optional arguments.
> -		 */
> -		args[0].to = args[0].from = NULL;
> -		token = match_token(p, f2fs_tokens, args);
> -
> -		switch (token) {
> -		case Opt_gc_background:
> -			name = match_strdup(&args[0]);
> -
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "on")) {
> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
> -			} else if (!strcmp(name, "off")) {
> -				if (f2fs_sb_has_blkzoned(sbi)) {
> -					f2fs_warn(sbi, "zoned devices need bggc");
> -					kfree(name);
> -					return -EINVAL;
> -				}

Missed to check this condition in f2fs_check_opt_consistency()?

Thanks,

> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
> -			} else if (!strcmp(name, "sync")) {
> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
> -			} else {
> -				kfree(name);
> +	switch (token) {
> +	case Opt_gc_background:
> +		F2FS_OPTION(sbi).bggc_mode = result.uint_32;
> +		break;
> +	case Opt_disable_roll_forward:
> +		set_opt(sbi, DISABLE_ROLL_FORWARD);
> +		break;
> +	case Opt_norecovery:
> +		/* requires ro mount, checked in f2fs_validate_options */
> +		set_opt(sbi, NORECOVERY);
> +		break;
> +	case Opt_discard:
> +		if (result.negated) {
> +			if (f2fs_hw_should_discard(sbi)) {
> +				f2fs_warn(sbi, "discard is required for zoned block devices");
>  				return -EINVAL;
>  			}
> -			kfree(name);
> -			break;
> -		case Opt_disable_roll_forward:
> -			set_opt(sbi, DISABLE_ROLL_FORWARD);
> -			break;
> -		case Opt_norecovery:
> -			/* requires ro mount, checked in f2fs_default_check */
> -			set_opt(sbi, NORECOVERY);
> -			break;
> -		case Opt_discard:
> +			clear_opt(sbi, DISCARD);
> +		} else {
>  			if (!f2fs_hw_support_discard(sbi)) {
>  				f2fs_warn(sbi, "device does not support discard");
>  				break;
>  			}
>  			set_opt(sbi, DISCARD);
> -			break;
> -		case Opt_nodiscard:
> -			if (f2fs_hw_should_discard(sbi)) {
> -				f2fs_warn(sbi, "discard is required for zoned block devices");
> -				return -EINVAL;
> -			}
> -			clear_opt(sbi, DISCARD);
> -			break;
> -		case Opt_noheap:
> -		case Opt_heap:
> -			f2fs_warn(sbi, "heap/no_heap options were deprecated");
> -			break;
> +		}
> +		break;
> +	case Opt_noheap:
> +	case Opt_heap:
> +		f2fs_warn(sbi, "heap/no_heap options were deprecated");
> +		break;
>  #ifdef CONFIG_F2FS_FS_XATTR
> -		case Opt_user_xattr:
> -			set_opt(sbi, XATTR_USER);
> -			break;
> -		case Opt_nouser_xattr:
> +	case Opt_user_xattr:
> +		if (result.negated)
>  			clear_opt(sbi, XATTR_USER);
> -			break;
> -		case Opt_inline_xattr:
> -			set_opt(sbi, INLINE_XATTR);
> -			break;
> -		case Opt_noinline_xattr:
> +		else
> +			set_opt(sbi, XATTR_USER);
> +		break;
> +	case Opt_inline_xattr:
> +		if (result.negated)
>  			clear_opt(sbi, INLINE_XATTR);
> -			break;
> -		case Opt_inline_xattr_size:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			set_opt(sbi, INLINE_XATTR_SIZE);
> -			F2FS_OPTION(sbi).inline_xattr_size = arg;
> -			break;
> +		else
> +			set_opt(sbi, INLINE_XATTR);
> +		break;
> +	case Opt_inline_xattr_size:
> +		set_opt(sbi, INLINE_XATTR_SIZE);
> +		F2FS_OPTION(sbi).inline_xattr_size = result.int_32;
> +		break;
>  #else
> -		case Opt_user_xattr:
> -		case Opt_nouser_xattr:
> -		case Opt_inline_xattr:
> -		case Opt_noinline_xattr:
> -		case Opt_inline_xattr_size:
> -			f2fs_info(sbi, "xattr options not supported");
> -			break;
> +	case Opt_user_xattr:
> +	case Opt_inline_xattr:
> +	case Opt_inline_xattr_size:
> +		f2fs_info(sbi, "%s options not supported", param->key);
> +		break;
>  #endif
>  #ifdef CONFIG_F2FS_FS_POSIX_ACL
> -		case Opt_acl:
> -			set_opt(sbi, POSIX_ACL);
> -			break;
> -		case Opt_noacl:
> +	case Opt_acl:
> +		if (result.negated)
>  			clear_opt(sbi, POSIX_ACL);
> -			break;
> +		else
> +			set_opt(sbi, POSIX_ACL);
> +		break;
>  #else
> -		case Opt_acl:
> -		case Opt_noacl:
> -			f2fs_info(sbi, "acl options not supported");
> -			break;
> +	case Opt_acl:
> +		f2fs_info(sbi, "%s options not supported", param->key);
> +		break;
>  #endif
> -		case Opt_active_logs:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			if (arg != 2 && arg != 4 &&
> -				arg != NR_CURSEG_PERSIST_TYPE)
> -				return -EINVAL;
> -			F2FS_OPTION(sbi).active_logs = arg;
> -			break;
> -		case Opt_disable_ext_identify:
> -			set_opt(sbi, DISABLE_EXT_IDENTIFY);
> -			break;
> -		case Opt_inline_data:
> +	case Opt_active_logs:
> +		if (result.int_32 != 2 && result.int_32 != 4 &&
> +			result.int_32 != NR_CURSEG_PERSIST_TYPE)
> +			return -EINVAL;
> +		F2FS_OPTION(sbi).active_logs = result.int_32;
> +		break;
> +	case Opt_disable_ext_identify:
> +		set_opt(sbi, DISABLE_EXT_IDENTIFY);
> +		break;
> +	case Opt_inline_data:
> +		if (result.negated)
> +			clear_opt(sbi, INLINE_DATA);
> +		else
>  			set_opt(sbi, INLINE_DATA);
> -			break;
> -		case Opt_inline_dentry:
> -			set_opt(sbi, INLINE_DENTRY);
> -			break;
> -		case Opt_noinline_dentry:
> +		break;
> +	case Opt_inline_dentry:
> +		if (result.negated)
>  			clear_opt(sbi, INLINE_DENTRY);
> -			break;
> -		case Opt_flush_merge:
> -			set_opt(sbi, FLUSH_MERGE);
> -			break;
> -		case Opt_noflush_merge:
> +		else
> +			set_opt(sbi, INLINE_DENTRY);
> +		break;
> +	case Opt_flush_merge:
> +		if (result.negated)
>  			clear_opt(sbi, FLUSH_MERGE);
> -			break;
> -		case Opt_nobarrier:
> +		else
> +			set_opt(sbi, FLUSH_MERGE);
> +		break;
> +	case Opt_barrier:
> +		if (result.negated)
>  			set_opt(sbi, NOBARRIER);
> -			break;
> -		case Opt_barrier:
> +		else
>  			clear_opt(sbi, NOBARRIER);
> -			break;
> -		case Opt_fastboot:
> -			set_opt(sbi, FASTBOOT);
> -			break;
> -		case Opt_extent_cache:
> -			set_opt(sbi, READ_EXTENT_CACHE);
> -			break;
> -		case Opt_noextent_cache:
> +		break;
> +	case Opt_fastboot:
> +		set_opt(sbi, FASTBOOT);
> +		break;
> +	case Opt_extent_cache:
> +		if (result.negated) {
>  			if (f2fs_sb_has_device_alias(sbi)) {
>  				f2fs_err(sbi, "device aliasing requires extent cache");
>  				return -EINVAL;
>  			}
>  			clear_opt(sbi, READ_EXTENT_CACHE);
> -			break;
> -		case Opt_noinline_data:
> -			clear_opt(sbi, INLINE_DATA);
> -			break;
> -		case Opt_data_flush:
> -			set_opt(sbi, DATA_FLUSH);
> -			break;
> -		case Opt_reserve_root:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			if (test_opt(sbi, RESERVE_ROOT)) {
> -				f2fs_info(sbi, "Preserve previous reserve_root=%u",
> -					  F2FS_OPTION(sbi).root_reserved_blocks);
> -			} else {
> -				F2FS_OPTION(sbi).root_reserved_blocks = arg;
> -				set_opt(sbi, RESERVE_ROOT);
> -			}
> -			break;
> -		case Opt_resuid:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			uid = make_kuid(current_user_ns(), arg);
> -			if (!uid_valid(uid)) {
> -				f2fs_err(sbi, "Invalid uid value %d", arg);
> -				return -EINVAL;
> -			}
> -			F2FS_OPTION(sbi).s_resuid = uid;
> -			break;
> -		case Opt_resgid:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			gid = make_kgid(current_user_ns(), arg);
> -			if (!gid_valid(gid)) {
> -				f2fs_err(sbi, "Invalid gid value %d", arg);
> -				return -EINVAL;
> -			}
> -			F2FS_OPTION(sbi).s_resgid = gid;
> -			break;
> -		case Opt_mode:
> -			name = match_strdup(&args[0]);
> -
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "adaptive")) {
> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
> -			} else if (!strcmp(name, "lfs")) {
> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
> -			} else if (!strcmp(name, "fragment:segment")) {
> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;
> -			} else if (!strcmp(name, "fragment:block")) {
> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> -			break;
> +		} else
> +			set_opt(sbi, READ_EXTENT_CACHE);
> +		break;
> +	case Opt_data_flush:
> +		set_opt(sbi, DATA_FLUSH);
> +		break;
> +	case Opt_reserve_root:
> +		if (test_opt(sbi, RESERVE_ROOT)) {
> +			f2fs_info(sbi, "Preserve previous reserve_root=%u",
> +				  F2FS_OPTION(sbi).root_reserved_blocks);
> +		} else {
> +			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
> +			set_opt(sbi, RESERVE_ROOT);
> +		}
> +		break;
> +	case Opt_resuid:
> +		F2FS_OPTION(sbi).s_resuid = result.uid;
> +		break;
> +	case Opt_resgid:
> +		F2FS_OPTION(sbi).s_resgid = result.gid;
> +		break;
> +	case Opt_mode:
> +		F2FS_OPTION(sbi).fs_mode = result.uint_32;
> +		break;
>  #ifdef CONFIG_F2FS_FAULT_INJECTION
> -		case Opt_fault_injection:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			if (f2fs_build_fault_attr(sbi, arg, 0, FAULT_RATE))
> -				return -EINVAL;
> -			set_opt(sbi, FAULT_INJECTION);
> -			break;
> +	case Opt_fault_injection:
> +		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
> +			return -EINVAL;
> +		set_opt(sbi, FAULT_INJECTION);
> +		break;
>  
> -		case Opt_fault_type:
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			if (f2fs_build_fault_attr(sbi, 0, arg, FAULT_TYPE))
> -				return -EINVAL;
> -			set_opt(sbi, FAULT_INJECTION);
> -			break;
> +	case Opt_fault_type:
> +		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
> +			return -EINVAL;
> +		set_opt(sbi, FAULT_INJECTION);
> +		break;
>  #else
> -		case Opt_fault_injection:
> -		case Opt_fault_type:
> -			f2fs_info(sbi, "fault injection options not supported");
> -			break;
> +	case Opt_fault_injection:
> +	case Opt_fault_type:
> +		f2fs_info(sbi, "%s options not supported", param->key);
> +		break;
>  #endif
> -		case Opt_lazytime:
> -			set_opt(sbi, LAZYTIME);
> -			break;
> -		case Opt_nolazytime:
> +	case Opt_lazytime:
> +		if (result.negated)
>  			clear_opt(sbi, LAZYTIME);
> -			break;
> +		else
> +			set_opt(sbi, LAZYTIME);
> +		break;
>  #ifdef CONFIG_QUOTA
> -		case Opt_quota:
> -		case Opt_usrquota:
> -			set_opt(sbi, USRQUOTA);
> -			break;
> -		case Opt_grpquota:
> -			set_opt(sbi, GRPQUOTA);
> -			break;
> -		case Opt_prjquota:
> -			set_opt(sbi, PRJQUOTA);
> -			break;
> -		case Opt_usrjquota:
> -			ret = f2fs_set_qf_name(sbi, USRQUOTA, &args[0]);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_grpjquota:
> -			ret = f2fs_set_qf_name(sbi, GRPQUOTA, &args[0]);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_prjjquota:
> -			ret = f2fs_set_qf_name(sbi, PRJQUOTA, &args[0]);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_offusrjquota:
> -			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_offgrpjquota:
> -			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_offprjjquota:
> -			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_jqfmt_vfsold:
> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
> -			break;
> -		case Opt_jqfmt_vfsv0:
> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
> -			break;
> -		case Opt_jqfmt_vfsv1:
> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
> -			break;
> -		case Opt_noquota:
> +	case Opt_quota:
> +		if (result.negated) {
>  			clear_opt(sbi, QUOTA);
>  			clear_opt(sbi, USRQUOTA);
>  			clear_opt(sbi, GRPQUOTA);
>  			clear_opt(sbi, PRJQUOTA);
> -			break;
> +		} else
> +			set_opt(sbi, USRQUOTA);
> +		break;
> +	case Opt_usrquota:
> +		set_opt(sbi, USRQUOTA);
> +		break;
> +	case Opt_grpquota:
> +		set_opt(sbi, GRPQUOTA);
> +		break;
> +	case Opt_prjquota:
> +		set_opt(sbi, PRJQUOTA);
> +		break;
> +	case Opt_usrjquota:
> +		if (!*param->string)
> +			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
> +		else
> +			ret = f2fs_set_qf_name(sbi, USRQUOTA, param);
> +		if (ret)
> +			return ret;
> +		break;
> +	case Opt_grpjquota:
> +		if (!*param->string)
> +			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
> +		else
> +			ret = f2fs_set_qf_name(sbi, GRPQUOTA, param);
> +		if (ret)
> +			return ret;
> +		break;
> +	case Opt_prjjquota:
> +		if (!*param->string)
> +			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
> +		else
> +			ret = f2fs_set_qf_name(sbi, PRJQUOTA, param);
> +		if (ret)
> +			return ret;
> +		break;
> +	case Opt_jqfmt:
> +		F2FS_OPTION(sbi).s_jquota_fmt = result.uint_32;
> +		break;
>  #else
> -		case Opt_quota:
> -		case Opt_usrquota:
> -		case Opt_grpquota:
> -		case Opt_prjquota:
> -		case Opt_usrjquota:
> -		case Opt_grpjquota:
> -		case Opt_prjjquota:
> -		case Opt_offusrjquota:
> -		case Opt_offgrpjquota:
> -		case Opt_offprjjquota:
> -		case Opt_jqfmt_vfsold:
> -		case Opt_jqfmt_vfsv0:
> -		case Opt_jqfmt_vfsv1:
> -		case Opt_noquota:
> -			f2fs_info(sbi, "quota operations not supported");
> -			break;
> +	case Opt_quota:
> +	case Opt_usrquota:
> +	case Opt_grpquota:
> +	case Opt_prjquota:
> +	case Opt_usrjquota:
> +	case Opt_grpjquota:
> +	case Opt_prjjquota:
> +		f2fs_info(sbi, "quota operations not supported");
> +		break;
>  #endif
> -		case Opt_alloc:
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -
> -			if (!strcmp(name, "default")) {
> -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
> -			} else if (!strcmp(name, "reuse")) {
> -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> -			break;
> -		case Opt_fsync:
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "posix")) {
> -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
> -			} else if (!strcmp(name, "strict")) {
> -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
> -			} else if (!strcmp(name, "nobarrier")) {
> -				F2FS_OPTION(sbi).fsync_mode =
> -							FSYNC_MODE_NOBARRIER;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> -			break;
> -		case Opt_test_dummy_encryption:
> -			ret = f2fs_set_test_dummy_encryption(sbi, p, &args[0],
> -							     is_remount);
> -			if (ret)
> -				return ret;
> -			break;
> -		case Opt_inlinecrypt:
> +	case Opt_alloc:
> +		F2FS_OPTION(sbi).alloc_mode = result.uint_32;
> +		break;
> +	case Opt_fsync:
> +		F2FS_OPTION(sbi).fsync_mode = result.uint_32;
> +		break;
> +	case Opt_test_dummy_encryption:
> +		ret = f2fs_set_test_dummy_encryption(sbi, param, is_remount);
> +		if (ret)
> +			return ret;
> +		break;
> +	case Opt_inlinecrypt:
>  #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
> -			set_opt(sbi, INLINECRYPT);
> +		set_opt(sbi, INLINECRYPT);
>  #else
> -			f2fs_info(sbi, "inline encryption not supported");
> +		f2fs_info(sbi, "inline encryption not supported");
>  #endif
> -			break;
> +		break;
> +	case Opt_checkpoint:
> +		/*
> +		 * Initialize args struct so we know whether arg was
> +		 * found; some options take optional arguments.
> +		 */
> +		args[0].from = args[0].to = NULL;
> +		arg = 0;
> +
> +		/* revert to match_table for checkpoint= options */
> +		token = match_token(param->string, f2fs_checkpoint_tokens, args);
> +		switch (token) {
>  		case Opt_checkpoint_disable_cap_perc:
>  			if (args->from && match_int(args, &arg))
>  				return -EINVAL;
> @@ -1185,270 +988,225 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>  		case Opt_checkpoint_enable:
>  			clear_opt(sbi, DISABLE_CHECKPOINT);
>  			break;
> -		case Opt_checkpoint_merge:
> -			set_opt(sbi, MERGE_CHECKPOINT);
> -			break;
> -		case Opt_nocheckpoint_merge:
> +		default:
> +			return -EINVAL;
> +		}
> +		break;
> +	case Opt_checkpoint_merge:
> +		if (result.negated)
>  			clear_opt(sbi, MERGE_CHECKPOINT);
> -			break;
> +		else
> +			set_opt(sbi, MERGE_CHECKPOINT);
> +		break;
>  #ifdef CONFIG_F2FS_FS_COMPRESSION
> -		case Opt_compress_algorithm:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "lzo")) {
> +	case Opt_compress_algorithm:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
> +			break;
> +		}
> +		name = param->string;
> +		if (!strcmp(name, "lzo")) {
>  #ifdef CONFIG_F2FS_FS_LZO
> -				F2FS_OPTION(sbi).compress_level = 0;
> -				F2FS_OPTION(sbi).compress_algorithm =
> -								COMPRESS_LZO;
> +			F2FS_OPTION(sbi).compress_level = 0;
> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
>  #else
> -				f2fs_info(sbi, "kernel doesn't support lzo compression");
> +			f2fs_info(sbi, "kernel doesn't support lzo compression");
>  #endif
> -			} else if (!strncmp(name, "lz4", 3)) {
> +		} else if (!strncmp(name, "lz4", 3)) {
>  #ifdef CONFIG_F2FS_FS_LZ4
> -				ret = f2fs_set_lz4hc_level(sbi, name);
> -				if (ret) {
> -					kfree(name);
> -					return -EINVAL;
> -				}
> -				F2FS_OPTION(sbi).compress_algorithm =
> -								COMPRESS_LZ4;
> +			ret = f2fs_set_lz4hc_level(sbi, name);
> +			if (ret)
> +				return -EINVAL;
> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
>  #else
> -				f2fs_info(sbi, "kernel doesn't support lz4 compression");
> +			f2fs_info(sbi, "kernel doesn't support lz4 compression");
>  #endif
> -			} else if (!strncmp(name, "zstd", 4)) {
> +		} else if (!strncmp(name, "zstd", 4)) {
>  #ifdef CONFIG_F2FS_FS_ZSTD
> -				ret = f2fs_set_zstd_level(sbi, name);
> -				if (ret) {
> -					kfree(name);
> -					return -EINVAL;
> -				}
> -				F2FS_OPTION(sbi).compress_algorithm =
> -								COMPRESS_ZSTD;
> +			ret = f2fs_set_zstd_level(sbi, name);
> +			if (ret)
> +				return -EINVAL;
> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
>  #else
> -				f2fs_info(sbi, "kernel doesn't support zstd compression");
> +			f2fs_info(sbi, "kernel doesn't support zstd compression");
>  #endif
> -			} else if (!strcmp(name, "lzo-rle")) {
> +		} else if (!strcmp(name, "lzo-rle")) {
>  #ifdef CONFIG_F2FS_FS_LZORLE
> -				F2FS_OPTION(sbi).compress_level = 0;
> -				F2FS_OPTION(sbi).compress_algorithm =
> -								COMPRESS_LZORLE;
> +			F2FS_OPTION(sbi).compress_level = 0;
> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
>  #else
> -				f2fs_info(sbi, "kernel doesn't support lzorle compression");
> +			f2fs_info(sbi, "kernel doesn't support lzorle compression");
>  #endif
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> +		} else
> +			return -EINVAL;
> +		break;
> +	case Opt_compress_log_size:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
>  			break;
> -		case Opt_compress_log_size:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			if (args->from && match_int(args, &arg))
> -				return -EINVAL;
> -			if (arg < MIN_COMPRESS_LOG_SIZE ||
> -				arg > MAX_COMPRESS_LOG_SIZE) {
> -				f2fs_err(sbi,
> -					"Compress cluster log size is out of range");
> -				return -EINVAL;
> -			}
> -			F2FS_OPTION(sbi).compress_log_size = arg;
> +		}
> +		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
> +		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
> +			f2fs_err(sbi,
> +				"Compress cluster log size is out of range");
> +			return -EINVAL;
> +		}
> +		F2FS_OPTION(sbi).compress_log_size = result.uint_32;
> +		break;
> +	case Opt_compress_extension:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
>  			break;
> -		case Opt_compress_extension:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -
> -			ext = F2FS_OPTION(sbi).extensions;
> -			ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> -
> -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
> -				ext_cnt >= COMPRESS_EXT_NUM) {
> -				f2fs_err(sbi,
> -					"invalid extension length/number");
> -				kfree(name);
> -				return -EINVAL;
> -			}
> +		}
> +		name = param->string;
> +		ext = F2FS_OPTION(sbi).extensions;
> +		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>  
> -			if (is_compress_extension_exist(sbi, name, true)) {
> -				kfree(name);
> -				break;
> -			}
> +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
> +		    ext_cnt >= COMPRESS_EXT_NUM) {
> +			f2fs_err(sbi, "invalid extension length/number");
> +			return -EINVAL;
> +		}
>  
> -			ret = strscpy(ext[ext_cnt], name);
> -			if (ret < 0) {
> -				kfree(name);
> -				return ret;
> -			}
> -			F2FS_OPTION(sbi).compress_ext_cnt++;
> -			kfree(name);
> +		if (is_compress_extension_exist(sbi, name, true))
>  			break;
> -		case Opt_nocompress_extension:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -
> -			noext = F2FS_OPTION(sbi).noextensions;
> -			noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>  
> -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
> -				noext_cnt >= COMPRESS_EXT_NUM) {
> -				f2fs_err(sbi,
> -					"invalid extension length/number");
> -				kfree(name);
> -				return -EINVAL;
> -			}
> +		ret = strscpy(ext[ext_cnt], name, F2FS_EXTENSION_LEN);
> +		if (ret < 0)
> +			return ret;
> +		F2FS_OPTION(sbi).compress_ext_cnt++;
> +		break;
> +	case Opt_nocompress_extension:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
> +			break;
> +		}
> +		name = param->string;
> +		noext = F2FS_OPTION(sbi).noextensions;
> +		noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>  
> -			if (is_compress_extension_exist(sbi, name, false)) {
> -				kfree(name);
> -				break;
> -			}
> +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
> +			noext_cnt >= COMPRESS_EXT_NUM) {
> +			f2fs_err(sbi, "invalid extension length/number");
> +			return -EINVAL;
> +		}
>  
> -			ret = strscpy(noext[noext_cnt], name);
> -			if (ret < 0) {
> -				kfree(name);
> -				return ret;
> -			}
> -			F2FS_OPTION(sbi).nocompress_ext_cnt++;
> -			kfree(name);
> +		if (is_compress_extension_exist(sbi, name, false))
>  			break;
> -		case Opt_compress_chksum:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			F2FS_OPTION(sbi).compress_chksum = true;
> +
> +		ret = strscpy(noext[noext_cnt], name, F2FS_EXTENSION_LEN);
> +		if (ret < 0)
> +			return ret;
> +		F2FS_OPTION(sbi).nocompress_ext_cnt++;
> +		break;
> +	case Opt_compress_chksum:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
>  			break;
> -		case Opt_compress_mode:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "fs")) {
> -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
> -			} else if (!strcmp(name, "user")) {
> -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> +		}
> +		F2FS_OPTION(sbi).compress_chksum = true;
> +		break;
> +	case Opt_compress_mode:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
>  			break;
> -		case Opt_compress_cache:
> -			if (!f2fs_sb_has_compression(sbi)) {
> -				f2fs_info(sbi, "Image doesn't support compression");
> -				break;
> -			}
> -			set_opt(sbi, COMPRESS_CACHE);
> +		}
> +		F2FS_OPTION(sbi).compress_mode = result.uint_32;
> +		break;
> +	case Opt_compress_cache:
> +		if (!f2fs_sb_has_compression(sbi)) {
> +			f2fs_info(sbi, "Image doesn't support compression");
>  			break;
> +		}
> +		set_opt(sbi, COMPRESS_CACHE);
> +		break;
>  #else
> -		case Opt_compress_algorithm:
> -		case Opt_compress_log_size:
> -		case Opt_compress_extension:
> -		case Opt_nocompress_extension:
> -		case Opt_compress_chksum:
> -		case Opt_compress_mode:
> -		case Opt_compress_cache:
> -			f2fs_info(sbi, "compression options not supported");
> -			break;
> +	case Opt_compress_algorithm:
> +	case Opt_compress_log_size:
> +	case Opt_compress_extension:
> +	case Opt_nocompress_extension:
> +	case Opt_compress_chksum:
> +	case Opt_compress_mode:
> +	case Opt_compress_cache:
> +		f2fs_info(sbi, "compression options not supported");
> +		break;
>  #endif
> -		case Opt_atgc:
> -			set_opt(sbi, ATGC);
> -			break;
> -		case Opt_gc_merge:
> -			set_opt(sbi, GC_MERGE);
> -			break;
> -		case Opt_nogc_merge:
> +	case Opt_atgc:
> +		set_opt(sbi, ATGC);
> +		break;
> +	case Opt_gc_merge:
> +		if (result.negated)
>  			clear_opt(sbi, GC_MERGE);
> -			break;
> -		case Opt_discard_unit:
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "block")) {
> -				F2FS_OPTION(sbi).discard_unit =
> -						DISCARD_UNIT_BLOCK;
> -			} else if (!strcmp(name, "segment")) {
> -				F2FS_OPTION(sbi).discard_unit =
> -						DISCARD_UNIT_SEGMENT;
> -			} else if (!strcmp(name, "section")) {
> -				F2FS_OPTION(sbi).discard_unit =
> -						DISCARD_UNIT_SECTION;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> -			break;
> -		case Opt_memory_mode:
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "normal")) {
> -				F2FS_OPTION(sbi).memory_mode =
> -						MEMORY_MODE_NORMAL;
> -			} else if (!strcmp(name, "low")) {
> -				F2FS_OPTION(sbi).memory_mode =
> -						MEMORY_MODE_LOW;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> -			}
> -			kfree(name);
> -			break;
> -		case Opt_age_extent_cache:
> -			set_opt(sbi, AGE_EXTENT_CACHE);
> -			break;
> -		case Opt_errors:
> -			name = match_strdup(&args[0]);
> -			if (!name)
> -				return -ENOMEM;
> -			if (!strcmp(name, "remount-ro")) {
> -				F2FS_OPTION(sbi).errors =
> -						MOUNT_ERRORS_READONLY;
> -			} else if (!strcmp(name, "continue")) {
> -				F2FS_OPTION(sbi).errors =
> -						MOUNT_ERRORS_CONTINUE;
> -			} else if (!strcmp(name, "panic")) {
> -				F2FS_OPTION(sbi).errors =
> -						MOUNT_ERRORS_PANIC;
> -			} else {
> -				kfree(name);
> -				return -EINVAL;
> +		else
> +			set_opt(sbi, GC_MERGE);
> +		break;
> +	case Opt_discard_unit:
> +		F2FS_OPTION(sbi).discard_unit = result.uint_32;
> +		break;
> +	case Opt_memory_mode:
> +		F2FS_OPTION(sbi).memory_mode = result.uint_32;
> +		break;
> +	case Opt_age_extent_cache:
> +		set_opt(sbi, AGE_EXTENT_CACHE);
> +		break;
> +	case Opt_errors:
> +		F2FS_OPTION(sbi).errors = result.uint_32;
> +		break;
> +	case Opt_nat_bits:
> +		set_opt(sbi, NAT_BITS);
> +		break;
> +	}
> +	return 0;
> +}
> +
> +static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
> +{
> +	struct fs_parameter param;
> +	struct fs_context fc;
> +	char *key;
> +	int ret;
> +
> +	if (!options)
> +		return 0;
> +
> +	memset(&fc, 0, sizeof(fc));
> +	fc.s_fs_info = sbi;
> +	if (is_remount)
> +		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
> +
> +	while ((key = strsep(&options, ",")) != NULL) {
> +		if (*key) {
> +			size_t v_len = 0;
> +			char *value = strchr(key, '=');
> +
> +			param.type = fs_value_is_flag;
> +			param.string = NULL;
> +
> +			if (value) {
> +				if (value == key)
> +					continue;
> +
> +				*value++ = 0;
> +				v_len = strlen(value);
> +				param.string = kmemdup_nul(value, v_len, GFP_KERNEL);
> +				if (!param.string)
> +					return -ENOMEM;
> +				param.type = fs_value_is_string;
>  			}
> -			kfree(name);
> -			break;
> -		case Opt_nat_bits:
> -			set_opt(sbi, NAT_BITS);
> -			break;
> -		default:
> -			f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
> -				 p);
> -			return -EINVAL;
> +
> +			param.key = key;
> +			param.size = v_len;
> +
> +			ret = handle_mount_opt(&fc, &param);
> +			kfree(param.string);
> +			if (ret < 0)
> +				return ret;
>  		}
>  	}
>  	return 0;
>  }
>  
> -static int f2fs_default_check(struct f2fs_sb_info *sbi)
> +static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>  {
>  #ifdef CONFIG_QUOTA
>  	if (f2fs_check_quota_options(sbi))
> @@ -2527,7 +2285,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>  	}
>  #endif
>  
> -	err = f2fs_default_check(sbi);
> +	err = f2fs_validate_options(sbi);
>  	if (err)
>  		goto restore_opts;
>  
> @@ -4725,7 +4483,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>  	if (err)
>  		goto free_options;
>  
> -	err = f2fs_default_check(sbi);
> +	err = f2fs_validate_options(sbi);
>  	if (err)
>  		goto free_options;
>  

Re: [PATCH v4 2/7] f2fs: move the option parser into handle_mount_opt

[Hongbo Li]

On 2025/7/4 11:27, Chao Yu wrote:
> On 6/2/25 17:02, Hongbo Li wrote:
>> In handle_mount_opt, we use fs_parameter to parse each option.
>> However we're still using the old API to get the options string.
>> Using fsparams parse_options allows us to remove many of the Opt_
>> enums, so remove them.
>>
>> The checkpoint disable cap (or percent) involves rather complex
>> parsing; we retain the old match_table mechanism for this, which
>> handles it well.
>>
>> There are some changes about parsing options:
>>    1. For `active_logs`, `inline_xattr_size` and `fault_injection`,
>>       we use s32 type according the internal structure to record the
>>       option's value.
>>
>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>> [sandeen: forward port, minor fixes and updates]
>> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
>> [hongbo: minor cleanup]
>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>> ---
>>   fs/f2fs/super.c | 1068 ++++++++++++++++++-----------------------------
>>   1 file changed, 413 insertions(+), 655 deletions(-)
>>
>> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
>> index 996633b8379e..dff2419ba905 100644
>> --- a/fs/f2fs/super.c
>> +++ b/fs/f2fs/super.c
>> @@ -27,6 +27,7 @@
>>   #include <linux/part_stat.h>
>>   #include <linux/zstd.h>
>>   #include <linux/lz4.h>
>> +#include <linux/ctype.h>
>>   #include <linux/fs_parser.h>
>>   
>>   #include "f2fs.h"
>> @@ -126,29 +127,20 @@ enum {
>>   	Opt_disable_roll_forward,
>>   	Opt_norecovery,
>>   	Opt_discard,
>> -	Opt_nodiscard,
>>   	Opt_noheap,
>>   	Opt_heap,
>>   	Opt_user_xattr,
>> -	Opt_nouser_xattr,
>>   	Opt_acl,
>> -	Opt_noacl,
>>   	Opt_active_logs,
>>   	Opt_disable_ext_identify,
>>   	Opt_inline_xattr,
>> -	Opt_noinline_xattr,
>>   	Opt_inline_xattr_size,
>>   	Opt_inline_data,
>>   	Opt_inline_dentry,
>> -	Opt_noinline_dentry,
>>   	Opt_flush_merge,
>> -	Opt_noflush_merge,
>>   	Opt_barrier,
>> -	Opt_nobarrier,
>>   	Opt_fastboot,
>>   	Opt_extent_cache,
>> -	Opt_noextent_cache,
>> -	Opt_noinline_data,
>>   	Opt_data_flush,
>>   	Opt_reserve_root,
>>   	Opt_resgid,
>> @@ -157,21 +149,13 @@ enum {
>>   	Opt_fault_injection,
>>   	Opt_fault_type,
>>   	Opt_lazytime,
>> -	Opt_nolazytime,
>>   	Opt_quota,
>> -	Opt_noquota,
>>   	Opt_usrquota,
>>   	Opt_grpquota,
>>   	Opt_prjquota,
>>   	Opt_usrjquota,
>>   	Opt_grpjquota,
>>   	Opt_prjjquota,
>> -	Opt_offusrjquota,
>> -	Opt_offgrpjquota,
>> -	Opt_offprjjquota,
>> -	Opt_jqfmt_vfsold,
>> -	Opt_jqfmt_vfsv0,
>> -	Opt_jqfmt_vfsv1,
>>   	Opt_alloc,
>>   	Opt_fsync,
>>   	Opt_test_dummy_encryption,
>> @@ -181,17 +165,15 @@ enum {
>>   	Opt_checkpoint_disable_cap_perc,
>>   	Opt_checkpoint_enable,
>>   	Opt_checkpoint_merge,
>> -	Opt_nocheckpoint_merge,
>>   	Opt_compress_algorithm,
>>   	Opt_compress_log_size,
>> -	Opt_compress_extension,
>>   	Opt_nocompress_extension,
>> +	Opt_compress_extension,
>>   	Opt_compress_chksum,
>>   	Opt_compress_mode,
>>   	Opt_compress_cache,
>>   	Opt_atgc,
>>   	Opt_gc_merge,
>> -	Opt_nogc_merge,
>>   	Opt_discard_unit,
>>   	Opt_memory_mode,
>>   	Opt_age_extent_cache,
>> @@ -321,83 +303,12 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
>>   	{}
>>   };
>>   
>> -static match_table_t f2fs_tokens = {
>> -	{Opt_gc_background, "background_gc=%s"},
>> -	{Opt_disable_roll_forward, "disable_roll_forward"},
>> -	{Opt_norecovery, "norecovery"},
>> -	{Opt_discard, "discard"},
>> -	{Opt_nodiscard, "nodiscard"},
>> -	{Opt_noheap, "no_heap"},
>> -	{Opt_heap, "heap"},
>> -	{Opt_user_xattr, "user_xattr"},
>> -	{Opt_nouser_xattr, "nouser_xattr"},
>> -	{Opt_acl, "acl"},
>> -	{Opt_noacl, "noacl"},
>> -	{Opt_active_logs, "active_logs=%u"},
>> -	{Opt_disable_ext_identify, "disable_ext_identify"},
>> -	{Opt_inline_xattr, "inline_xattr"},
>> -	{Opt_noinline_xattr, "noinline_xattr"},
>> -	{Opt_inline_xattr_size, "inline_xattr_size=%u"},
>> -	{Opt_inline_data, "inline_data"},
>> -	{Opt_inline_dentry, "inline_dentry"},
>> -	{Opt_noinline_dentry, "noinline_dentry"},
>> -	{Opt_flush_merge, "flush_merge"},
>> -	{Opt_noflush_merge, "noflush_merge"},
>> -	{Opt_barrier, "barrier"},
>> -	{Opt_nobarrier, "nobarrier"},
>> -	{Opt_fastboot, "fastboot"},
>> -	{Opt_extent_cache, "extent_cache"},
>> -	{Opt_noextent_cache, "noextent_cache"},
>> -	{Opt_noinline_data, "noinline_data"},
>> -	{Opt_data_flush, "data_flush"},
>> -	{Opt_reserve_root, "reserve_root=%u"},
>> -	{Opt_resgid, "resgid=%u"},
>> -	{Opt_resuid, "resuid=%u"},
>> -	{Opt_mode, "mode=%s"},
>> -	{Opt_fault_injection, "fault_injection=%u"},
>> -	{Opt_fault_type, "fault_type=%u"},
>> -	{Opt_lazytime, "lazytime"},
>> -	{Opt_nolazytime, "nolazytime"},
>> -	{Opt_quota, "quota"},
>> -	{Opt_noquota, "noquota"},
>> -	{Opt_usrquota, "usrquota"},
>> -	{Opt_grpquota, "grpquota"},
>> -	{Opt_prjquota, "prjquota"},
>> -	{Opt_usrjquota, "usrjquota=%s"},
>> -	{Opt_grpjquota, "grpjquota=%s"},
>> -	{Opt_prjjquota, "prjjquota=%s"},
>> -	{Opt_offusrjquota, "usrjquota="},
>> -	{Opt_offgrpjquota, "grpjquota="},
>> -	{Opt_offprjjquota, "prjjquota="},
>> -	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
>> -	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
>> -	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
>> -	{Opt_alloc, "alloc_mode=%s"},
>> -	{Opt_fsync, "fsync_mode=%s"},
>> -	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
>> -	{Opt_test_dummy_encryption, "test_dummy_encryption"},
>> -	{Opt_inlinecrypt, "inlinecrypt"},
>> -	{Opt_checkpoint_disable, "checkpoint=disable"},
>> -	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
>> -	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
>> -	{Opt_checkpoint_enable, "checkpoint=enable"},
>> -	{Opt_checkpoint_merge, "checkpoint_merge"},
>> -	{Opt_nocheckpoint_merge, "nocheckpoint_merge"},
>> -	{Opt_compress_algorithm, "compress_algorithm=%s"},
>> -	{Opt_compress_log_size, "compress_log_size=%u"},
>> -	{Opt_compress_extension, "compress_extension=%s"},
>> -	{Opt_nocompress_extension, "nocompress_extension=%s"},
>> -	{Opt_compress_chksum, "compress_chksum"},
>> -	{Opt_compress_mode, "compress_mode=%s"},
>> -	{Opt_compress_cache, "compress_cache"},
>> -	{Opt_atgc, "atgc"},
>> -	{Opt_gc_merge, "gc_merge"},
>> -	{Opt_nogc_merge, "nogc_merge"},
>> -	{Opt_discard_unit, "discard_unit=%s"},
>> -	{Opt_memory_mode, "memory=%s"},
>> -	{Opt_age_extent_cache, "age_extent_cache"},
>> -	{Opt_errors, "errors=%s"},
>> -	{Opt_nat_bits, "nat_bits"},
>> +/* Resort to a match_table for this interestingly formatted option */
>> +static match_table_t f2fs_checkpoint_tokens = {
>> +	{Opt_checkpoint_disable, "disable"},
>> +	{Opt_checkpoint_disable_cap, "disable:%u"},
>> +	{Opt_checkpoint_disable_cap_perc, "disable:%u%%"},
>> +	{Opt_checkpoint_enable, "enable"},
>>   	{Opt_err, NULL},
>>   };
>>   
>> @@ -513,7 +424,7 @@ static void init_once(void *foo)
>>   static const char * const quotatypes[] = INITQFNAMES;
>>   #define QTYPE2NAME(t) (quotatypes[t])
>>   static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
>> -							substring_t *args)
>> +			    struct fs_parameter *param)
>>   {
>>   	struct super_block *sb = sbi->sb;
>>   	char *qname;
>> @@ -528,7 +439,7 @@ static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
>>   		return 0;
>>   	}
>>   
>> -	qname = match_strdup(args);
>> +	qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
>>   	if (!qname) {
>>   		f2fs_err(sbi, "Not enough memory for storing quotafile name");
>>   		return -ENOMEM;
>> @@ -613,14 +524,9 @@ static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
>>   #endif
>>   
>>   static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
>> -					  const char *opt,
>> -					  const substring_t *arg,
>> +					  const struct fs_parameter *param,
>>   					  bool is_remount)
>>   {
>> -	struct fs_parameter param = {
>> -		.type = fs_value_is_string,
>> -		.string = arg->from ? arg->from : "",
>> -	};
>>   	struct fscrypt_dummy_policy *policy =
>>   		&F2FS_OPTION(sbi).dummy_enc_policy;
>>   	int err;
>> @@ -646,17 +552,17 @@ static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
>>   		return -EINVAL;
>>   	}
>>   
>> -	err = fscrypt_parse_test_dummy_encryption(&param, policy);
>> +	err = fscrypt_parse_test_dummy_encryption(param, policy);
>>   	if (err) {
>>   		if (err == -EEXIST)
>>   			f2fs_warn(sbi,
>>   				  "Can't change test_dummy_encryption on remount");
>>   		else if (err == -EINVAL)
>>   			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
>> -				  opt);
>> +				  param->key);
>>   		else
>>   			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
>> -				  opt, err);
>> +				  param->key, err);
>>   		return -EINVAL;
>>   	}
>>   	f2fs_warn(sbi, "Test dummy encryption mode enabled");
>> @@ -799,372 +705,269 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
>>   #endif
>>   #endif
>>   
>> -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
>> +static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   {
>> -	substring_t args[MAX_OPT_ARGS];
>> +	struct f2fs_sb_info *sbi = fc->s_fs_info;
>>   #ifdef CONFIG_F2FS_FS_COMPRESSION
>>   	unsigned char (*ext)[F2FS_EXTENSION_LEN];
>>   	unsigned char (*noext)[F2FS_EXTENSION_LEN];
>>   	int ext_cnt, noext_cnt;
>> +	char *name;
>>   #endif
>> -	char *p, *name;
>> -	int arg = 0;
>> -	kuid_t uid;
>> -	kgid_t gid;
>> -	int ret;
>> +	substring_t args[MAX_OPT_ARGS];
>> +	struct fs_parse_result result;
>> +	bool is_remount;
>> +	int token, ret, arg;
>>   
>> -	if (!options)
>> -		return 0;
>> +	token = fs_parse(fc, f2fs_param_specs, param, &result);
>> +	if (token < 0)
>> +		return token;
>>   
>> -	while ((p = strsep(&options, ",")) != NULL) {
>> -		int token;
>> +	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
>>   
>> -		if (!*p)
>> -			continue;
>> -		/*
>> -		 * Initialize args struct so we know whether arg was
>> -		 * found; some options take optional arguments.
>> -		 */
>> -		args[0].to = args[0].from = NULL;
>> -		token = match_token(p, f2fs_tokens, args);
>> -
>> -		switch (token) {
>> -		case Opt_gc_background:
>> -			name = match_strdup(&args[0]);
>> -
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "on")) {
>> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
>> -			} else if (!strcmp(name, "off")) {
>> -				if (f2fs_sb_has_blkzoned(sbi)) {
>> -					f2fs_warn(sbi, "zoned devices need bggc");
>> -					kfree(name);
>> -					return -EINVAL;
>> -				}
> 
> Missed to check this condition in f2fs_check_opt_consistency()?
> 

Thanks for pointing this. Yeah, we should add this in 
f2fs_check_opt_consistency like this:

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 0a070dadbb42..86938dd5491e 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -1458,6 +1458,10 @@ static int f2fs_check_opt_consistency(struct 
fs_context *fc,
          * devices, but mandatory for host-managed zoned block devices.
          */
         if (f2fs_sb_has_blkzoned(sbi)) {
+               if (F2FS_CTX_OPTION(ctx).bggc_mode == BGGC_MODE_OFF) {
+                       f2fs_warn(sbi, "zoned devices need bggc");
+                       return -EINVAL;
+               }
  #ifdef CONFIG_BLK_DEV_ZONED
                 if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
                 F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {

Thanks,
Hongbo

> Thanks,
> 
>> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
>> -			} else if (!strcmp(name, "sync")) {
>> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
>> -			} else {
>> -				kfree(name);
>> +	switch (token) {
>> +	case Opt_gc_background:
>> +		F2FS_OPTION(sbi).bggc_mode = result.uint_32;
>> +		break;
>> +	case Opt_disable_roll_forward:
>> +		set_opt(sbi, DISABLE_ROLL_FORWARD);
>> +		break;
>> +	case Opt_norecovery:
>> +		/* requires ro mount, checked in f2fs_validate_options */
>> +		set_opt(sbi, NORECOVERY);
>> +		break;
>> +	case Opt_discard:
>> +		if (result.negated) {
>> +			if (f2fs_hw_should_discard(sbi)) {
>> +				f2fs_warn(sbi, "discard is required for zoned block devices");
>>   				return -EINVAL;
>>   			}
>> -			kfree(name);
>> -			break;
>> -		case Opt_disable_roll_forward:
>> -			set_opt(sbi, DISABLE_ROLL_FORWARD);
>> -			break;
>> -		case Opt_norecovery:
>> -			/* requires ro mount, checked in f2fs_default_check */
>> -			set_opt(sbi, NORECOVERY);
>> -			break;
>> -		case Opt_discard:
>> +			clear_opt(sbi, DISCARD);
>> +		} else {
>>   			if (!f2fs_hw_support_discard(sbi)) {
>>   				f2fs_warn(sbi, "device does not support discard");
>>   				break;
>>   			}
>>   			set_opt(sbi, DISCARD);
>> -			break;
>> -		case Opt_nodiscard:
>> -			if (f2fs_hw_should_discard(sbi)) {
>> -				f2fs_warn(sbi, "discard is required for zoned block devices");
>> -				return -EINVAL;
>> -			}
>> -			clear_opt(sbi, DISCARD);
>> -			break;
>> -		case Opt_noheap:
>> -		case Opt_heap:
>> -			f2fs_warn(sbi, "heap/no_heap options were deprecated");
>> -			break;
>> +		}
>> +		break;
>> +	case Opt_noheap:
>> +	case Opt_heap:
>> +		f2fs_warn(sbi, "heap/no_heap options were deprecated");
>> +		break;
>>   #ifdef CONFIG_F2FS_FS_XATTR
>> -		case Opt_user_xattr:
>> -			set_opt(sbi, XATTR_USER);
>> -			break;
>> -		case Opt_nouser_xattr:
>> +	case Opt_user_xattr:
>> +		if (result.negated)
>>   			clear_opt(sbi, XATTR_USER);
>> -			break;
>> -		case Opt_inline_xattr:
>> -			set_opt(sbi, INLINE_XATTR);
>> -			break;
>> -		case Opt_noinline_xattr:
>> +		else
>> +			set_opt(sbi, XATTR_USER);
>> +		break;
>> +	case Opt_inline_xattr:
>> +		if (result.negated)
>>   			clear_opt(sbi, INLINE_XATTR);
>> -			break;
>> -		case Opt_inline_xattr_size:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			set_opt(sbi, INLINE_XATTR_SIZE);
>> -			F2FS_OPTION(sbi).inline_xattr_size = arg;
>> -			break;
>> +		else
>> +			set_opt(sbi, INLINE_XATTR);
>> +		break;
>> +	case Opt_inline_xattr_size:
>> +		set_opt(sbi, INLINE_XATTR_SIZE);
>> +		F2FS_OPTION(sbi).inline_xattr_size = result.int_32;
>> +		break;
>>   #else
>> -		case Opt_user_xattr:
>> -		case Opt_nouser_xattr:
>> -		case Opt_inline_xattr:
>> -		case Opt_noinline_xattr:
>> -		case Opt_inline_xattr_size:
>> -			f2fs_info(sbi, "xattr options not supported");
>> -			break;
>> +	case Opt_user_xattr:
>> +	case Opt_inline_xattr:
>> +	case Opt_inline_xattr_size:
>> +		f2fs_info(sbi, "%s options not supported", param->key);
>> +		break;
>>   #endif
>>   #ifdef CONFIG_F2FS_FS_POSIX_ACL
>> -		case Opt_acl:
>> -			set_opt(sbi, POSIX_ACL);
>> -			break;
>> -		case Opt_noacl:
>> +	case Opt_acl:
>> +		if (result.negated)
>>   			clear_opt(sbi, POSIX_ACL);
>> -			break;
>> +		else
>> +			set_opt(sbi, POSIX_ACL);
>> +		break;
>>   #else
>> -		case Opt_acl:
>> -		case Opt_noacl:
>> -			f2fs_info(sbi, "acl options not supported");
>> -			break;
>> +	case Opt_acl:
>> +		f2fs_info(sbi, "%s options not supported", param->key);
>> +		break;
>>   #endif
>> -		case Opt_active_logs:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			if (arg != 2 && arg != 4 &&
>> -				arg != NR_CURSEG_PERSIST_TYPE)
>> -				return -EINVAL;
>> -			F2FS_OPTION(sbi).active_logs = arg;
>> -			break;
>> -		case Opt_disable_ext_identify:
>> -			set_opt(sbi, DISABLE_EXT_IDENTIFY);
>> -			break;
>> -		case Opt_inline_data:
>> +	case Opt_active_logs:
>> +		if (result.int_32 != 2 && result.int_32 != 4 &&
>> +			result.int_32 != NR_CURSEG_PERSIST_TYPE)
>> +			return -EINVAL;
>> +		F2FS_OPTION(sbi).active_logs = result.int_32;
>> +		break;
>> +	case Opt_disable_ext_identify:
>> +		set_opt(sbi, DISABLE_EXT_IDENTIFY);
>> +		break;
>> +	case Opt_inline_data:
>> +		if (result.negated)
>> +			clear_opt(sbi, INLINE_DATA);
>> +		else
>>   			set_opt(sbi, INLINE_DATA);
>> -			break;
>> -		case Opt_inline_dentry:
>> -			set_opt(sbi, INLINE_DENTRY);
>> -			break;
>> -		case Opt_noinline_dentry:
>> +		break;
>> +	case Opt_inline_dentry:
>> +		if (result.negated)
>>   			clear_opt(sbi, INLINE_DENTRY);
>> -			break;
>> -		case Opt_flush_merge:
>> -			set_opt(sbi, FLUSH_MERGE);
>> -			break;
>> -		case Opt_noflush_merge:
>> +		else
>> +			set_opt(sbi, INLINE_DENTRY);
>> +		break;
>> +	case Opt_flush_merge:
>> +		if (result.negated)
>>   			clear_opt(sbi, FLUSH_MERGE);
>> -			break;
>> -		case Opt_nobarrier:
>> +		else
>> +			set_opt(sbi, FLUSH_MERGE);
>> +		break;
>> +	case Opt_barrier:
>> +		if (result.negated)
>>   			set_opt(sbi, NOBARRIER);
>> -			break;
>> -		case Opt_barrier:
>> +		else
>>   			clear_opt(sbi, NOBARRIER);
>> -			break;
>> -		case Opt_fastboot:
>> -			set_opt(sbi, FASTBOOT);
>> -			break;
>> -		case Opt_extent_cache:
>> -			set_opt(sbi, READ_EXTENT_CACHE);
>> -			break;
>> -		case Opt_noextent_cache:
>> +		break;
>> +	case Opt_fastboot:
>> +		set_opt(sbi, FASTBOOT);
>> +		break;
>> +	case Opt_extent_cache:
>> +		if (result.negated) {
>>   			if (f2fs_sb_has_device_alias(sbi)) {
>>   				f2fs_err(sbi, "device aliasing requires extent cache");
>>   				return -EINVAL;
>>   			}
>>   			clear_opt(sbi, READ_EXTENT_CACHE);
>> -			break;
>> -		case Opt_noinline_data:
>> -			clear_opt(sbi, INLINE_DATA);
>> -			break;
>> -		case Opt_data_flush:
>> -			set_opt(sbi, DATA_FLUSH);
>> -			break;
>> -		case Opt_reserve_root:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			if (test_opt(sbi, RESERVE_ROOT)) {
>> -				f2fs_info(sbi, "Preserve previous reserve_root=%u",
>> -					  F2FS_OPTION(sbi).root_reserved_blocks);
>> -			} else {
>> -				F2FS_OPTION(sbi).root_reserved_blocks = arg;
>> -				set_opt(sbi, RESERVE_ROOT);
>> -			}
>> -			break;
>> -		case Opt_resuid:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			uid = make_kuid(current_user_ns(), arg);
>> -			if (!uid_valid(uid)) {
>> -				f2fs_err(sbi, "Invalid uid value %d", arg);
>> -				return -EINVAL;
>> -			}
>> -			F2FS_OPTION(sbi).s_resuid = uid;
>> -			break;
>> -		case Opt_resgid:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			gid = make_kgid(current_user_ns(), arg);
>> -			if (!gid_valid(gid)) {
>> -				f2fs_err(sbi, "Invalid gid value %d", arg);
>> -				return -EINVAL;
>> -			}
>> -			F2FS_OPTION(sbi).s_resgid = gid;
>> -			break;
>> -		case Opt_mode:
>> -			name = match_strdup(&args[0]);
>> -
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "adaptive")) {
>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
>> -			} else if (!strcmp(name, "lfs")) {
>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
>> -			} else if (!strcmp(name, "fragment:segment")) {
>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;
>> -			} else if (!strcmp(name, "fragment:block")) {
>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> -			break;
>> +		} else
>> +			set_opt(sbi, READ_EXTENT_CACHE);
>> +		break;
>> +	case Opt_data_flush:
>> +		set_opt(sbi, DATA_FLUSH);
>> +		break;
>> +	case Opt_reserve_root:
>> +		if (test_opt(sbi, RESERVE_ROOT)) {
>> +			f2fs_info(sbi, "Preserve previous reserve_root=%u",
>> +				  F2FS_OPTION(sbi).root_reserved_blocks);
>> +		} else {
>> +			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
>> +			set_opt(sbi, RESERVE_ROOT);
>> +		}
>> +		break;
>> +	case Opt_resuid:
>> +		F2FS_OPTION(sbi).s_resuid = result.uid;
>> +		break;
>> +	case Opt_resgid:
>> +		F2FS_OPTION(sbi).s_resgid = result.gid;
>> +		break;
>> +	case Opt_mode:
>> +		F2FS_OPTION(sbi).fs_mode = result.uint_32;
>> +		break;
>>   #ifdef CONFIG_F2FS_FAULT_INJECTION
>> -		case Opt_fault_injection:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			if (f2fs_build_fault_attr(sbi, arg, 0, FAULT_RATE))
>> -				return -EINVAL;
>> -			set_opt(sbi, FAULT_INJECTION);
>> -			break;
>> +	case Opt_fault_injection:
>> +		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
>> +			return -EINVAL;
>> +		set_opt(sbi, FAULT_INJECTION);
>> +		break;
>>   
>> -		case Opt_fault_type:
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			if (f2fs_build_fault_attr(sbi, 0, arg, FAULT_TYPE))
>> -				return -EINVAL;
>> -			set_opt(sbi, FAULT_INJECTION);
>> -			break;
>> +	case Opt_fault_type:
>> +		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
>> +			return -EINVAL;
>> +		set_opt(sbi, FAULT_INJECTION);
>> +		break;
>>   #else
>> -		case Opt_fault_injection:
>> -		case Opt_fault_type:
>> -			f2fs_info(sbi, "fault injection options not supported");
>> -			break;
>> +	case Opt_fault_injection:
>> +	case Opt_fault_type:
>> +		f2fs_info(sbi, "%s options not supported", param->key);
>> +		break;
>>   #endif
>> -		case Opt_lazytime:
>> -			set_opt(sbi, LAZYTIME);
>> -			break;
>> -		case Opt_nolazytime:
>> +	case Opt_lazytime:
>> +		if (result.negated)
>>   			clear_opt(sbi, LAZYTIME);
>> -			break;
>> +		else
>> +			set_opt(sbi, LAZYTIME);
>> +		break;
>>   #ifdef CONFIG_QUOTA
>> -		case Opt_quota:
>> -		case Opt_usrquota:
>> -			set_opt(sbi, USRQUOTA);
>> -			break;
>> -		case Opt_grpquota:
>> -			set_opt(sbi, GRPQUOTA);
>> -			break;
>> -		case Opt_prjquota:
>> -			set_opt(sbi, PRJQUOTA);
>> -			break;
>> -		case Opt_usrjquota:
>> -			ret = f2fs_set_qf_name(sbi, USRQUOTA, &args[0]);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_grpjquota:
>> -			ret = f2fs_set_qf_name(sbi, GRPQUOTA, &args[0]);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_prjjquota:
>> -			ret = f2fs_set_qf_name(sbi, PRJQUOTA, &args[0]);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_offusrjquota:
>> -			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_offgrpjquota:
>> -			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_offprjjquota:
>> -			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_jqfmt_vfsold:
>> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
>> -			break;
>> -		case Opt_jqfmt_vfsv0:
>> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
>> -			break;
>> -		case Opt_jqfmt_vfsv1:
>> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
>> -			break;
>> -		case Opt_noquota:
>> +	case Opt_quota:
>> +		if (result.negated) {
>>   			clear_opt(sbi, QUOTA);
>>   			clear_opt(sbi, USRQUOTA);
>>   			clear_opt(sbi, GRPQUOTA);
>>   			clear_opt(sbi, PRJQUOTA);
>> -			break;
>> +		} else
>> +			set_opt(sbi, USRQUOTA);
>> +		break;
>> +	case Opt_usrquota:
>> +		set_opt(sbi, USRQUOTA);
>> +		break;
>> +	case Opt_grpquota:
>> +		set_opt(sbi, GRPQUOTA);
>> +		break;
>> +	case Opt_prjquota:
>> +		set_opt(sbi, PRJQUOTA);
>> +		break;
>> +	case Opt_usrjquota:
>> +		if (!*param->string)
>> +			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
>> +		else
>> +			ret = f2fs_set_qf_name(sbi, USRQUOTA, param);
>> +		if (ret)
>> +			return ret;
>> +		break;
>> +	case Opt_grpjquota:
>> +		if (!*param->string)
>> +			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
>> +		else
>> +			ret = f2fs_set_qf_name(sbi, GRPQUOTA, param);
>> +		if (ret)
>> +			return ret;
>> +		break;
>> +	case Opt_prjjquota:
>> +		if (!*param->string)
>> +			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
>> +		else
>> +			ret = f2fs_set_qf_name(sbi, PRJQUOTA, param);
>> +		if (ret)
>> +			return ret;
>> +		break;
>> +	case Opt_jqfmt:
>> +		F2FS_OPTION(sbi).s_jquota_fmt = result.uint_32;
>> +		break;
>>   #else
>> -		case Opt_quota:
>> -		case Opt_usrquota:
>> -		case Opt_grpquota:
>> -		case Opt_prjquota:
>> -		case Opt_usrjquota:
>> -		case Opt_grpjquota:
>> -		case Opt_prjjquota:
>> -		case Opt_offusrjquota:
>> -		case Opt_offgrpjquota:
>> -		case Opt_offprjjquota:
>> -		case Opt_jqfmt_vfsold:
>> -		case Opt_jqfmt_vfsv0:
>> -		case Opt_jqfmt_vfsv1:
>> -		case Opt_noquota:
>> -			f2fs_info(sbi, "quota operations not supported");
>> -			break;
>> +	case Opt_quota:
>> +	case Opt_usrquota:
>> +	case Opt_grpquota:
>> +	case Opt_prjquota:
>> +	case Opt_usrjquota:
>> +	case Opt_grpjquota:
>> +	case Opt_prjjquota:
>> +		f2fs_info(sbi, "quota operations not supported");
>> +		break;
>>   #endif
>> -		case Opt_alloc:
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -
>> -			if (!strcmp(name, "default")) {
>> -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
>> -			} else if (!strcmp(name, "reuse")) {
>> -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> -			break;
>> -		case Opt_fsync:
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "posix")) {
>> -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
>> -			} else if (!strcmp(name, "strict")) {
>> -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
>> -			} else if (!strcmp(name, "nobarrier")) {
>> -				F2FS_OPTION(sbi).fsync_mode =
>> -							FSYNC_MODE_NOBARRIER;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> -			break;
>> -		case Opt_test_dummy_encryption:
>> -			ret = f2fs_set_test_dummy_encryption(sbi, p, &args[0],
>> -							     is_remount);
>> -			if (ret)
>> -				return ret;
>> -			break;
>> -		case Opt_inlinecrypt:
>> +	case Opt_alloc:
>> +		F2FS_OPTION(sbi).alloc_mode = result.uint_32;
>> +		break;
>> +	case Opt_fsync:
>> +		F2FS_OPTION(sbi).fsync_mode = result.uint_32;
>> +		break;
>> +	case Opt_test_dummy_encryption:
>> +		ret = f2fs_set_test_dummy_encryption(sbi, param, is_remount);
>> +		if (ret)
>> +			return ret;
>> +		break;
>> +	case Opt_inlinecrypt:
>>   #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
>> -			set_opt(sbi, INLINECRYPT);
>> +		set_opt(sbi, INLINECRYPT);
>>   #else
>> -			f2fs_info(sbi, "inline encryption not supported");
>> +		f2fs_info(sbi, "inline encryption not supported");
>>   #endif
>> -			break;
>> +		break;
>> +	case Opt_checkpoint:
>> +		/*
>> +		 * Initialize args struct so we know whether arg was
>> +		 * found; some options take optional arguments.
>> +		 */
>> +		args[0].from = args[0].to = NULL;
>> +		arg = 0;
>> +
>> +		/* revert to match_table for checkpoint= options */
>> +		token = match_token(param->string, f2fs_checkpoint_tokens, args);
>> +		switch (token) {
>>   		case Opt_checkpoint_disable_cap_perc:
>>   			if (args->from && match_int(args, &arg))
>>   				return -EINVAL;
>> @@ -1185,270 +988,225 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>>   		case Opt_checkpoint_enable:
>>   			clear_opt(sbi, DISABLE_CHECKPOINT);
>>   			break;
>> -		case Opt_checkpoint_merge:
>> -			set_opt(sbi, MERGE_CHECKPOINT);
>> -			break;
>> -		case Opt_nocheckpoint_merge:
>> +		default:
>> +			return -EINVAL;
>> +		}
>> +		break;
>> +	case Opt_checkpoint_merge:
>> +		if (result.negated)
>>   			clear_opt(sbi, MERGE_CHECKPOINT);
>> -			break;
>> +		else
>> +			set_opt(sbi, MERGE_CHECKPOINT);
>> +		break;
>>   #ifdef CONFIG_F2FS_FS_COMPRESSION
>> -		case Opt_compress_algorithm:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "lzo")) {
>> +	case Opt_compress_algorithm:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>> +			break;
>> +		}
>> +		name = param->string;
>> +		if (!strcmp(name, "lzo")) {
>>   #ifdef CONFIG_F2FS_FS_LZO
>> -				F2FS_OPTION(sbi).compress_level = 0;
>> -				F2FS_OPTION(sbi).compress_algorithm =
>> -								COMPRESS_LZO;
>> +			F2FS_OPTION(sbi).compress_level = 0;
>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
>>   #else
>> -				f2fs_info(sbi, "kernel doesn't support lzo compression");
>> +			f2fs_info(sbi, "kernel doesn't support lzo compression");
>>   #endif
>> -			} else if (!strncmp(name, "lz4", 3)) {
>> +		} else if (!strncmp(name, "lz4", 3)) {
>>   #ifdef CONFIG_F2FS_FS_LZ4
>> -				ret = f2fs_set_lz4hc_level(sbi, name);
>> -				if (ret) {
>> -					kfree(name);
>> -					return -EINVAL;
>> -				}
>> -				F2FS_OPTION(sbi).compress_algorithm =
>> -								COMPRESS_LZ4;
>> +			ret = f2fs_set_lz4hc_level(sbi, name);
>> +			if (ret)
>> +				return -EINVAL;
>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
>>   #else
>> -				f2fs_info(sbi, "kernel doesn't support lz4 compression");
>> +			f2fs_info(sbi, "kernel doesn't support lz4 compression");
>>   #endif
>> -			} else if (!strncmp(name, "zstd", 4)) {
>> +		} else if (!strncmp(name, "zstd", 4)) {
>>   #ifdef CONFIG_F2FS_FS_ZSTD
>> -				ret = f2fs_set_zstd_level(sbi, name);
>> -				if (ret) {
>> -					kfree(name);
>> -					return -EINVAL;
>> -				}
>> -				F2FS_OPTION(sbi).compress_algorithm =
>> -								COMPRESS_ZSTD;
>> +			ret = f2fs_set_zstd_level(sbi, name);
>> +			if (ret)
>> +				return -EINVAL;
>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
>>   #else
>> -				f2fs_info(sbi, "kernel doesn't support zstd compression");
>> +			f2fs_info(sbi, "kernel doesn't support zstd compression");
>>   #endif
>> -			} else if (!strcmp(name, "lzo-rle")) {
>> +		} else if (!strcmp(name, "lzo-rle")) {
>>   #ifdef CONFIG_F2FS_FS_LZORLE
>> -				F2FS_OPTION(sbi).compress_level = 0;
>> -				F2FS_OPTION(sbi).compress_algorithm =
>> -								COMPRESS_LZORLE;
>> +			F2FS_OPTION(sbi).compress_level = 0;
>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
>>   #else
>> -				f2fs_info(sbi, "kernel doesn't support lzorle compression");
>> +			f2fs_info(sbi, "kernel doesn't support lzorle compression");
>>   #endif
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> +		} else
>> +			return -EINVAL;
>> +		break;
>> +	case Opt_compress_log_size:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>>   			break;
>> -		case Opt_compress_log_size:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			if (args->from && match_int(args, &arg))
>> -				return -EINVAL;
>> -			if (arg < MIN_COMPRESS_LOG_SIZE ||
>> -				arg > MAX_COMPRESS_LOG_SIZE) {
>> -				f2fs_err(sbi,
>> -					"Compress cluster log size is out of range");
>> -				return -EINVAL;
>> -			}
>> -			F2FS_OPTION(sbi).compress_log_size = arg;
>> +		}
>> +		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
>> +		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
>> +			f2fs_err(sbi,
>> +				"Compress cluster log size is out of range");
>> +			return -EINVAL;
>> +		}
>> +		F2FS_OPTION(sbi).compress_log_size = result.uint_32;
>> +		break;
>> +	case Opt_compress_extension:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>>   			break;
>> -		case Opt_compress_extension:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -
>> -			ext = F2FS_OPTION(sbi).extensions;
>> -			ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>> -
>> -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
>> -				ext_cnt >= COMPRESS_EXT_NUM) {
>> -				f2fs_err(sbi,
>> -					"invalid extension length/number");
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> +		}
>> +		name = param->string;
>> +		ext = F2FS_OPTION(sbi).extensions;
>> +		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>>   
>> -			if (is_compress_extension_exist(sbi, name, true)) {
>> -				kfree(name);
>> -				break;
>> -			}
>> +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
>> +		    ext_cnt >= COMPRESS_EXT_NUM) {
>> +			f2fs_err(sbi, "invalid extension length/number");
>> +			return -EINVAL;
>> +		}
>>   
>> -			ret = strscpy(ext[ext_cnt], name);
>> -			if (ret < 0) {
>> -				kfree(name);
>> -				return ret;
>> -			}
>> -			F2FS_OPTION(sbi).compress_ext_cnt++;
>> -			kfree(name);
>> +		if (is_compress_extension_exist(sbi, name, true))
>>   			break;
>> -		case Opt_nocompress_extension:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -
>> -			noext = F2FS_OPTION(sbi).noextensions;
>> -			noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>>   
>> -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
>> -				noext_cnt >= COMPRESS_EXT_NUM) {
>> -				f2fs_err(sbi,
>> -					"invalid extension length/number");
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> +		ret = strscpy(ext[ext_cnt], name, F2FS_EXTENSION_LEN);
>> +		if (ret < 0)
>> +			return ret;
>> +		F2FS_OPTION(sbi).compress_ext_cnt++;
>> +		break;
>> +	case Opt_nocompress_extension:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>> +			break;
>> +		}
>> +		name = param->string;
>> +		noext = F2FS_OPTION(sbi).noextensions;
>> +		noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>>   
>> -			if (is_compress_extension_exist(sbi, name, false)) {
>> -				kfree(name);
>> -				break;
>> -			}
>> +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
>> +			noext_cnt >= COMPRESS_EXT_NUM) {
>> +			f2fs_err(sbi, "invalid extension length/number");
>> +			return -EINVAL;
>> +		}
>>   
>> -			ret = strscpy(noext[noext_cnt], name);
>> -			if (ret < 0) {
>> -				kfree(name);
>> -				return ret;
>> -			}
>> -			F2FS_OPTION(sbi).nocompress_ext_cnt++;
>> -			kfree(name);
>> +		if (is_compress_extension_exist(sbi, name, false))
>>   			break;
>> -		case Opt_compress_chksum:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			F2FS_OPTION(sbi).compress_chksum = true;
>> +
>> +		ret = strscpy(noext[noext_cnt], name, F2FS_EXTENSION_LEN);
>> +		if (ret < 0)
>> +			return ret;
>> +		F2FS_OPTION(sbi).nocompress_ext_cnt++;
>> +		break;
>> +	case Opt_compress_chksum:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>>   			break;
>> -		case Opt_compress_mode:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "fs")) {
>> -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
>> -			} else if (!strcmp(name, "user")) {
>> -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> +		}
>> +		F2FS_OPTION(sbi).compress_chksum = true;
>> +		break;
>> +	case Opt_compress_mode:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>>   			break;
>> -		case Opt_compress_cache:
>> -			if (!f2fs_sb_has_compression(sbi)) {
>> -				f2fs_info(sbi, "Image doesn't support compression");
>> -				break;
>> -			}
>> -			set_opt(sbi, COMPRESS_CACHE);
>> +		}
>> +		F2FS_OPTION(sbi).compress_mode = result.uint_32;
>> +		break;
>> +	case Opt_compress_cache:
>> +		if (!f2fs_sb_has_compression(sbi)) {
>> +			f2fs_info(sbi, "Image doesn't support compression");
>>   			break;
>> +		}
>> +		set_opt(sbi, COMPRESS_CACHE);
>> +		break;
>>   #else
>> -		case Opt_compress_algorithm:
>> -		case Opt_compress_log_size:
>> -		case Opt_compress_extension:
>> -		case Opt_nocompress_extension:
>> -		case Opt_compress_chksum:
>> -		case Opt_compress_mode:
>> -		case Opt_compress_cache:
>> -			f2fs_info(sbi, "compression options not supported");
>> -			break;
>> +	case Opt_compress_algorithm:
>> +	case Opt_compress_log_size:
>> +	case Opt_compress_extension:
>> +	case Opt_nocompress_extension:
>> +	case Opt_compress_chksum:
>> +	case Opt_compress_mode:
>> +	case Opt_compress_cache:
>> +		f2fs_info(sbi, "compression options not supported");
>> +		break;
>>   #endif
>> -		case Opt_atgc:
>> -			set_opt(sbi, ATGC);
>> -			break;
>> -		case Opt_gc_merge:
>> -			set_opt(sbi, GC_MERGE);
>> -			break;
>> -		case Opt_nogc_merge:
>> +	case Opt_atgc:
>> +		set_opt(sbi, ATGC);
>> +		break;
>> +	case Opt_gc_merge:
>> +		if (result.negated)
>>   			clear_opt(sbi, GC_MERGE);
>> -			break;
>> -		case Opt_discard_unit:
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "block")) {
>> -				F2FS_OPTION(sbi).discard_unit =
>> -						DISCARD_UNIT_BLOCK;
>> -			} else if (!strcmp(name, "segment")) {
>> -				F2FS_OPTION(sbi).discard_unit =
>> -						DISCARD_UNIT_SEGMENT;
>> -			} else if (!strcmp(name, "section")) {
>> -				F2FS_OPTION(sbi).discard_unit =
>> -						DISCARD_UNIT_SECTION;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> -			break;
>> -		case Opt_memory_mode:
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "normal")) {
>> -				F2FS_OPTION(sbi).memory_mode =
>> -						MEMORY_MODE_NORMAL;
>> -			} else if (!strcmp(name, "low")) {
>> -				F2FS_OPTION(sbi).memory_mode =
>> -						MEMORY_MODE_LOW;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> -			}
>> -			kfree(name);
>> -			break;
>> -		case Opt_age_extent_cache:
>> -			set_opt(sbi, AGE_EXTENT_CACHE);
>> -			break;
>> -		case Opt_errors:
>> -			name = match_strdup(&args[0]);
>> -			if (!name)
>> -				return -ENOMEM;
>> -			if (!strcmp(name, "remount-ro")) {
>> -				F2FS_OPTION(sbi).errors =
>> -						MOUNT_ERRORS_READONLY;
>> -			} else if (!strcmp(name, "continue")) {
>> -				F2FS_OPTION(sbi).errors =
>> -						MOUNT_ERRORS_CONTINUE;
>> -			} else if (!strcmp(name, "panic")) {
>> -				F2FS_OPTION(sbi).errors =
>> -						MOUNT_ERRORS_PANIC;
>> -			} else {
>> -				kfree(name);
>> -				return -EINVAL;
>> +		else
>> +			set_opt(sbi, GC_MERGE);
>> +		break;
>> +	case Opt_discard_unit:
>> +		F2FS_OPTION(sbi).discard_unit = result.uint_32;
>> +		break;
>> +	case Opt_memory_mode:
>> +		F2FS_OPTION(sbi).memory_mode = result.uint_32;
>> +		break;
>> +	case Opt_age_extent_cache:
>> +		set_opt(sbi, AGE_EXTENT_CACHE);
>> +		break;
>> +	case Opt_errors:
>> +		F2FS_OPTION(sbi).errors = result.uint_32;
>> +		break;
>> +	case Opt_nat_bits:
>> +		set_opt(sbi, NAT_BITS);
>> +		break;
>> +	}
>> +	return 0;
>> +}
>> +
>> +static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
>> +{
>> +	struct fs_parameter param;
>> +	struct fs_context fc;
>> +	char *key;
>> +	int ret;
>> +
>> +	if (!options)
>> +		return 0;
>> +
>> +	memset(&fc, 0, sizeof(fc));
>> +	fc.s_fs_info = sbi;
>> +	if (is_remount)
>> +		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
>> +
>> +	while ((key = strsep(&options, ",")) != NULL) {
>> +		if (*key) {
>> +			size_t v_len = 0;
>> +			char *value = strchr(key, '=');
>> +
>> +			param.type = fs_value_is_flag;
>> +			param.string = NULL;
>> +
>> +			if (value) {
>> +				if (value == key)
>> +					continue;
>> +
>> +				*value++ = 0;
>> +				v_len = strlen(value);
>> +				param.string = kmemdup_nul(value, v_len, GFP_KERNEL);
>> +				if (!param.string)
>> +					return -ENOMEM;
>> +				param.type = fs_value_is_string;
>>   			}
>> -			kfree(name);
>> -			break;
>> -		case Opt_nat_bits:
>> -			set_opt(sbi, NAT_BITS);
>> -			break;
>> -		default:
>> -			f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
>> -				 p);
>> -			return -EINVAL;
>> +
>> +			param.key = key;
>> +			param.size = v_len;
>> +
>> +			ret = handle_mount_opt(&fc, &param);
>> +			kfree(param.string);
>> +			if (ret < 0)
>> +				return ret;
>>   		}
>>   	}
>>   	return 0;
>>   }
>>   
>> -static int f2fs_default_check(struct f2fs_sb_info *sbi)
>> +static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>>   {
>>   #ifdef CONFIG_QUOTA
>>   	if (f2fs_check_quota_options(sbi))
>> @@ -2527,7 +2285,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>   	}
>>   #endif
>>   
>> -	err = f2fs_default_check(sbi);
>> +	err = f2fs_validate_options(sbi);
>>   	if (err)
>>   		goto restore_opts;
>>   
>> @@ -4725,7 +4483,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>   	if (err)
>>   		goto free_options;
>>   
>> -	err = f2fs_default_check(sbi);
>> +	err = f2fs_validate_options(sbi);
>>   	if (err)
>>   		goto free_options;
>>   
> 

Re: [PATCH v4 2/7] f2fs: move the option parser into handle_mount_opt

[Jaegeuk Kim]

Hongbo,

Could you please post v5?

Thanks,

On 07/07, Hongbo Li wrote:
> 
> 
> On 2025/7/4 11:27, Chao Yu wrote:
> > On 6/2/25 17:02, Hongbo Li wrote:
> > > In handle_mount_opt, we use fs_parameter to parse each option.
> > > However we're still using the old API to get the options string.
> > > Using fsparams parse_options allows us to remove many of the Opt_
> > > enums, so remove them.
> > > 
> > > The checkpoint disable cap (or percent) involves rather complex
> > > parsing; we retain the old match_table mechanism for this, which
> > > handles it well.
> > > 
> > > There are some changes about parsing options:
> > >    1. For `active_logs`, `inline_xattr_size` and `fault_injection`,
> > >       we use s32 type according the internal structure to record the
> > >       option's value.
> > > 
> > > Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
> > > [sandeen: forward port, minor fixes and updates]
> > > Signed-off-by: Eric Sandeen <sandeen@redhat.com>
> > > [hongbo: minor cleanup]
> > > Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
> > > ---
> > >   fs/f2fs/super.c | 1068 ++++++++++++++++++-----------------------------
> > >   1 file changed, 413 insertions(+), 655 deletions(-)
> > > 
> > > diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> > > index 996633b8379e..dff2419ba905 100644
> > > --- a/fs/f2fs/super.c
> > > +++ b/fs/f2fs/super.c
> > > @@ -27,6 +27,7 @@
> > >   #include <linux/part_stat.h>
> > >   #include <linux/zstd.h>
> > >   #include <linux/lz4.h>
> > > +#include <linux/ctype.h>
> > >   #include <linux/fs_parser.h>
> > >   #include "f2fs.h"
> > > @@ -126,29 +127,20 @@ enum {
> > >   	Opt_disable_roll_forward,
> > >   	Opt_norecovery,
> > >   	Opt_discard,
> > > -	Opt_nodiscard,
> > >   	Opt_noheap,
> > >   	Opt_heap,
> > >   	Opt_user_xattr,
> > > -	Opt_nouser_xattr,
> > >   	Opt_acl,
> > > -	Opt_noacl,
> > >   	Opt_active_logs,
> > >   	Opt_disable_ext_identify,
> > >   	Opt_inline_xattr,
> > > -	Opt_noinline_xattr,
> > >   	Opt_inline_xattr_size,
> > >   	Opt_inline_data,
> > >   	Opt_inline_dentry,
> > > -	Opt_noinline_dentry,
> > >   	Opt_flush_merge,
> > > -	Opt_noflush_merge,
> > >   	Opt_barrier,
> > > -	Opt_nobarrier,
> > >   	Opt_fastboot,
> > >   	Opt_extent_cache,
> > > -	Opt_noextent_cache,
> > > -	Opt_noinline_data,
> > >   	Opt_data_flush,
> > >   	Opt_reserve_root,
> > >   	Opt_resgid,
> > > @@ -157,21 +149,13 @@ enum {
> > >   	Opt_fault_injection,
> > >   	Opt_fault_type,
> > >   	Opt_lazytime,
> > > -	Opt_nolazytime,
> > >   	Opt_quota,
> > > -	Opt_noquota,
> > >   	Opt_usrquota,
> > >   	Opt_grpquota,
> > >   	Opt_prjquota,
> > >   	Opt_usrjquota,
> > >   	Opt_grpjquota,
> > >   	Opt_prjjquota,
> > > -	Opt_offusrjquota,
> > > -	Opt_offgrpjquota,
> > > -	Opt_offprjjquota,
> > > -	Opt_jqfmt_vfsold,
> > > -	Opt_jqfmt_vfsv0,
> > > -	Opt_jqfmt_vfsv1,
> > >   	Opt_alloc,
> > >   	Opt_fsync,
> > >   	Opt_test_dummy_encryption,
> > > @@ -181,17 +165,15 @@ enum {
> > >   	Opt_checkpoint_disable_cap_perc,
> > >   	Opt_checkpoint_enable,
> > >   	Opt_checkpoint_merge,
> > > -	Opt_nocheckpoint_merge,
> > >   	Opt_compress_algorithm,
> > >   	Opt_compress_log_size,
> > > -	Opt_compress_extension,
> > >   	Opt_nocompress_extension,
> > > +	Opt_compress_extension,
> > >   	Opt_compress_chksum,
> > >   	Opt_compress_mode,
> > >   	Opt_compress_cache,
> > >   	Opt_atgc,
> > >   	Opt_gc_merge,
> > > -	Opt_nogc_merge,
> > >   	Opt_discard_unit,
> > >   	Opt_memory_mode,
> > >   	Opt_age_extent_cache,
> > > @@ -321,83 +303,12 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
> > >   	{}
> > >   };
> > > -static match_table_t f2fs_tokens = {
> > > -	{Opt_gc_background, "background_gc=%s"},
> > > -	{Opt_disable_roll_forward, "disable_roll_forward"},
> > > -	{Opt_norecovery, "norecovery"},
> > > -	{Opt_discard, "discard"},
> > > -	{Opt_nodiscard, "nodiscard"},
> > > -	{Opt_noheap, "no_heap"},
> > > -	{Opt_heap, "heap"},
> > > -	{Opt_user_xattr, "user_xattr"},
> > > -	{Opt_nouser_xattr, "nouser_xattr"},
> > > -	{Opt_acl, "acl"},
> > > -	{Opt_noacl, "noacl"},
> > > -	{Opt_active_logs, "active_logs=%u"},
> > > -	{Opt_disable_ext_identify, "disable_ext_identify"},
> > > -	{Opt_inline_xattr, "inline_xattr"},
> > > -	{Opt_noinline_xattr, "noinline_xattr"},
> > > -	{Opt_inline_xattr_size, "inline_xattr_size=%u"},
> > > -	{Opt_inline_data, "inline_data"},
> > > -	{Opt_inline_dentry, "inline_dentry"},
> > > -	{Opt_noinline_dentry, "noinline_dentry"},
> > > -	{Opt_flush_merge, "flush_merge"},
> > > -	{Opt_noflush_merge, "noflush_merge"},
> > > -	{Opt_barrier, "barrier"},
> > > -	{Opt_nobarrier, "nobarrier"},
> > > -	{Opt_fastboot, "fastboot"},
> > > -	{Opt_extent_cache, "extent_cache"},
> > > -	{Opt_noextent_cache, "noextent_cache"},
> > > -	{Opt_noinline_data, "noinline_data"},
> > > -	{Opt_data_flush, "data_flush"},
> > > -	{Opt_reserve_root, "reserve_root=%u"},
> > > -	{Opt_resgid, "resgid=%u"},
> > > -	{Opt_resuid, "resuid=%u"},
> > > -	{Opt_mode, "mode=%s"},
> > > -	{Opt_fault_injection, "fault_injection=%u"},
> > > -	{Opt_fault_type, "fault_type=%u"},
> > > -	{Opt_lazytime, "lazytime"},
> > > -	{Opt_nolazytime, "nolazytime"},
> > > -	{Opt_quota, "quota"},
> > > -	{Opt_noquota, "noquota"},
> > > -	{Opt_usrquota, "usrquota"},
> > > -	{Opt_grpquota, "grpquota"},
> > > -	{Opt_prjquota, "prjquota"},
> > > -	{Opt_usrjquota, "usrjquota=%s"},
> > > -	{Opt_grpjquota, "grpjquota=%s"},
> > > -	{Opt_prjjquota, "prjjquota=%s"},
> > > -	{Opt_offusrjquota, "usrjquota="},
> > > -	{Opt_offgrpjquota, "grpjquota="},
> > > -	{Opt_offprjjquota, "prjjquota="},
> > > -	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
> > > -	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
> > > -	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
> > > -	{Opt_alloc, "alloc_mode=%s"},
> > > -	{Opt_fsync, "fsync_mode=%s"},
> > > -	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
> > > -	{Opt_test_dummy_encryption, "test_dummy_encryption"},
> > > -	{Opt_inlinecrypt, "inlinecrypt"},
> > > -	{Opt_checkpoint_disable, "checkpoint=disable"},
> > > -	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
> > > -	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
> > > -	{Opt_checkpoint_enable, "checkpoint=enable"},
> > > -	{Opt_checkpoint_merge, "checkpoint_merge"},
> > > -	{Opt_nocheckpoint_merge, "nocheckpoint_merge"},
> > > -	{Opt_compress_algorithm, "compress_algorithm=%s"},
> > > -	{Opt_compress_log_size, "compress_log_size=%u"},
> > > -	{Opt_compress_extension, "compress_extension=%s"},
> > > -	{Opt_nocompress_extension, "nocompress_extension=%s"},
> > > -	{Opt_compress_chksum, "compress_chksum"},
> > > -	{Opt_compress_mode, "compress_mode=%s"},
> > > -	{Opt_compress_cache, "compress_cache"},
> > > -	{Opt_atgc, "atgc"},
> > > -	{Opt_gc_merge, "gc_merge"},
> > > -	{Opt_nogc_merge, "nogc_merge"},
> > > -	{Opt_discard_unit, "discard_unit=%s"},
> > > -	{Opt_memory_mode, "memory=%s"},
> > > -	{Opt_age_extent_cache, "age_extent_cache"},
> > > -	{Opt_errors, "errors=%s"},
> > > -	{Opt_nat_bits, "nat_bits"},
> > > +/* Resort to a match_table for this interestingly formatted option */
> > > +static match_table_t f2fs_checkpoint_tokens = {
> > > +	{Opt_checkpoint_disable, "disable"},
> > > +	{Opt_checkpoint_disable_cap, "disable:%u"},
> > > +	{Opt_checkpoint_disable_cap_perc, "disable:%u%%"},
> > > +	{Opt_checkpoint_enable, "enable"},
> > >   	{Opt_err, NULL},
> > >   };
> > > @@ -513,7 +424,7 @@ static void init_once(void *foo)
> > >   static const char * const quotatypes[] = INITQFNAMES;
> > >   #define QTYPE2NAME(t) (quotatypes[t])
> > >   static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
> > > -							substring_t *args)
> > > +			    struct fs_parameter *param)
> > >   {
> > >   	struct super_block *sb = sbi->sb;
> > >   	char *qname;
> > > @@ -528,7 +439,7 @@ static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
> > >   		return 0;
> > >   	}
> > > -	qname = match_strdup(args);
> > > +	qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
> > >   	if (!qname) {
> > >   		f2fs_err(sbi, "Not enough memory for storing quotafile name");
> > >   		return -ENOMEM;
> > > @@ -613,14 +524,9 @@ static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
> > >   #endif
> > >   static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
> > > -					  const char *opt,
> > > -					  const substring_t *arg,
> > > +					  const struct fs_parameter *param,
> > >   					  bool is_remount)
> > >   {
> > > -	struct fs_parameter param = {
> > > -		.type = fs_value_is_string,
> > > -		.string = arg->from ? arg->from : "",
> > > -	};
> > >   	struct fscrypt_dummy_policy *policy =
> > >   		&F2FS_OPTION(sbi).dummy_enc_policy;
> > >   	int err;
> > > @@ -646,17 +552,17 @@ static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
> > >   		return -EINVAL;
> > >   	}
> > > -	err = fscrypt_parse_test_dummy_encryption(&param, policy);
> > > +	err = fscrypt_parse_test_dummy_encryption(param, policy);
> > >   	if (err) {
> > >   		if (err == -EEXIST)
> > >   			f2fs_warn(sbi,
> > >   				  "Can't change test_dummy_encryption on remount");
> > >   		else if (err == -EINVAL)
> > >   			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
> > > -				  opt);
> > > +				  param->key);
> > >   		else
> > >   			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
> > > -				  opt, err);
> > > +				  param->key, err);
> > >   		return -EINVAL;
> > >   	}
> > >   	f2fs_warn(sbi, "Test dummy encryption mode enabled");
> > > @@ -799,372 +705,269 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
> > >   #endif
> > >   #endif
> > > -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
> > > +static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
> > >   {
> > > -	substring_t args[MAX_OPT_ARGS];
> > > +	struct f2fs_sb_info *sbi = fc->s_fs_info;
> > >   #ifdef CONFIG_F2FS_FS_COMPRESSION
> > >   	unsigned char (*ext)[F2FS_EXTENSION_LEN];
> > >   	unsigned char (*noext)[F2FS_EXTENSION_LEN];
> > >   	int ext_cnt, noext_cnt;
> > > +	char *name;
> > >   #endif
> > > -	char *p, *name;
> > > -	int arg = 0;
> > > -	kuid_t uid;
> > > -	kgid_t gid;
> > > -	int ret;
> > > +	substring_t args[MAX_OPT_ARGS];
> > > +	struct fs_parse_result result;
> > > +	bool is_remount;
> > > +	int token, ret, arg;
> > > -	if (!options)
> > > -		return 0;
> > > +	token = fs_parse(fc, f2fs_param_specs, param, &result);
> > > +	if (token < 0)
> > > +		return token;
> > > -	while ((p = strsep(&options, ",")) != NULL) {
> > > -		int token;
> > > +	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
> > > -		if (!*p)
> > > -			continue;
> > > -		/*
> > > -		 * Initialize args struct so we know whether arg was
> > > -		 * found; some options take optional arguments.
> > > -		 */
> > > -		args[0].to = args[0].from = NULL;
> > > -		token = match_token(p, f2fs_tokens, args);
> > > -
> > > -		switch (token) {
> > > -		case Opt_gc_background:
> > > -			name = match_strdup(&args[0]);
> > > -
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "on")) {
> > > -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
> > > -			} else if (!strcmp(name, "off")) {
> > > -				if (f2fs_sb_has_blkzoned(sbi)) {
> > > -					f2fs_warn(sbi, "zoned devices need bggc");
> > > -					kfree(name);
> > > -					return -EINVAL;
> > > -				}
> > 
> > Missed to check this condition in f2fs_check_opt_consistency()?
> > 
> 
> Thanks for pointing this. Yeah, we should add this in
> f2fs_check_opt_consistency like this:
> 
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 0a070dadbb42..86938dd5491e 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -1458,6 +1458,10 @@ static int f2fs_check_opt_consistency(struct
> fs_context *fc,
>          * devices, but mandatory for host-managed zoned block devices.
>          */
>         if (f2fs_sb_has_blkzoned(sbi)) {
> +               if (F2FS_CTX_OPTION(ctx).bggc_mode == BGGC_MODE_OFF) {
> +                       f2fs_warn(sbi, "zoned devices need bggc");
> +                       return -EINVAL;
> +               }
>  #ifdef CONFIG_BLK_DEV_ZONED
>                 if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
>                 F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {
> 
> Thanks,
> Hongbo
> 
> > Thanks,
> > 
> > > -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
> > > -			} else if (!strcmp(name, "sync")) {
> > > -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
> > > -			} else {
> > > -				kfree(name);
> > > +	switch (token) {
> > > +	case Opt_gc_background:
> > > +		F2FS_OPTION(sbi).bggc_mode = result.uint_32;
> > > +		break;
> > > +	case Opt_disable_roll_forward:
> > > +		set_opt(sbi, DISABLE_ROLL_FORWARD);
> > > +		break;
> > > +	case Opt_norecovery:
> > > +		/* requires ro mount, checked in f2fs_validate_options */
> > > +		set_opt(sbi, NORECOVERY);
> > > +		break;
> > > +	case Opt_discard:
> > > +		if (result.negated) {
> > > +			if (f2fs_hw_should_discard(sbi)) {
> > > +				f2fs_warn(sbi, "discard is required for zoned block devices");
> > >   				return -EINVAL;
> > >   			}
> > > -			kfree(name);
> > > -			break;
> > > -		case Opt_disable_roll_forward:
> > > -			set_opt(sbi, DISABLE_ROLL_FORWARD);
> > > -			break;
> > > -		case Opt_norecovery:
> > > -			/* requires ro mount, checked in f2fs_default_check */
> > > -			set_opt(sbi, NORECOVERY);
> > > -			break;
> > > -		case Opt_discard:
> > > +			clear_opt(sbi, DISCARD);
> > > +		} else {
> > >   			if (!f2fs_hw_support_discard(sbi)) {
> > >   				f2fs_warn(sbi, "device does not support discard");
> > >   				break;
> > >   			}
> > >   			set_opt(sbi, DISCARD);
> > > -			break;
> > > -		case Opt_nodiscard:
> > > -			if (f2fs_hw_should_discard(sbi)) {
> > > -				f2fs_warn(sbi, "discard is required for zoned block devices");
> > > -				return -EINVAL;
> > > -			}
> > > -			clear_opt(sbi, DISCARD);
> > > -			break;
> > > -		case Opt_noheap:
> > > -		case Opt_heap:
> > > -			f2fs_warn(sbi, "heap/no_heap options were deprecated");
> > > -			break;
> > > +		}
> > > +		break;
> > > +	case Opt_noheap:
> > > +	case Opt_heap:
> > > +		f2fs_warn(sbi, "heap/no_heap options were deprecated");
> > > +		break;
> > >   #ifdef CONFIG_F2FS_FS_XATTR
> > > -		case Opt_user_xattr:
> > > -			set_opt(sbi, XATTR_USER);
> > > -			break;
> > > -		case Opt_nouser_xattr:
> > > +	case Opt_user_xattr:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, XATTR_USER);
> > > -			break;
> > > -		case Opt_inline_xattr:
> > > -			set_opt(sbi, INLINE_XATTR);
> > > -			break;
> > > -		case Opt_noinline_xattr:
> > > +		else
> > > +			set_opt(sbi, XATTR_USER);
> > > +		break;
> > > +	case Opt_inline_xattr:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, INLINE_XATTR);
> > > -			break;
> > > -		case Opt_inline_xattr_size:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			set_opt(sbi, INLINE_XATTR_SIZE);
> > > -			F2FS_OPTION(sbi).inline_xattr_size = arg;
> > > -			break;
> > > +		else
> > > +			set_opt(sbi, INLINE_XATTR);
> > > +		break;
> > > +	case Opt_inline_xattr_size:
> > > +		set_opt(sbi, INLINE_XATTR_SIZE);
> > > +		F2FS_OPTION(sbi).inline_xattr_size = result.int_32;
> > > +		break;
> > >   #else
> > > -		case Opt_user_xattr:
> > > -		case Opt_nouser_xattr:
> > > -		case Opt_inline_xattr:
> > > -		case Opt_noinline_xattr:
> > > -		case Opt_inline_xattr_size:
> > > -			f2fs_info(sbi, "xattr options not supported");
> > > -			break;
> > > +	case Opt_user_xattr:
> > > +	case Opt_inline_xattr:
> > > +	case Opt_inline_xattr_size:
> > > +		f2fs_info(sbi, "%s options not supported", param->key);
> > > +		break;
> > >   #endif
> > >   #ifdef CONFIG_F2FS_FS_POSIX_ACL
> > > -		case Opt_acl:
> > > -			set_opt(sbi, POSIX_ACL);
> > > -			break;
> > > -		case Opt_noacl:
> > > +	case Opt_acl:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, POSIX_ACL);
> > > -			break;
> > > +		else
> > > +			set_opt(sbi, POSIX_ACL);
> > > +		break;
> > >   #else
> > > -		case Opt_acl:
> > > -		case Opt_noacl:
> > > -			f2fs_info(sbi, "acl options not supported");
> > > -			break;
> > > +	case Opt_acl:
> > > +		f2fs_info(sbi, "%s options not supported", param->key);
> > > +		break;
> > >   #endif
> > > -		case Opt_active_logs:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			if (arg != 2 && arg != 4 &&
> > > -				arg != NR_CURSEG_PERSIST_TYPE)
> > > -				return -EINVAL;
> > > -			F2FS_OPTION(sbi).active_logs = arg;
> > > -			break;
> > > -		case Opt_disable_ext_identify:
> > > -			set_opt(sbi, DISABLE_EXT_IDENTIFY);
> > > -			break;
> > > -		case Opt_inline_data:
> > > +	case Opt_active_logs:
> > > +		if (result.int_32 != 2 && result.int_32 != 4 &&
> > > +			result.int_32 != NR_CURSEG_PERSIST_TYPE)
> > > +			return -EINVAL;
> > > +		F2FS_OPTION(sbi).active_logs = result.int_32;
> > > +		break;
> > > +	case Opt_disable_ext_identify:
> > > +		set_opt(sbi, DISABLE_EXT_IDENTIFY);
> > > +		break;
> > > +	case Opt_inline_data:
> > > +		if (result.negated)
> > > +			clear_opt(sbi, INLINE_DATA);
> > > +		else
> > >   			set_opt(sbi, INLINE_DATA);
> > > -			break;
> > > -		case Opt_inline_dentry:
> > > -			set_opt(sbi, INLINE_DENTRY);
> > > -			break;
> > > -		case Opt_noinline_dentry:
> > > +		break;
> > > +	case Opt_inline_dentry:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, INLINE_DENTRY);
> > > -			break;
> > > -		case Opt_flush_merge:
> > > -			set_opt(sbi, FLUSH_MERGE);
> > > -			break;
> > > -		case Opt_noflush_merge:
> > > +		else
> > > +			set_opt(sbi, INLINE_DENTRY);
> > > +		break;
> > > +	case Opt_flush_merge:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, FLUSH_MERGE);
> > > -			break;
> > > -		case Opt_nobarrier:
> > > +		else
> > > +			set_opt(sbi, FLUSH_MERGE);
> > > +		break;
> > > +	case Opt_barrier:
> > > +		if (result.negated)
> > >   			set_opt(sbi, NOBARRIER);
> > > -			break;
> > > -		case Opt_barrier:
> > > +		else
> > >   			clear_opt(sbi, NOBARRIER);
> > > -			break;
> > > -		case Opt_fastboot:
> > > -			set_opt(sbi, FASTBOOT);
> > > -			break;
> > > -		case Opt_extent_cache:
> > > -			set_opt(sbi, READ_EXTENT_CACHE);
> > > -			break;
> > > -		case Opt_noextent_cache:
> > > +		break;
> > > +	case Opt_fastboot:
> > > +		set_opt(sbi, FASTBOOT);
> > > +		break;
> > > +	case Opt_extent_cache:
> > > +		if (result.negated) {
> > >   			if (f2fs_sb_has_device_alias(sbi)) {
> > >   				f2fs_err(sbi, "device aliasing requires extent cache");
> > >   				return -EINVAL;
> > >   			}
> > >   			clear_opt(sbi, READ_EXTENT_CACHE);
> > > -			break;
> > > -		case Opt_noinline_data:
> > > -			clear_opt(sbi, INLINE_DATA);
> > > -			break;
> > > -		case Opt_data_flush:
> > > -			set_opt(sbi, DATA_FLUSH);
> > > -			break;
> > > -		case Opt_reserve_root:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			if (test_opt(sbi, RESERVE_ROOT)) {
> > > -				f2fs_info(sbi, "Preserve previous reserve_root=%u",
> > > -					  F2FS_OPTION(sbi).root_reserved_blocks);
> > > -			} else {
> > > -				F2FS_OPTION(sbi).root_reserved_blocks = arg;
> > > -				set_opt(sbi, RESERVE_ROOT);
> > > -			}
> > > -			break;
> > > -		case Opt_resuid:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			uid = make_kuid(current_user_ns(), arg);
> > > -			if (!uid_valid(uid)) {
> > > -				f2fs_err(sbi, "Invalid uid value %d", arg);
> > > -				return -EINVAL;
> > > -			}
> > > -			F2FS_OPTION(sbi).s_resuid = uid;
> > > -			break;
> > > -		case Opt_resgid:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			gid = make_kgid(current_user_ns(), arg);
> > > -			if (!gid_valid(gid)) {
> > > -				f2fs_err(sbi, "Invalid gid value %d", arg);
> > > -				return -EINVAL;
> > > -			}
> > > -			F2FS_OPTION(sbi).s_resgid = gid;
> > > -			break;
> > > -		case Opt_mode:
> > > -			name = match_strdup(&args[0]);
> > > -
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "adaptive")) {
> > > -				F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
> > > -			} else if (!strcmp(name, "lfs")) {
> > > -				F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
> > > -			} else if (!strcmp(name, "fragment:segment")) {
> > > -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;
> > > -			} else if (!strcmp(name, "fragment:block")) {
> > > -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > -			break;
> > > +		} else
> > > +			set_opt(sbi, READ_EXTENT_CACHE);
> > > +		break;
> > > +	case Opt_data_flush:
> > > +		set_opt(sbi, DATA_FLUSH);
> > > +		break;
> > > +	case Opt_reserve_root:
> > > +		if (test_opt(sbi, RESERVE_ROOT)) {
> > > +			f2fs_info(sbi, "Preserve previous reserve_root=%u",
> > > +				  F2FS_OPTION(sbi).root_reserved_blocks);
> > > +		} else {
> > > +			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
> > > +			set_opt(sbi, RESERVE_ROOT);
> > > +		}
> > > +		break;
> > > +	case Opt_resuid:
> > > +		F2FS_OPTION(sbi).s_resuid = result.uid;
> > > +		break;
> > > +	case Opt_resgid:
> > > +		F2FS_OPTION(sbi).s_resgid = result.gid;
> > > +		break;
> > > +	case Opt_mode:
> > > +		F2FS_OPTION(sbi).fs_mode = result.uint_32;
> > > +		break;
> > >   #ifdef CONFIG_F2FS_FAULT_INJECTION
> > > -		case Opt_fault_injection:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			if (f2fs_build_fault_attr(sbi, arg, 0, FAULT_RATE))
> > > -				return -EINVAL;
> > > -			set_opt(sbi, FAULT_INJECTION);
> > > -			break;
> > > +	case Opt_fault_injection:
> > > +		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
> > > +			return -EINVAL;
> > > +		set_opt(sbi, FAULT_INJECTION);
> > > +		break;
> > > -		case Opt_fault_type:
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			if (f2fs_build_fault_attr(sbi, 0, arg, FAULT_TYPE))
> > > -				return -EINVAL;
> > > -			set_opt(sbi, FAULT_INJECTION);
> > > -			break;
> > > +	case Opt_fault_type:
> > > +		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
> > > +			return -EINVAL;
> > > +		set_opt(sbi, FAULT_INJECTION);
> > > +		break;
> > >   #else
> > > -		case Opt_fault_injection:
> > > -		case Opt_fault_type:
> > > -			f2fs_info(sbi, "fault injection options not supported");
> > > -			break;
> > > +	case Opt_fault_injection:
> > > +	case Opt_fault_type:
> > > +		f2fs_info(sbi, "%s options not supported", param->key);
> > > +		break;
> > >   #endif
> > > -		case Opt_lazytime:
> > > -			set_opt(sbi, LAZYTIME);
> > > -			break;
> > > -		case Opt_nolazytime:
> > > +	case Opt_lazytime:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, LAZYTIME);
> > > -			break;
> > > +		else
> > > +			set_opt(sbi, LAZYTIME);
> > > +		break;
> > >   #ifdef CONFIG_QUOTA
> > > -		case Opt_quota:
> > > -		case Opt_usrquota:
> > > -			set_opt(sbi, USRQUOTA);
> > > -			break;
> > > -		case Opt_grpquota:
> > > -			set_opt(sbi, GRPQUOTA);
> > > -			break;
> > > -		case Opt_prjquota:
> > > -			set_opt(sbi, PRJQUOTA);
> > > -			break;
> > > -		case Opt_usrjquota:
> > > -			ret = f2fs_set_qf_name(sbi, USRQUOTA, &args[0]);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_grpjquota:
> > > -			ret = f2fs_set_qf_name(sbi, GRPQUOTA, &args[0]);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_prjjquota:
> > > -			ret = f2fs_set_qf_name(sbi, PRJQUOTA, &args[0]);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_offusrjquota:
> > > -			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_offgrpjquota:
> > > -			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_offprjjquota:
> > > -			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_jqfmt_vfsold:
> > > -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
> > > -			break;
> > > -		case Opt_jqfmt_vfsv0:
> > > -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
> > > -			break;
> > > -		case Opt_jqfmt_vfsv1:
> > > -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
> > > -			break;
> > > -		case Opt_noquota:
> > > +	case Opt_quota:
> > > +		if (result.negated) {
> > >   			clear_opt(sbi, QUOTA);
> > >   			clear_opt(sbi, USRQUOTA);
> > >   			clear_opt(sbi, GRPQUOTA);
> > >   			clear_opt(sbi, PRJQUOTA);
> > > -			break;
> > > +		} else
> > > +			set_opt(sbi, USRQUOTA);
> > > +		break;
> > > +	case Opt_usrquota:
> > > +		set_opt(sbi, USRQUOTA);
> > > +		break;
> > > +	case Opt_grpquota:
> > > +		set_opt(sbi, GRPQUOTA);
> > > +		break;
> > > +	case Opt_prjquota:
> > > +		set_opt(sbi, PRJQUOTA);
> > > +		break;
> > > +	case Opt_usrjquota:
> > > +		if (!*param->string)
> > > +			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
> > > +		else
> > > +			ret = f2fs_set_qf_name(sbi, USRQUOTA, param);
> > > +		if (ret)
> > > +			return ret;
> > > +		break;
> > > +	case Opt_grpjquota:
> > > +		if (!*param->string)
> > > +			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
> > > +		else
> > > +			ret = f2fs_set_qf_name(sbi, GRPQUOTA, param);
> > > +		if (ret)
> > > +			return ret;
> > > +		break;
> > > +	case Opt_prjjquota:
> > > +		if (!*param->string)
> > > +			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
> > > +		else
> > > +			ret = f2fs_set_qf_name(sbi, PRJQUOTA, param);
> > > +		if (ret)
> > > +			return ret;
> > > +		break;
> > > +	case Opt_jqfmt:
> > > +		F2FS_OPTION(sbi).s_jquota_fmt = result.uint_32;
> > > +		break;
> > >   #else
> > > -		case Opt_quota:
> > > -		case Opt_usrquota:
> > > -		case Opt_grpquota:
> > > -		case Opt_prjquota:
> > > -		case Opt_usrjquota:
> > > -		case Opt_grpjquota:
> > > -		case Opt_prjjquota:
> > > -		case Opt_offusrjquota:
> > > -		case Opt_offgrpjquota:
> > > -		case Opt_offprjjquota:
> > > -		case Opt_jqfmt_vfsold:
> > > -		case Opt_jqfmt_vfsv0:
> > > -		case Opt_jqfmt_vfsv1:
> > > -		case Opt_noquota:
> > > -			f2fs_info(sbi, "quota operations not supported");
> > > -			break;
> > > +	case Opt_quota:
> > > +	case Opt_usrquota:
> > > +	case Opt_grpquota:
> > > +	case Opt_prjquota:
> > > +	case Opt_usrjquota:
> > > +	case Opt_grpjquota:
> > > +	case Opt_prjjquota:
> > > +		f2fs_info(sbi, "quota operations not supported");
> > > +		break;
> > >   #endif
> > > -		case Opt_alloc:
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -
> > > -			if (!strcmp(name, "default")) {
> > > -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
> > > -			} else if (!strcmp(name, "reuse")) {
> > > -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > -			break;
> > > -		case Opt_fsync:
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "posix")) {
> > > -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
> > > -			} else if (!strcmp(name, "strict")) {
> > > -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
> > > -			} else if (!strcmp(name, "nobarrier")) {
> > > -				F2FS_OPTION(sbi).fsync_mode =
> > > -							FSYNC_MODE_NOBARRIER;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > -			break;
> > > -		case Opt_test_dummy_encryption:
> > > -			ret = f2fs_set_test_dummy_encryption(sbi, p, &args[0],
> > > -							     is_remount);
> > > -			if (ret)
> > > -				return ret;
> > > -			break;
> > > -		case Opt_inlinecrypt:
> > > +	case Opt_alloc:
> > > +		F2FS_OPTION(sbi).alloc_mode = result.uint_32;
> > > +		break;
> > > +	case Opt_fsync:
> > > +		F2FS_OPTION(sbi).fsync_mode = result.uint_32;
> > > +		break;
> > > +	case Opt_test_dummy_encryption:
> > > +		ret = f2fs_set_test_dummy_encryption(sbi, param, is_remount);
> > > +		if (ret)
> > > +			return ret;
> > > +		break;
> > > +	case Opt_inlinecrypt:
> > >   #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
> > > -			set_opt(sbi, INLINECRYPT);
> > > +		set_opt(sbi, INLINECRYPT);
> > >   #else
> > > -			f2fs_info(sbi, "inline encryption not supported");
> > > +		f2fs_info(sbi, "inline encryption not supported");
> > >   #endif
> > > -			break;
> > > +		break;
> > > +	case Opt_checkpoint:
> > > +		/*
> > > +		 * Initialize args struct so we know whether arg was
> > > +		 * found; some options take optional arguments.
> > > +		 */
> > > +		args[0].from = args[0].to = NULL;
> > > +		arg = 0;
> > > +
> > > +		/* revert to match_table for checkpoint= options */
> > > +		token = match_token(param->string, f2fs_checkpoint_tokens, args);
> > > +		switch (token) {
> > >   		case Opt_checkpoint_disable_cap_perc:
> > >   			if (args->from && match_int(args, &arg))
> > >   				return -EINVAL;
> > > @@ -1185,270 +988,225 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
> > >   		case Opt_checkpoint_enable:
> > >   			clear_opt(sbi, DISABLE_CHECKPOINT);
> > >   			break;
> > > -		case Opt_checkpoint_merge:
> > > -			set_opt(sbi, MERGE_CHECKPOINT);
> > > -			break;
> > > -		case Opt_nocheckpoint_merge:
> > > +		default:
> > > +			return -EINVAL;
> > > +		}
> > > +		break;
> > > +	case Opt_checkpoint_merge:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, MERGE_CHECKPOINT);
> > > -			break;
> > > +		else
> > > +			set_opt(sbi, MERGE_CHECKPOINT);
> > > +		break;
> > >   #ifdef CONFIG_F2FS_FS_COMPRESSION
> > > -		case Opt_compress_algorithm:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "lzo")) {
> > > +	case Opt_compress_algorithm:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > > +			break;
> > > +		}
> > > +		name = param->string;
> > > +		if (!strcmp(name, "lzo")) {
> > >   #ifdef CONFIG_F2FS_FS_LZO
> > > -				F2FS_OPTION(sbi).compress_level = 0;
> > > -				F2FS_OPTION(sbi).compress_algorithm =
> > > -								COMPRESS_LZO;
> > > +			F2FS_OPTION(sbi).compress_level = 0;
> > > +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
> > >   #else
> > > -				f2fs_info(sbi, "kernel doesn't support lzo compression");
> > > +			f2fs_info(sbi, "kernel doesn't support lzo compression");
> > >   #endif
> > > -			} else if (!strncmp(name, "lz4", 3)) {
> > > +		} else if (!strncmp(name, "lz4", 3)) {
> > >   #ifdef CONFIG_F2FS_FS_LZ4
> > > -				ret = f2fs_set_lz4hc_level(sbi, name);
> > > -				if (ret) {
> > > -					kfree(name);
> > > -					return -EINVAL;
> > > -				}
> > > -				F2FS_OPTION(sbi).compress_algorithm =
> > > -								COMPRESS_LZ4;
> > > +			ret = f2fs_set_lz4hc_level(sbi, name);
> > > +			if (ret)
> > > +				return -EINVAL;
> > > +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
> > >   #else
> > > -				f2fs_info(sbi, "kernel doesn't support lz4 compression");
> > > +			f2fs_info(sbi, "kernel doesn't support lz4 compression");
> > >   #endif
> > > -			} else if (!strncmp(name, "zstd", 4)) {
> > > +		} else if (!strncmp(name, "zstd", 4)) {
> > >   #ifdef CONFIG_F2FS_FS_ZSTD
> > > -				ret = f2fs_set_zstd_level(sbi, name);
> > > -				if (ret) {
> > > -					kfree(name);
> > > -					return -EINVAL;
> > > -				}
> > > -				F2FS_OPTION(sbi).compress_algorithm =
> > > -								COMPRESS_ZSTD;
> > > +			ret = f2fs_set_zstd_level(sbi, name);
> > > +			if (ret)
> > > +				return -EINVAL;
> > > +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
> > >   #else
> > > -				f2fs_info(sbi, "kernel doesn't support zstd compression");
> > > +			f2fs_info(sbi, "kernel doesn't support zstd compression");
> > >   #endif
> > > -			} else if (!strcmp(name, "lzo-rle")) {
> > > +		} else if (!strcmp(name, "lzo-rle")) {
> > >   #ifdef CONFIG_F2FS_FS_LZORLE
> > > -				F2FS_OPTION(sbi).compress_level = 0;
> > > -				F2FS_OPTION(sbi).compress_algorithm =
> > > -								COMPRESS_LZORLE;
> > > +			F2FS_OPTION(sbi).compress_level = 0;
> > > +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
> > >   #else
> > > -				f2fs_info(sbi, "kernel doesn't support lzorle compression");
> > > +			f2fs_info(sbi, "kernel doesn't support lzorle compression");
> > >   #endif
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > +		} else
> > > +			return -EINVAL;
> > > +		break;
> > > +	case Opt_compress_log_size:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > >   			break;
> > > -		case Opt_compress_log_size:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			if (args->from && match_int(args, &arg))
> > > -				return -EINVAL;
> > > -			if (arg < MIN_COMPRESS_LOG_SIZE ||
> > > -				arg > MAX_COMPRESS_LOG_SIZE) {
> > > -				f2fs_err(sbi,
> > > -					"Compress cluster log size is out of range");
> > > -				return -EINVAL;
> > > -			}
> > > -			F2FS_OPTION(sbi).compress_log_size = arg;
> > > +		}
> > > +		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
> > > +		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
> > > +			f2fs_err(sbi,
> > > +				"Compress cluster log size is out of range");
> > > +			return -EINVAL;
> > > +		}
> > > +		F2FS_OPTION(sbi).compress_log_size = result.uint_32;
> > > +		break;
> > > +	case Opt_compress_extension:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > >   			break;
> > > -		case Opt_compress_extension:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -
> > > -			ext = F2FS_OPTION(sbi).extensions;
> > > -			ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> > > -
> > > -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
> > > -				ext_cnt >= COMPRESS_EXT_NUM) {
> > > -				f2fs_err(sbi,
> > > -					"invalid extension length/number");
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > +		}
> > > +		name = param->string;
> > > +		ext = F2FS_OPTION(sbi).extensions;
> > > +		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> > > -			if (is_compress_extension_exist(sbi, name, true)) {
> > > -				kfree(name);
> > > -				break;
> > > -			}
> > > +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
> > > +		    ext_cnt >= COMPRESS_EXT_NUM) {
> > > +			f2fs_err(sbi, "invalid extension length/number");
> > > +			return -EINVAL;
> > > +		}
> > > -			ret = strscpy(ext[ext_cnt], name);
> > > -			if (ret < 0) {
> > > -				kfree(name);
> > > -				return ret;
> > > -			}
> > > -			F2FS_OPTION(sbi).compress_ext_cnt++;
> > > -			kfree(name);
> > > +		if (is_compress_extension_exist(sbi, name, true))
> > >   			break;
> > > -		case Opt_nocompress_extension:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -
> > > -			noext = F2FS_OPTION(sbi).noextensions;
> > > -			noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
> > > -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
> > > -				noext_cnt >= COMPRESS_EXT_NUM) {
> > > -				f2fs_err(sbi,
> > > -					"invalid extension length/number");
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > +		ret = strscpy(ext[ext_cnt], name, F2FS_EXTENSION_LEN);
> > > +		if (ret < 0)
> > > +			return ret;
> > > +		F2FS_OPTION(sbi).compress_ext_cnt++;
> > > +		break;
> > > +	case Opt_nocompress_extension:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > > +			break;
> > > +		}
> > > +		name = param->string;
> > > +		noext = F2FS_OPTION(sbi).noextensions;
> > > +		noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
> > > -			if (is_compress_extension_exist(sbi, name, false)) {
> > > -				kfree(name);
> > > -				break;
> > > -			}
> > > +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
> > > +			noext_cnt >= COMPRESS_EXT_NUM) {
> > > +			f2fs_err(sbi, "invalid extension length/number");
> > > +			return -EINVAL;
> > > +		}
> > > -			ret = strscpy(noext[noext_cnt], name);
> > > -			if (ret < 0) {
> > > -				kfree(name);
> > > -				return ret;
> > > -			}
> > > -			F2FS_OPTION(sbi).nocompress_ext_cnt++;
> > > -			kfree(name);
> > > +		if (is_compress_extension_exist(sbi, name, false))
> > >   			break;
> > > -		case Opt_compress_chksum:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			F2FS_OPTION(sbi).compress_chksum = true;
> > > +
> > > +		ret = strscpy(noext[noext_cnt], name, F2FS_EXTENSION_LEN);
> > > +		if (ret < 0)
> > > +			return ret;
> > > +		F2FS_OPTION(sbi).nocompress_ext_cnt++;
> > > +		break;
> > > +	case Opt_compress_chksum:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > >   			break;
> > > -		case Opt_compress_mode:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "fs")) {
> > > -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
> > > -			} else if (!strcmp(name, "user")) {
> > > -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > +		}
> > > +		F2FS_OPTION(sbi).compress_chksum = true;
> > > +		break;
> > > +	case Opt_compress_mode:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > >   			break;
> > > -		case Opt_compress_cache:
> > > -			if (!f2fs_sb_has_compression(sbi)) {
> > > -				f2fs_info(sbi, "Image doesn't support compression");
> > > -				break;
> > > -			}
> > > -			set_opt(sbi, COMPRESS_CACHE);
> > > +		}
> > > +		F2FS_OPTION(sbi).compress_mode = result.uint_32;
> > > +		break;
> > > +	case Opt_compress_cache:
> > > +		if (!f2fs_sb_has_compression(sbi)) {
> > > +			f2fs_info(sbi, "Image doesn't support compression");
> > >   			break;
> > > +		}
> > > +		set_opt(sbi, COMPRESS_CACHE);
> > > +		break;
> > >   #else
> > > -		case Opt_compress_algorithm:
> > > -		case Opt_compress_log_size:
> > > -		case Opt_compress_extension:
> > > -		case Opt_nocompress_extension:
> > > -		case Opt_compress_chksum:
> > > -		case Opt_compress_mode:
> > > -		case Opt_compress_cache:
> > > -			f2fs_info(sbi, "compression options not supported");
> > > -			break;
> > > +	case Opt_compress_algorithm:
> > > +	case Opt_compress_log_size:
> > > +	case Opt_compress_extension:
> > > +	case Opt_nocompress_extension:
> > > +	case Opt_compress_chksum:
> > > +	case Opt_compress_mode:
> > > +	case Opt_compress_cache:
> > > +		f2fs_info(sbi, "compression options not supported");
> > > +		break;
> > >   #endif
> > > -		case Opt_atgc:
> > > -			set_opt(sbi, ATGC);
> > > -			break;
> > > -		case Opt_gc_merge:
> > > -			set_opt(sbi, GC_MERGE);
> > > -			break;
> > > -		case Opt_nogc_merge:
> > > +	case Opt_atgc:
> > > +		set_opt(sbi, ATGC);
> > > +		break;
> > > +	case Opt_gc_merge:
> > > +		if (result.negated)
> > >   			clear_opt(sbi, GC_MERGE);
> > > -			break;
> > > -		case Opt_discard_unit:
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "block")) {
> > > -				F2FS_OPTION(sbi).discard_unit =
> > > -						DISCARD_UNIT_BLOCK;
> > > -			} else if (!strcmp(name, "segment")) {
> > > -				F2FS_OPTION(sbi).discard_unit =
> > > -						DISCARD_UNIT_SEGMENT;
> > > -			} else if (!strcmp(name, "section")) {
> > > -				F2FS_OPTION(sbi).discard_unit =
> > > -						DISCARD_UNIT_SECTION;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > -			break;
> > > -		case Opt_memory_mode:
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "normal")) {
> > > -				F2FS_OPTION(sbi).memory_mode =
> > > -						MEMORY_MODE_NORMAL;
> > > -			} else if (!strcmp(name, "low")) {
> > > -				F2FS_OPTION(sbi).memory_mode =
> > > -						MEMORY_MODE_LOW;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > -			}
> > > -			kfree(name);
> > > -			break;
> > > -		case Opt_age_extent_cache:
> > > -			set_opt(sbi, AGE_EXTENT_CACHE);
> > > -			break;
> > > -		case Opt_errors:
> > > -			name = match_strdup(&args[0]);
> > > -			if (!name)
> > > -				return -ENOMEM;
> > > -			if (!strcmp(name, "remount-ro")) {
> > > -				F2FS_OPTION(sbi).errors =
> > > -						MOUNT_ERRORS_READONLY;
> > > -			} else if (!strcmp(name, "continue")) {
> > > -				F2FS_OPTION(sbi).errors =
> > > -						MOUNT_ERRORS_CONTINUE;
> > > -			} else if (!strcmp(name, "panic")) {
> > > -				F2FS_OPTION(sbi).errors =
> > > -						MOUNT_ERRORS_PANIC;
> > > -			} else {
> > > -				kfree(name);
> > > -				return -EINVAL;
> > > +		else
> > > +			set_opt(sbi, GC_MERGE);
> > > +		break;
> > > +	case Opt_discard_unit:
> > > +		F2FS_OPTION(sbi).discard_unit = result.uint_32;
> > > +		break;
> > > +	case Opt_memory_mode:
> > > +		F2FS_OPTION(sbi).memory_mode = result.uint_32;
> > > +		break;
> > > +	case Opt_age_extent_cache:
> > > +		set_opt(sbi, AGE_EXTENT_CACHE);
> > > +		break;
> > > +	case Opt_errors:
> > > +		F2FS_OPTION(sbi).errors = result.uint_32;
> > > +		break;
> > > +	case Opt_nat_bits:
> > > +		set_opt(sbi, NAT_BITS);
> > > +		break;
> > > +	}
> > > +	return 0;
> > > +}
> > > +
> > > +static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
> > > +{
> > > +	struct fs_parameter param;
> > > +	struct fs_context fc;
> > > +	char *key;
> > > +	int ret;
> > > +
> > > +	if (!options)
> > > +		return 0;
> > > +
> > > +	memset(&fc, 0, sizeof(fc));
> > > +	fc.s_fs_info = sbi;
> > > +	if (is_remount)
> > > +		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
> > > +
> > > +	while ((key = strsep(&options, ",")) != NULL) {
> > > +		if (*key) {
> > > +			size_t v_len = 0;
> > > +			char *value = strchr(key, '=');
> > > +
> > > +			param.type = fs_value_is_flag;
> > > +			param.string = NULL;
> > > +
> > > +			if (value) {
> > > +				if (value == key)
> > > +					continue;
> > > +
> > > +				*value++ = 0;
> > > +				v_len = strlen(value);
> > > +				param.string = kmemdup_nul(value, v_len, GFP_KERNEL);
> > > +				if (!param.string)
> > > +					return -ENOMEM;
> > > +				param.type = fs_value_is_string;
> > >   			}
> > > -			kfree(name);
> > > -			break;
> > > -		case Opt_nat_bits:
> > > -			set_opt(sbi, NAT_BITS);
> > > -			break;
> > > -		default:
> > > -			f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
> > > -				 p);
> > > -			return -EINVAL;
> > > +
> > > +			param.key = key;
> > > +			param.size = v_len;
> > > +
> > > +			ret = handle_mount_opt(&fc, &param);
> > > +			kfree(param.string);
> > > +			if (ret < 0)
> > > +				return ret;
> > >   		}
> > >   	}
> > >   	return 0;
> > >   }
> > > -static int f2fs_default_check(struct f2fs_sb_info *sbi)
> > > +static int f2fs_validate_options(struct f2fs_sb_info *sbi)
> > >   {
> > >   #ifdef CONFIG_QUOTA
> > >   	if (f2fs_check_quota_options(sbi))
> > > @@ -2527,7 +2285,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
> > >   	}
> > >   #endif
> > > -	err = f2fs_default_check(sbi);
> > > +	err = f2fs_validate_options(sbi);
> > >   	if (err)
> > >   		goto restore_opts;
> > > @@ -4725,7 +4483,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
> > >   	if (err)
> > >   		goto free_options;
> > > -	err = f2fs_default_check(sbi);
> > > +	err = f2fs_validate_options(sbi);
> > >   	if (err)
> > >   		goto free_options;
> > 

Re: [PATCH v4 2/7] f2fs: move the option parser into handle_mount_opt

[Hongbo Li]

On 2025/7/10 1:48, Jaegeuk Kim wrote:
> Hongbo,
> 
> Could you please post v5?
> 

Ok, so I summary the new comments:
1. The missing in f2fs_check_opt_consistency for bggc_mode(off) with 
blkzoned.
2. The 0day-ci robot reports in [1]

[1] 
https://lore.kernel.org/oe-kbuild-all/202507042222.t8N0OTvE-lkp@intel.com/

Thanks,
Hongbo

> Thanks,
> 
> On 07/07, Hongbo Li wrote:
>>
>>
>> On 2025/7/4 11:27, Chao Yu wrote:
>>> On 6/2/25 17:02, Hongbo Li wrote:
>>>> In handle_mount_opt, we use fs_parameter to parse each option.
>>>> However we're still using the old API to get the options string.
>>>> Using fsparams parse_options allows us to remove many of the Opt_
>>>> enums, so remove them.
>>>>
>>>> The checkpoint disable cap (or percent) involves rather complex
>>>> parsing; we retain the old match_table mechanism for this, which
>>>> handles it well.
>>>>
>>>> There are some changes about parsing options:
>>>>     1. For `active_logs`, `inline_xattr_size` and `fault_injection`,
>>>>        we use s32 type according the internal structure to record the
>>>>        option's value.
>>>>
>>>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>>>> [sandeen: forward port, minor fixes and updates]
>>>> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
>>>> [hongbo: minor cleanup]
>>>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>>>> ---
>>>>    fs/f2fs/super.c | 1068 ++++++++++++++++++-----------------------------
>>>>    1 file changed, 413 insertions(+), 655 deletions(-)
>>>>
>>>> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
>>>> index 996633b8379e..dff2419ba905 100644
>>>> --- a/fs/f2fs/super.c
>>>> +++ b/fs/f2fs/super.c
>>>> @@ -27,6 +27,7 @@
>>>>    #include <linux/part_stat.h>
>>>>    #include <linux/zstd.h>
>>>>    #include <linux/lz4.h>
>>>> +#include <linux/ctype.h>
>>>>    #include <linux/fs_parser.h>
>>>>    #include "f2fs.h"
>>>> @@ -126,29 +127,20 @@ enum {
>>>>    	Opt_disable_roll_forward,
>>>>    	Opt_norecovery,
>>>>    	Opt_discard,
>>>> -	Opt_nodiscard,
>>>>    	Opt_noheap,
>>>>    	Opt_heap,
>>>>    	Opt_user_xattr,
>>>> -	Opt_nouser_xattr,
>>>>    	Opt_acl,
>>>> -	Opt_noacl,
>>>>    	Opt_active_logs,
>>>>    	Opt_disable_ext_identify,
>>>>    	Opt_inline_xattr,
>>>> -	Opt_noinline_xattr,
>>>>    	Opt_inline_xattr_size,
>>>>    	Opt_inline_data,
>>>>    	Opt_inline_dentry,
>>>> -	Opt_noinline_dentry,
>>>>    	Opt_flush_merge,
>>>> -	Opt_noflush_merge,
>>>>    	Opt_barrier,
>>>> -	Opt_nobarrier,
>>>>    	Opt_fastboot,
>>>>    	Opt_extent_cache,
>>>> -	Opt_noextent_cache,
>>>> -	Opt_noinline_data,
>>>>    	Opt_data_flush,
>>>>    	Opt_reserve_root,
>>>>    	Opt_resgid,
>>>> @@ -157,21 +149,13 @@ enum {
>>>>    	Opt_fault_injection,
>>>>    	Opt_fault_type,
>>>>    	Opt_lazytime,
>>>> -	Opt_nolazytime,
>>>>    	Opt_quota,
>>>> -	Opt_noquota,
>>>>    	Opt_usrquota,
>>>>    	Opt_grpquota,
>>>>    	Opt_prjquota,
>>>>    	Opt_usrjquota,
>>>>    	Opt_grpjquota,
>>>>    	Opt_prjjquota,
>>>> -	Opt_offusrjquota,
>>>> -	Opt_offgrpjquota,
>>>> -	Opt_offprjjquota,
>>>> -	Opt_jqfmt_vfsold,
>>>> -	Opt_jqfmt_vfsv0,
>>>> -	Opt_jqfmt_vfsv1,
>>>>    	Opt_alloc,
>>>>    	Opt_fsync,
>>>>    	Opt_test_dummy_encryption,
>>>> @@ -181,17 +165,15 @@ enum {
>>>>    	Opt_checkpoint_disable_cap_perc,
>>>>    	Opt_checkpoint_enable,
>>>>    	Opt_checkpoint_merge,
>>>> -	Opt_nocheckpoint_merge,
>>>>    	Opt_compress_algorithm,
>>>>    	Opt_compress_log_size,
>>>> -	Opt_compress_extension,
>>>>    	Opt_nocompress_extension,
>>>> +	Opt_compress_extension,
>>>>    	Opt_compress_chksum,
>>>>    	Opt_compress_mode,
>>>>    	Opt_compress_cache,
>>>>    	Opt_atgc,
>>>>    	Opt_gc_merge,
>>>> -	Opt_nogc_merge,
>>>>    	Opt_discard_unit,
>>>>    	Opt_memory_mode,
>>>>    	Opt_age_extent_cache,
>>>> @@ -321,83 +303,12 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
>>>>    	{}
>>>>    };
>>>> -static match_table_t f2fs_tokens = {
>>>> -	{Opt_gc_background, "background_gc=%s"},
>>>> -	{Opt_disable_roll_forward, "disable_roll_forward"},
>>>> -	{Opt_norecovery, "norecovery"},
>>>> -	{Opt_discard, "discard"},
>>>> -	{Opt_nodiscard, "nodiscard"},
>>>> -	{Opt_noheap, "no_heap"},
>>>> -	{Opt_heap, "heap"},
>>>> -	{Opt_user_xattr, "user_xattr"},
>>>> -	{Opt_nouser_xattr, "nouser_xattr"},
>>>> -	{Opt_acl, "acl"},
>>>> -	{Opt_noacl, "noacl"},
>>>> -	{Opt_active_logs, "active_logs=%u"},
>>>> -	{Opt_disable_ext_identify, "disable_ext_identify"},
>>>> -	{Opt_inline_xattr, "inline_xattr"},
>>>> -	{Opt_noinline_xattr, "noinline_xattr"},
>>>> -	{Opt_inline_xattr_size, "inline_xattr_size=%u"},
>>>> -	{Opt_inline_data, "inline_data"},
>>>> -	{Opt_inline_dentry, "inline_dentry"},
>>>> -	{Opt_noinline_dentry, "noinline_dentry"},
>>>> -	{Opt_flush_merge, "flush_merge"},
>>>> -	{Opt_noflush_merge, "noflush_merge"},
>>>> -	{Opt_barrier, "barrier"},
>>>> -	{Opt_nobarrier, "nobarrier"},
>>>> -	{Opt_fastboot, "fastboot"},
>>>> -	{Opt_extent_cache, "extent_cache"},
>>>> -	{Opt_noextent_cache, "noextent_cache"},
>>>> -	{Opt_noinline_data, "noinline_data"},
>>>> -	{Opt_data_flush, "data_flush"},
>>>> -	{Opt_reserve_root, "reserve_root=%u"},
>>>> -	{Opt_resgid, "resgid=%u"},
>>>> -	{Opt_resuid, "resuid=%u"},
>>>> -	{Opt_mode, "mode=%s"},
>>>> -	{Opt_fault_injection, "fault_injection=%u"},
>>>> -	{Opt_fault_type, "fault_type=%u"},
>>>> -	{Opt_lazytime, "lazytime"},
>>>> -	{Opt_nolazytime, "nolazytime"},
>>>> -	{Opt_quota, "quota"},
>>>> -	{Opt_noquota, "noquota"},
>>>> -	{Opt_usrquota, "usrquota"},
>>>> -	{Opt_grpquota, "grpquota"},
>>>> -	{Opt_prjquota, "prjquota"},
>>>> -	{Opt_usrjquota, "usrjquota=%s"},
>>>> -	{Opt_grpjquota, "grpjquota=%s"},
>>>> -	{Opt_prjjquota, "prjjquota=%s"},
>>>> -	{Opt_offusrjquota, "usrjquota="},
>>>> -	{Opt_offgrpjquota, "grpjquota="},
>>>> -	{Opt_offprjjquota, "prjjquota="},
>>>> -	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
>>>> -	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
>>>> -	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
>>>> -	{Opt_alloc, "alloc_mode=%s"},
>>>> -	{Opt_fsync, "fsync_mode=%s"},
>>>> -	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
>>>> -	{Opt_test_dummy_encryption, "test_dummy_encryption"},
>>>> -	{Opt_inlinecrypt, "inlinecrypt"},
>>>> -	{Opt_checkpoint_disable, "checkpoint=disable"},
>>>> -	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
>>>> -	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
>>>> -	{Opt_checkpoint_enable, "checkpoint=enable"},
>>>> -	{Opt_checkpoint_merge, "checkpoint_merge"},
>>>> -	{Opt_nocheckpoint_merge, "nocheckpoint_merge"},
>>>> -	{Opt_compress_algorithm, "compress_algorithm=%s"},
>>>> -	{Opt_compress_log_size, "compress_log_size=%u"},
>>>> -	{Opt_compress_extension, "compress_extension=%s"},
>>>> -	{Opt_nocompress_extension, "nocompress_extension=%s"},
>>>> -	{Opt_compress_chksum, "compress_chksum"},
>>>> -	{Opt_compress_mode, "compress_mode=%s"},
>>>> -	{Opt_compress_cache, "compress_cache"},
>>>> -	{Opt_atgc, "atgc"},
>>>> -	{Opt_gc_merge, "gc_merge"},
>>>> -	{Opt_nogc_merge, "nogc_merge"},
>>>> -	{Opt_discard_unit, "discard_unit=%s"},
>>>> -	{Opt_memory_mode, "memory=%s"},
>>>> -	{Opt_age_extent_cache, "age_extent_cache"},
>>>> -	{Opt_errors, "errors=%s"},
>>>> -	{Opt_nat_bits, "nat_bits"},
>>>> +/* Resort to a match_table for this interestingly formatted option */
>>>> +static match_table_t f2fs_checkpoint_tokens = {
>>>> +	{Opt_checkpoint_disable, "disable"},
>>>> +	{Opt_checkpoint_disable_cap, "disable:%u"},
>>>> +	{Opt_checkpoint_disable_cap_perc, "disable:%u%%"},
>>>> +	{Opt_checkpoint_enable, "enable"},
>>>>    	{Opt_err, NULL},
>>>>    };
>>>> @@ -513,7 +424,7 @@ static void init_once(void *foo)
>>>>    static const char * const quotatypes[] = INITQFNAMES;
>>>>    #define QTYPE2NAME(t) (quotatypes[t])
>>>>    static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
>>>> -							substring_t *args)
>>>> +			    struct fs_parameter *param)
>>>>    {
>>>>    	struct super_block *sb = sbi->sb;
>>>>    	char *qname;
>>>> @@ -528,7 +439,7 @@ static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
>>>>    		return 0;
>>>>    	}
>>>> -	qname = match_strdup(args);
>>>> +	qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
>>>>    	if (!qname) {
>>>>    		f2fs_err(sbi, "Not enough memory for storing quotafile name");
>>>>    		return -ENOMEM;
>>>> @@ -613,14 +524,9 @@ static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
>>>>    #endif
>>>>    static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
>>>> -					  const char *opt,
>>>> -					  const substring_t *arg,
>>>> +					  const struct fs_parameter *param,
>>>>    					  bool is_remount)
>>>>    {
>>>> -	struct fs_parameter param = {
>>>> -		.type = fs_value_is_string,
>>>> -		.string = arg->from ? arg->from : "",
>>>> -	};
>>>>    	struct fscrypt_dummy_policy *policy =
>>>>    		&F2FS_OPTION(sbi).dummy_enc_policy;
>>>>    	int err;
>>>> @@ -646,17 +552,17 @@ static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
>>>>    		return -EINVAL;
>>>>    	}
>>>> -	err = fscrypt_parse_test_dummy_encryption(&param, policy);
>>>> +	err = fscrypt_parse_test_dummy_encryption(param, policy);
>>>>    	if (err) {
>>>>    		if (err == -EEXIST)
>>>>    			f2fs_warn(sbi,
>>>>    				  "Can't change test_dummy_encryption on remount");
>>>>    		else if (err == -EINVAL)
>>>>    			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
>>>> -				  opt);
>>>> +				  param->key);
>>>>    		else
>>>>    			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
>>>> -				  opt, err);
>>>> +				  param->key, err);
>>>>    		return -EINVAL;
>>>>    	}
>>>>    	f2fs_warn(sbi, "Test dummy encryption mode enabled");
>>>> @@ -799,372 +705,269 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
>>>>    #endif
>>>>    #endif
>>>> -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
>>>> +static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>>    {
>>>> -	substring_t args[MAX_OPT_ARGS];
>>>> +	struct f2fs_sb_info *sbi = fc->s_fs_info;
>>>>    #ifdef CONFIG_F2FS_FS_COMPRESSION
>>>>    	unsigned char (*ext)[F2FS_EXTENSION_LEN];
>>>>    	unsigned char (*noext)[F2FS_EXTENSION_LEN];
>>>>    	int ext_cnt, noext_cnt;
>>>> +	char *name;
>>>>    #endif
>>>> -	char *p, *name;
>>>> -	int arg = 0;
>>>> -	kuid_t uid;
>>>> -	kgid_t gid;
>>>> -	int ret;
>>>> +	substring_t args[MAX_OPT_ARGS];
>>>> +	struct fs_parse_result result;
>>>> +	bool is_remount;
>>>> +	int token, ret, arg;
>>>> -	if (!options)
>>>> -		return 0;
>>>> +	token = fs_parse(fc, f2fs_param_specs, param, &result);
>>>> +	if (token < 0)
>>>> +		return token;
>>>> -	while ((p = strsep(&options, ",")) != NULL) {
>>>> -		int token;
>>>> +	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
>>>> -		if (!*p)
>>>> -			continue;
>>>> -		/*
>>>> -		 * Initialize args struct so we know whether arg was
>>>> -		 * found; some options take optional arguments.
>>>> -		 */
>>>> -		args[0].to = args[0].from = NULL;
>>>> -		token = match_token(p, f2fs_tokens, args);
>>>> -
>>>> -		switch (token) {
>>>> -		case Opt_gc_background:
>>>> -			name = match_strdup(&args[0]);
>>>> -
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "on")) {
>>>> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
>>>> -			} else if (!strcmp(name, "off")) {
>>>> -				if (f2fs_sb_has_blkzoned(sbi)) {
>>>> -					f2fs_warn(sbi, "zoned devices need bggc");
>>>> -					kfree(name);
>>>> -					return -EINVAL;
>>>> -				}
>>>
>>> Missed to check this condition in f2fs_check_opt_consistency()?
>>>
>>
>> Thanks for pointing this. Yeah, we should add this in
>> f2fs_check_opt_consistency like this:
>>
>> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
>> index 0a070dadbb42..86938dd5491e 100644
>> --- a/fs/f2fs/super.c
>> +++ b/fs/f2fs/super.c
>> @@ -1458,6 +1458,10 @@ static int f2fs_check_opt_consistency(struct
>> fs_context *fc,
>>           * devices, but mandatory for host-managed zoned block devices.
>>           */
>>          if (f2fs_sb_has_blkzoned(sbi)) {
>> +               if (F2FS_CTX_OPTION(ctx).bggc_mode == BGGC_MODE_OFF) {
>> +                       f2fs_warn(sbi, "zoned devices need bggc");
>> +                       return -EINVAL;
>> +               }
>>   #ifdef CONFIG_BLK_DEV_ZONED
>>                  if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
>>                  F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {
>>
>> Thanks,
>> Hongbo
>>
>>> Thanks,
>>>
>>>> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
>>>> -			} else if (!strcmp(name, "sync")) {
>>>> -				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
>>>> -			} else {
>>>> -				kfree(name);
>>>> +	switch (token) {
>>>> +	case Opt_gc_background:
>>>> +		F2FS_OPTION(sbi).bggc_mode = result.uint_32;
>>>> +		break;
>>>> +	case Opt_disable_roll_forward:
>>>> +		set_opt(sbi, DISABLE_ROLL_FORWARD);
>>>> +		break;
>>>> +	case Opt_norecovery:
>>>> +		/* requires ro mount, checked in f2fs_validate_options */
>>>> +		set_opt(sbi, NORECOVERY);
>>>> +		break;
>>>> +	case Opt_discard:
>>>> +		if (result.negated) {
>>>> +			if (f2fs_hw_should_discard(sbi)) {
>>>> +				f2fs_warn(sbi, "discard is required for zoned block devices");
>>>>    				return -EINVAL;
>>>>    			}
>>>> -			kfree(name);
>>>> -			break;
>>>> -		case Opt_disable_roll_forward:
>>>> -			set_opt(sbi, DISABLE_ROLL_FORWARD);
>>>> -			break;
>>>> -		case Opt_norecovery:
>>>> -			/* requires ro mount, checked in f2fs_default_check */
>>>> -			set_opt(sbi, NORECOVERY);
>>>> -			break;
>>>> -		case Opt_discard:
>>>> +			clear_opt(sbi, DISCARD);
>>>> +		} else {
>>>>    			if (!f2fs_hw_support_discard(sbi)) {
>>>>    				f2fs_warn(sbi, "device does not support discard");
>>>>    				break;
>>>>    			}
>>>>    			set_opt(sbi, DISCARD);
>>>> -			break;
>>>> -		case Opt_nodiscard:
>>>> -			if (f2fs_hw_should_discard(sbi)) {
>>>> -				f2fs_warn(sbi, "discard is required for zoned block devices");
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			clear_opt(sbi, DISCARD);
>>>> -			break;
>>>> -		case Opt_noheap:
>>>> -		case Opt_heap:
>>>> -			f2fs_warn(sbi, "heap/no_heap options were deprecated");
>>>> -			break;
>>>> +		}
>>>> +		break;
>>>> +	case Opt_noheap:
>>>> +	case Opt_heap:
>>>> +		f2fs_warn(sbi, "heap/no_heap options were deprecated");
>>>> +		break;
>>>>    #ifdef CONFIG_F2FS_FS_XATTR
>>>> -		case Opt_user_xattr:
>>>> -			set_opt(sbi, XATTR_USER);
>>>> -			break;
>>>> -		case Opt_nouser_xattr:
>>>> +	case Opt_user_xattr:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, XATTR_USER);
>>>> -			break;
>>>> -		case Opt_inline_xattr:
>>>> -			set_opt(sbi, INLINE_XATTR);
>>>> -			break;
>>>> -		case Opt_noinline_xattr:
>>>> +		else
>>>> +			set_opt(sbi, XATTR_USER);
>>>> +		break;
>>>> +	case Opt_inline_xattr:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, INLINE_XATTR);
>>>> -			break;
>>>> -		case Opt_inline_xattr_size:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			set_opt(sbi, INLINE_XATTR_SIZE);
>>>> -			F2FS_OPTION(sbi).inline_xattr_size = arg;
>>>> -			break;
>>>> +		else
>>>> +			set_opt(sbi, INLINE_XATTR);
>>>> +		break;
>>>> +	case Opt_inline_xattr_size:
>>>> +		set_opt(sbi, INLINE_XATTR_SIZE);
>>>> +		F2FS_OPTION(sbi).inline_xattr_size = result.int_32;
>>>> +		break;
>>>>    #else
>>>> -		case Opt_user_xattr:
>>>> -		case Opt_nouser_xattr:
>>>> -		case Opt_inline_xattr:
>>>> -		case Opt_noinline_xattr:
>>>> -		case Opt_inline_xattr_size:
>>>> -			f2fs_info(sbi, "xattr options not supported");
>>>> -			break;
>>>> +	case Opt_user_xattr:
>>>> +	case Opt_inline_xattr:
>>>> +	case Opt_inline_xattr_size:
>>>> +		f2fs_info(sbi, "%s options not supported", param->key);
>>>> +		break;
>>>>    #endif
>>>>    #ifdef CONFIG_F2FS_FS_POSIX_ACL
>>>> -		case Opt_acl:
>>>> -			set_opt(sbi, POSIX_ACL);
>>>> -			break;
>>>> -		case Opt_noacl:
>>>> +	case Opt_acl:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, POSIX_ACL);
>>>> -			break;
>>>> +		else
>>>> +			set_opt(sbi, POSIX_ACL);
>>>> +		break;
>>>>    #else
>>>> -		case Opt_acl:
>>>> -		case Opt_noacl:
>>>> -			f2fs_info(sbi, "acl options not supported");
>>>> -			break;
>>>> +	case Opt_acl:
>>>> +		f2fs_info(sbi, "%s options not supported", param->key);
>>>> +		break;
>>>>    #endif
>>>> -		case Opt_active_logs:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			if (arg != 2 && arg != 4 &&
>>>> -				arg != NR_CURSEG_PERSIST_TYPE)
>>>> -				return -EINVAL;
>>>> -			F2FS_OPTION(sbi).active_logs = arg;
>>>> -			break;
>>>> -		case Opt_disable_ext_identify:
>>>> -			set_opt(sbi, DISABLE_EXT_IDENTIFY);
>>>> -			break;
>>>> -		case Opt_inline_data:
>>>> +	case Opt_active_logs:
>>>> +		if (result.int_32 != 2 && result.int_32 != 4 &&
>>>> +			result.int_32 != NR_CURSEG_PERSIST_TYPE)
>>>> +			return -EINVAL;
>>>> +		F2FS_OPTION(sbi).active_logs = result.int_32;
>>>> +		break;
>>>> +	case Opt_disable_ext_identify:
>>>> +		set_opt(sbi, DISABLE_EXT_IDENTIFY);
>>>> +		break;
>>>> +	case Opt_inline_data:
>>>> +		if (result.negated)
>>>> +			clear_opt(sbi, INLINE_DATA);
>>>> +		else
>>>>    			set_opt(sbi, INLINE_DATA);
>>>> -			break;
>>>> -		case Opt_inline_dentry:
>>>> -			set_opt(sbi, INLINE_DENTRY);
>>>> -			break;
>>>> -		case Opt_noinline_dentry:
>>>> +		break;
>>>> +	case Opt_inline_dentry:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, INLINE_DENTRY);
>>>> -			break;
>>>> -		case Opt_flush_merge:
>>>> -			set_opt(sbi, FLUSH_MERGE);
>>>> -			break;
>>>> -		case Opt_noflush_merge:
>>>> +		else
>>>> +			set_opt(sbi, INLINE_DENTRY);
>>>> +		break;
>>>> +	case Opt_flush_merge:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, FLUSH_MERGE);
>>>> -			break;
>>>> -		case Opt_nobarrier:
>>>> +		else
>>>> +			set_opt(sbi, FLUSH_MERGE);
>>>> +		break;
>>>> +	case Opt_barrier:
>>>> +		if (result.negated)
>>>>    			set_opt(sbi, NOBARRIER);
>>>> -			break;
>>>> -		case Opt_barrier:
>>>> +		else
>>>>    			clear_opt(sbi, NOBARRIER);
>>>> -			break;
>>>> -		case Opt_fastboot:
>>>> -			set_opt(sbi, FASTBOOT);
>>>> -			break;
>>>> -		case Opt_extent_cache:
>>>> -			set_opt(sbi, READ_EXTENT_CACHE);
>>>> -			break;
>>>> -		case Opt_noextent_cache:
>>>> +		break;
>>>> +	case Opt_fastboot:
>>>> +		set_opt(sbi, FASTBOOT);
>>>> +		break;
>>>> +	case Opt_extent_cache:
>>>> +		if (result.negated) {
>>>>    			if (f2fs_sb_has_device_alias(sbi)) {
>>>>    				f2fs_err(sbi, "device aliasing requires extent cache");
>>>>    				return -EINVAL;
>>>>    			}
>>>>    			clear_opt(sbi, READ_EXTENT_CACHE);
>>>> -			break;
>>>> -		case Opt_noinline_data:
>>>> -			clear_opt(sbi, INLINE_DATA);
>>>> -			break;
>>>> -		case Opt_data_flush:
>>>> -			set_opt(sbi, DATA_FLUSH);
>>>> -			break;
>>>> -		case Opt_reserve_root:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			if (test_opt(sbi, RESERVE_ROOT)) {
>>>> -				f2fs_info(sbi, "Preserve previous reserve_root=%u",
>>>> -					  F2FS_OPTION(sbi).root_reserved_blocks);
>>>> -			} else {
>>>> -				F2FS_OPTION(sbi).root_reserved_blocks = arg;
>>>> -				set_opt(sbi, RESERVE_ROOT);
>>>> -			}
>>>> -			break;
>>>> -		case Opt_resuid:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			uid = make_kuid(current_user_ns(), arg);
>>>> -			if (!uid_valid(uid)) {
>>>> -				f2fs_err(sbi, "Invalid uid value %d", arg);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			F2FS_OPTION(sbi).s_resuid = uid;
>>>> -			break;
>>>> -		case Opt_resgid:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			gid = make_kgid(current_user_ns(), arg);
>>>> -			if (!gid_valid(gid)) {
>>>> -				f2fs_err(sbi, "Invalid gid value %d", arg);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			F2FS_OPTION(sbi).s_resgid = gid;
>>>> -			break;
>>>> -		case Opt_mode:
>>>> -			name = match_strdup(&args[0]);
>>>> -
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "adaptive")) {
>>>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
>>>> -			} else if (!strcmp(name, "lfs")) {
>>>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
>>>> -			} else if (!strcmp(name, "fragment:segment")) {
>>>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;
>>>> -			} else if (!strcmp(name, "fragment:block")) {
>>>> -				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> -			break;
>>>> +		} else
>>>> +			set_opt(sbi, READ_EXTENT_CACHE);
>>>> +		break;
>>>> +	case Opt_data_flush:
>>>> +		set_opt(sbi, DATA_FLUSH);
>>>> +		break;
>>>> +	case Opt_reserve_root:
>>>> +		if (test_opt(sbi, RESERVE_ROOT)) {
>>>> +			f2fs_info(sbi, "Preserve previous reserve_root=%u",
>>>> +				  F2FS_OPTION(sbi).root_reserved_blocks);
>>>> +		} else {
>>>> +			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
>>>> +			set_opt(sbi, RESERVE_ROOT);
>>>> +		}
>>>> +		break;
>>>> +	case Opt_resuid:
>>>> +		F2FS_OPTION(sbi).s_resuid = result.uid;
>>>> +		break;
>>>> +	case Opt_resgid:
>>>> +		F2FS_OPTION(sbi).s_resgid = result.gid;
>>>> +		break;
>>>> +	case Opt_mode:
>>>> +		F2FS_OPTION(sbi).fs_mode = result.uint_32;
>>>> +		break;
>>>>    #ifdef CONFIG_F2FS_FAULT_INJECTION
>>>> -		case Opt_fault_injection:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			if (f2fs_build_fault_attr(sbi, arg, 0, FAULT_RATE))
>>>> -				return -EINVAL;
>>>> -			set_opt(sbi, FAULT_INJECTION);
>>>> -			break;
>>>> +	case Opt_fault_injection:
>>>> +		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
>>>> +			return -EINVAL;
>>>> +		set_opt(sbi, FAULT_INJECTION);
>>>> +		break;
>>>> -		case Opt_fault_type:
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			if (f2fs_build_fault_attr(sbi, 0, arg, FAULT_TYPE))
>>>> -				return -EINVAL;
>>>> -			set_opt(sbi, FAULT_INJECTION);
>>>> -			break;
>>>> +	case Opt_fault_type:
>>>> +		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
>>>> +			return -EINVAL;
>>>> +		set_opt(sbi, FAULT_INJECTION);
>>>> +		break;
>>>>    #else
>>>> -		case Opt_fault_injection:
>>>> -		case Opt_fault_type:
>>>> -			f2fs_info(sbi, "fault injection options not supported");
>>>> -			break;
>>>> +	case Opt_fault_injection:
>>>> +	case Opt_fault_type:
>>>> +		f2fs_info(sbi, "%s options not supported", param->key);
>>>> +		break;
>>>>    #endif
>>>> -		case Opt_lazytime:
>>>> -			set_opt(sbi, LAZYTIME);
>>>> -			break;
>>>> -		case Opt_nolazytime:
>>>> +	case Opt_lazytime:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, LAZYTIME);
>>>> -			break;
>>>> +		else
>>>> +			set_opt(sbi, LAZYTIME);
>>>> +		break;
>>>>    #ifdef CONFIG_QUOTA
>>>> -		case Opt_quota:
>>>> -		case Opt_usrquota:
>>>> -			set_opt(sbi, USRQUOTA);
>>>> -			break;
>>>> -		case Opt_grpquota:
>>>> -			set_opt(sbi, GRPQUOTA);
>>>> -			break;
>>>> -		case Opt_prjquota:
>>>> -			set_opt(sbi, PRJQUOTA);
>>>> -			break;
>>>> -		case Opt_usrjquota:
>>>> -			ret = f2fs_set_qf_name(sbi, USRQUOTA, &args[0]);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_grpjquota:
>>>> -			ret = f2fs_set_qf_name(sbi, GRPQUOTA, &args[0]);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_prjjquota:
>>>> -			ret = f2fs_set_qf_name(sbi, PRJQUOTA, &args[0]);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_offusrjquota:
>>>> -			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_offgrpjquota:
>>>> -			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_offprjjquota:
>>>> -			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_jqfmt_vfsold:
>>>> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
>>>> -			break;
>>>> -		case Opt_jqfmt_vfsv0:
>>>> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
>>>> -			break;
>>>> -		case Opt_jqfmt_vfsv1:
>>>> -			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
>>>> -			break;
>>>> -		case Opt_noquota:
>>>> +	case Opt_quota:
>>>> +		if (result.negated) {
>>>>    			clear_opt(sbi, QUOTA);
>>>>    			clear_opt(sbi, USRQUOTA);
>>>>    			clear_opt(sbi, GRPQUOTA);
>>>>    			clear_opt(sbi, PRJQUOTA);
>>>> -			break;
>>>> +		} else
>>>> +			set_opt(sbi, USRQUOTA);
>>>> +		break;
>>>> +	case Opt_usrquota:
>>>> +		set_opt(sbi, USRQUOTA);
>>>> +		break;
>>>> +	case Opt_grpquota:
>>>> +		set_opt(sbi, GRPQUOTA);
>>>> +		break;
>>>> +	case Opt_prjquota:
>>>> +		set_opt(sbi, PRJQUOTA);
>>>> +		break;
>>>> +	case Opt_usrjquota:
>>>> +		if (!*param->string)
>>>> +			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
>>>> +		else
>>>> +			ret = f2fs_set_qf_name(sbi, USRQUOTA, param);
>>>> +		if (ret)
>>>> +			return ret;
>>>> +		break;
>>>> +	case Opt_grpjquota:
>>>> +		if (!*param->string)
>>>> +			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
>>>> +		else
>>>> +			ret = f2fs_set_qf_name(sbi, GRPQUOTA, param);
>>>> +		if (ret)
>>>> +			return ret;
>>>> +		break;
>>>> +	case Opt_prjjquota:
>>>> +		if (!*param->string)
>>>> +			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
>>>> +		else
>>>> +			ret = f2fs_set_qf_name(sbi, PRJQUOTA, param);
>>>> +		if (ret)
>>>> +			return ret;
>>>> +		break;
>>>> +	case Opt_jqfmt:
>>>> +		F2FS_OPTION(sbi).s_jquota_fmt = result.uint_32;
>>>> +		break;
>>>>    #else
>>>> -		case Opt_quota:
>>>> -		case Opt_usrquota:
>>>> -		case Opt_grpquota:
>>>> -		case Opt_prjquota:
>>>> -		case Opt_usrjquota:
>>>> -		case Opt_grpjquota:
>>>> -		case Opt_prjjquota:
>>>> -		case Opt_offusrjquota:
>>>> -		case Opt_offgrpjquota:
>>>> -		case Opt_offprjjquota:
>>>> -		case Opt_jqfmt_vfsold:
>>>> -		case Opt_jqfmt_vfsv0:
>>>> -		case Opt_jqfmt_vfsv1:
>>>> -		case Opt_noquota:
>>>> -			f2fs_info(sbi, "quota operations not supported");
>>>> -			break;
>>>> +	case Opt_quota:
>>>> +	case Opt_usrquota:
>>>> +	case Opt_grpquota:
>>>> +	case Opt_prjquota:
>>>> +	case Opt_usrjquota:
>>>> +	case Opt_grpjquota:
>>>> +	case Opt_prjjquota:
>>>> +		f2fs_info(sbi, "quota operations not supported");
>>>> +		break;
>>>>    #endif
>>>> -		case Opt_alloc:
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -
>>>> -			if (!strcmp(name, "default")) {
>>>> -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
>>>> -			} else if (!strcmp(name, "reuse")) {
>>>> -				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> -			break;
>>>> -		case Opt_fsync:
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "posix")) {
>>>> -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
>>>> -			} else if (!strcmp(name, "strict")) {
>>>> -				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
>>>> -			} else if (!strcmp(name, "nobarrier")) {
>>>> -				F2FS_OPTION(sbi).fsync_mode =
>>>> -							FSYNC_MODE_NOBARRIER;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> -			break;
>>>> -		case Opt_test_dummy_encryption:
>>>> -			ret = f2fs_set_test_dummy_encryption(sbi, p, &args[0],
>>>> -							     is_remount);
>>>> -			if (ret)
>>>> -				return ret;
>>>> -			break;
>>>> -		case Opt_inlinecrypt:
>>>> +	case Opt_alloc:
>>>> +		F2FS_OPTION(sbi).alloc_mode = result.uint_32;
>>>> +		break;
>>>> +	case Opt_fsync:
>>>> +		F2FS_OPTION(sbi).fsync_mode = result.uint_32;
>>>> +		break;
>>>> +	case Opt_test_dummy_encryption:
>>>> +		ret = f2fs_set_test_dummy_encryption(sbi, param, is_remount);
>>>> +		if (ret)
>>>> +			return ret;
>>>> +		break;
>>>> +	case Opt_inlinecrypt:
>>>>    #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
>>>> -			set_opt(sbi, INLINECRYPT);
>>>> +		set_opt(sbi, INLINECRYPT);
>>>>    #else
>>>> -			f2fs_info(sbi, "inline encryption not supported");
>>>> +		f2fs_info(sbi, "inline encryption not supported");
>>>>    #endif
>>>> -			break;
>>>> +		break;
>>>> +	case Opt_checkpoint:
>>>> +		/*
>>>> +		 * Initialize args struct so we know whether arg was
>>>> +		 * found; some options take optional arguments.
>>>> +		 */
>>>> +		args[0].from = args[0].to = NULL;
>>>> +		arg = 0;
>>>> +
>>>> +		/* revert to match_table for checkpoint= options */
>>>> +		token = match_token(param->string, f2fs_checkpoint_tokens, args);
>>>> +		switch (token) {
>>>>    		case Opt_checkpoint_disable_cap_perc:
>>>>    			if (args->from && match_int(args, &arg))
>>>>    				return -EINVAL;
>>>> @@ -1185,270 +988,225 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>>>>    		case Opt_checkpoint_enable:
>>>>    			clear_opt(sbi, DISABLE_CHECKPOINT);
>>>>    			break;
>>>> -		case Opt_checkpoint_merge:
>>>> -			set_opt(sbi, MERGE_CHECKPOINT);
>>>> -			break;
>>>> -		case Opt_nocheckpoint_merge:
>>>> +		default:
>>>> +			return -EINVAL;
>>>> +		}
>>>> +		break;
>>>> +	case Opt_checkpoint_merge:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, MERGE_CHECKPOINT);
>>>> -			break;
>>>> +		else
>>>> +			set_opt(sbi, MERGE_CHECKPOINT);
>>>> +		break;
>>>>    #ifdef CONFIG_F2FS_FS_COMPRESSION
>>>> -		case Opt_compress_algorithm:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "lzo")) {
>>>> +	case Opt_compress_algorithm:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>> +			break;
>>>> +		}
>>>> +		name = param->string;
>>>> +		if (!strcmp(name, "lzo")) {
>>>>    #ifdef CONFIG_F2FS_FS_LZO
>>>> -				F2FS_OPTION(sbi).compress_level = 0;
>>>> -				F2FS_OPTION(sbi).compress_algorithm =
>>>> -								COMPRESS_LZO;
>>>> +			F2FS_OPTION(sbi).compress_level = 0;
>>>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
>>>>    #else
>>>> -				f2fs_info(sbi, "kernel doesn't support lzo compression");
>>>> +			f2fs_info(sbi, "kernel doesn't support lzo compression");
>>>>    #endif
>>>> -			} else if (!strncmp(name, "lz4", 3)) {
>>>> +		} else if (!strncmp(name, "lz4", 3)) {
>>>>    #ifdef CONFIG_F2FS_FS_LZ4
>>>> -				ret = f2fs_set_lz4hc_level(sbi, name);
>>>> -				if (ret) {
>>>> -					kfree(name);
>>>> -					return -EINVAL;
>>>> -				}
>>>> -				F2FS_OPTION(sbi).compress_algorithm =
>>>> -								COMPRESS_LZ4;
>>>> +			ret = f2fs_set_lz4hc_level(sbi, name);
>>>> +			if (ret)
>>>> +				return -EINVAL;
>>>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
>>>>    #else
>>>> -				f2fs_info(sbi, "kernel doesn't support lz4 compression");
>>>> +			f2fs_info(sbi, "kernel doesn't support lz4 compression");
>>>>    #endif
>>>> -			} else if (!strncmp(name, "zstd", 4)) {
>>>> +		} else if (!strncmp(name, "zstd", 4)) {
>>>>    #ifdef CONFIG_F2FS_FS_ZSTD
>>>> -				ret = f2fs_set_zstd_level(sbi, name);
>>>> -				if (ret) {
>>>> -					kfree(name);
>>>> -					return -EINVAL;
>>>> -				}
>>>> -				F2FS_OPTION(sbi).compress_algorithm =
>>>> -								COMPRESS_ZSTD;
>>>> +			ret = f2fs_set_zstd_level(sbi, name);
>>>> +			if (ret)
>>>> +				return -EINVAL;
>>>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
>>>>    #else
>>>> -				f2fs_info(sbi, "kernel doesn't support zstd compression");
>>>> +			f2fs_info(sbi, "kernel doesn't support zstd compression");
>>>>    #endif
>>>> -			} else if (!strcmp(name, "lzo-rle")) {
>>>> +		} else if (!strcmp(name, "lzo-rle")) {
>>>>    #ifdef CONFIG_F2FS_FS_LZORLE
>>>> -				F2FS_OPTION(sbi).compress_level = 0;
>>>> -				F2FS_OPTION(sbi).compress_algorithm =
>>>> -								COMPRESS_LZORLE;
>>>> +			F2FS_OPTION(sbi).compress_level = 0;
>>>> +			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
>>>>    #else
>>>> -				f2fs_info(sbi, "kernel doesn't support lzorle compression");
>>>> +			f2fs_info(sbi, "kernel doesn't support lzorle compression");
>>>>    #endif
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> +		} else
>>>> +			return -EINVAL;
>>>> +		break;
>>>> +	case Opt_compress_log_size:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>>    			break;
>>>> -		case Opt_compress_log_size:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			if (args->from && match_int(args, &arg))
>>>> -				return -EINVAL;
>>>> -			if (arg < MIN_COMPRESS_LOG_SIZE ||
>>>> -				arg > MAX_COMPRESS_LOG_SIZE) {
>>>> -				f2fs_err(sbi,
>>>> -					"Compress cluster log size is out of range");
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			F2FS_OPTION(sbi).compress_log_size = arg;
>>>> +		}
>>>> +		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
>>>> +		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
>>>> +			f2fs_err(sbi,
>>>> +				"Compress cluster log size is out of range");
>>>> +			return -EINVAL;
>>>> +		}
>>>> +		F2FS_OPTION(sbi).compress_log_size = result.uint_32;
>>>> +		break;
>>>> +	case Opt_compress_extension:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>>    			break;
>>>> -		case Opt_compress_extension:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -
>>>> -			ext = F2FS_OPTION(sbi).extensions;
>>>> -			ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>>>> -
>>>> -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
>>>> -				ext_cnt >= COMPRESS_EXT_NUM) {
>>>> -				f2fs_err(sbi,
>>>> -					"invalid extension length/number");
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> +		}
>>>> +		name = param->string;
>>>> +		ext = F2FS_OPTION(sbi).extensions;
>>>> +		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>>>> -			if (is_compress_extension_exist(sbi, name, true)) {
>>>> -				kfree(name);
>>>> -				break;
>>>> -			}
>>>> +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
>>>> +		    ext_cnt >= COMPRESS_EXT_NUM) {
>>>> +			f2fs_err(sbi, "invalid extension length/number");
>>>> +			return -EINVAL;
>>>> +		}
>>>> -			ret = strscpy(ext[ext_cnt], name);
>>>> -			if (ret < 0) {
>>>> -				kfree(name);
>>>> -				return ret;
>>>> -			}
>>>> -			F2FS_OPTION(sbi).compress_ext_cnt++;
>>>> -			kfree(name);
>>>> +		if (is_compress_extension_exist(sbi, name, true))
>>>>    			break;
>>>> -		case Opt_nocompress_extension:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -
>>>> -			noext = F2FS_OPTION(sbi).noextensions;
>>>> -			noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>>>> -			if (strlen(name) >= F2FS_EXTENSION_LEN ||
>>>> -				noext_cnt >= COMPRESS_EXT_NUM) {
>>>> -				f2fs_err(sbi,
>>>> -					"invalid extension length/number");
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> +		ret = strscpy(ext[ext_cnt], name, F2FS_EXTENSION_LEN);
>>>> +		if (ret < 0)
>>>> +			return ret;
>>>> +		F2FS_OPTION(sbi).compress_ext_cnt++;
>>>> +		break;
>>>> +	case Opt_nocompress_extension:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>> +			break;
>>>> +		}
>>>> +		name = param->string;
>>>> +		noext = F2FS_OPTION(sbi).noextensions;
>>>> +		noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>>>> -			if (is_compress_extension_exist(sbi, name, false)) {
>>>> -				kfree(name);
>>>> -				break;
>>>> -			}
>>>> +		if (strlen(name) >= F2FS_EXTENSION_LEN ||
>>>> +			noext_cnt >= COMPRESS_EXT_NUM) {
>>>> +			f2fs_err(sbi, "invalid extension length/number");
>>>> +			return -EINVAL;
>>>> +		}
>>>> -			ret = strscpy(noext[noext_cnt], name);
>>>> -			if (ret < 0) {
>>>> -				kfree(name);
>>>> -				return ret;
>>>> -			}
>>>> -			F2FS_OPTION(sbi).nocompress_ext_cnt++;
>>>> -			kfree(name);
>>>> +		if (is_compress_extension_exist(sbi, name, false))
>>>>    			break;
>>>> -		case Opt_compress_chksum:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			F2FS_OPTION(sbi).compress_chksum = true;
>>>> +
>>>> +		ret = strscpy(noext[noext_cnt], name, F2FS_EXTENSION_LEN);
>>>> +		if (ret < 0)
>>>> +			return ret;
>>>> +		F2FS_OPTION(sbi).nocompress_ext_cnt++;
>>>> +		break;
>>>> +	case Opt_compress_chksum:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>>    			break;
>>>> -		case Opt_compress_mode:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "fs")) {
>>>> -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
>>>> -			} else if (!strcmp(name, "user")) {
>>>> -				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> +		}
>>>> +		F2FS_OPTION(sbi).compress_chksum = true;
>>>> +		break;
>>>> +	case Opt_compress_mode:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>>    			break;
>>>> -		case Opt_compress_cache:
>>>> -			if (!f2fs_sb_has_compression(sbi)) {
>>>> -				f2fs_info(sbi, "Image doesn't support compression");
>>>> -				break;
>>>> -			}
>>>> -			set_opt(sbi, COMPRESS_CACHE);
>>>> +		}
>>>> +		F2FS_OPTION(sbi).compress_mode = result.uint_32;
>>>> +		break;
>>>> +	case Opt_compress_cache:
>>>> +		if (!f2fs_sb_has_compression(sbi)) {
>>>> +			f2fs_info(sbi, "Image doesn't support compression");
>>>>    			break;
>>>> +		}
>>>> +		set_opt(sbi, COMPRESS_CACHE);
>>>> +		break;
>>>>    #else
>>>> -		case Opt_compress_algorithm:
>>>> -		case Opt_compress_log_size:
>>>> -		case Opt_compress_extension:
>>>> -		case Opt_nocompress_extension:
>>>> -		case Opt_compress_chksum:
>>>> -		case Opt_compress_mode:
>>>> -		case Opt_compress_cache:
>>>> -			f2fs_info(sbi, "compression options not supported");
>>>> -			break;
>>>> +	case Opt_compress_algorithm:
>>>> +	case Opt_compress_log_size:
>>>> +	case Opt_compress_extension:
>>>> +	case Opt_nocompress_extension:
>>>> +	case Opt_compress_chksum:
>>>> +	case Opt_compress_mode:
>>>> +	case Opt_compress_cache:
>>>> +		f2fs_info(sbi, "compression options not supported");
>>>> +		break;
>>>>    #endif
>>>> -		case Opt_atgc:
>>>> -			set_opt(sbi, ATGC);
>>>> -			break;
>>>> -		case Opt_gc_merge:
>>>> -			set_opt(sbi, GC_MERGE);
>>>> -			break;
>>>> -		case Opt_nogc_merge:
>>>> +	case Opt_atgc:
>>>> +		set_opt(sbi, ATGC);
>>>> +		break;
>>>> +	case Opt_gc_merge:
>>>> +		if (result.negated)
>>>>    			clear_opt(sbi, GC_MERGE);
>>>> -			break;
>>>> -		case Opt_discard_unit:
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "block")) {
>>>> -				F2FS_OPTION(sbi).discard_unit =
>>>> -						DISCARD_UNIT_BLOCK;
>>>> -			} else if (!strcmp(name, "segment")) {
>>>> -				F2FS_OPTION(sbi).discard_unit =
>>>> -						DISCARD_UNIT_SEGMENT;
>>>> -			} else if (!strcmp(name, "section")) {
>>>> -				F2FS_OPTION(sbi).discard_unit =
>>>> -						DISCARD_UNIT_SECTION;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> -			break;
>>>> -		case Opt_memory_mode:
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "normal")) {
>>>> -				F2FS_OPTION(sbi).memory_mode =
>>>> -						MEMORY_MODE_NORMAL;
>>>> -			} else if (!strcmp(name, "low")) {
>>>> -				F2FS_OPTION(sbi).memory_mode =
>>>> -						MEMORY_MODE_LOW;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> -			}
>>>> -			kfree(name);
>>>> -			break;
>>>> -		case Opt_age_extent_cache:
>>>> -			set_opt(sbi, AGE_EXTENT_CACHE);
>>>> -			break;
>>>> -		case Opt_errors:
>>>> -			name = match_strdup(&args[0]);
>>>> -			if (!name)
>>>> -				return -ENOMEM;
>>>> -			if (!strcmp(name, "remount-ro")) {
>>>> -				F2FS_OPTION(sbi).errors =
>>>> -						MOUNT_ERRORS_READONLY;
>>>> -			} else if (!strcmp(name, "continue")) {
>>>> -				F2FS_OPTION(sbi).errors =
>>>> -						MOUNT_ERRORS_CONTINUE;
>>>> -			} else if (!strcmp(name, "panic")) {
>>>> -				F2FS_OPTION(sbi).errors =
>>>> -						MOUNT_ERRORS_PANIC;
>>>> -			} else {
>>>> -				kfree(name);
>>>> -				return -EINVAL;
>>>> +		else
>>>> +			set_opt(sbi, GC_MERGE);
>>>> +		break;
>>>> +	case Opt_discard_unit:
>>>> +		F2FS_OPTION(sbi).discard_unit = result.uint_32;
>>>> +		break;
>>>> +	case Opt_memory_mode:
>>>> +		F2FS_OPTION(sbi).memory_mode = result.uint_32;
>>>> +		break;
>>>> +	case Opt_age_extent_cache:
>>>> +		set_opt(sbi, AGE_EXTENT_CACHE);
>>>> +		break;
>>>> +	case Opt_errors:
>>>> +		F2FS_OPTION(sbi).errors = result.uint_32;
>>>> +		break;
>>>> +	case Opt_nat_bits:
>>>> +		set_opt(sbi, NAT_BITS);
>>>> +		break;
>>>> +	}
>>>> +	return 0;
>>>> +}
>>>> +
>>>> +static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
>>>> +{
>>>> +	struct fs_parameter param;
>>>> +	struct fs_context fc;
>>>> +	char *key;
>>>> +	int ret;
>>>> +
>>>> +	if (!options)
>>>> +		return 0;
>>>> +
>>>> +	memset(&fc, 0, sizeof(fc));
>>>> +	fc.s_fs_info = sbi;
>>>> +	if (is_remount)
>>>> +		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
>>>> +
>>>> +	while ((key = strsep(&options, ",")) != NULL) {
>>>> +		if (*key) {
>>>> +			size_t v_len = 0;
>>>> +			char *value = strchr(key, '=');
>>>> +
>>>> +			param.type = fs_value_is_flag;
>>>> +			param.string = NULL;
>>>> +
>>>> +			if (value) {
>>>> +				if (value == key)
>>>> +					continue;
>>>> +
>>>> +				*value++ = 0;
>>>> +				v_len = strlen(value);
>>>> +				param.string = kmemdup_nul(value, v_len, GFP_KERNEL);
>>>> +				if (!param.string)
>>>> +					return -ENOMEM;
>>>> +				param.type = fs_value_is_string;
>>>>    			}
>>>> -			kfree(name);
>>>> -			break;
>>>> -		case Opt_nat_bits:
>>>> -			set_opt(sbi, NAT_BITS);
>>>> -			break;
>>>> -		default:
>>>> -			f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
>>>> -				 p);
>>>> -			return -EINVAL;
>>>> +
>>>> +			param.key = key;
>>>> +			param.size = v_len;
>>>> +
>>>> +			ret = handle_mount_opt(&fc, &param);
>>>> +			kfree(param.string);
>>>> +			if (ret < 0)
>>>> +				return ret;
>>>>    		}
>>>>    	}
>>>>    	return 0;
>>>>    }
>>>> -static int f2fs_default_check(struct f2fs_sb_info *sbi)
>>>> +static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>>>>    {
>>>>    #ifdef CONFIG_QUOTA
>>>>    	if (f2fs_check_quota_options(sbi))
>>>> @@ -2527,7 +2285,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>>>    	}
>>>>    #endif
>>>> -	err = f2fs_default_check(sbi);
>>>> +	err = f2fs_validate_options(sbi);
>>>>    	if (err)
>>>>    		goto restore_opts;
>>>> @@ -4725,7 +4483,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>>>    	if (err)
>>>>    		goto free_options;
>>>> -	err = f2fs_default_check(sbi);
>>>> +	err = f2fs_validate_options(sbi);
>>>>    	if (err)
>>>>    		goto free_options;
>>>
> 

[PATCH v4 3/7] f2fs: Allow sbi to be NULL in f2fs_printk

[Hongbo Li]

At the parsing phase of the new mount api, sbi will not be
available. So here allows sbi to be NULL in f2fs log helpers
and use that in handle_mount_opt().

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
---
 fs/f2fs/super.c | 90 +++++++++++++++++++++++++++----------------------
 1 file changed, 49 insertions(+), 41 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index dff2419ba905..150287b1e732 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -325,11 +325,19 @@ void f2fs_printk(struct f2fs_sb_info *sbi, bool limit_rate,
 	vaf.fmt = printk_skip_level(fmt);
 	vaf.va = &args;
 	if (limit_rate)
-		printk_ratelimited("%c%cF2FS-fs (%s): %pV\n",
-			KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
+		if (sbi)
+			printk_ratelimited("%c%cF2FS-fs (%s): %pV\n",
+				KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
+		else
+			printk_ratelimited("%c%cF2FS-fs: %pV\n",
+				KERN_SOH_ASCII, level, &vaf);
 	else
-		printk("%c%cF2FS-fs (%s): %pV\n",
-			KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
+		if (sbi)
+			printk("%c%cF2FS-fs (%s): %pV\n",
+				KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
+		else
+			printk("%c%cF2FS-fs: %pV\n",
+				KERN_SOH_ASCII, level, &vaf);
 
 	va_end(args);
 }
@@ -739,13 +747,13 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 	case Opt_discard:
 		if (result.negated) {
 			if (f2fs_hw_should_discard(sbi)) {
-				f2fs_warn(sbi, "discard is required for zoned block devices");
+				f2fs_warn(NULL, "discard is required for zoned block devices");
 				return -EINVAL;
 			}
 			clear_opt(sbi, DISCARD);
 		} else {
 			if (!f2fs_hw_support_discard(sbi)) {
-				f2fs_warn(sbi, "device does not support discard");
+				f2fs_warn(NULL, "device does not support discard");
 				break;
 			}
 			set_opt(sbi, DISCARD);
@@ -753,7 +761,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 	case Opt_noheap:
 	case Opt_heap:
-		f2fs_warn(sbi, "heap/no_heap options were deprecated");
+		f2fs_warn(NULL, "heap/no_heap options were deprecated");
 		break;
 #ifdef CONFIG_F2FS_FS_XATTR
 	case Opt_user_xattr:
@@ -776,7 +784,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 	case Opt_user_xattr:
 	case Opt_inline_xattr:
 	case Opt_inline_xattr_size:
-		f2fs_info(sbi, "%s options not supported", param->key);
+		f2fs_info(NULL, "%s options not supported", param->key);
 		break;
 #endif
 #ifdef CONFIG_F2FS_FS_POSIX_ACL
@@ -788,7 +796,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 #else
 	case Opt_acl:
-		f2fs_info(sbi, "%s options not supported", param->key);
+		f2fs_info(NULL, "%s options not supported", param->key);
 		break;
 #endif
 	case Opt_active_logs:
@@ -842,7 +850,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 	case Opt_reserve_root:
 		if (test_opt(sbi, RESERVE_ROOT)) {
-			f2fs_info(sbi, "Preserve previous reserve_root=%u",
+			f2fs_info(NULL, "Preserve previous reserve_root=%u",
 				  F2FS_OPTION(sbi).root_reserved_blocks);
 		} else {
 			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
@@ -873,7 +881,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #else
 	case Opt_fault_injection:
 	case Opt_fault_type:
-		f2fs_info(sbi, "%s options not supported", param->key);
+		f2fs_info(NULL, "%s options not supported", param->key);
 		break;
 #endif
 	case Opt_lazytime:
@@ -936,7 +944,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 	case Opt_usrjquota:
 	case Opt_grpjquota:
 	case Opt_prjjquota:
-		f2fs_info(sbi, "quota operations not supported");
+		f2fs_info(NULL, "quota operations not supported");
 		break;
 #endif
 	case Opt_alloc:
@@ -954,7 +962,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
 		set_opt(sbi, INLINECRYPT);
 #else
-		f2fs_info(sbi, "inline encryption not supported");
+		f2fs_info(NULL, "inline encryption not supported");
 #endif
 		break;
 	case Opt_checkpoint:
@@ -1001,7 +1009,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	case Opt_compress_algorithm:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		name = param->string;
@@ -1010,7 +1018,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			F2FS_OPTION(sbi).compress_level = 0;
 			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
 #else
-			f2fs_info(sbi, "kernel doesn't support lzo compression");
+			f2fs_info(NULL, "kernel doesn't support lzo compression");
 #endif
 		} else if (!strncmp(name, "lz4", 3)) {
 #ifdef CONFIG_F2FS_FS_LZ4
@@ -1019,7 +1027,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 				return -EINVAL;
 			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
 #else
-			f2fs_info(sbi, "kernel doesn't support lz4 compression");
+			f2fs_info(NULL, "kernel doesn't support lz4 compression");
 #endif
 		} else if (!strncmp(name, "zstd", 4)) {
 #ifdef CONFIG_F2FS_FS_ZSTD
@@ -1028,26 +1036,26 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 				return -EINVAL;
 			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
 #else
-			f2fs_info(sbi, "kernel doesn't support zstd compression");
+			f2fs_info(NULL, "kernel doesn't support zstd compression");
 #endif
 		} else if (!strcmp(name, "lzo-rle")) {
 #ifdef CONFIG_F2FS_FS_LZORLE
 			F2FS_OPTION(sbi).compress_level = 0;
 			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
 #else
-			f2fs_info(sbi, "kernel doesn't support lzorle compression");
+			f2fs_info(NULL, "kernel doesn't support lzorle compression");
 #endif
 		} else
 			return -EINVAL;
 		break;
 	case Opt_compress_log_size:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
 		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
-			f2fs_err(sbi,
+			f2fs_err(NULL,
 				"Compress cluster log size is out of range");
 			return -EINVAL;
 		}
@@ -1055,7 +1063,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 	case Opt_compress_extension:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		name = param->string;
@@ -1064,7 +1072,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 
 		if (strlen(name) >= F2FS_EXTENSION_LEN ||
 		    ext_cnt >= COMPRESS_EXT_NUM) {
-			f2fs_err(sbi, "invalid extension length/number");
+			f2fs_err(NULL, "invalid extension length/number");
 			return -EINVAL;
 		}
 
@@ -1078,7 +1086,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 	case Opt_nocompress_extension:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		name = param->string;
@@ -1087,7 +1095,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 
 		if (strlen(name) >= F2FS_EXTENSION_LEN ||
 			noext_cnt >= COMPRESS_EXT_NUM) {
-			f2fs_err(sbi, "invalid extension length/number");
+			f2fs_err(NULL, "invalid extension length/number");
 			return -EINVAL;
 		}
 
@@ -1101,21 +1109,21 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 	case Opt_compress_chksum:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		F2FS_OPTION(sbi).compress_chksum = true;
 		break;
 	case Opt_compress_mode:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		F2FS_OPTION(sbi).compress_mode = result.uint_32;
 		break;
 	case Opt_compress_cache:
 		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(sbi, "Image doesn't support compression");
+			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
 		set_opt(sbi, COMPRESS_CACHE);
@@ -1128,7 +1136,7 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 	case Opt_compress_chksum:
 	case Opt_compress_mode:
 	case Opt_compress_cache:
-		f2fs_info(sbi, "compression options not supported");
+		f2fs_info(NULL, "compression options not supported");
 		break;
 #endif
 	case Opt_atgc:
@@ -1213,17 +1221,17 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
 		return -EINVAL;
 #else
 	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
-		f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
+		f2fs_info(NULL, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
 		return -EINVAL;
 	}
 	if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
-		f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
+		f2fs_err(NULL, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
 		return -EINVAL;
 	}
 #endif
 
 	if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {
-		f2fs_err(sbi,
+		f2fs_err(NULL,
 			"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
 		return -EINVAL;
 	}
@@ -1237,24 +1245,24 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
 #ifdef CONFIG_BLK_DEV_ZONED
 		if (F2FS_OPTION(sbi).discard_unit !=
 						DISCARD_UNIT_SECTION) {
-			f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");
+			f2fs_info(NULL, "Zoned block device doesn't need small discard, set discard_unit=section by default");
 			F2FS_OPTION(sbi).discard_unit =
 					DISCARD_UNIT_SECTION;
 		}
 
 		if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {
-			f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");
+			f2fs_info(NULL, "Only lfs mode is allowed with zoned block device feature");
 			return -EINVAL;
 		}
 #else
-		f2fs_err(sbi, "Zoned block device support is not enabled");
+		f2fs_err(NULL, "Zoned block device support is not enabled");
 		return -EINVAL;
 #endif
 	}
 
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	if (f2fs_test_compress_extension(sbi)) {
-		f2fs_err(sbi, "invalid compress or nocompress extension");
+		f2fs_err(NULL, "invalid compress or nocompress extension");
 		return -EINVAL;
 	}
 #endif
@@ -1264,11 +1272,11 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
 
 		if (!f2fs_sb_has_extra_attr(sbi) ||
 			!f2fs_sb_has_flexible_inline_xattr(sbi)) {
-			f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
+			f2fs_err(NULL, "extra_attr or flexible_inline_xattr feature is off");
 			return -EINVAL;
 		}
 		if (!test_opt(sbi, INLINE_XATTR)) {
-			f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
+			f2fs_err(NULL, "inline_xattr_size option should be set with inline_xattr option");
 			return -EINVAL;
 		}
 
@@ -1277,24 +1285,24 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
 
 		if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
 				F2FS_OPTION(sbi).inline_xattr_size > max_size) {
-			f2fs_err(sbi, "inline xattr size is out of range: %d ~ %d",
+			f2fs_err(NULL, "inline xattr size is out of range: %d ~ %d",
 				 min_size, max_size);
 			return -EINVAL;
 		}
 	}
 
 	if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {
-		f2fs_err(sbi, "LFS is not compatible with ATGC");
+		f2fs_err(NULL, "LFS is not compatible with ATGC");
 		return -EINVAL;
 	}
 
 	if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {
-		f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");
+		f2fs_err(NULL, "FLUSH_MERGE not compatible with readonly mode");
 		return -EINVAL;
 	}
 
 	if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
-		f2fs_err(sbi, "Allow to mount readonly mode only");
+		f2fs_err(NULL, "Allow to mount readonly mode only");
 		return -EROFS;
 	}
 
-- 
2.33.0

[PATCH v4 4/7] f2fs: Add f2fs_fs_context to record the mount options

[Hongbo Li]

At the parsing phase of mouont in the new mount api, options
value will be recorded with the context, and then it will be
used in fill_super and other helpers.

Note that, this is a temporary status, we want remove the sb
and sbi usages in handle_mount_opt. So here the f2fs_fs_context
only records the mount options, it will be copied in sb/sbi in
later process. (At this point in the series, mount options are
temporarily not set during mount.)

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port, minor fixes and updates]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
---
 fs/f2fs/super.c | 419 ++++++++++++++++++++++++++++--------------------
 1 file changed, 244 insertions(+), 175 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 150287b1e732..87db6eb9ef07 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -312,8 +312,65 @@ static match_table_t f2fs_checkpoint_tokens = {
 	{Opt_err, NULL},
 };
 
+#define F2FS_SPEC_background_gc			(1 << 0)
+#define F2FS_SPEC_inline_xattr_size		(1 << 1)
+#define F2FS_SPEC_active_logs			(1 << 2)
+#define F2FS_SPEC_reserve_root			(1 << 3)
+#define F2FS_SPEC_resgid			(1 << 4)
+#define F2FS_SPEC_resuid			(1 << 5)
+#define F2FS_SPEC_mode				(1 << 6)
+#define F2FS_SPEC_fault_injection		(1 << 7)
+#define F2FS_SPEC_fault_type			(1 << 8)
+#define F2FS_SPEC_jqfmt				(1 << 9)
+#define F2FS_SPEC_alloc_mode			(1 << 10)
+#define F2FS_SPEC_fsync_mode			(1 << 11)
+#define F2FS_SPEC_checkpoint_disable_cap	(1 << 12)
+#define F2FS_SPEC_checkpoint_disable_cap_perc	(1 << 13)
+#define F2FS_SPEC_compress_level		(1 << 14)
+#define F2FS_SPEC_compress_algorithm		(1 << 15)
+#define F2FS_SPEC_compress_log_size		(1 << 16)
+#define F2FS_SPEC_compress_extension		(1 << 17)
+#define F2FS_SPEC_nocompress_extension		(1 << 18)
+#define F2FS_SPEC_compress_chksum		(1 << 19)
+#define F2FS_SPEC_compress_mode			(1 << 20)
+#define F2FS_SPEC_discard_unit			(1 << 21)
+#define F2FS_SPEC_memory_mode			(1 << 22)
+#define F2FS_SPEC_errors			(1 << 23)
+
+struct f2fs_fs_context {
+	struct f2fs_mount_info info;
+	unsigned int	opt_mask;	/* Bits changed */
+	unsigned int	spec_mask;
+	unsigned short	qname_mask;
+	unsigned long	sflags;
+	unsigned long	sflags_mask;
+};
+
+#define F2FS_CTX_INFO(ctx)	((ctx)->info)
+
+static inline void ctx_set_opt(struct f2fs_fs_context *ctx,
+			       unsigned int flag)
+{
+	ctx->info.opt |= flag;
+	ctx->opt_mask |= flag;
+}
+
+static inline void ctx_clear_opt(struct f2fs_fs_context *ctx,
+				 unsigned int flag)
+{
+	ctx->info.opt &= ~flag;
+	ctx->opt_mask |= flag;
+}
+
+static inline void ctx_set_flags(struct f2fs_fs_context *ctx,
+				 unsigned int flag)
+{
+	ctx->sflags |= flag;
+	ctx->sflags_mask |= flag;
+}
+
 void f2fs_printk(struct f2fs_sb_info *sbi, bool limit_rate,
-						const char *fmt, ...)
+					const char *fmt, ...)
 {
 	struct va_format vaf;
 	va_list args;
@@ -431,57 +488,51 @@ static void init_once(void *foo)
 #ifdef CONFIG_QUOTA
 static const char * const quotatypes[] = INITQFNAMES;
 #define QTYPE2NAME(t) (quotatypes[t])
-static int f2fs_set_qf_name(struct f2fs_sb_info *sbi, int qtype,
-			    struct fs_parameter *param)
+/*
+ * Note the name of the specified quota file.
+ */
+static int f2fs_note_qf_name(struct fs_context *fc, int qtype,
+			     struct fs_parameter *param)
 {
-	struct super_block *sb = sbi->sb;
+	struct f2fs_fs_context *ctx = fc->fs_private;
 	char *qname;
-	int ret = -EINVAL;
 
-	if (sb_any_quota_loaded(sb) && !F2FS_OPTION(sbi).s_qf_names[qtype]) {
-		f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
+	if (param->size < 1) {
+		f2fs_err(NULL, "Missing quota name");
 		return -EINVAL;
 	}
-	if (f2fs_sb_has_quota_ino(sbi)) {
-		f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
+	if (strchr(param->string, '/')) {
+		f2fs_err(NULL, "quotafile must be on filesystem root");
+		return -EINVAL;
+	}
+	if (ctx->info.s_qf_names[qtype]) {
+		if (strcmp(ctx->info.s_qf_names[qtype], param->string) != 0) {
+			f2fs_err(NULL, "Quota file already specified");
+			return -EINVAL;
+		}
 		return 0;
 	}
 
 	qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
 	if (!qname) {
-		f2fs_err(sbi, "Not enough memory for storing quotafile name");
+		f2fs_err(NULL, "Not enough memory for storing quotafile name");
 		return -ENOMEM;
 	}
-	if (F2FS_OPTION(sbi).s_qf_names[qtype]) {
-		if (strcmp(F2FS_OPTION(sbi).s_qf_names[qtype], qname) == 0)
-			ret = 0;
-		else
-			f2fs_err(sbi, "%s quota file already specified",
-				 QTYPE2NAME(qtype));
-		goto errout;
-	}
-	if (strchr(qname, '/')) {
-		f2fs_err(sbi, "quotafile must be on filesystem root");
-		goto errout;
-	}
-	F2FS_OPTION(sbi).s_qf_names[qtype] = qname;
-	set_opt(sbi, QUOTA);
+	F2FS_CTX_INFO(ctx).s_qf_names[qtype] = qname;
+	ctx->qname_mask |= 1 << qtype;
 	return 0;
-errout:
-	kfree(qname);
-	return ret;
 }
 
-static int f2fs_clear_qf_name(struct f2fs_sb_info *sbi, int qtype)
+/*
+ * Clear the name of the specified quota file.
+ */
+static int f2fs_unnote_qf_name(struct fs_context *fc, int qtype)
 {
-	struct super_block *sb = sbi->sb;
+	struct f2fs_fs_context *ctx = fc->fs_private;
 
-	if (sb_any_quota_loaded(sb) && F2FS_OPTION(sbi).s_qf_names[qtype]) {
-		f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
-		return -EINVAL;
-	}
-	kfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
-	F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;
+	kfree(ctx->info.s_qf_names[qtype]);
+	ctx->info.s_qf_names[qtype] = NULL;
+	ctx->qname_mask |= 1 << qtype;
 	return 0;
 }
 
@@ -531,54 +582,33 @@ static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
 }
 #endif
 
-static int f2fs_set_test_dummy_encryption(struct f2fs_sb_info *sbi,
-					  const struct fs_parameter *param,
-					  bool is_remount)
+static int f2fs_parse_test_dummy_encryption(const struct fs_parameter *param,
+					    struct f2fs_fs_context *ctx)
 {
-	struct fscrypt_dummy_policy *policy =
-		&F2FS_OPTION(sbi).dummy_enc_policy;
 	int err;
 
 	if (!IS_ENABLED(CONFIG_FS_ENCRYPTION)) {
-		f2fs_warn(sbi, "test_dummy_encryption option not supported");
+		f2fs_warn(NULL, "test_dummy_encryption option not supported");
 		return -EINVAL;
 	}
-
-	if (!f2fs_sb_has_encrypt(sbi)) {
-		f2fs_err(sbi, "Encrypt feature is off");
-		return -EINVAL;
-	}
-
-	/*
-	 * This mount option is just for testing, and it's not worthwhile to
-	 * implement the extra complexity (e.g. RCU protection) that would be
-	 * needed to allow it to be set or changed during remount.  We do allow
-	 * it to be specified during remount, but only if there is no change.
-	 */
-	if (is_remount && !fscrypt_is_dummy_policy_set(policy)) {
-		f2fs_warn(sbi, "Can't set test_dummy_encryption on remount");
-		return -EINVAL;
-	}
-
-	err = fscrypt_parse_test_dummy_encryption(param, policy);
+	err = fscrypt_parse_test_dummy_encryption(param,
+					&ctx->info.dummy_enc_policy);
 	if (err) {
-		if (err == -EEXIST)
-			f2fs_warn(sbi,
-				  "Can't change test_dummy_encryption on remount");
-		else if (err == -EINVAL)
-			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
+		if (err == -EINVAL)
+			f2fs_warn(NULL, "Value of option \"%s\" is unrecognized",
 				  param->key);
+		else if (err == -EEXIST)
+			f2fs_warn(NULL, "Conflicting test_dummy_encryption options");
 		else
-			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
+			f2fs_warn(NULL, "Error processing option \"%s\" [%d]",
 				  param->key, err);
 		return -EINVAL;
 	}
-	f2fs_warn(sbi, "Test dummy encryption mode enabled");
 	return 0;
 }
 
 #ifdef CONFIG_F2FS_FS_COMPRESSION
-static bool is_compress_extension_exist(struct f2fs_sb_info *sbi,
+static bool is_compress_extension_exist(struct f2fs_mount_info *info,
 					const char *new_ext, bool is_ext)
 {
 	unsigned char (*ext)[F2FS_EXTENSION_LEN];
@@ -586,11 +616,11 @@ static bool is_compress_extension_exist(struct f2fs_sb_info *sbi,
 	int i;
 
 	if (is_ext) {
-		ext = F2FS_OPTION(sbi).extensions;
-		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
+		ext = info->extensions;
+		ext_cnt = info->compress_ext_cnt;
 	} else {
-		ext = F2FS_OPTION(sbi).noextensions;
-		ext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
+		ext = info->noextensions;
+		ext_cnt = info->nocompress_ext_cnt;
 	}
 
 	for (i = 0; i < ext_cnt; i++) {
@@ -639,58 +669,62 @@ static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)
 }
 
 #ifdef CONFIG_F2FS_FS_LZ4
-static int f2fs_set_lz4hc_level(struct f2fs_sb_info *sbi, const char *str)
+static int f2fs_set_lz4hc_level(struct f2fs_fs_context *ctx, const char *str)
 {
 #ifdef CONFIG_F2FS_FS_LZ4HC
 	unsigned int level;
 
 	if (strlen(str) == 3) {
-		F2FS_OPTION(sbi).compress_level = 0;
+		F2FS_CTX_INFO(ctx).compress_level = 0;
+		ctx->spec_mask |= F2FS_SPEC_compress_level;
 		return 0;
 	}
 
 	str += 3;
 
 	if (str[0] != ':') {
-		f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");
+		f2fs_info(NULL, "wrong format, e.g. <alg_name>:<compr_level>");
 		return -EINVAL;
 	}
 	if (kstrtouint(str + 1, 10, &level))
 		return -EINVAL;
 
 	if (!f2fs_is_compress_level_valid(COMPRESS_LZ4, level)) {
-		f2fs_info(sbi, "invalid lz4hc compress level: %d", level);
+		f2fs_info(NULL, "invalid lz4hc compress level: %d", level);
 		return -EINVAL;
 	}
 
-	F2FS_OPTION(sbi).compress_level = level;
+	F2FS_CTX_INFO(ctx).compress_level = level;
+	ctx->spec_mask |= F2FS_SPEC_compress_level;
 	return 0;
 #else
 	if (strlen(str) == 3) {
-		F2FS_OPTION(sbi).compress_level = 0;
+		F2FS_CTX_INFO(ctx).compress_level = 0;
+		ctx->spec_mask |= F2FS_SPEC_compress_level;
 		return 0;
 	}
-	f2fs_info(sbi, "kernel doesn't support lz4hc compression");
+	f2fs_info(NULL, "kernel doesn't support lz4hc compression");
 	return -EINVAL;
 #endif
 }
 #endif
 
 #ifdef CONFIG_F2FS_FS_ZSTD
-static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
+static int f2fs_set_zstd_level(struct f2fs_fs_context *ctx, const char *str)
 {
 	int level;
 	int len = 4;
 
 	if (strlen(str) == len) {
-		F2FS_OPTION(sbi).compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
+		F2FS_CTX_INFO(ctx).compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
+		ctx->spec_mask |= F2FS_SPEC_compress_level;
 		return 0;
 	}
 
 	str += len;
 
 	if (str[0] != ':') {
-		f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");
+		f2fs_info(NULL, "wrong format, e.g. <alg_name>:<compr_level>");
 		return -EINVAL;
 	}
 	if (kstrtoint(str + 1, 10, &level))
@@ -698,16 +732,17 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
 
 	/* f2fs does not support negative compress level now */
 	if (level < 0) {
-		f2fs_info(sbi, "do not support negative compress level: %d", level);
+		f2fs_info(NULL, "do not support negative compress level: %d", level);
 		return -ERANGE;
 	}
 
 	if (!f2fs_is_compress_level_valid(COMPRESS_ZSTD, level)) {
-		f2fs_info(sbi, "invalid zstd compress level: %d", level);
+		f2fs_info(NULL, "invalid zstd compress level: %d", level);
 		return -EINVAL;
 	}
 
-	F2FS_OPTION(sbi).compress_level = level;
+	F2FS_CTX_INFO(ctx).compress_level = level;
+	ctx->spec_mask |= F2FS_SPEC_compress_level;
 	return 0;
 }
 #endif
@@ -715,6 +750,7 @@ static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
 
 static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 {
+	struct f2fs_fs_context *ctx = fc->fs_private;
 	struct f2fs_sb_info *sbi = fc->s_fs_info;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	unsigned char (*ext)[F2FS_EXTENSION_LEN];
@@ -735,14 +771,15 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 
 	switch (token) {
 	case Opt_gc_background:
-		F2FS_OPTION(sbi).bggc_mode = result.uint_32;
+		F2FS_CTX_INFO(ctx).bggc_mode = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_background_gc;
 		break;
 	case Opt_disable_roll_forward:
-		set_opt(sbi, DISABLE_ROLL_FORWARD);
+		ctx_set_opt(ctx, F2FS_MOUNT_DISABLE_ROLL_FORWARD);
 		break;
 	case Opt_norecovery:
 		/* requires ro mount, checked in f2fs_validate_options */
-		set_opt(sbi, NORECOVERY);
+		ctx_set_opt(ctx, F2FS_MOUNT_NORECOVERY);
 		break;
 	case Opt_discard:
 		if (result.negated) {
@@ -750,13 +787,13 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 				f2fs_warn(NULL, "discard is required for zoned block devices");
 				return -EINVAL;
 			}
-			clear_opt(sbi, DISCARD);
+			ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
 		} else {
 			if (!f2fs_hw_support_discard(sbi)) {
 				f2fs_warn(NULL, "device does not support discard");
 				break;
 			}
-			set_opt(sbi, DISCARD);
+			ctx_set_opt(ctx, F2FS_MOUNT_DISCARD);
 		}
 		break;
 	case Opt_noheap:
@@ -766,19 +803,20 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #ifdef CONFIG_F2FS_FS_XATTR
 	case Opt_user_xattr:
 		if (result.negated)
-			clear_opt(sbi, XATTR_USER);
+			ctx_clear_opt(ctx, F2FS_MOUNT_XATTR_USER);
 		else
-			set_opt(sbi, XATTR_USER);
+			ctx_set_opt(ctx, F2FS_MOUNT_XATTR_USER);
 		break;
 	case Opt_inline_xattr:
 		if (result.negated)
-			clear_opt(sbi, INLINE_XATTR);
+			ctx_clear_opt(ctx, F2FS_MOUNT_INLINE_XATTR);
 		else
-			set_opt(sbi, INLINE_XATTR);
+			ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR);
 		break;
 	case Opt_inline_xattr_size:
-		set_opt(sbi, INLINE_XATTR_SIZE);
-		F2FS_OPTION(sbi).inline_xattr_size = result.int_32;
+		ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE);
+		F2FS_CTX_INFO(ctx).inline_xattr_size = result.int_32;
+		ctx->spec_mask |= F2FS_SPEC_inline_xattr_size;
 		break;
 #else
 	case Opt_user_xattr:
@@ -790,9 +828,9 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 	case Opt_acl:
 		if (result.negated)
-			clear_opt(sbi, POSIX_ACL);
+			ctx_clear_opt(ctx, F2FS_MOUNT_POSIX_ACL);
 		else
-			set_opt(sbi, POSIX_ACL);
+			ctx_set_opt(ctx, F2FS_MOUNT_POSIX_ACL);
 		break;
 #else
 	case Opt_acl:
@@ -803,37 +841,38 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		if (result.int_32 != 2 && result.int_32 != 4 &&
 			result.int_32 != NR_CURSEG_PERSIST_TYPE)
 			return -EINVAL;
-		F2FS_OPTION(sbi).active_logs = result.int_32;
+		ctx->spec_mask |= F2FS_SPEC_active_logs;
+		F2FS_CTX_INFO(ctx).active_logs = result.int_32;
 		break;
 	case Opt_disable_ext_identify:
-		set_opt(sbi, DISABLE_EXT_IDENTIFY);
+		ctx_set_opt(ctx, F2FS_MOUNT_DISABLE_EXT_IDENTIFY);
 		break;
 	case Opt_inline_data:
 		if (result.negated)
-			clear_opt(sbi, INLINE_DATA);
+			ctx_clear_opt(ctx, F2FS_MOUNT_INLINE_DATA);
 		else
-			set_opt(sbi, INLINE_DATA);
+			ctx_set_opt(ctx, F2FS_MOUNT_INLINE_DATA);
 		break;
 	case Opt_inline_dentry:
 		if (result.negated)
-			clear_opt(sbi, INLINE_DENTRY);
+			ctx_clear_opt(ctx, F2FS_MOUNT_INLINE_DENTRY);
 		else
-			set_opt(sbi, INLINE_DENTRY);
+			ctx_set_opt(ctx, F2FS_MOUNT_INLINE_DENTRY);
 		break;
 	case Opt_flush_merge:
 		if (result.negated)
-			clear_opt(sbi, FLUSH_MERGE);
+			ctx_clear_opt(ctx, F2FS_MOUNT_FLUSH_MERGE);
 		else
-			set_opt(sbi, FLUSH_MERGE);
+			ctx_set_opt(ctx, F2FS_MOUNT_FLUSH_MERGE);
 		break;
 	case Opt_barrier:
 		if (result.negated)
-			set_opt(sbi, NOBARRIER);
+			ctx_set_opt(ctx, F2FS_MOUNT_NOBARRIER);
 		else
-			clear_opt(sbi, NOBARRIER);
+			ctx_clear_opt(ctx, F2FS_MOUNT_NOBARRIER);
 		break;
 	case Opt_fastboot:
-		set_opt(sbi, FASTBOOT);
+		ctx_set_opt(ctx, F2FS_MOUNT_FASTBOOT);
 		break;
 	case Opt_extent_cache:
 		if (result.negated) {
@@ -841,42 +880,50 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 				f2fs_err(sbi, "device aliasing requires extent cache");
 				return -EINVAL;
 			}
-			clear_opt(sbi, READ_EXTENT_CACHE);
+			ctx_clear_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
 		} else
-			set_opt(sbi, READ_EXTENT_CACHE);
+			ctx_set_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
 		break;
 	case Opt_data_flush:
-		set_opt(sbi, DATA_FLUSH);
+		ctx_set_opt(ctx, F2FS_MOUNT_DATA_FLUSH);
 		break;
 	case Opt_reserve_root:
 		if (test_opt(sbi, RESERVE_ROOT)) {
 			f2fs_info(NULL, "Preserve previous reserve_root=%u",
 				  F2FS_OPTION(sbi).root_reserved_blocks);
 		} else {
-			F2FS_OPTION(sbi).root_reserved_blocks = result.int_32;
-			set_opt(sbi, RESERVE_ROOT);
+			ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
+			F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
+			ctx->spec_mask |= F2FS_SPEC_reserve_root;
 		}
 		break;
 	case Opt_resuid:
-		F2FS_OPTION(sbi).s_resuid = result.uid;
+		F2FS_CTX_INFO(ctx).s_resuid = result.uid;
+		ctx->spec_mask |= F2FS_SPEC_resuid;
 		break;
 	case Opt_resgid:
-		F2FS_OPTION(sbi).s_resgid = result.gid;
+		F2FS_CTX_INFO(ctx).s_resgid = result.gid;
+		ctx->spec_mask |= F2FS_SPEC_resgid;
 		break;
 	case Opt_mode:
-		F2FS_OPTION(sbi).fs_mode = result.uint_32;
+		F2FS_CTX_INFO(ctx).fs_mode = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_mode;
 		break;
 #ifdef CONFIG_F2FS_FAULT_INJECTION
 	case Opt_fault_injection:
 		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
 			return -EINVAL;
-		set_opt(sbi, FAULT_INJECTION);
+		F2FS_CTX_INFO(ctx).fault_info.inject_rate = result.int_32;
+		ctx->spec_mask |= F2FS_SPEC_fault_injection;
+		ctx_set_opt(ctx, F2FS_MOUNT_FAULT_INJECTION);
 		break;
 
 	case Opt_fault_type:
 		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
 			return -EINVAL;
-		set_opt(sbi, FAULT_INJECTION);
+		F2FS_CTX_INFO(ctx).fault_info.inject_type = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_fault_type;
+		ctx_set_opt(ctx, F2FS_MOUNT_FAULT_INJECTION);
 		break;
 #else
 	case Opt_fault_injection:
@@ -886,55 +933,56 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #endif
 	case Opt_lazytime:
 		if (result.negated)
-			clear_opt(sbi, LAZYTIME);
+			ctx_clear_opt(ctx, F2FS_MOUNT_LAZYTIME);
 		else
-			set_opt(sbi, LAZYTIME);
+			ctx_set_opt(ctx, F2FS_MOUNT_LAZYTIME);
 		break;
 #ifdef CONFIG_QUOTA
 	case Opt_quota:
 		if (result.negated) {
-			clear_opt(sbi, QUOTA);
-			clear_opt(sbi, USRQUOTA);
-			clear_opt(sbi, GRPQUOTA);
-			clear_opt(sbi, PRJQUOTA);
+			ctx_clear_opt(ctx, F2FS_MOUNT_QUOTA);
+			ctx_clear_opt(ctx, F2FS_MOUNT_USRQUOTA);
+			ctx_clear_opt(ctx, F2FS_MOUNT_GRPQUOTA);
+			ctx_clear_opt(ctx, F2FS_MOUNT_PRJQUOTA);
 		} else
-			set_opt(sbi, USRQUOTA);
+			ctx_set_opt(ctx, F2FS_MOUNT_USRQUOTA);
 		break;
 	case Opt_usrquota:
-		set_opt(sbi, USRQUOTA);
+		ctx_set_opt(ctx, F2FS_MOUNT_USRQUOTA);
 		break;
 	case Opt_grpquota:
-		set_opt(sbi, GRPQUOTA);
+		ctx_set_opt(ctx, F2FS_MOUNT_GRPQUOTA);
 		break;
 	case Opt_prjquota:
-		set_opt(sbi, PRJQUOTA);
+		ctx_set_opt(ctx, F2FS_MOUNT_PRJQUOTA);
 		break;
 	case Opt_usrjquota:
 		if (!*param->string)
-			ret = f2fs_clear_qf_name(sbi, USRQUOTA);
+			ret = f2fs_unnote_qf_name(fc, USRQUOTA);
 		else
-			ret = f2fs_set_qf_name(sbi, USRQUOTA, param);
+			ret = f2fs_note_qf_name(fc, USRQUOTA, param);
 		if (ret)
 			return ret;
 		break;
 	case Opt_grpjquota:
 		if (!*param->string)
-			ret = f2fs_clear_qf_name(sbi, GRPQUOTA);
+			ret = f2fs_unnote_qf_name(fc, GRPQUOTA);
 		else
-			ret = f2fs_set_qf_name(sbi, GRPQUOTA, param);
+			ret = f2fs_note_qf_name(fc, GRPQUOTA, param);
 		if (ret)
 			return ret;
 		break;
 	case Opt_prjjquota:
 		if (!*param->string)
-			ret = f2fs_clear_qf_name(sbi, PRJQUOTA);
+			ret = f2fs_unnote_qf_name(fc, PRJQUOTA);
 		else
-			ret = f2fs_set_qf_name(sbi, PRJQUOTA, param);
+			ret = f2fs_note_qf_name(fc, PRJQUOTA, param);
 		if (ret)
 			return ret;
 		break;
 	case Opt_jqfmt:
-		F2FS_OPTION(sbi).s_jquota_fmt = result.uint_32;
+		F2FS_CTX_INFO(ctx).s_jquota_fmt = result.int_32;
+		ctx->spec_mask |= F2FS_SPEC_jqfmt;
 		break;
 #else
 	case Opt_quota:
@@ -948,19 +996,21 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 #endif
 	case Opt_alloc:
-		F2FS_OPTION(sbi).alloc_mode = result.uint_32;
+		F2FS_CTX_INFO(ctx).alloc_mode = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_alloc_mode;
 		break;
 	case Opt_fsync:
-		F2FS_OPTION(sbi).fsync_mode = result.uint_32;
+		F2FS_CTX_INFO(ctx).fsync_mode = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_fsync_mode;
 		break;
 	case Opt_test_dummy_encryption:
-		ret = f2fs_set_test_dummy_encryption(sbi, param, is_remount);
+		ret = f2fs_parse_test_dummy_encryption(param, ctx);
 		if (ret)
 			return ret;
 		break;
 	case Opt_inlinecrypt:
 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
-		set_opt(sbi, INLINECRYPT);
+		ctx_set_opt(ctx, F2FS_MOUNT_INLINECRYPT);
 #else
 		f2fs_info(NULL, "inline encryption not supported");
 #endif
@@ -981,20 +1031,22 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 				return -EINVAL;
 			if (arg < 0 || arg > 100)
 				return -EINVAL;
-			F2FS_OPTION(sbi).unusable_cap_perc = arg;
-			set_opt(sbi, DISABLE_CHECKPOINT);
+			F2FS_CTX_INFO(ctx).unusable_cap_perc = arg;
+			ctx->spec_mask |= F2FS_SPEC_checkpoint_disable_cap_perc;
+			ctx_set_opt(ctx, F2FS_MOUNT_DISABLE_CHECKPOINT);
 			break;
 		case Opt_checkpoint_disable_cap:
 			if (args->from && match_int(args, &arg))
 				return -EINVAL;
-			F2FS_OPTION(sbi).unusable_cap = arg;
-			set_opt(sbi, DISABLE_CHECKPOINT);
+			F2FS_CTX_INFO(ctx).unusable_cap = arg;
+			ctx->spec_mask |= F2FS_SPEC_checkpoint_disable_cap;
+			ctx_set_opt(ctx, F2FS_MOUNT_DISABLE_CHECKPOINT);
 			break;
 		case Opt_checkpoint_disable:
-			set_opt(sbi, DISABLE_CHECKPOINT);
+			ctx_set_opt(ctx, F2FS_MOUNT_DISABLE_CHECKPOINT);
 			break;
 		case Opt_checkpoint_enable:
-			clear_opt(sbi, DISABLE_CHECKPOINT);
+			ctx_clear_opt(ctx, F2FS_MOUNT_DISABLE_CHECKPOINT);
 			break;
 		default:
 			return -EINVAL;
@@ -1002,9 +1054,9 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 	case Opt_checkpoint_merge:
 		if (result.negated)
-			clear_opt(sbi, MERGE_CHECKPOINT);
+			ctx_clear_opt(ctx, F2FS_MOUNT_MERGE_CHECKPOINT);
 		else
-			set_opt(sbi, MERGE_CHECKPOINT);
+			ctx_set_opt(ctx, F2FS_MOUNT_MERGE_CHECKPOINT);
 		break;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	case Opt_compress_algorithm:
@@ -1015,33 +1067,39 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		name = param->string;
 		if (!strcmp(name, "lzo")) {
 #ifdef CONFIG_F2FS_FS_LZO
-			F2FS_OPTION(sbi).compress_level = 0;
-			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZO;
+			F2FS_CTX_INFO(ctx).compress_level = 0;
+			F2FS_CTX_INFO(ctx).compress_algorithm = COMPRESS_LZO;
+			ctx->spec_mask |= F2FS_SPEC_compress_level;
+			ctx->spec_mask |= F2FS_SPEC_compress_algorithm;
 #else
 			f2fs_info(NULL, "kernel doesn't support lzo compression");
 #endif
 		} else if (!strncmp(name, "lz4", 3)) {
 #ifdef CONFIG_F2FS_FS_LZ4
-			ret = f2fs_set_lz4hc_level(sbi, name);
+			ret = f2fs_set_lz4hc_level(ctx, name);
 			if (ret)
 				return -EINVAL;
-			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
+			F2FS_CTX_INFO(ctx).compress_algorithm = COMPRESS_LZ4;
+			ctx->spec_mask |= F2FS_SPEC_compress_algorithm;
 #else
 			f2fs_info(NULL, "kernel doesn't support lz4 compression");
 #endif
 		} else if (!strncmp(name, "zstd", 4)) {
 #ifdef CONFIG_F2FS_FS_ZSTD
-			ret = f2fs_set_zstd_level(sbi, name);
+			ret = f2fs_set_zstd_level(ctx, name);
 			if (ret)
 				return -EINVAL;
-			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_ZSTD;
+			F2FS_CTX_INFO(ctx).compress_algorithm = COMPRESS_ZSTD;
+			ctx->spec_mask |= F2FS_SPEC_compress_algorithm;
 #else
 			f2fs_info(NULL, "kernel doesn't support zstd compression");
 #endif
 		} else if (!strcmp(name, "lzo-rle")) {
 #ifdef CONFIG_F2FS_FS_LZORLE
-			F2FS_OPTION(sbi).compress_level = 0;
-			F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZORLE;
+			F2FS_CTX_INFO(ctx).compress_level = 0;
+			F2FS_CTX_INFO(ctx).compress_algorithm = COMPRESS_LZORLE;
+			ctx->spec_mask |= F2FS_SPEC_compress_level;
+			ctx->spec_mask |= F2FS_SPEC_compress_algorithm;
 #else
 			f2fs_info(NULL, "kernel doesn't support lzorle compression");
 #endif
@@ -1059,7 +1117,8 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 				"Compress cluster log size is out of range");
 			return -EINVAL;
 		}
-		F2FS_OPTION(sbi).compress_log_size = result.uint_32;
+		F2FS_CTX_INFO(ctx).compress_log_size = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_compress_log_size;
 		break;
 	case Opt_compress_extension:
 		if (!f2fs_sb_has_compression(sbi)) {
@@ -1067,8 +1126,8 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			break;
 		}
 		name = param->string;
-		ext = F2FS_OPTION(sbi).extensions;
-		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
+		ext = F2FS_CTX_INFO(ctx).extensions;
+		ext_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
 
 		if (strlen(name) >= F2FS_EXTENSION_LEN ||
 		    ext_cnt >= COMPRESS_EXT_NUM) {
@@ -1076,13 +1135,14 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			return -EINVAL;
 		}
 
-		if (is_compress_extension_exist(sbi, name, true))
+		if (is_compress_extension_exist(&ctx->info, name, true))
 			break;
 
 		ret = strscpy(ext[ext_cnt], name, F2FS_EXTENSION_LEN);
 		if (ret < 0)
 			return ret;
-		F2FS_OPTION(sbi).compress_ext_cnt++;
+		F2FS_CTX_INFO(ctx).compress_ext_cnt++;
+		ctx->spec_mask |= F2FS_SPEC_compress_extension;
 		break;
 	case Opt_nocompress_extension:
 		if (!f2fs_sb_has_compression(sbi)) {
@@ -1090,8 +1150,8 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			break;
 		}
 		name = param->string;
-		noext = F2FS_OPTION(sbi).noextensions;
-		noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
+		noext = F2FS_CTX_INFO(ctx).noextensions;
+		noext_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
 
 		if (strlen(name) >= F2FS_EXTENSION_LEN ||
 			noext_cnt >= COMPRESS_EXT_NUM) {
@@ -1099,34 +1159,37 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			return -EINVAL;
 		}
 
-		if (is_compress_extension_exist(sbi, name, false))
+		if (is_compress_extension_exist(&ctx->info, name, false))
 			break;
 
 		ret = strscpy(noext[noext_cnt], name, F2FS_EXTENSION_LEN);
 		if (ret < 0)
 			return ret;
-		F2FS_OPTION(sbi).nocompress_ext_cnt++;
+		F2FS_CTX_INFO(ctx).nocompress_ext_cnt++;
+		ctx->spec_mask |= F2FS_SPEC_nocompress_extension;
 		break;
 	case Opt_compress_chksum:
 		if (!f2fs_sb_has_compression(sbi)) {
 			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
-		F2FS_OPTION(sbi).compress_chksum = true;
+		F2FS_CTX_INFO(ctx).compress_chksum = true;
+		ctx->spec_mask |= F2FS_SPEC_compress_chksum;
 		break;
 	case Opt_compress_mode:
 		if (!f2fs_sb_has_compression(sbi)) {
 			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
-		F2FS_OPTION(sbi).compress_mode = result.uint_32;
+		F2FS_CTX_INFO(ctx).compress_mode = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_compress_mode;
 		break;
 	case Opt_compress_cache:
 		if (!f2fs_sb_has_compression(sbi)) {
 			f2fs_info(NULL, "Image doesn't support compression");
 			break;
 		}
-		set_opt(sbi, COMPRESS_CACHE);
+		ctx_set_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE);
 		break;
 #else
 	case Opt_compress_algorithm:
@@ -1140,28 +1203,31 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 #endif
 	case Opt_atgc:
-		set_opt(sbi, ATGC);
+		ctx_set_opt(ctx, F2FS_MOUNT_ATGC);
 		break;
 	case Opt_gc_merge:
 		if (result.negated)
-			clear_opt(sbi, GC_MERGE);
+			ctx_clear_opt(ctx, F2FS_MOUNT_GC_MERGE);
 		else
-			set_opt(sbi, GC_MERGE);
+			ctx_set_opt(ctx, F2FS_MOUNT_GC_MERGE);
 		break;
 	case Opt_discard_unit:
-		F2FS_OPTION(sbi).discard_unit = result.uint_32;
+		F2FS_CTX_INFO(ctx).discard_unit = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_discard_unit;
 		break;
 	case Opt_memory_mode:
-		F2FS_OPTION(sbi).memory_mode = result.uint_32;
+		F2FS_CTX_INFO(ctx).memory_mode = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_memory_mode;
 		break;
 	case Opt_age_extent_cache:
-		set_opt(sbi, AGE_EXTENT_CACHE);
+		ctx_set_opt(ctx, F2FS_MOUNT_AGE_EXTENT_CACHE);
 		break;
 	case Opt_errors:
-		F2FS_OPTION(sbi).errors = result.uint_32;
+		F2FS_CTX_INFO(ctx).errors = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_errors;
 		break;
 	case Opt_nat_bits:
-		set_opt(sbi, NAT_BITS);
+		ctx_set_opt(ctx, F2FS_MOUNT_NAT_BITS);
 		break;
 	}
 	return 0;
@@ -1171,6 +1237,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
 {
 	struct fs_parameter param;
 	struct fs_context fc;
+	struct f2fs_fs_context ctx;
 	char *key;
 	int ret;
 
@@ -1179,6 +1246,8 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
 
 	memset(&fc, 0, sizeof(fc));
 	fc.s_fs_info = sbi;
+	fc.fs_private = &ctx;
+
 	if (is_remount)
 		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
 
-- 
2.33.0

[PATCH v4 5/7] f2fs: separate the options parsing and options checking

[Hongbo Li]

The new mount api separates option parsing and super block setup
into two distinct steps and so we need to separate the options
parsing out of the parse_options().

In order to achieve this, here we handle the mount options with
three steps:
  - Firstly, we move sb/sbi out of handle_mount_opt.
    As the former patch introduced f2fs_fs_context, so we record
    the changed mount options in this context. In handle_mount_opt,
    sb/sbi is null, so we should move all relative code out of
    handle_mount_opt (thus, some check case which use sb/sbi should
    move out).
  - Secondly, we introduce the some check helpers to keep the option
    consistent.
    During filling superblock period, sb/sbi are ready. So we check
    the f2fs_fs_context which holds the mount options base on sb/sbi.
  - Thirdly, we apply the new mount options to sb/sbi.
    After checking the f2fs_fs_context, all changed on mount options
    are valid. So we can apply them to sb/sbi directly.

After do these, option parsing and super block setting have been
decoupled. Also it should have retained the original execution
flow.

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port, minor fixes and updates]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
[hongbo: minor fixes]
Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
---
 fs/f2fs/super.c | 736 +++++++++++++++++++++++++++++++++++-------------
 1 file changed, 543 insertions(+), 193 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 87db6eb9ef07..9835e7cd1071 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -362,6 +362,12 @@ static inline void ctx_clear_opt(struct f2fs_fs_context *ctx,
 	ctx->opt_mask |= flag;
 }
 
+static inline bool ctx_test_opt(struct f2fs_fs_context *ctx,
+				unsigned int flag)
+{
+	return ctx->info.opt & flag;
+}
+
 static inline void ctx_set_flags(struct f2fs_fs_context *ctx,
 				 unsigned int flag)
 {
@@ -535,51 +541,6 @@ static int f2fs_unnote_qf_name(struct fs_context *fc, int qtype)
 	ctx->qname_mask |= 1 << qtype;
 	return 0;
 }
-
-static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
-{
-	/*
-	 * We do the test below only for project quotas. 'usrquota' and
-	 * 'grpquota' mount options are allowed even without quota feature
-	 * to support legacy quotas in quota files.
-	 */
-	if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
-		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
-		return -1;
-	}
-	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
-			F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
-			F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
-		if (test_opt(sbi, USRQUOTA) &&
-				F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
-			clear_opt(sbi, USRQUOTA);
-
-		if (test_opt(sbi, GRPQUOTA) &&
-				F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
-			clear_opt(sbi, GRPQUOTA);
-
-		if (test_opt(sbi, PRJQUOTA) &&
-				F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
-			clear_opt(sbi, PRJQUOTA);
-
-		if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
-				test_opt(sbi, PRJQUOTA)) {
-			f2fs_err(sbi, "old and new quota format mixing");
-			return -1;
-		}
-
-		if (!F2FS_OPTION(sbi).s_jquota_fmt) {
-			f2fs_err(sbi, "journaled quota format not specified");
-			return -1;
-		}
-	}
-
-	if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
-		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
-		F2FS_OPTION(sbi).s_jquota_fmt = 0;
-	}
-	return 0;
-}
 #endif
 
 static int f2fs_parse_test_dummy_encryption(const struct fs_parameter *param,
@@ -638,28 +599,28 @@ static bool is_compress_extension_exist(struct f2fs_mount_info *info,
  * extension will be treated as special cases and will not be compressed.
  * 3. Don't allow the non-compress extension specifies all files.
  */
-static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)
+static int f2fs_test_compress_extension(unsigned char (*noext)[F2FS_EXTENSION_LEN],
+					int noext_cnt,
+					unsigned char (*ext)[F2FS_EXTENSION_LEN],
+					int ext_cnt)
 {
-	unsigned char (*ext)[F2FS_EXTENSION_LEN];
-	unsigned char (*noext)[F2FS_EXTENSION_LEN];
-	int ext_cnt, noext_cnt, index = 0, no_index = 0;
-
-	ext = F2FS_OPTION(sbi).extensions;
-	ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
-	noext = F2FS_OPTION(sbi).noextensions;
-	noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
+	int index = 0, no_index = 0;
 
 	if (!noext_cnt)
 		return 0;
 
 	for (no_index = 0; no_index < noext_cnt; no_index++) {
+		if (strlen(noext[no_index]) == 0)
+			continue;
 		if (!strcasecmp("*", noext[no_index])) {
-			f2fs_info(sbi, "Don't allow the nocompress extension specifies all files");
+			f2fs_info(NULL, "Don't allow the nocompress extension specifies all files");
 			return -EINVAL;
 		}
 		for (index = 0; index < ext_cnt; index++) {
+			if (strlen(ext[index]) == 0)
+				continue;
 			if (!strcasecmp(ext[index], noext[no_index])) {
-				f2fs_info(sbi, "Don't allow the same extension %s appear in both compress and nocompress extension",
+				f2fs_info(NULL, "Don't allow the same extension %s appear in both compress and nocompress extension",
 						ext[index]);
 				return -EINVAL;
 			}
@@ -751,7 +712,6 @@ static int f2fs_set_zstd_level(struct f2fs_fs_context *ctx, const char *str)
 static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 {
 	struct f2fs_fs_context *ctx = fc->fs_private;
-	struct f2fs_sb_info *sbi = fc->s_fs_info;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	unsigned char (*ext)[F2FS_EXTENSION_LEN];
 	unsigned char (*noext)[F2FS_EXTENSION_LEN];
@@ -760,15 +720,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 #endif
 	substring_t args[MAX_OPT_ARGS];
 	struct fs_parse_result result;
-	bool is_remount;
 	int token, ret, arg;
 
 	token = fs_parse(fc, f2fs_param_specs, param, &result);
 	if (token < 0)
 		return token;
 
-	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
-
 	switch (token) {
 	case Opt_gc_background:
 		F2FS_CTX_INFO(ctx).bggc_mode = result.uint_32;
@@ -782,19 +739,10 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		ctx_set_opt(ctx, F2FS_MOUNT_NORECOVERY);
 		break;
 	case Opt_discard:
-		if (result.negated) {
-			if (f2fs_hw_should_discard(sbi)) {
-				f2fs_warn(NULL, "discard is required for zoned block devices");
-				return -EINVAL;
-			}
+		if (result.negated)
 			ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
-		} else {
-			if (!f2fs_hw_support_discard(sbi)) {
-				f2fs_warn(NULL, "device does not support discard");
-				break;
-			}
+		else
 			ctx_set_opt(ctx, F2FS_MOUNT_DISCARD);
-		}
 		break;
 	case Opt_noheap:
 	case Opt_heap:
@@ -814,6 +762,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR);
 		break;
 	case Opt_inline_xattr_size:
+		if (result.int_32 < MIN_INLINE_XATTR_SIZE ||
+			result.int_32 > MAX_INLINE_XATTR_SIZE) {
+			f2fs_err(NULL, "inline xattr size is out of range: %lu ~ %lu",
+				MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
+			return -EINVAL;
+		}
 		ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE);
 		F2FS_CTX_INFO(ctx).inline_xattr_size = result.int_32;
 		ctx->spec_mask |= F2FS_SPEC_inline_xattr_size;
@@ -875,27 +829,18 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		ctx_set_opt(ctx, F2FS_MOUNT_FASTBOOT);
 		break;
 	case Opt_extent_cache:
-		if (result.negated) {
-			if (f2fs_sb_has_device_alias(sbi)) {
-				f2fs_err(sbi, "device aliasing requires extent cache");
-				return -EINVAL;
-			}
+		if (result.negated)
 			ctx_clear_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
-		} else
+		else
 			ctx_set_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
 		break;
 	case Opt_data_flush:
 		ctx_set_opt(ctx, F2FS_MOUNT_DATA_FLUSH);
 		break;
 	case Opt_reserve_root:
-		if (test_opt(sbi, RESERVE_ROOT)) {
-			f2fs_info(NULL, "Preserve previous reserve_root=%u",
-				  F2FS_OPTION(sbi).root_reserved_blocks);
-		} else {
-			ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
-			F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
-			ctx->spec_mask |= F2FS_SPEC_reserve_root;
-		}
+		ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
+		F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
+		ctx->spec_mask |= F2FS_SPEC_reserve_root;
 		break;
 	case Opt_resuid:
 		F2FS_CTX_INFO(ctx).s_resuid = result.uid;
@@ -911,15 +856,13 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 #ifdef CONFIG_F2FS_FAULT_INJECTION
 	case Opt_fault_injection:
-		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
-			return -EINVAL;
 		F2FS_CTX_INFO(ctx).fault_info.inject_rate = result.int_32;
 		ctx->spec_mask |= F2FS_SPEC_fault_injection;
 		ctx_set_opt(ctx, F2FS_MOUNT_FAULT_INJECTION);
 		break;
 
 	case Opt_fault_type:
-		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
+		if (result.uint_32 > BIT(FAULT_MAX))
 			return -EINVAL;
 		F2FS_CTX_INFO(ctx).fault_info.inject_type = result.uint_32;
 		ctx->spec_mask |= F2FS_SPEC_fault_type;
@@ -1060,10 +1003,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		break;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
 	case Opt_compress_algorithm:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		name = param->string;
 		if (!strcmp(name, "lzo")) {
 #ifdef CONFIG_F2FS_FS_LZO
@@ -1107,10 +1046,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 			return -EINVAL;
 		break;
 	case Opt_compress_log_size:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
 		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
 			f2fs_err(NULL,
@@ -1121,10 +1056,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		ctx->spec_mask |= F2FS_SPEC_compress_log_size;
 		break;
 	case Opt_compress_extension:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		name = param->string;
 		ext = F2FS_CTX_INFO(ctx).extensions;
 		ext_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
@@ -1145,10 +1076,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		ctx->spec_mask |= F2FS_SPEC_compress_extension;
 		break;
 	case Opt_nocompress_extension:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		name = param->string;
 		noext = F2FS_CTX_INFO(ctx).noextensions;
 		noext_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
@@ -1169,26 +1096,14 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 		ctx->spec_mask |= F2FS_SPEC_nocompress_extension;
 		break;
 	case Opt_compress_chksum:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		F2FS_CTX_INFO(ctx).compress_chksum = true;
 		ctx->spec_mask |= F2FS_SPEC_compress_chksum;
 		break;
 	case Opt_compress_mode:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		F2FS_CTX_INFO(ctx).compress_mode = result.uint_32;
 		ctx->spec_mask |= F2FS_SPEC_compress_mode;
 		break;
 	case Opt_compress_cache:
-		if (!f2fs_sb_has_compression(sbi)) {
-			f2fs_info(NULL, "Image doesn't support compression");
-			break;
-		}
 		ctx_set_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE);
 		break;
 #else
@@ -1233,24 +1148,15 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
 	return 0;
 }
 
-static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
+static int parse_options(struct fs_context *fc, char *options)
 {
 	struct fs_parameter param;
-	struct fs_context fc;
-	struct f2fs_fs_context ctx;
 	char *key;
 	int ret;
 
 	if (!options)
 		return 0;
 
-	memset(&fc, 0, sizeof(fc));
-	fc.s_fs_info = sbi;
-	fc.fs_private = &ctx;
-
-	if (is_remount)
-		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
-
 	while ((key = strsep(&options, ",")) != NULL) {
 		if (*key) {
 			size_t v_len = 0;
@@ -1274,7 +1180,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
 			param.key = key;
 			param.size = v_len;
 
-			ret = handle_mount_opt(&fc, &param);
+			ret = handle_mount_opt(fc, &param);
 			kfree(param.string);
 			if (ret < 0)
 				return ret;
@@ -1283,24 +1189,298 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
 	return 0;
 }
 
-static int f2fs_validate_options(struct f2fs_sb_info *sbi)
+/*
+ * Check quota settings consistency.
+ */
+static int f2fs_check_quota_consistency(struct fs_context *fc,
+					struct super_block *sb)
 {
-#ifdef CONFIG_QUOTA
-	if (f2fs_check_quota_options(sbi))
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+ #ifdef CONFIG_QUOTA
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	bool quota_feature = f2fs_sb_has_quota_ino(sbi);
+	bool quota_turnon = sb_any_quota_loaded(sb);
+	char *old_qname, *new_qname;
+	bool usr_qf_name, grp_qf_name, prj_qf_name, usrquota, grpquota, prjquota;
+	int i;
+
+	/*
+	 * We do the test below only for project quotas. 'usrquota' and
+	 * 'grpquota' mount options are allowed even without quota feature
+	 * to support legacy quotas in quota files.
+	 */
+	if (ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA) &&
+			!f2fs_sb_has_project_quota(sbi)) {
+		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
 		return -EINVAL;
+	}
+
+	if (ctx->qname_mask) {
+		for (i = 0; i < MAXQUOTAS; i++) {
+			if (!(ctx->qname_mask & (1 << i)))
+				continue;
+
+			old_qname = F2FS_OPTION(sbi).s_qf_names[i];
+			new_qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
+			if (quota_turnon &&
+				!!old_qname != !!new_qname)
+				goto err_jquota_change;
+
+			if (old_qname) {
+				if (strcmp(old_qname, new_qname) == 0) {
+					ctx->qname_mask &= ~(1 << i);
+					continue;
+				}
+				goto err_jquota_specified;
+			}
+
+			if (quota_feature) {
+				f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
+				ctx->qname_mask &= ~(1 << i);
+				kfree(F2FS_CTX_INFO(ctx).s_qf_names[i]);
+				F2FS_CTX_INFO(ctx).s_qf_names[i] = NULL;
+			}
+		}
+	}
+
+	/* Make sure we don't mix old and new quota format */
+	usr_qf_name = F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
+			F2FS_CTX_INFO(ctx).s_qf_names[USRQUOTA];
+	grp_qf_name = F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
+			F2FS_CTX_INFO(ctx).s_qf_names[GRPQUOTA];
+	prj_qf_name = F2FS_OPTION(sbi).s_qf_names[PRJQUOTA] ||
+			F2FS_CTX_INFO(ctx).s_qf_names[PRJQUOTA];
+	usrquota = test_opt(sbi, USRQUOTA) ||
+			ctx_test_opt(ctx, F2FS_MOUNT_USRQUOTA);
+	grpquota = test_opt(sbi, GRPQUOTA) ||
+			ctx_test_opt(ctx, F2FS_MOUNT_GRPQUOTA);
+	prjquota = test_opt(sbi, PRJQUOTA) ||
+			ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA);
+
+	if (usr_qf_name) {
+		ctx_clear_opt(ctx, F2FS_MOUNT_USRQUOTA);
+		usrquota = false;
+	}
+	if (grp_qf_name) {
+		ctx_clear_opt(ctx, F2FS_MOUNT_GRPQUOTA);
+		grpquota = false;
+	}
+	if (prj_qf_name) {
+		ctx_clear_opt(ctx, F2FS_MOUNT_PRJQUOTA);
+		prjquota = false;
+	}
+	if (usr_qf_name || grp_qf_name || prj_qf_name) {
+		if (grpquota || usrquota || prjquota) {
+			f2fs_err(sbi, "old and new quota format mixing");
+			return -EINVAL;
+		}
+		if (!(ctx->spec_mask & F2FS_SPEC_jqfmt ||
+				F2FS_OPTION(sbi).s_jquota_fmt)) {
+			f2fs_err(sbi, "journaled quota format not specified");
+			return -EINVAL;
+		}
+	}
+	return 0;
+
+err_jquota_change:
+	f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
+	return -EINVAL;
+err_jquota_specified:
+	f2fs_err(sbi, "%s quota file already specified",
+		 QTYPE2NAME(i));
+	return -EINVAL;
+
 #else
-	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
-		f2fs_info(NULL, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
+	if (f2fs_readonly(sbi->sb))
+		return 0;
+	if (f2fs_sb_has_quota_ino(sbi)) {
+		f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
 		return -EINVAL;
 	}
-	if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
-		f2fs_err(NULL, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
+	if (f2fs_sb_has_project_quota(sbi)) {
+		f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
 		return -EINVAL;
 	}
+
+	return 0;
 #endif
+}
+
+static int f2fs_check_test_dummy_encryption(struct fs_context *fc,
+					    struct super_block *sb)
+{
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+
+	if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy))
+		return 0;
+
+	if (!f2fs_sb_has_encrypt(sbi)) {
+		f2fs_err(sbi, "Encrypt feature is off");
+		return -EINVAL;
+	}
+
+	/*
+	 * This mount option is just for testing, and it's not worthwhile to
+	 * implement the extra complexity (e.g. RCU protection) that would be
+	 * needed to allow it to be set or changed during remount.  We do allow
+	 * it to be specified during remount, but only if there is no change.
+	 */
+	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
+		if (fscrypt_dummy_policies_equal(&F2FS_OPTION(sbi).dummy_enc_policy,
+				&F2FS_CTX_INFO(ctx).dummy_enc_policy))
+			return 0;
+		f2fs_warn(sbi, "Can't set or change test_dummy_encryption on remount");
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static inline bool test_compression_spec(unsigned int mask)
+{
+	return mask & (F2FS_SPEC_compress_algorithm
+			| F2FS_SPEC_compress_log_size
+			| F2FS_SPEC_compress_extension
+			| F2FS_SPEC_nocompress_extension
+			| F2FS_SPEC_compress_chksum
+			| F2FS_SPEC_compress_mode);
+}
+
+static inline void clear_compression_spec(struct f2fs_fs_context *ctx)
+{
+	ctx->spec_mask &= ~(F2FS_SPEC_compress_algorithm
+						| F2FS_SPEC_compress_log_size
+						| F2FS_SPEC_compress_extension
+						| F2FS_SPEC_nocompress_extension
+						| F2FS_SPEC_compress_chksum
+						| F2FS_SPEC_compress_mode);
+}
+
+static int f2fs_check_compression(struct fs_context *fc,
+				  struct super_block *sb)
+{
+#ifdef CONFIG_F2FS_FS_COMPRESSION
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+	int i, cnt;
+
+	if (!f2fs_sb_has_compression(sbi)) {
+		if (test_compression_spec(ctx->spec_mask) ||
+			ctx_test_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE))
+			f2fs_info(sbi, "Image doesn't support compression");
+		clear_compression_spec(ctx);
+		ctx->opt_mask &= ~F2FS_MOUNT_COMPRESS_CACHE;
+		return 0;
+	}
+	if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
+		cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
+		for (i = 0; i < F2FS_CTX_INFO(ctx).compress_ext_cnt; i++) {
+			if (is_compress_extension_exist(&F2FS_OPTION(sbi),
+					F2FS_CTX_INFO(ctx).extensions[i], true)) {
+				F2FS_CTX_INFO(ctx).extensions[i][0] = '\0';
+				cnt--;
+			}
+		}
+		if (F2FS_OPTION(sbi).compress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
+			f2fs_err(sbi, "invalid extension length/number");
+			return -EINVAL;
+		}
+	}
+	if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
+		cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
+		for (i = 0; i < F2FS_CTX_INFO(ctx).nocompress_ext_cnt; i++) {
+			if (is_compress_extension_exist(&F2FS_OPTION(sbi),
+					F2FS_CTX_INFO(ctx).noextensions[i], false)) {
+				F2FS_CTX_INFO(ctx).noextensions[i][0] = '\0';
+				cnt--;
+			}
+		}
+		if (F2FS_OPTION(sbi).nocompress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
+			f2fs_err(sbi, "invalid noextension length/number");
+			return -EINVAL;
+		}
+	}
+
+	if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
+				F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
+				F2FS_CTX_INFO(ctx).extensions,
+				F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
+		f2fs_err(sbi, "new noextensions conflicts with new extensions");
+		return -EINVAL;
+	}
+	if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
+				F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
+				F2FS_OPTION(sbi).extensions,
+				F2FS_OPTION(sbi).compress_ext_cnt)) {
+		f2fs_err(sbi, "new noextensions conflicts with old extensions");
+		return -EINVAL;
+	}
+	if (f2fs_test_compress_extension(F2FS_OPTION(sbi).noextensions,
+				F2FS_OPTION(sbi).nocompress_ext_cnt,
+				F2FS_CTX_INFO(ctx).extensions,
+				F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
+		f2fs_err(sbi, "new extensions conflicts with old noextensions");
+		return -EINVAL;
+	}
+#endif
+	return 0;
+}
+
+static int f2fs_check_opt_consistency(struct fs_context *fc,
+				      struct super_block *sb)
+{
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+	int err;
+
+	if (ctx_test_opt(ctx, F2FS_MOUNT_NORECOVERY) && !f2fs_readonly(sb))
+		return -EINVAL;
+
+	if (f2fs_hw_should_discard(sbi) &&
+			(ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
+			!ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
+		f2fs_warn(sbi, "discard is required for zoned block devices");
+		return -EINVAL;
+	}
+
+	if (!f2fs_hw_support_discard(sbi) &&
+			(ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
+			ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
+		f2fs_warn(sbi, "device does not support discard");
+		ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
+		ctx->opt_mask &= ~F2FS_MOUNT_DISCARD;
+	}
+
+	if (f2fs_sb_has_device_alias(sbi) &&
+			(ctx->opt_mask & F2FS_MOUNT_READ_EXTENT_CACHE) &&
+			!ctx_test_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE)) {
+		f2fs_err(sbi, "device aliasing requires extent cache");
+		return -EINVAL;
+	}
+
+	if (test_opt(sbi, RESERVE_ROOT) &&
+			(ctx->opt_mask & F2FS_MOUNT_RESERVE_ROOT) &&
+			ctx_test_opt(ctx, F2FS_MOUNT_RESERVE_ROOT)) {
+		f2fs_info(sbi, "Preserve previous reserve_root=%u",
+			F2FS_OPTION(sbi).root_reserved_blocks);
+		ctx_clear_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
+		ctx->opt_mask &= ~F2FS_MOUNT_RESERVE_ROOT;
+	}
+
+	err = f2fs_check_test_dummy_encryption(fc, sb);
+	if (err)
+		return err;
+
+	err = f2fs_check_compression(fc, sb);
+	if (err)
+		return err;
+
+	err = f2fs_check_quota_consistency(fc, sb);
+	if (err)
+		return err;
 
 	if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {
-		f2fs_err(NULL,
+		f2fs_err(sbi,
 			"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
 		return -EINVAL;
 	}
@@ -1312,74 +1492,236 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
 	 */
 	if (f2fs_sb_has_blkzoned(sbi)) {
 #ifdef CONFIG_BLK_DEV_ZONED
-		if (F2FS_OPTION(sbi).discard_unit !=
-						DISCARD_UNIT_SECTION) {
-			f2fs_info(NULL, "Zoned block device doesn't need small discard, set discard_unit=section by default");
-			F2FS_OPTION(sbi).discard_unit =
-					DISCARD_UNIT_SECTION;
+		if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
+		F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {
+			f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");
+			F2FS_CTX_INFO(ctx).discard_unit = DISCARD_UNIT_SECTION;
 		}
 
-		if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {
-			f2fs_info(NULL, "Only lfs mode is allowed with zoned block device feature");
+		if ((ctx->spec_mask & F2FS_SPEC_mode) &&
+		F2FS_CTX_INFO(ctx).fs_mode != FS_MODE_LFS) {
+			f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");
 			return -EINVAL;
 		}
 #else
-		f2fs_err(NULL, "Zoned block device support is not enabled");
+		f2fs_err(sbi, "Zoned block device support is not enabled");
 		return -EINVAL;
 #endif
 	}
 
-#ifdef CONFIG_F2FS_FS_COMPRESSION
-	if (f2fs_test_compress_extension(sbi)) {
-		f2fs_err(NULL, "invalid compress or nocompress extension");
-		return -EINVAL;
-	}
-#endif
-
-	if (test_opt(sbi, INLINE_XATTR_SIZE)) {
-		int min_size, max_size;
-
+	if (ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE)) {
 		if (!f2fs_sb_has_extra_attr(sbi) ||
 			!f2fs_sb_has_flexible_inline_xattr(sbi)) {
-			f2fs_err(NULL, "extra_attr or flexible_inline_xattr feature is off");
+			f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
 			return -EINVAL;
 		}
-		if (!test_opt(sbi, INLINE_XATTR)) {
-			f2fs_err(NULL, "inline_xattr_size option should be set with inline_xattr option");
-			return -EINVAL;
-		}
-
-		min_size = MIN_INLINE_XATTR_SIZE;
-		max_size = MAX_INLINE_XATTR_SIZE;
-
-		if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
-				F2FS_OPTION(sbi).inline_xattr_size > max_size) {
-			f2fs_err(NULL, "inline xattr size is out of range: %d ~ %d",
-				 min_size, max_size);
+		if (!ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR) && !test_opt(sbi, INLINE_XATTR)) {
+			f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
 			return -EINVAL;
 		}
 	}
 
-	if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {
-		f2fs_err(NULL, "LFS is not compatible with ATGC");
+	if (ctx_test_opt(ctx, F2FS_MOUNT_ATGC) &&
+	    F2FS_CTX_INFO(ctx).fs_mode == FS_MODE_LFS) {
+		f2fs_err(sbi, "LFS is not compatible with ATGC");
 		return -EINVAL;
 	}
 
-	if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {
-		f2fs_err(NULL, "FLUSH_MERGE not compatible with readonly mode");
+	if (f2fs_is_readonly(sbi) && ctx_test_opt(ctx, F2FS_MOUNT_FLUSH_MERGE)) {
+		f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");
 		return -EINVAL;
 	}
 
 	if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
-		f2fs_err(NULL, "Allow to mount readonly mode only");
+		f2fs_err(sbi, "Allow to mount readonly mode only");
 		return -EROFS;
 	}
+	return 0;
+}
+
+static void f2fs_apply_quota_options(struct fs_context *fc,
+				     struct super_block *sb)
+{
+#ifdef CONFIG_QUOTA
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+	bool quota_feature = f2fs_sb_has_quota_ino(sbi);
+	char *qname;
+	int i;
+
+	if (quota_feature)
+		return;
+
+	for (i = 0; i < MAXQUOTAS; i++) {
+		if (!(ctx->qname_mask & (1 << i)))
+			continue;
+
+		qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
+		if (qname) {
+			qname = kstrdup(F2FS_CTX_INFO(ctx).s_qf_names[i],
+					GFP_KERNEL | __GFP_NOFAIL);
+			set_opt(sbi, QUOTA);
+		}
+		F2FS_OPTION(sbi).s_qf_names[i] = qname;
+	}
+
+	if (ctx->spec_mask & F2FS_SPEC_jqfmt)
+		F2FS_OPTION(sbi).s_jquota_fmt = F2FS_CTX_INFO(ctx).s_jquota_fmt;
+
+	if (quota_feature && F2FS_OPTION(sbi).s_jquota_fmt) {
+		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
+		F2FS_OPTION(sbi).s_jquota_fmt = 0;
+	}
+#endif
+}
+
+static void f2fs_apply_test_dummy_encryption(struct fs_context *fc,
+					     struct super_block *sb)
+{
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+
+	if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy) ||
+		/* if already set, it was already verified to be the same */
+		fscrypt_is_dummy_policy_set(&F2FS_OPTION(sbi).dummy_enc_policy))
+		return;
+	swap(F2FS_OPTION(sbi).dummy_enc_policy, F2FS_CTX_INFO(ctx).dummy_enc_policy);
+	f2fs_warn(sbi, "Test dummy encryption mode enabled");
+}
+
+static void f2fs_apply_compression(struct fs_context *fc,
+				   struct super_block *sb)
+{
+#ifdef CONFIG_F2FS_FS_COMPRESSION
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
+	unsigned char (*ctx_ext)[F2FS_EXTENSION_LEN];
+	unsigned char (*sbi_ext)[F2FS_EXTENSION_LEN];
+	int ctx_cnt, sbi_cnt, i;
+
+	if (ctx->spec_mask & F2FS_SPEC_compress_level)
+		F2FS_OPTION(sbi).compress_level =
+					F2FS_CTX_INFO(ctx).compress_level;
+	if (ctx->spec_mask & F2FS_SPEC_compress_algorithm)
+		F2FS_OPTION(sbi).compress_algorithm =
+					F2FS_CTX_INFO(ctx).compress_algorithm;
+	if (ctx->spec_mask & F2FS_SPEC_compress_log_size)
+		F2FS_OPTION(sbi).compress_log_size =
+					F2FS_CTX_INFO(ctx).compress_log_size;
+	if (ctx->spec_mask & F2FS_SPEC_compress_chksum)
+		F2FS_OPTION(sbi).compress_chksum =
+					F2FS_CTX_INFO(ctx).compress_chksum;
+	if (ctx->spec_mask & F2FS_SPEC_compress_mode)
+		F2FS_OPTION(sbi).compress_mode =
+					F2FS_CTX_INFO(ctx).compress_mode;
+	if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
+		ctx_ext = F2FS_CTX_INFO(ctx).extensions;
+		ctx_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
+		sbi_ext = F2FS_OPTION(sbi).extensions;
+		sbi_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
+		for (i = 0; i < ctx_cnt; i++) {
+			if (strlen(ctx_ext[i]) == 0)
+				continue;
+			strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
+			sbi_cnt++;
+		}
+		F2FS_OPTION(sbi).compress_ext_cnt = sbi_cnt;
+	}
+	if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
+		ctx_ext = F2FS_CTX_INFO(ctx).noextensions;
+		ctx_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
+		sbi_ext = F2FS_OPTION(sbi).noextensions;
+		sbi_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
+		for (i = 0; i < ctx_cnt; i++) {
+			if (strlen(ctx_ext[i]) == 0)
+				continue;
+			strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
+			sbi_cnt++;
+		}
+		F2FS_OPTION(sbi).nocompress_ext_cnt = sbi_cnt;
+	}
+#endif
+}
+
+static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
+{
+	struct f2fs_fs_context *ctx = fc->fs_private;
+	struct f2fs_sb_info *sbi = F2FS_SB(sb);
 
-	if (test_opt(sbi, NORECOVERY) && !f2fs_readonly(sbi->sb)) {
-		f2fs_err(sbi, "norecovery requires readonly mount");
+	F2FS_OPTION(sbi).opt &= ~ctx->opt_mask;
+	F2FS_OPTION(sbi).opt |= F2FS_CTX_INFO(ctx).opt;
+	sb->s_flags &= ~ctx->sflags_mask;
+	sb->s_flags |= ctx->sflags;
+
+	if (ctx->spec_mask & F2FS_SPEC_background_gc)
+		F2FS_OPTION(sbi).bggc_mode = F2FS_CTX_INFO(ctx).bggc_mode;
+	if (ctx->spec_mask & F2FS_SPEC_inline_xattr_size)
+		F2FS_OPTION(sbi).inline_xattr_size =
+					F2FS_CTX_INFO(ctx).inline_xattr_size;
+	if (ctx->spec_mask & F2FS_SPEC_active_logs)
+		F2FS_OPTION(sbi).active_logs = F2FS_CTX_INFO(ctx).active_logs;
+	if (ctx->spec_mask & F2FS_SPEC_reserve_root)
+		F2FS_OPTION(sbi).root_reserved_blocks =
+					F2FS_CTX_INFO(ctx).root_reserved_blocks;
+	if (ctx->spec_mask & F2FS_SPEC_resgid)
+		F2FS_OPTION(sbi).s_resgid = F2FS_CTX_INFO(ctx).s_resgid;
+	if (ctx->spec_mask & F2FS_SPEC_resuid)
+		F2FS_OPTION(sbi).s_resuid = F2FS_CTX_INFO(ctx).s_resuid;
+	if (ctx->spec_mask & F2FS_SPEC_mode)
+		F2FS_OPTION(sbi).fs_mode = F2FS_CTX_INFO(ctx).fs_mode;
+#ifdef CONFIG_F2FS_FAULT_INJECTION
+	if (ctx->spec_mask & F2FS_SPEC_fault_injection)
+		(void)f2fs_build_fault_attr(sbi,
+		F2FS_CTX_INFO(ctx).fault_info.inject_rate, 0, FAULT_RATE);
+	if (ctx->spec_mask & F2FS_SPEC_fault_type)
+		(void)f2fs_build_fault_attr(sbi, 0,
+			F2FS_CTX_INFO(ctx).fault_info.inject_type, FAULT_TYPE);
+#endif
+	if (ctx->spec_mask & F2FS_SPEC_alloc_mode)
+		F2FS_OPTION(sbi).alloc_mode = F2FS_CTX_INFO(ctx).alloc_mode;
+	if (ctx->spec_mask & F2FS_SPEC_fsync_mode)
+		F2FS_OPTION(sbi).fsync_mode = F2FS_CTX_INFO(ctx).fsync_mode;
+	if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap)
+		F2FS_OPTION(sbi).unusable_cap = F2FS_CTX_INFO(ctx).unusable_cap;
+	if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap_perc)
+		F2FS_OPTION(sbi).unusable_cap_perc =
+					F2FS_CTX_INFO(ctx).unusable_cap_perc;
+	if (ctx->spec_mask & F2FS_SPEC_discard_unit)
+		F2FS_OPTION(sbi).discard_unit = F2FS_CTX_INFO(ctx).discard_unit;
+	if (ctx->spec_mask & F2FS_SPEC_memory_mode)
+		F2FS_OPTION(sbi).memory_mode = F2FS_CTX_INFO(ctx).memory_mode;
+	if (ctx->spec_mask & F2FS_SPEC_errors)
+		F2FS_OPTION(sbi).errors = F2FS_CTX_INFO(ctx).errors;
+
+	f2fs_apply_compression(fc, sb);
+	f2fs_apply_test_dummy_encryption(fc, sb);
+	f2fs_apply_quota_options(fc, sb);
+}
+
+static int f2fs_sanity_check_options(struct f2fs_sb_info *sbi, bool remount)
+{
+	if (f2fs_sb_has_device_alias(sbi) &&
+	    !test_opt(sbi, READ_EXTENT_CACHE)) {
+		f2fs_err(sbi, "device aliasing requires extent cache");
 		return -EINVAL;
 	}
 
+	if (!remount)
+		return 0;
+
+#ifdef CONFIG_BLK_DEV_ZONED
+	if (f2fs_sb_has_blkzoned(sbi) &&
+	    sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
+		f2fs_err(sbi,
+			"zoned: max open zones %u is too small, need at least %u open zones",
+				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
+		return -EINVAL;
+	}
+#endif
+	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
+		f2fs_warn(sbi, "LFS is not compatible with IPU");
+		return -EINVAL;
+	}
 	return 0;
 }
 
@@ -2290,6 +2632,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(sb);
 	struct f2fs_mount_info org_mount_opt;
+	struct f2fs_fs_context ctx;
+	struct fs_context fc;
 	unsigned long old_sb_flags;
 	int err;
 	bool need_restart_gc = false, need_stop_gc = false;
@@ -2346,23 +2690,23 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 
 	default_options(sbi, true);
 
+	memset(&fc, 0, sizeof(fc));
+	memset(&ctx, 0, sizeof(ctx));
+	fc.fs_private = &ctx;
+	fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
+
 	/* parse mount options */
-	err = parse_options(sbi, data, true);
+	err = parse_options(&fc, data);
 	if (err)
 		goto restore_opts;
 
-#ifdef CONFIG_BLK_DEV_ZONED
-	if (f2fs_sb_has_blkzoned(sbi) &&
-		sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
-		f2fs_err(sbi,
-			"zoned: max open zones %u is too small, need at least %u open zones",
-				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
-		err = -EINVAL;
+	err = f2fs_check_opt_consistency(&fc, sb);
+	if (err)
 		goto restore_opts;
-	}
-#endif
 
-	err = f2fs_validate_options(sbi);
+	f2fs_apply_options(&fc, sb);
+
+	err = f2fs_sanity_check_options(sbi, true);
 	if (err)
 		goto restore_opts;
 
@@ -2398,12 +2742,6 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		}
 	}
 #endif
-	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
-		err = -EINVAL;
-		f2fs_warn(sbi, "LFS is not compatible with IPU");
-		goto restore_opts;
-	}
-
 	/* disallow enable atgc dynamically */
 	if (no_atgc == !!test_opt(sbi, ATGC)) {
 		err = -EINVAL;
@@ -4483,6 +4821,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 {
 	struct f2fs_sb_info *sbi;
 	struct f2fs_super_block *raw_super;
+	struct f2fs_fs_context ctx;
+	struct fs_context fc;
 	struct inode *root;
 	int err;
 	bool skip_recovery = false, need_fsck = false;
@@ -4499,6 +4839,9 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 	raw_super = NULL;
 	valid_super_block = -1;
 	recovery = 0;
+	memset(&fc, 0, sizeof(fc));
+	memset(&ctx, 0, sizeof(ctx));
+	fc.fs_private = &ctx;
 
 	/* allocate memory for f2fs-specific super block info */
 	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
@@ -4556,11 +4899,17 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 		goto free_sb_buf;
 	}
 
-	err = parse_options(sbi, options, false);
+	err = parse_options(&fc, options);
 	if (err)
 		goto free_options;
 
-	err = f2fs_validate_options(sbi);
+	err = f2fs_check_opt_consistency(&fc, sb);
+	if (err)
+		goto free_options;
+
+	f2fs_apply_options(&fc, sb);
+
+	err = f2fs_sanity_check_options(sbi, false);
 	if (err)
 		goto free_options;
 
@@ -4981,7 +5330,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 	for (i = 0; i < MAXQUOTAS; i++)
 		kfree(F2FS_OPTION(sbi).s_qf_names[i]);
 #endif
-	fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
+	/* no need to free dummy_enc_policy, we just keep it in ctx when failed */
+	swap(F2FS_CTX_INFO(&ctx).dummy_enc_policy, F2FS_OPTION(sbi).dummy_enc_policy);
 	kvfree(options);
 free_sb_buf:
 	kfree(raw_super);
-- 
2.33.0

Re: [PATCH v4 5/7] f2fs: separate the options parsing and options checking

[Chao Yu]

On 6/2/25 17:02, Hongbo Li wrote:G
> The new mount api separates option parsing and super block setup
> into two distinct steps and so we need to separate the options
> parsing out of the parse_options().
> 
> In order to achieve this, here we handle the mount options with
> three steps:
>   - Firstly, we move sb/sbi out of handle_mount_opt.
>     As the former patch introduced f2fs_fs_context, so we record
>     the changed mount options in this context. In handle_mount_opt,
>     sb/sbi is null, so we should move all relative code out of
>     handle_mount_opt (thus, some check case which use sb/sbi should
>     move out).
>   - Secondly, we introduce the some check helpers to keep the option
>     consistent.
>     During filling superblock period, sb/sbi are ready. So we check
>     the f2fs_fs_context which holds the mount options base on sb/sbi.
>   - Thirdly, we apply the new mount options to sb/sbi.
>     After checking the f2fs_fs_context, all changed on mount options
>     are valid. So we can apply them to sb/sbi directly.
> 
> After do these, option parsing and super block setting have been
> decoupled. Also it should have retained the original execution
> flow.
> 
> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
> [sandeen: forward port, minor fixes and updates]
> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
> [hongbo: minor fixes]
> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
> ---
>  fs/f2fs/super.c | 736 +++++++++++++++++++++++++++++++++++-------------
>  1 file changed, 543 insertions(+), 193 deletions(-)
> 
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 87db6eb9ef07..9835e7cd1071 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -362,6 +362,12 @@ static inline void ctx_clear_opt(struct f2fs_fs_context *ctx,
>  	ctx->opt_mask |= flag;
>  }
>  
> +static inline bool ctx_test_opt(struct f2fs_fs_context *ctx,
> +				unsigned int flag)
> +{
> +	return ctx->info.opt & flag;
> +}
> +
>  static inline void ctx_set_flags(struct f2fs_fs_context *ctx,
>  				 unsigned int flag)
>  {
> @@ -535,51 +541,6 @@ static int f2fs_unnote_qf_name(struct fs_context *fc, int qtype)
>  	ctx->qname_mask |= 1 << qtype;
>  	return 0;
>  }
> -
> -static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
> -{
> -	/*
> -	 * We do the test below only for project quotas. 'usrquota' and
> -	 * 'grpquota' mount options are allowed even without quota feature
> -	 * to support legacy quotas in quota files.
> -	 */
> -	if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
> -		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
> -		return -1;
> -	}
> -	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
> -			F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
> -			F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
> -		if (test_opt(sbi, USRQUOTA) &&
> -				F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
> -			clear_opt(sbi, USRQUOTA);
> -
> -		if (test_opt(sbi, GRPQUOTA) &&
> -				F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
> -			clear_opt(sbi, GRPQUOTA);
> -
> -		if (test_opt(sbi, PRJQUOTA) &&
> -				F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
> -			clear_opt(sbi, PRJQUOTA);
> -
> -		if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
> -				test_opt(sbi, PRJQUOTA)) {
> -			f2fs_err(sbi, "old and new quota format mixing");
> -			return -1;
> -		}
> -
> -		if (!F2FS_OPTION(sbi).s_jquota_fmt) {
> -			f2fs_err(sbi, "journaled quota format not specified");
> -			return -1;
> -		}
> -	}
> -
> -	if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
> -		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
> -		F2FS_OPTION(sbi).s_jquota_fmt = 0;
> -	}
> -	return 0;
> -}
>  #endif
>  
>  static int f2fs_parse_test_dummy_encryption(const struct fs_parameter *param,
> @@ -638,28 +599,28 @@ static bool is_compress_extension_exist(struct f2fs_mount_info *info,
>   * extension will be treated as special cases and will not be compressed.
>   * 3. Don't allow the non-compress extension specifies all files.
>   */
> -static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)
> +static int f2fs_test_compress_extension(unsigned char (*noext)[F2FS_EXTENSION_LEN],
> +					int noext_cnt,
> +					unsigned char (*ext)[F2FS_EXTENSION_LEN],
> +					int ext_cnt)
>  {
> -	unsigned char (*ext)[F2FS_EXTENSION_LEN];
> -	unsigned char (*noext)[F2FS_EXTENSION_LEN];
> -	int ext_cnt, noext_cnt, index = 0, no_index = 0;
> -
> -	ext = F2FS_OPTION(sbi).extensions;
> -	ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> -	noext = F2FS_OPTION(sbi).noextensions;
> -	noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
> +	int index = 0, no_index = 0;
>  
>  	if (!noext_cnt)
>  		return 0;
>  
>  	for (no_index = 0; no_index < noext_cnt; no_index++) {
> +		if (strlen(noext[no_index]) == 0)
> +			continue;
>  		if (!strcasecmp("*", noext[no_index])) {
> -			f2fs_info(sbi, "Don't allow the nocompress extension specifies all files");
> +			f2fs_info(NULL, "Don't allow the nocompress extension specifies all files");
>  			return -EINVAL;
>  		}
>  		for (index = 0; index < ext_cnt; index++) {
> +			if (strlen(ext[index]) == 0)
> +				continue;
>  			if (!strcasecmp(ext[index], noext[no_index])) {
> -				f2fs_info(sbi, "Don't allow the same extension %s appear in both compress and nocompress extension",
> +				f2fs_info(NULL, "Don't allow the same extension %s appear in both compress and nocompress extension",
>  						ext[index]);
>  				return -EINVAL;
>  			}
> @@ -751,7 +712,6 @@ static int f2fs_set_zstd_level(struct f2fs_fs_context *ctx, const char *str)
>  static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  {
>  	struct f2fs_fs_context *ctx = fc->fs_private;
> -	struct f2fs_sb_info *sbi = fc->s_fs_info;
>  #ifdef CONFIG_F2FS_FS_COMPRESSION
>  	unsigned char (*ext)[F2FS_EXTENSION_LEN];
>  	unsigned char (*noext)[F2FS_EXTENSION_LEN];
> @@ -760,15 +720,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  #endif
>  	substring_t args[MAX_OPT_ARGS];
>  	struct fs_parse_result result;
> -	bool is_remount;
>  	int token, ret, arg;
>  
>  	token = fs_parse(fc, f2fs_param_specs, param, &result);
>  	if (token < 0)
>  		return token;
>  
> -	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
> -
>  	switch (token) {
>  	case Opt_gc_background:
>  		F2FS_CTX_INFO(ctx).bggc_mode = result.uint_32;
> @@ -782,19 +739,10 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		ctx_set_opt(ctx, F2FS_MOUNT_NORECOVERY);
>  		break;
>  	case Opt_discard:
> -		if (result.negated) {
> -			if (f2fs_hw_should_discard(sbi)) {
> -				f2fs_warn(NULL, "discard is required for zoned block devices");
> -				return -EINVAL;
> -			}
> +		if (result.negated)
>  			ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
> -		} else {
> -			if (!f2fs_hw_support_discard(sbi)) {
> -				f2fs_warn(NULL, "device does not support discard");
> -				break;
> -			}
> +		else
>  			ctx_set_opt(ctx, F2FS_MOUNT_DISCARD);
> -		}
>  		break;
>  	case Opt_noheap:
>  	case Opt_heap:
> @@ -814,6 +762,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  			ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR);
>  		break;
>  	case Opt_inline_xattr_size:
> +		if (result.int_32 < MIN_INLINE_XATTR_SIZE ||
> +			result.int_32 > MAX_INLINE_XATTR_SIZE) {
> +			f2fs_err(NULL, "inline xattr size is out of range: %lu ~ %lu",
> +				MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
> +			return -EINVAL;
> +		}
>  		ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE);
>  		F2FS_CTX_INFO(ctx).inline_xattr_size = result.int_32;
>  		ctx->spec_mask |= F2FS_SPEC_inline_xattr_size;
> @@ -875,27 +829,18 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		ctx_set_opt(ctx, F2FS_MOUNT_FASTBOOT);
>  		break;
>  	case Opt_extent_cache:
> -		if (result.negated) {
> -			if (f2fs_sb_has_device_alias(sbi)) {
> -				f2fs_err(sbi, "device aliasing requires extent cache");
> -				return -EINVAL;
> -			}
> +		if (result.negated)
>  			ctx_clear_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
> -		} else
> +		else
>  			ctx_set_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
>  		break;
>  	case Opt_data_flush:
>  		ctx_set_opt(ctx, F2FS_MOUNT_DATA_FLUSH);
>  		break;
>  	case Opt_reserve_root:
> -		if (test_opt(sbi, RESERVE_ROOT)) {
> -			f2fs_info(NULL, "Preserve previous reserve_root=%u",
> -				  F2FS_OPTION(sbi).root_reserved_blocks);
> -		} else {
> -			ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
> -			F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
> -			ctx->spec_mask |= F2FS_SPEC_reserve_root;
> -		}
> +		ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
> +		F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
> +		ctx->spec_mask |= F2FS_SPEC_reserve_root;
>  		break;
>  	case Opt_resuid:
>  		F2FS_CTX_INFO(ctx).s_resuid = result.uid;
> @@ -911,15 +856,13 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		break;
>  #ifdef CONFIG_F2FS_FAULT_INJECTION
>  	case Opt_fault_injection:
> -		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
> -			return -EINVAL;
>  		F2FS_CTX_INFO(ctx).fault_info.inject_rate = result.int_32;
>  		ctx->spec_mask |= F2FS_SPEC_fault_injection;
>  		ctx_set_opt(ctx, F2FS_MOUNT_FAULT_INJECTION);
>  		break;
>  
>  	case Opt_fault_type:
> -		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
> +		if (result.uint_32 > BIT(FAULT_MAX))
>  			return -EINVAL;
>  		F2FS_CTX_INFO(ctx).fault_info.inject_type = result.uint_32;
>  		ctx->spec_mask |= F2FS_SPEC_fault_type;
> @@ -1060,10 +1003,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		break;
>  #ifdef CONFIG_F2FS_FS_COMPRESSION
>  	case Opt_compress_algorithm:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		name = param->string;
>  		if (!strcmp(name, "lzo")) {
>  #ifdef CONFIG_F2FS_FS_LZO
> @@ -1107,10 +1046,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  			return -EINVAL;
>  		break;
>  	case Opt_compress_log_size:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
>  		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
>  			f2fs_err(NULL,
> @@ -1121,10 +1056,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		ctx->spec_mask |= F2FS_SPEC_compress_log_size;
>  		break;
>  	case Opt_compress_extension:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		name = param->string;
>  		ext = F2FS_CTX_INFO(ctx).extensions;
>  		ext_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
> @@ -1145,10 +1076,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		ctx->spec_mask |= F2FS_SPEC_compress_extension;
>  		break;
>  	case Opt_nocompress_extension:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		name = param->string;
>  		noext = F2FS_CTX_INFO(ctx).noextensions;
>  		noext_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
> @@ -1169,26 +1096,14 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  		ctx->spec_mask |= F2FS_SPEC_nocompress_extension;
>  		break;
>  	case Opt_compress_chksum:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		F2FS_CTX_INFO(ctx).compress_chksum = true;
>  		ctx->spec_mask |= F2FS_SPEC_compress_chksum;
>  		break;
>  	case Opt_compress_mode:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		F2FS_CTX_INFO(ctx).compress_mode = result.uint_32;
>  		ctx->spec_mask |= F2FS_SPEC_compress_mode;
>  		break;
>  	case Opt_compress_cache:
> -		if (!f2fs_sb_has_compression(sbi)) {
> -			f2fs_info(NULL, "Image doesn't support compression");
> -			break;
> -		}
>  		ctx_set_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE);
>  		break;
>  #else
> @@ -1233,24 +1148,15 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>  	return 0;
>  }
>  
> -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
> +static int parse_options(struct fs_context *fc, char *options)
>  {
>  	struct fs_parameter param;
> -	struct fs_context fc;
> -	struct f2fs_fs_context ctx;
>  	char *key;
>  	int ret;
>  
>  	if (!options)
>  		return 0;
>  
> -	memset(&fc, 0, sizeof(fc));
> -	fc.s_fs_info = sbi;
> -	fc.fs_private = &ctx;
> -
> -	if (is_remount)
> -		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
> -
>  	while ((key = strsep(&options, ",")) != NULL) {
>  		if (*key) {
>  			size_t v_len = 0;
> @@ -1274,7 +1180,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>  			param.key = key;
>  			param.size = v_len;
>  
> -			ret = handle_mount_opt(&fc, &param);
> +			ret = handle_mount_opt(fc, &param);
>  			kfree(param.string);
>  			if (ret < 0)
>  				return ret;
> @@ -1283,24 +1189,298 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>  	return 0;
>  }
>  
> -static int f2fs_validate_options(struct f2fs_sb_info *sbi)
> +/*
> + * Check quota settings consistency.
> + */
> +static int f2fs_check_quota_consistency(struct fs_context *fc,
> +					struct super_block *sb)
>  {
> -#ifdef CONFIG_QUOTA
> -	if (f2fs_check_quota_options(sbi))
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> + #ifdef CONFIG_QUOTA
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	bool quota_feature = f2fs_sb_has_quota_ino(sbi);
> +	bool quota_turnon = sb_any_quota_loaded(sb);
> +	char *old_qname, *new_qname;
> +	bool usr_qf_name, grp_qf_name, prj_qf_name, usrquota, grpquota, prjquota;
> +	int i;
> +
> +	/*
> +	 * We do the test below only for project quotas. 'usrquota' and
> +	 * 'grpquota' mount options are allowed even without quota feature
> +	 * to support legacy quotas in quota files.
> +	 */
> +	if (ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA) &&
> +			!f2fs_sb_has_project_quota(sbi)) {
> +		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
>  		return -EINVAL;
> +	}
> +
> +	if (ctx->qname_mask) {
> +		for (i = 0; i < MAXQUOTAS; i++) {
> +			if (!(ctx->qname_mask & (1 << i)))
> +				continue;
> +
> +			old_qname = F2FS_OPTION(sbi).s_qf_names[i];
> +			new_qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
> +			if (quota_turnon &&
> +				!!old_qname != !!new_qname)
> +				goto err_jquota_change;
> +
> +			if (old_qname) {
> +				if (strcmp(old_qname, new_qname) == 0) {
> +					ctx->qname_mask &= ~(1 << i);
> +					continue;
> +				}
> +				goto err_jquota_specified;
> +			}
> +
> +			if (quota_feature) {
> +				f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
> +				ctx->qname_mask &= ~(1 << i);
> +				kfree(F2FS_CTX_INFO(ctx).s_qf_names[i]);
> +				F2FS_CTX_INFO(ctx).s_qf_names[i] = NULL;
> +			}
> +		}
> +	}
> +
> +	/* Make sure we don't mix old and new quota format */
> +	usr_qf_name = F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
> +			F2FS_CTX_INFO(ctx).s_qf_names[USRQUOTA];
> +	grp_qf_name = F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
> +			F2FS_CTX_INFO(ctx).s_qf_names[GRPQUOTA];
> +	prj_qf_name = F2FS_OPTION(sbi).s_qf_names[PRJQUOTA] ||
> +			F2FS_CTX_INFO(ctx).s_qf_names[PRJQUOTA];
> +	usrquota = test_opt(sbi, USRQUOTA) ||
> +			ctx_test_opt(ctx, F2FS_MOUNT_USRQUOTA);
> +	grpquota = test_opt(sbi, GRPQUOTA) ||
> +			ctx_test_opt(ctx, F2FS_MOUNT_GRPQUOTA);
> +	prjquota = test_opt(sbi, PRJQUOTA) ||
> +			ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA);
> +
> +	if (usr_qf_name) {
> +		ctx_clear_opt(ctx, F2FS_MOUNT_USRQUOTA);
> +		usrquota = false;
> +	}
> +	if (grp_qf_name) {
> +		ctx_clear_opt(ctx, F2FS_MOUNT_GRPQUOTA);
> +		grpquota = false;
> +	}
> +	if (prj_qf_name) {
> +		ctx_clear_opt(ctx, F2FS_MOUNT_PRJQUOTA);
> +		prjquota = false;
> +	}
> +	if (usr_qf_name || grp_qf_name || prj_qf_name) {
> +		if (grpquota || usrquota || prjquota) {
> +			f2fs_err(sbi, "old and new quota format mixing");
> +			return -EINVAL;
> +		}
> +		if (!(ctx->spec_mask & F2FS_SPEC_jqfmt ||
> +				F2FS_OPTION(sbi).s_jquota_fmt)) {
> +			f2fs_err(sbi, "journaled quota format not specified");
> +			return -EINVAL;
> +		}
> +	}
> +	return 0;
> +
> +err_jquota_change:
> +	f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
> +	return -EINVAL;
> +err_jquota_specified:
> +	f2fs_err(sbi, "%s quota file already specified",
> +		 QTYPE2NAME(i));
> +	return -EINVAL;
> +
>  #else
> -	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
> -		f2fs_info(NULL, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
> +	if (f2fs_readonly(sbi->sb))
> +		return 0;
> +	if (f2fs_sb_has_quota_ino(sbi)) {
> +		f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>  		return -EINVAL;
>  	}
> -	if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
> -		f2fs_err(NULL, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
> +	if (f2fs_sb_has_project_quota(sbi)) {
> +		f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>  		return -EINVAL;
>  	}
> +
> +	return 0;
>  #endif
> +}
> +
> +static int f2fs_check_test_dummy_encryption(struct fs_context *fc,
> +					    struct super_block *sb)
> +{
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> +
> +	if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy))
> +		return 0;
> +
> +	if (!f2fs_sb_has_encrypt(sbi)) {
> +		f2fs_err(sbi, "Encrypt feature is off");
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * This mount option is just for testing, and it's not worthwhile to
> +	 * implement the extra complexity (e.g. RCU protection) that would be
> +	 * needed to allow it to be set or changed during remount.  We do allow
> +	 * it to be specified during remount, but only if there is no change.
> +	 */
> +	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
> +		if (fscrypt_dummy_policies_equal(&F2FS_OPTION(sbi).dummy_enc_policy,
> +				&F2FS_CTX_INFO(ctx).dummy_enc_policy))
> +			return 0;
> +		f2fs_warn(sbi, "Can't set or change test_dummy_encryption on remount");
> +		return -EINVAL;
> +	}
> +	return 0;
> +}
> +
> +static inline bool test_compression_spec(unsigned int mask)
> +{
> +	return mask & (F2FS_SPEC_compress_algorithm
> +			| F2FS_SPEC_compress_log_size
> +			| F2FS_SPEC_compress_extension
> +			| F2FS_SPEC_nocompress_extension
> +			| F2FS_SPEC_compress_chksum
> +			| F2FS_SPEC_compress_mode);
> +}
> +
> +static inline void clear_compression_spec(struct f2fs_fs_context *ctx)
> +{
> +	ctx->spec_mask &= ~(F2FS_SPEC_compress_algorithm
> +						| F2FS_SPEC_compress_log_size
> +						| F2FS_SPEC_compress_extension
> +						| F2FS_SPEC_nocompress_extension
> +						| F2FS_SPEC_compress_chksum
> +						| F2FS_SPEC_compress_mode);
> +}
> +
> +static int f2fs_check_compression(struct fs_context *fc,
> +				  struct super_block *sb)
> +{
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> +	int i, cnt;
> +
> +	if (!f2fs_sb_has_compression(sbi)) {
> +		if (test_compression_spec(ctx->spec_mask) ||
> +			ctx_test_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE))
> +			f2fs_info(sbi, "Image doesn't support compression");
> +		clear_compression_spec(ctx);
> +		ctx->opt_mask &= ~F2FS_MOUNT_COMPRESS_CACHE;
> +		return 0;
> +	}
> +	if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
> +		cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
> +		for (i = 0; i < F2FS_CTX_INFO(ctx).compress_ext_cnt; i++) {
> +			if (is_compress_extension_exist(&F2FS_OPTION(sbi),
> +					F2FS_CTX_INFO(ctx).extensions[i], true)) {
> +				F2FS_CTX_INFO(ctx).extensions[i][0] = '\0';
> +				cnt--;
> +			}
> +		}
> +		if (F2FS_OPTION(sbi).compress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
> +			f2fs_err(sbi, "invalid extension length/number");
> +			return -EINVAL;
> +		}
> +	}
> +	if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
> +		cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
> +		for (i = 0; i < F2FS_CTX_INFO(ctx).nocompress_ext_cnt; i++) {
> +			if (is_compress_extension_exist(&F2FS_OPTION(sbi),
> +					F2FS_CTX_INFO(ctx).noextensions[i], false)) {
> +				F2FS_CTX_INFO(ctx).noextensions[i][0] = '\0';
> +				cnt--;
> +			}
> +		}
> +		if (F2FS_OPTION(sbi).nocompress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
> +			f2fs_err(sbi, "invalid noextension length/number");
> +			return -EINVAL;
> +		}
> +	}
> +
> +	if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
> +				F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
> +				F2FS_CTX_INFO(ctx).extensions,
> +				F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
> +		f2fs_err(sbi, "new noextensions conflicts with new extensions");
> +		return -EINVAL;
> +	}
> +	if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
> +				F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
> +				F2FS_OPTION(sbi).extensions,
> +				F2FS_OPTION(sbi).compress_ext_cnt)) {
> +		f2fs_err(sbi, "new noextensions conflicts with old extensions");
> +		return -EINVAL;
> +	}
> +	if (f2fs_test_compress_extension(F2FS_OPTION(sbi).noextensions,
> +				F2FS_OPTION(sbi).nocompress_ext_cnt,
> +				F2FS_CTX_INFO(ctx).extensions,
> +				F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
> +		f2fs_err(sbi, "new extensions conflicts with old noextensions");
> +		return -EINVAL;
> +	}
> +#endif
> +	return 0;
> +}
> +
> +static int f2fs_check_opt_consistency(struct fs_context *fc,
> +				      struct super_block *sb)
> +{
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> +	int err;
> +
> +	if (ctx_test_opt(ctx, F2FS_MOUNT_NORECOVERY) && !f2fs_readonly(sb))
> +		return -EINVAL;
> +
> +	if (f2fs_hw_should_discard(sbi) &&
> +			(ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
> +			!ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
> +		f2fs_warn(sbi, "discard is required for zoned block devices");
> +		return -EINVAL;
> +	}
> +
> +	if (!f2fs_hw_support_discard(sbi) &&
> +			(ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
> +			ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
> +		f2fs_warn(sbi, "device does not support discard");
> +		ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
> +		ctx->opt_mask &= ~F2FS_MOUNT_DISCARD;
> +	}
> +
> +	if (f2fs_sb_has_device_alias(sbi) &&
> +			(ctx->opt_mask & F2FS_MOUNT_READ_EXTENT_CACHE) &&
> +			!ctx_test_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE)) {
> +		f2fs_err(sbi, "device aliasing requires extent cache");
> +		return -EINVAL;
> +	}
> +
> +	if (test_opt(sbi, RESERVE_ROOT) &&
> +			(ctx->opt_mask & F2FS_MOUNT_RESERVE_ROOT) &&
> +			ctx_test_opt(ctx, F2FS_MOUNT_RESERVE_ROOT)) {
> +		f2fs_info(sbi, "Preserve previous reserve_root=%u",
> +			F2FS_OPTION(sbi).root_reserved_blocks);
> +		ctx_clear_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
> +		ctx->opt_mask &= ~F2FS_MOUNT_RESERVE_ROOT;
> +	}
> +
> +	err = f2fs_check_test_dummy_encryption(fc, sb);
> +	if (err)
> +		return err;
> +
> +	err = f2fs_check_compression(fc, sb);
> +	if (err)
> +		return err;
> +
> +	err = f2fs_check_quota_consistency(fc, sb);
> +	if (err)
> +		return err;
>  
>  	if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {
> -		f2fs_err(NULL,
> +		f2fs_err(sbi,
>  			"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
>  		return -EINVAL;
>  	}
> @@ -1312,74 +1492,236 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>  	 */
>  	if (f2fs_sb_has_blkzoned(sbi)) {
>  #ifdef CONFIG_BLK_DEV_ZONED
> -		if (F2FS_OPTION(sbi).discard_unit !=
> -						DISCARD_UNIT_SECTION) {
> -			f2fs_info(NULL, "Zoned block device doesn't need small discard, set discard_unit=section by default");
> -			F2FS_OPTION(sbi).discard_unit =
> -					DISCARD_UNIT_SECTION;
> +		if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
> +		F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {
> +			f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");
> +			F2FS_CTX_INFO(ctx).discard_unit = DISCARD_UNIT_SECTION;
>  		}
>  
> -		if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {
> -			f2fs_info(NULL, "Only lfs mode is allowed with zoned block device feature");
> +		if ((ctx->spec_mask & F2FS_SPEC_mode) &&
> +		F2FS_CTX_INFO(ctx).fs_mode != FS_MODE_LFS) {
> +			f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");
>  			return -EINVAL;
>  		}
>  #else
> -		f2fs_err(NULL, "Zoned block device support is not enabled");
> +		f2fs_err(sbi, "Zoned block device support is not enabled");
>  		return -EINVAL;
>  #endif
>  	}
>  
> -#ifdef CONFIG_F2FS_FS_COMPRESSION
> -	if (f2fs_test_compress_extension(sbi)) {
> -		f2fs_err(NULL, "invalid compress or nocompress extension");
> -		return -EINVAL;
> -	}
> -#endif
> -
> -	if (test_opt(sbi, INLINE_XATTR_SIZE)) {
> -		int min_size, max_size;
> -
> +	if (ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE)) {
>  		if (!f2fs_sb_has_extra_attr(sbi) ||
>  			!f2fs_sb_has_flexible_inline_xattr(sbi)) {
> -			f2fs_err(NULL, "extra_attr or flexible_inline_xattr feature is off");
> +			f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
>  			return -EINVAL;
>  		}
> -		if (!test_opt(sbi, INLINE_XATTR)) {
> -			f2fs_err(NULL, "inline_xattr_size option should be set with inline_xattr option");
> -			return -EINVAL;
> -		}
> -
> -		min_size = MIN_INLINE_XATTR_SIZE;
> -		max_size = MAX_INLINE_XATTR_SIZE;
> -
> -		if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
> -				F2FS_OPTION(sbi).inline_xattr_size > max_size) {
> -			f2fs_err(NULL, "inline xattr size is out of range: %d ~ %d",
> -				 min_size, max_size);
> +		if (!ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR) && !test_opt(sbi, INLINE_XATTR)) {
> +			f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
>  			return -EINVAL;
>  		}
>  	}
>  
> -	if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {
> -		f2fs_err(NULL, "LFS is not compatible with ATGC");
> +	if (ctx_test_opt(ctx, F2FS_MOUNT_ATGC) &&
> +	    F2FS_CTX_INFO(ctx).fs_mode == FS_MODE_LFS) {
> +		f2fs_err(sbi, "LFS is not compatible with ATGC");
>  		return -EINVAL;
>  	}
>  
> -	if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {
> -		f2fs_err(NULL, "FLUSH_MERGE not compatible with readonly mode");
> +	if (f2fs_is_readonly(sbi) && ctx_test_opt(ctx, F2FS_MOUNT_FLUSH_MERGE)) {
> +		f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");
>  		return -EINVAL;
>  	}
>  
>  	if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
> -		f2fs_err(NULL, "Allow to mount readonly mode only");
> +		f2fs_err(sbi, "Allow to mount readonly mode only");
>  		return -EROFS;
>  	}
> +	return 0;
> +}
> +
> +static void f2fs_apply_quota_options(struct fs_context *fc,
> +				     struct super_block *sb)
> +{
> +#ifdef CONFIG_QUOTA
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> +	bool quota_feature = f2fs_sb_has_quota_ino(sbi);
> +	char *qname;
> +	int i;
> +
> +	if (quota_feature)
> +		return;
> +
> +	for (i = 0; i < MAXQUOTAS; i++) {
> +		if (!(ctx->qname_mask & (1 << i)))
> +			continue;
> +
> +		qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
> +		if (qname) {
> +			qname = kstrdup(F2FS_CTX_INFO(ctx).s_qf_names[i],
> +					GFP_KERNEL | __GFP_NOFAIL);
> +			set_opt(sbi, QUOTA);
> +		}
> +		F2FS_OPTION(sbi).s_qf_names[i] = qname;
> +	}
> +
> +	if (ctx->spec_mask & F2FS_SPEC_jqfmt)
> +		F2FS_OPTION(sbi).s_jquota_fmt = F2FS_CTX_INFO(ctx).s_jquota_fmt;
> +
> +	if (quota_feature && F2FS_OPTION(sbi).s_jquota_fmt) {
> +		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
> +		F2FS_OPTION(sbi).s_jquota_fmt = 0;
> +	}
> +#endif
> +}
> +
> +static void f2fs_apply_test_dummy_encryption(struct fs_context *fc,
> +					     struct super_block *sb)
> +{
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> +
> +	if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy) ||
> +		/* if already set, it was already verified to be the same */
> +		fscrypt_is_dummy_policy_set(&F2FS_OPTION(sbi).dummy_enc_policy))
> +		return;
> +	swap(F2FS_OPTION(sbi).dummy_enc_policy, F2FS_CTX_INFO(ctx).dummy_enc_policy);
> +	f2fs_warn(sbi, "Test dummy encryption mode enabled");
> +}
> +
> +static void f2fs_apply_compression(struct fs_context *fc,
> +				   struct super_block *sb)
> +{
> +#ifdef CONFIG_F2FS_FS_COMPRESSION
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
> +	unsigned char (*ctx_ext)[F2FS_EXTENSION_LEN];
> +	unsigned char (*sbi_ext)[F2FS_EXTENSION_LEN];
> +	int ctx_cnt, sbi_cnt, i;
> +
> +	if (ctx->spec_mask & F2FS_SPEC_compress_level)
> +		F2FS_OPTION(sbi).compress_level =
> +					F2FS_CTX_INFO(ctx).compress_level;
> +	if (ctx->spec_mask & F2FS_SPEC_compress_algorithm)
> +		F2FS_OPTION(sbi).compress_algorithm =
> +					F2FS_CTX_INFO(ctx).compress_algorithm;
> +	if (ctx->spec_mask & F2FS_SPEC_compress_log_size)
> +		F2FS_OPTION(sbi).compress_log_size =
> +					F2FS_CTX_INFO(ctx).compress_log_size;
> +	if (ctx->spec_mask & F2FS_SPEC_compress_chksum)
> +		F2FS_OPTION(sbi).compress_chksum =
> +					F2FS_CTX_INFO(ctx).compress_chksum;
> +	if (ctx->spec_mask & F2FS_SPEC_compress_mode)
> +		F2FS_OPTION(sbi).compress_mode =
> +					F2FS_CTX_INFO(ctx).compress_mode;
> +	if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
> +		ctx_ext = F2FS_CTX_INFO(ctx).extensions;
> +		ctx_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
> +		sbi_ext = F2FS_OPTION(sbi).extensions;
> +		sbi_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
> +		for (i = 0; i < ctx_cnt; i++) {
> +			if (strlen(ctx_ext[i]) == 0)
> +				continue;
> +			strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
> +			sbi_cnt++;
> +		}
> +		F2FS_OPTION(sbi).compress_ext_cnt = sbi_cnt;
> +	}
> +	if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
> +		ctx_ext = F2FS_CTX_INFO(ctx).noextensions;
> +		ctx_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
> +		sbi_ext = F2FS_OPTION(sbi).noextensions;
> +		sbi_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
> +		for (i = 0; i < ctx_cnt; i++) {
> +			if (strlen(ctx_ext[i]) == 0)
> +				continue;
> +			strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
> +			sbi_cnt++;
> +		}
> +		F2FS_OPTION(sbi).nocompress_ext_cnt = sbi_cnt;
> +	}
> +#endif
> +}
> +
> +static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
> +{
> +	struct f2fs_fs_context *ctx = fc->fs_private;
> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>  
> -	if (test_opt(sbi, NORECOVERY) && !f2fs_readonly(sbi->sb)) {
> -		f2fs_err(sbi, "norecovery requires readonly mount");
> +	F2FS_OPTION(sbi).opt &= ~ctx->opt_mask;
> +	F2FS_OPTION(sbi).opt |= F2FS_CTX_INFO(ctx).opt;
> +	sb->s_flags &= ~ctx->sflags_mask;
> +	sb->s_flags |= ctx->sflags;
> +
> +	if (ctx->spec_mask & F2FS_SPEC_background_gc)
> +		F2FS_OPTION(sbi).bggc_mode = F2FS_CTX_INFO(ctx).bggc_mode;
> +	if (ctx->spec_mask & F2FS_SPEC_inline_xattr_size)
> +		F2FS_OPTION(sbi).inline_xattr_size =
> +					F2FS_CTX_INFO(ctx).inline_xattr_size;
> +	if (ctx->spec_mask & F2FS_SPEC_active_logs)
> +		F2FS_OPTION(sbi).active_logs = F2FS_CTX_INFO(ctx).active_logs;
> +	if (ctx->spec_mask & F2FS_SPEC_reserve_root)
> +		F2FS_OPTION(sbi).root_reserved_blocks =
> +					F2FS_CTX_INFO(ctx).root_reserved_blocks;
> +	if (ctx->spec_mask & F2FS_SPEC_resgid)
> +		F2FS_OPTION(sbi).s_resgid = F2FS_CTX_INFO(ctx).s_resgid;
> +	if (ctx->spec_mask & F2FS_SPEC_resuid)
> +		F2FS_OPTION(sbi).s_resuid = F2FS_CTX_INFO(ctx).s_resuid;
> +	if (ctx->spec_mask & F2FS_SPEC_mode)
> +		F2FS_OPTION(sbi).fs_mode = F2FS_CTX_INFO(ctx).fs_mode;
> +#ifdef CONFIG_F2FS_FAULT_INJECTION
> +	if (ctx->spec_mask & F2FS_SPEC_fault_injection)
> +		(void)f2fs_build_fault_attr(sbi,
> +		F2FS_CTX_INFO(ctx).fault_info.inject_rate, 0, FAULT_RATE);
> +	if (ctx->spec_mask & F2FS_SPEC_fault_type)
> +		(void)f2fs_build_fault_attr(sbi, 0,
> +			F2FS_CTX_INFO(ctx).fault_info.inject_type, FAULT_TYPE);
> +#endif
> +	if (ctx->spec_mask & F2FS_SPEC_alloc_mode)
> +		F2FS_OPTION(sbi).alloc_mode = F2FS_CTX_INFO(ctx).alloc_mode;
> +	if (ctx->spec_mask & F2FS_SPEC_fsync_mode)
> +		F2FS_OPTION(sbi).fsync_mode = F2FS_CTX_INFO(ctx).fsync_mode;
> +	if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap)
> +		F2FS_OPTION(sbi).unusable_cap = F2FS_CTX_INFO(ctx).unusable_cap;
> +	if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap_perc)
> +		F2FS_OPTION(sbi).unusable_cap_perc =
> +					F2FS_CTX_INFO(ctx).unusable_cap_perc;
> +	if (ctx->spec_mask & F2FS_SPEC_discard_unit)
> +		F2FS_OPTION(sbi).discard_unit = F2FS_CTX_INFO(ctx).discard_unit;
> +	if (ctx->spec_mask & F2FS_SPEC_memory_mode)
> +		F2FS_OPTION(sbi).memory_mode = F2FS_CTX_INFO(ctx).memory_mode;
> +	if (ctx->spec_mask & F2FS_SPEC_errors)
> +		F2FS_OPTION(sbi).errors = F2FS_CTX_INFO(ctx).errors;
> +
> +	f2fs_apply_compression(fc, sb);
> +	f2fs_apply_test_dummy_encryption(fc, sb);
> +	f2fs_apply_quota_options(fc, sb);
> +}
> +
> +static int f2fs_sanity_check_options(struct f2fs_sb_info *sbi, bool remount)
> +{
> +	if (f2fs_sb_has_device_alias(sbi) &&
> +	    !test_opt(sbi, READ_EXTENT_CACHE)) {
> +		f2fs_err(sbi, "device aliasing requires extent cache");
>  		return -EINVAL;
>  	}
>  
> +	if (!remount)
> +		return 0;
> +
> +#ifdef CONFIG_BLK_DEV_ZONED
> +	if (f2fs_sb_has_blkzoned(sbi) &&
> +	    sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
> +		f2fs_err(sbi,
> +			"zoned: max open zones %u is too small, need at least %u open zones",
> +				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
> +		return -EINVAL;
> +	}
> +#endif
> +	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
> +		f2fs_warn(sbi, "LFS is not compatible with IPU");
> +		return -EINVAL;
> +	}
>  	return 0;
>  }
>  
> @@ -2290,6 +2632,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>  {
>  	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>  	struct f2fs_mount_info org_mount_opt;
> +	struct f2fs_fs_context ctx;
> +	struct fs_context fc;
>  	unsigned long old_sb_flags;
>  	int err;
>  	bool need_restart_gc = false, need_stop_gc = false;
> @@ -2346,23 +2690,23 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>  
>  	default_options(sbi, true);
>  
> +	memset(&fc, 0, sizeof(fc));
> +	memset(&ctx, 0, sizeof(ctx));
> +	fc.fs_private = &ctx;
> +	fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
> +
>  	/* parse mount options */
> -	err = parse_options(sbi, data, true);
> +	err = parse_options(&fc, data);
>  	if (err)
>  		goto restore_opts;
>  
> -#ifdef CONFIG_BLK_DEV_ZONED
> -	if (f2fs_sb_has_blkzoned(sbi) &&
> -		sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
> -		f2fs_err(sbi,
> -			"zoned: max open zones %u is too small, need at least %u open zones",
> -				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
> -		err = -EINVAL;
> +	err = f2fs_check_opt_consistency(&fc, sb);
> +	if (err)
>  		goto restore_opts;
> -	}
> -#endif
>  
> -	err = f2fs_validate_options(sbi);
> +	f2fs_apply_options(&fc, sb);
> +
> +	err = f2fs_sanity_check_options(sbi, true);
>  	if (err)
>  		goto restore_opts;
>  
> @@ -2398,12 +2742,6 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>  		}
>  	}
>  #endif
> -	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
> -		err = -EINVAL;
> -		f2fs_warn(sbi, "LFS is not compatible with IPU");
> -		goto restore_opts;
> -	}
> -
>  	/* disallow enable atgc dynamically */
>  	if (no_atgc == !!test_opt(sbi, ATGC)) {
>  		err = -EINVAL;
> @@ -4483,6 +4821,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>  {
>  	struct f2fs_sb_info *sbi;
>  	struct f2fs_super_block *raw_super;
> +	struct f2fs_fs_context ctx;
> +	struct fs_context fc;
>  	struct inode *root;
>  	int err;
>  	bool skip_recovery = false, need_fsck = false;
> @@ -4499,6 +4839,9 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>  	raw_super = NULL;
>  	valid_super_block = -1;
>  	recovery = 0;
> +	memset(&fc, 0, sizeof(fc));
> +	memset(&ctx, 0, sizeof(ctx));
> +	fc.fs_private = &ctx;
>  
>  	/* allocate memory for f2fs-specific super block info */
>  	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
> @@ -4556,11 +4899,17 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>  		goto free_sb_buf;
>  	}
>  
> -	err = parse_options(sbi, options, false);
> +	err = parse_options(&fc, options);
>  	if (err)
>  		goto free_options;
>  
> -	err = f2fs_validate_options(sbi);
> +	err = f2fs_check_opt_consistency(&fc, sb);
> +	if (err)
> +		goto free_options;
> +
> +	f2fs_apply_options(&fc, sb);
> +
> +	err = f2fs_sanity_check_options(sbi, false);
>  	if (err)
>  		goto free_options;
>  
> @@ -4981,7 +5330,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>  	for (i = 0; i < MAXQUOTAS; i++)
>  		kfree(F2FS_OPTION(sbi).s_qf_names[i]);
>  #endif
> -	fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
> +	/* no need to free dummy_enc_policy, we just keep it in ctx when failed */
> +	swap(F2FS_CTX_INFO(&ctx).dummy_enc_policy, F2FS_OPTION(sbi).dummy_enc_policy);

I can see ext4 will free dummy_enc_policy in error path of fill_super, is
there any difference?

Thanks,

>  	kvfree(options);
>  free_sb_buf:
>  	kfree(raw_super);

Re: [PATCH v4 5/7] f2fs: separate the options parsing and options checking

[Hongbo Li]

On 2025/7/7 20:17, Chao Yu wrote:
> On 6/2/25 17:02, Hongbo Li wrote:G
>> The new mount api separates option parsing and super block setup
>> into two distinct steps and so we need to separate the options
>> parsing out of the parse_options().
>>
>> In order to achieve this, here we handle the mount options with
>> three steps:
>>    - Firstly, we move sb/sbi out of handle_mount_opt.
>>      As the former patch introduced f2fs_fs_context, so we record
>>      the changed mount options in this context. In handle_mount_opt,
>>      sb/sbi is null, so we should move all relative code out of
>>      handle_mount_opt (thus, some check case which use sb/sbi should
>>      move out).
>>    - Secondly, we introduce the some check helpers to keep the option
>>      consistent.
>>      During filling superblock period, sb/sbi are ready. So we check
>>      the f2fs_fs_context which holds the mount options base on sb/sbi.
>>    - Thirdly, we apply the new mount options to sb/sbi.
>>      After checking the f2fs_fs_context, all changed on mount options
>>      are valid. So we can apply them to sb/sbi directly.
>>
>> After do these, option parsing and super block setting have been
>> decoupled. Also it should have retained the original execution
>> flow.
>>
>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>> [sandeen: forward port, minor fixes and updates]
>> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
>> [hongbo: minor fixes]
>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>> ---
>>   fs/f2fs/super.c | 736 +++++++++++++++++++++++++++++++++++-------------
>>   1 file changed, 543 insertions(+), 193 deletions(-)
>>
>> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
>> index 87db6eb9ef07..9835e7cd1071 100644
>> --- a/fs/f2fs/super.c
>> +++ b/fs/f2fs/super.c
>> @@ -362,6 +362,12 @@ static inline void ctx_clear_opt(struct f2fs_fs_context *ctx,
>>   	ctx->opt_mask |= flag;
>>   }
>>   
>> +static inline bool ctx_test_opt(struct f2fs_fs_context *ctx,
>> +				unsigned int flag)
>> +{
>> +	return ctx->info.opt & flag;
>> +}
>> +
>>   static inline void ctx_set_flags(struct f2fs_fs_context *ctx,
>>   				 unsigned int flag)
>>   {
>> @@ -535,51 +541,6 @@ static int f2fs_unnote_qf_name(struct fs_context *fc, int qtype)
>>   	ctx->qname_mask |= 1 << qtype;
>>   	return 0;
>>   }
>> -
>> -static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
>> -{
>> -	/*
>> -	 * We do the test below only for project quotas. 'usrquota' and
>> -	 * 'grpquota' mount options are allowed even without quota feature
>> -	 * to support legacy quotas in quota files.
>> -	 */
>> -	if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
>> -		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
>> -		return -1;
>> -	}
>> -	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
>> -			F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
>> -			F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
>> -		if (test_opt(sbi, USRQUOTA) &&
>> -				F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
>> -			clear_opt(sbi, USRQUOTA);
>> -
>> -		if (test_opt(sbi, GRPQUOTA) &&
>> -				F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
>> -			clear_opt(sbi, GRPQUOTA);
>> -
>> -		if (test_opt(sbi, PRJQUOTA) &&
>> -				F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
>> -			clear_opt(sbi, PRJQUOTA);
>> -
>> -		if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
>> -				test_opt(sbi, PRJQUOTA)) {
>> -			f2fs_err(sbi, "old and new quota format mixing");
>> -			return -1;
>> -		}
>> -
>> -		if (!F2FS_OPTION(sbi).s_jquota_fmt) {
>> -			f2fs_err(sbi, "journaled quota format not specified");
>> -			return -1;
>> -		}
>> -	}
>> -
>> -	if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
>> -		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
>> -		F2FS_OPTION(sbi).s_jquota_fmt = 0;
>> -	}
>> -	return 0;
>> -}
>>   #endif
>>   
>>   static int f2fs_parse_test_dummy_encryption(const struct fs_parameter *param,
>> @@ -638,28 +599,28 @@ static bool is_compress_extension_exist(struct f2fs_mount_info *info,
>>    * extension will be treated as special cases and will not be compressed.
>>    * 3. Don't allow the non-compress extension specifies all files.
>>    */
>> -static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)
>> +static int f2fs_test_compress_extension(unsigned char (*noext)[F2FS_EXTENSION_LEN],
>> +					int noext_cnt,
>> +					unsigned char (*ext)[F2FS_EXTENSION_LEN],
>> +					int ext_cnt)
>>   {
>> -	unsigned char (*ext)[F2FS_EXTENSION_LEN];
>> -	unsigned char (*noext)[F2FS_EXTENSION_LEN];
>> -	int ext_cnt, noext_cnt, index = 0, no_index = 0;
>> -
>> -	ext = F2FS_OPTION(sbi).extensions;
>> -	ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>> -	noext = F2FS_OPTION(sbi).noextensions;
>> -	noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>> +	int index = 0, no_index = 0;
>>   
>>   	if (!noext_cnt)
>>   		return 0;
>>   
>>   	for (no_index = 0; no_index < noext_cnt; no_index++) {
>> +		if (strlen(noext[no_index]) == 0)
>> +			continue;
>>   		if (!strcasecmp("*", noext[no_index])) {
>> -			f2fs_info(sbi, "Don't allow the nocompress extension specifies all files");
>> +			f2fs_info(NULL, "Don't allow the nocompress extension specifies all files");
>>   			return -EINVAL;
>>   		}
>>   		for (index = 0; index < ext_cnt; index++) {
>> +			if (strlen(ext[index]) == 0)
>> +				continue;
>>   			if (!strcasecmp(ext[index], noext[no_index])) {
>> -				f2fs_info(sbi, "Don't allow the same extension %s appear in both compress and nocompress extension",
>> +				f2fs_info(NULL, "Don't allow the same extension %s appear in both compress and nocompress extension",
>>   						ext[index]);
>>   				return -EINVAL;
>>   			}
>> @@ -751,7 +712,6 @@ static int f2fs_set_zstd_level(struct f2fs_fs_context *ctx, const char *str)
>>   static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   {
>>   	struct f2fs_fs_context *ctx = fc->fs_private;
>> -	struct f2fs_sb_info *sbi = fc->s_fs_info;
>>   #ifdef CONFIG_F2FS_FS_COMPRESSION
>>   	unsigned char (*ext)[F2FS_EXTENSION_LEN];
>>   	unsigned char (*noext)[F2FS_EXTENSION_LEN];
>> @@ -760,15 +720,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   #endif
>>   	substring_t args[MAX_OPT_ARGS];
>>   	struct fs_parse_result result;
>> -	bool is_remount;
>>   	int token, ret, arg;
>>   
>>   	token = fs_parse(fc, f2fs_param_specs, param, &result);
>>   	if (token < 0)
>>   		return token;
>>   
>> -	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
>> -
>>   	switch (token) {
>>   	case Opt_gc_background:
>>   		F2FS_CTX_INFO(ctx).bggc_mode = result.uint_32;
>> @@ -782,19 +739,10 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		ctx_set_opt(ctx, F2FS_MOUNT_NORECOVERY);
>>   		break;
>>   	case Opt_discard:
>> -		if (result.negated) {
>> -			if (f2fs_hw_should_discard(sbi)) {
>> -				f2fs_warn(NULL, "discard is required for zoned block devices");
>> -				return -EINVAL;
>> -			}
>> +		if (result.negated)
>>   			ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
>> -		} else {
>> -			if (!f2fs_hw_support_discard(sbi)) {
>> -				f2fs_warn(NULL, "device does not support discard");
>> -				break;
>> -			}
>> +		else
>>   			ctx_set_opt(ctx, F2FS_MOUNT_DISCARD);
>> -		}
>>   		break;
>>   	case Opt_noheap:
>>   	case Opt_heap:
>> @@ -814,6 +762,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   			ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR);
>>   		break;
>>   	case Opt_inline_xattr_size:
>> +		if (result.int_32 < MIN_INLINE_XATTR_SIZE ||
>> +			result.int_32 > MAX_INLINE_XATTR_SIZE) {
>> +			f2fs_err(NULL, "inline xattr size is out of range: %lu ~ %lu",
>> +				MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
>> +			return -EINVAL;
>> +		}
>>   		ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE);
>>   		F2FS_CTX_INFO(ctx).inline_xattr_size = result.int_32;
>>   		ctx->spec_mask |= F2FS_SPEC_inline_xattr_size;
>> @@ -875,27 +829,18 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		ctx_set_opt(ctx, F2FS_MOUNT_FASTBOOT);
>>   		break;
>>   	case Opt_extent_cache:
>> -		if (result.negated) {
>> -			if (f2fs_sb_has_device_alias(sbi)) {
>> -				f2fs_err(sbi, "device aliasing requires extent cache");
>> -				return -EINVAL;
>> -			}
>> +		if (result.negated)
>>   			ctx_clear_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
>> -		} else
>> +		else
>>   			ctx_set_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
>>   		break;
>>   	case Opt_data_flush:
>>   		ctx_set_opt(ctx, F2FS_MOUNT_DATA_FLUSH);
>>   		break;
>>   	case Opt_reserve_root:
>> -		if (test_opt(sbi, RESERVE_ROOT)) {
>> -			f2fs_info(NULL, "Preserve previous reserve_root=%u",
>> -				  F2FS_OPTION(sbi).root_reserved_blocks);
>> -		} else {
>> -			ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
>> -			F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
>> -			ctx->spec_mask |= F2FS_SPEC_reserve_root;
>> -		}
>> +		ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
>> +		F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
>> +		ctx->spec_mask |= F2FS_SPEC_reserve_root;
>>   		break;
>>   	case Opt_resuid:
>>   		F2FS_CTX_INFO(ctx).s_resuid = result.uid;
>> @@ -911,15 +856,13 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		break;
>>   #ifdef CONFIG_F2FS_FAULT_INJECTION
>>   	case Opt_fault_injection:
>> -		if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
>> -			return -EINVAL;
>>   		F2FS_CTX_INFO(ctx).fault_info.inject_rate = result.int_32;
>>   		ctx->spec_mask |= F2FS_SPEC_fault_injection;
>>   		ctx_set_opt(ctx, F2FS_MOUNT_FAULT_INJECTION);
>>   		break;
>>   
>>   	case Opt_fault_type:
>> -		if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
>> +		if (result.uint_32 > BIT(FAULT_MAX))
>>   			return -EINVAL;
>>   		F2FS_CTX_INFO(ctx).fault_info.inject_type = result.uint_32;
>>   		ctx->spec_mask |= F2FS_SPEC_fault_type;
>> @@ -1060,10 +1003,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		break;
>>   #ifdef CONFIG_F2FS_FS_COMPRESSION
>>   	case Opt_compress_algorithm:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		name = param->string;
>>   		if (!strcmp(name, "lzo")) {
>>   #ifdef CONFIG_F2FS_FS_LZO
>> @@ -1107,10 +1046,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   			return -EINVAL;
>>   		break;
>>   	case Opt_compress_log_size:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
>>   		    result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
>>   			f2fs_err(NULL,
>> @@ -1121,10 +1056,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		ctx->spec_mask |= F2FS_SPEC_compress_log_size;
>>   		break;
>>   	case Opt_compress_extension:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		name = param->string;
>>   		ext = F2FS_CTX_INFO(ctx).extensions;
>>   		ext_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
>> @@ -1145,10 +1076,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		ctx->spec_mask |= F2FS_SPEC_compress_extension;
>>   		break;
>>   	case Opt_nocompress_extension:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		name = param->string;
>>   		noext = F2FS_CTX_INFO(ctx).noextensions;
>>   		noext_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
>> @@ -1169,26 +1096,14 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   		ctx->spec_mask |= F2FS_SPEC_nocompress_extension;
>>   		break;
>>   	case Opt_compress_chksum:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		F2FS_CTX_INFO(ctx).compress_chksum = true;
>>   		ctx->spec_mask |= F2FS_SPEC_compress_chksum;
>>   		break;
>>   	case Opt_compress_mode:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		F2FS_CTX_INFO(ctx).compress_mode = result.uint_32;
>>   		ctx->spec_mask |= F2FS_SPEC_compress_mode;
>>   		break;
>>   	case Opt_compress_cache:
>> -		if (!f2fs_sb_has_compression(sbi)) {
>> -			f2fs_info(NULL, "Image doesn't support compression");
>> -			break;
>> -		}
>>   		ctx_set_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE);
>>   		break;
>>   #else
>> @@ -1233,24 +1148,15 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>   	return 0;
>>   }
>>   
>> -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
>> +static int parse_options(struct fs_context *fc, char *options)
>>   {
>>   	struct fs_parameter param;
>> -	struct fs_context fc;
>> -	struct f2fs_fs_context ctx;
>>   	char *key;
>>   	int ret;
>>   
>>   	if (!options)
>>   		return 0;
>>   
>> -	memset(&fc, 0, sizeof(fc));
>> -	fc.s_fs_info = sbi;
>> -	fc.fs_private = &ctx;
>> -
>> -	if (is_remount)
>> -		fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
>> -
>>   	while ((key = strsep(&options, ",")) != NULL) {
>>   		if (*key) {
>>   			size_t v_len = 0;
>> @@ -1274,7 +1180,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>>   			param.key = key;
>>   			param.size = v_len;
>>   
>> -			ret = handle_mount_opt(&fc, &param);
>> +			ret = handle_mount_opt(fc, &param);
>>   			kfree(param.string);
>>   			if (ret < 0)
>>   				return ret;
>> @@ -1283,24 +1189,298 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>>   	return 0;
>>   }
>>   
>> -static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>> +/*
>> + * Check quota settings consistency.
>> + */
>> +static int f2fs_check_quota_consistency(struct fs_context *fc,
>> +					struct super_block *sb)
>>   {
>> -#ifdef CONFIG_QUOTA
>> -	if (f2fs_check_quota_options(sbi))
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> + #ifdef CONFIG_QUOTA
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	bool quota_feature = f2fs_sb_has_quota_ino(sbi);
>> +	bool quota_turnon = sb_any_quota_loaded(sb);
>> +	char *old_qname, *new_qname;
>> +	bool usr_qf_name, grp_qf_name, prj_qf_name, usrquota, grpquota, prjquota;
>> +	int i;
>> +
>> +	/*
>> +	 * We do the test below only for project quotas. 'usrquota' and
>> +	 * 'grpquota' mount options are allowed even without quota feature
>> +	 * to support legacy quotas in quota files.
>> +	 */
>> +	if (ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA) &&
>> +			!f2fs_sb_has_project_quota(sbi)) {
>> +		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
>>   		return -EINVAL;
>> +	}
>> +
>> +	if (ctx->qname_mask) {
>> +		for (i = 0; i < MAXQUOTAS; i++) {
>> +			if (!(ctx->qname_mask & (1 << i)))
>> +				continue;
>> +
>> +			old_qname = F2FS_OPTION(sbi).s_qf_names[i];
>> +			new_qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
>> +			if (quota_turnon &&
>> +				!!old_qname != !!new_qname)
>> +				goto err_jquota_change;
>> +
>> +			if (old_qname) {
>> +				if (strcmp(old_qname, new_qname) == 0) {
>> +					ctx->qname_mask &= ~(1 << i);
>> +					continue;
>> +				}
>> +				goto err_jquota_specified;
>> +			}
>> +
>> +			if (quota_feature) {
>> +				f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
>> +				ctx->qname_mask &= ~(1 << i);
>> +				kfree(F2FS_CTX_INFO(ctx).s_qf_names[i]);
>> +				F2FS_CTX_INFO(ctx).s_qf_names[i] = NULL;
>> +			}
>> +		}
>> +	}
>> +
>> +	/* Make sure we don't mix old and new quota format */
>> +	usr_qf_name = F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
>> +			F2FS_CTX_INFO(ctx).s_qf_names[USRQUOTA];
>> +	grp_qf_name = F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
>> +			F2FS_CTX_INFO(ctx).s_qf_names[GRPQUOTA];
>> +	prj_qf_name = F2FS_OPTION(sbi).s_qf_names[PRJQUOTA] ||
>> +			F2FS_CTX_INFO(ctx).s_qf_names[PRJQUOTA];
>> +	usrquota = test_opt(sbi, USRQUOTA) ||
>> +			ctx_test_opt(ctx, F2FS_MOUNT_USRQUOTA);
>> +	grpquota = test_opt(sbi, GRPQUOTA) ||
>> +			ctx_test_opt(ctx, F2FS_MOUNT_GRPQUOTA);
>> +	prjquota = test_opt(sbi, PRJQUOTA) ||
>> +			ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA);
>> +
>> +	if (usr_qf_name) {
>> +		ctx_clear_opt(ctx, F2FS_MOUNT_USRQUOTA);
>> +		usrquota = false;
>> +	}
>> +	if (grp_qf_name) {
>> +		ctx_clear_opt(ctx, F2FS_MOUNT_GRPQUOTA);
>> +		grpquota = false;
>> +	}
>> +	if (prj_qf_name) {
>> +		ctx_clear_opt(ctx, F2FS_MOUNT_PRJQUOTA);
>> +		prjquota = false;
>> +	}
>> +	if (usr_qf_name || grp_qf_name || prj_qf_name) {
>> +		if (grpquota || usrquota || prjquota) {
>> +			f2fs_err(sbi, "old and new quota format mixing");
>> +			return -EINVAL;
>> +		}
>> +		if (!(ctx->spec_mask & F2FS_SPEC_jqfmt ||
>> +				F2FS_OPTION(sbi).s_jquota_fmt)) {
>> +			f2fs_err(sbi, "journaled quota format not specified");
>> +			return -EINVAL;
>> +		}
>> +	}
>> +	return 0;
>> +
>> +err_jquota_change:
>> +	f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
>> +	return -EINVAL;
>> +err_jquota_specified:
>> +	f2fs_err(sbi, "%s quota file already specified",
>> +		 QTYPE2NAME(i));
>> +	return -EINVAL;
>> +
>>   #else
>> -	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
>> -		f2fs_info(NULL, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>> +	if (f2fs_readonly(sbi->sb))
>> +		return 0;
>> +	if (f2fs_sb_has_quota_ino(sbi)) {
>> +		f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>>   		return -EINVAL;
>>   	}
>> -	if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
>> -		f2fs_err(NULL, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>> +	if (f2fs_sb_has_project_quota(sbi)) {
>> +		f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>>   		return -EINVAL;
>>   	}
>> +
>> +	return 0;
>>   #endif
>> +}
>> +
>> +static int f2fs_check_test_dummy_encryption(struct fs_context *fc,
>> +					    struct super_block *sb)
>> +{
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> +
>> +	if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy))
>> +		return 0;
>> +
>> +	if (!f2fs_sb_has_encrypt(sbi)) {
>> +		f2fs_err(sbi, "Encrypt feature is off");
>> +		return -EINVAL;
>> +	}
>> +
>> +	/*
>> +	 * This mount option is just for testing, and it's not worthwhile to
>> +	 * implement the extra complexity (e.g. RCU protection) that would be
>> +	 * needed to allow it to be set or changed during remount.  We do allow
>> +	 * it to be specified during remount, but only if there is no change.
>> +	 */
>> +	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
>> +		if (fscrypt_dummy_policies_equal(&F2FS_OPTION(sbi).dummy_enc_policy,
>> +				&F2FS_CTX_INFO(ctx).dummy_enc_policy))
>> +			return 0;
>> +		f2fs_warn(sbi, "Can't set or change test_dummy_encryption on remount");
>> +		return -EINVAL;
>> +	}
>> +	return 0;
>> +}
>> +
>> +static inline bool test_compression_spec(unsigned int mask)
>> +{
>> +	return mask & (F2FS_SPEC_compress_algorithm
>> +			| F2FS_SPEC_compress_log_size
>> +			| F2FS_SPEC_compress_extension
>> +			| F2FS_SPEC_nocompress_extension
>> +			| F2FS_SPEC_compress_chksum
>> +			| F2FS_SPEC_compress_mode);
>> +}
>> +
>> +static inline void clear_compression_spec(struct f2fs_fs_context *ctx)
>> +{
>> +	ctx->spec_mask &= ~(F2FS_SPEC_compress_algorithm
>> +						| F2FS_SPEC_compress_log_size
>> +						| F2FS_SPEC_compress_extension
>> +						| F2FS_SPEC_nocompress_extension
>> +						| F2FS_SPEC_compress_chksum
>> +						| F2FS_SPEC_compress_mode);
>> +}
>> +
>> +static int f2fs_check_compression(struct fs_context *fc,
>> +				  struct super_block *sb)
>> +{
>> +#ifdef CONFIG_F2FS_FS_COMPRESSION
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> +	int i, cnt;
>> +
>> +	if (!f2fs_sb_has_compression(sbi)) {
>> +		if (test_compression_spec(ctx->spec_mask) ||
>> +			ctx_test_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE))
>> +			f2fs_info(sbi, "Image doesn't support compression");
>> +		clear_compression_spec(ctx);
>> +		ctx->opt_mask &= ~F2FS_MOUNT_COMPRESS_CACHE;
>> +		return 0;
>> +	}
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
>> +		cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
>> +		for (i = 0; i < F2FS_CTX_INFO(ctx).compress_ext_cnt; i++) {
>> +			if (is_compress_extension_exist(&F2FS_OPTION(sbi),
>> +					F2FS_CTX_INFO(ctx).extensions[i], true)) {
>> +				F2FS_CTX_INFO(ctx).extensions[i][0] = '\0';
>> +				cnt--;
>> +			}
>> +		}
>> +		if (F2FS_OPTION(sbi).compress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
>> +			f2fs_err(sbi, "invalid extension length/number");
>> +			return -EINVAL;
>> +		}
>> +	}
>> +	if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
>> +		cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
>> +		for (i = 0; i < F2FS_CTX_INFO(ctx).nocompress_ext_cnt; i++) {
>> +			if (is_compress_extension_exist(&F2FS_OPTION(sbi),
>> +					F2FS_CTX_INFO(ctx).noextensions[i], false)) {
>> +				F2FS_CTX_INFO(ctx).noextensions[i][0] = '\0';
>> +				cnt--;
>> +			}
>> +		}
>> +		if (F2FS_OPTION(sbi).nocompress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
>> +			f2fs_err(sbi, "invalid noextension length/number");
>> +			return -EINVAL;
>> +		}
>> +	}
>> +
>> +	if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
>> +				F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
>> +				F2FS_CTX_INFO(ctx).extensions,
>> +				F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
>> +		f2fs_err(sbi, "new noextensions conflicts with new extensions");
>> +		return -EINVAL;
>> +	}
>> +	if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
>> +				F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
>> +				F2FS_OPTION(sbi).extensions,
>> +				F2FS_OPTION(sbi).compress_ext_cnt)) {
>> +		f2fs_err(sbi, "new noextensions conflicts with old extensions");
>> +		return -EINVAL;
>> +	}
>> +	if (f2fs_test_compress_extension(F2FS_OPTION(sbi).noextensions,
>> +				F2FS_OPTION(sbi).nocompress_ext_cnt,
>> +				F2FS_CTX_INFO(ctx).extensions,
>> +				F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
>> +		f2fs_err(sbi, "new extensions conflicts with old noextensions");
>> +		return -EINVAL;
>> +	}
>> +#endif
>> +	return 0;
>> +}
>> +
>> +static int f2fs_check_opt_consistency(struct fs_context *fc,
>> +				      struct super_block *sb)
>> +{
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> +	int err;
>> +
>> +	if (ctx_test_opt(ctx, F2FS_MOUNT_NORECOVERY) && !f2fs_readonly(sb))
>> +		return -EINVAL;
>> +
>> +	if (f2fs_hw_should_discard(sbi) &&
>> +			(ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
>> +			!ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
>> +		f2fs_warn(sbi, "discard is required for zoned block devices");
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (!f2fs_hw_support_discard(sbi) &&
>> +			(ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
>> +			ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
>> +		f2fs_warn(sbi, "device does not support discard");
>> +		ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
>> +		ctx->opt_mask &= ~F2FS_MOUNT_DISCARD;
>> +	}
>> +
>> +	if (f2fs_sb_has_device_alias(sbi) &&
>> +			(ctx->opt_mask & F2FS_MOUNT_READ_EXTENT_CACHE) &&
>> +			!ctx_test_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE)) {
>> +		f2fs_err(sbi, "device aliasing requires extent cache");
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (test_opt(sbi, RESERVE_ROOT) &&
>> +			(ctx->opt_mask & F2FS_MOUNT_RESERVE_ROOT) &&
>> +			ctx_test_opt(ctx, F2FS_MOUNT_RESERVE_ROOT)) {
>> +		f2fs_info(sbi, "Preserve previous reserve_root=%u",
>> +			F2FS_OPTION(sbi).root_reserved_blocks);
>> +		ctx_clear_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
>> +		ctx->opt_mask &= ~F2FS_MOUNT_RESERVE_ROOT;
>> +	}
>> +
>> +	err = f2fs_check_test_dummy_encryption(fc, sb);
>> +	if (err)
>> +		return err;
>> +
>> +	err = f2fs_check_compression(fc, sb);
>> +	if (err)
>> +		return err;
>> +
>> +	err = f2fs_check_quota_consistency(fc, sb);
>> +	if (err)
>> +		return err;
>>   
>>   	if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {
>> -		f2fs_err(NULL,
>> +		f2fs_err(sbi,
>>   			"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
>>   		return -EINVAL;
>>   	}
>> @@ -1312,74 +1492,236 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>>   	 */
>>   	if (f2fs_sb_has_blkzoned(sbi)) {
>>   #ifdef CONFIG_BLK_DEV_ZONED
>> -		if (F2FS_OPTION(sbi).discard_unit !=
>> -						DISCARD_UNIT_SECTION) {
>> -			f2fs_info(NULL, "Zoned block device doesn't need small discard, set discard_unit=section by default");
>> -			F2FS_OPTION(sbi).discard_unit =
>> -					DISCARD_UNIT_SECTION;
>> +		if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
>> +		F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {
>> +			f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");
>> +			F2FS_CTX_INFO(ctx).discard_unit = DISCARD_UNIT_SECTION;
>>   		}
>>   
>> -		if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {
>> -			f2fs_info(NULL, "Only lfs mode is allowed with zoned block device feature");
>> +		if ((ctx->spec_mask & F2FS_SPEC_mode) &&
>> +		F2FS_CTX_INFO(ctx).fs_mode != FS_MODE_LFS) {
>> +			f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");
>>   			return -EINVAL;
>>   		}
>>   #else
>> -		f2fs_err(NULL, "Zoned block device support is not enabled");
>> +		f2fs_err(sbi, "Zoned block device support is not enabled");
>>   		return -EINVAL;
>>   #endif
>>   	}
>>   
>> -#ifdef CONFIG_F2FS_FS_COMPRESSION
>> -	if (f2fs_test_compress_extension(sbi)) {
>> -		f2fs_err(NULL, "invalid compress or nocompress extension");
>> -		return -EINVAL;
>> -	}
>> -#endif
>> -
>> -	if (test_opt(sbi, INLINE_XATTR_SIZE)) {
>> -		int min_size, max_size;
>> -
>> +	if (ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE)) {
>>   		if (!f2fs_sb_has_extra_attr(sbi) ||
>>   			!f2fs_sb_has_flexible_inline_xattr(sbi)) {
>> -			f2fs_err(NULL, "extra_attr or flexible_inline_xattr feature is off");
>> +			f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
>>   			return -EINVAL;
>>   		}
>> -		if (!test_opt(sbi, INLINE_XATTR)) {
>> -			f2fs_err(NULL, "inline_xattr_size option should be set with inline_xattr option");
>> -			return -EINVAL;
>> -		}
>> -
>> -		min_size = MIN_INLINE_XATTR_SIZE;
>> -		max_size = MAX_INLINE_XATTR_SIZE;
>> -
>> -		if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
>> -				F2FS_OPTION(sbi).inline_xattr_size > max_size) {
>> -			f2fs_err(NULL, "inline xattr size is out of range: %d ~ %d",
>> -				 min_size, max_size);
>> +		if (!ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR) && !test_opt(sbi, INLINE_XATTR)) {
>> +			f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
>>   			return -EINVAL;
>>   		}
>>   	}
>>   
>> -	if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {
>> -		f2fs_err(NULL, "LFS is not compatible with ATGC");
>> +	if (ctx_test_opt(ctx, F2FS_MOUNT_ATGC) &&
>> +	    F2FS_CTX_INFO(ctx).fs_mode == FS_MODE_LFS) {
>> +		f2fs_err(sbi, "LFS is not compatible with ATGC");
>>   		return -EINVAL;
>>   	}
>>   
>> -	if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {
>> -		f2fs_err(NULL, "FLUSH_MERGE not compatible with readonly mode");
>> +	if (f2fs_is_readonly(sbi) && ctx_test_opt(ctx, F2FS_MOUNT_FLUSH_MERGE)) {
>> +		f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");
>>   		return -EINVAL;
>>   	}
>>   
>>   	if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
>> -		f2fs_err(NULL, "Allow to mount readonly mode only");
>> +		f2fs_err(sbi, "Allow to mount readonly mode only");
>>   		return -EROFS;
>>   	}
>> +	return 0;
>> +}
>> +
>> +static void f2fs_apply_quota_options(struct fs_context *fc,
>> +				     struct super_block *sb)
>> +{
>> +#ifdef CONFIG_QUOTA
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> +	bool quota_feature = f2fs_sb_has_quota_ino(sbi);
>> +	char *qname;
>> +	int i;
>> +
>> +	if (quota_feature)
>> +		return;
>> +
>> +	for (i = 0; i < MAXQUOTAS; i++) {
>> +		if (!(ctx->qname_mask & (1 << i)))
>> +			continue;
>> +
>> +		qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
>> +		if (qname) {
>> +			qname = kstrdup(F2FS_CTX_INFO(ctx).s_qf_names[i],
>> +					GFP_KERNEL | __GFP_NOFAIL);
>> +			set_opt(sbi, QUOTA);
>> +		}
>> +		F2FS_OPTION(sbi).s_qf_names[i] = qname;
>> +	}
>> +
>> +	if (ctx->spec_mask & F2FS_SPEC_jqfmt)
>> +		F2FS_OPTION(sbi).s_jquota_fmt = F2FS_CTX_INFO(ctx).s_jquota_fmt;
>> +
>> +	if (quota_feature && F2FS_OPTION(sbi).s_jquota_fmt) {
>> +		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
>> +		F2FS_OPTION(sbi).s_jquota_fmt = 0;
>> +	}
>> +#endif
>> +}
>> +
>> +static void f2fs_apply_test_dummy_encryption(struct fs_context *fc,
>> +					     struct super_block *sb)
>> +{
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> +
>> +	if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy) ||
>> +		/* if already set, it was already verified to be the same */
>> +		fscrypt_is_dummy_policy_set(&F2FS_OPTION(sbi).dummy_enc_policy))
>> +		return;
>> +	swap(F2FS_OPTION(sbi).dummy_enc_policy, F2FS_CTX_INFO(ctx).dummy_enc_policy);
>> +	f2fs_warn(sbi, "Test dummy encryption mode enabled");
>> +}
>> +
>> +static void f2fs_apply_compression(struct fs_context *fc,
>> +				   struct super_block *sb)
>> +{
>> +#ifdef CONFIG_F2FS_FS_COMPRESSION
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>> +	unsigned char (*ctx_ext)[F2FS_EXTENSION_LEN];
>> +	unsigned char (*sbi_ext)[F2FS_EXTENSION_LEN];
>> +	int ctx_cnt, sbi_cnt, i;
>> +
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_level)
>> +		F2FS_OPTION(sbi).compress_level =
>> +					F2FS_CTX_INFO(ctx).compress_level;
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_algorithm)
>> +		F2FS_OPTION(sbi).compress_algorithm =
>> +					F2FS_CTX_INFO(ctx).compress_algorithm;
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_log_size)
>> +		F2FS_OPTION(sbi).compress_log_size =
>> +					F2FS_CTX_INFO(ctx).compress_log_size;
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_chksum)
>> +		F2FS_OPTION(sbi).compress_chksum =
>> +					F2FS_CTX_INFO(ctx).compress_chksum;
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_mode)
>> +		F2FS_OPTION(sbi).compress_mode =
>> +					F2FS_CTX_INFO(ctx).compress_mode;
>> +	if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
>> +		ctx_ext = F2FS_CTX_INFO(ctx).extensions;
>> +		ctx_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
>> +		sbi_ext = F2FS_OPTION(sbi).extensions;
>> +		sbi_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>> +		for (i = 0; i < ctx_cnt; i++) {
>> +			if (strlen(ctx_ext[i]) == 0)
>> +				continue;
>> +			strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
>> +			sbi_cnt++;
>> +		}
>> +		F2FS_OPTION(sbi).compress_ext_cnt = sbi_cnt;
>> +	}
>> +	if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
>> +		ctx_ext = F2FS_CTX_INFO(ctx).noextensions;
>> +		ctx_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
>> +		sbi_ext = F2FS_OPTION(sbi).noextensions;
>> +		sbi_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>> +		for (i = 0; i < ctx_cnt; i++) {
>> +			if (strlen(ctx_ext[i]) == 0)
>> +				continue;
>> +			strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
>> +			sbi_cnt++;
>> +		}
>> +		F2FS_OPTION(sbi).nocompress_ext_cnt = sbi_cnt;
>> +	}
>> +#endif
>> +}
>> +
>> +static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
>> +{
>> +	struct f2fs_fs_context *ctx = fc->fs_private;
>> +	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>   
>> -	if (test_opt(sbi, NORECOVERY) && !f2fs_readonly(sbi->sb)) {
>> -		f2fs_err(sbi, "norecovery requires readonly mount");
>> +	F2FS_OPTION(sbi).opt &= ~ctx->opt_mask;
>> +	F2FS_OPTION(sbi).opt |= F2FS_CTX_INFO(ctx).opt;
>> +	sb->s_flags &= ~ctx->sflags_mask;
>> +	sb->s_flags |= ctx->sflags;
>> +
>> +	if (ctx->spec_mask & F2FS_SPEC_background_gc)
>> +		F2FS_OPTION(sbi).bggc_mode = F2FS_CTX_INFO(ctx).bggc_mode;
>> +	if (ctx->spec_mask & F2FS_SPEC_inline_xattr_size)
>> +		F2FS_OPTION(sbi).inline_xattr_size =
>> +					F2FS_CTX_INFO(ctx).inline_xattr_size;
>> +	if (ctx->spec_mask & F2FS_SPEC_active_logs)
>> +		F2FS_OPTION(sbi).active_logs = F2FS_CTX_INFO(ctx).active_logs;
>> +	if (ctx->spec_mask & F2FS_SPEC_reserve_root)
>> +		F2FS_OPTION(sbi).root_reserved_blocks =
>> +					F2FS_CTX_INFO(ctx).root_reserved_blocks;
>> +	if (ctx->spec_mask & F2FS_SPEC_resgid)
>> +		F2FS_OPTION(sbi).s_resgid = F2FS_CTX_INFO(ctx).s_resgid;
>> +	if (ctx->spec_mask & F2FS_SPEC_resuid)
>> +		F2FS_OPTION(sbi).s_resuid = F2FS_CTX_INFO(ctx).s_resuid;
>> +	if (ctx->spec_mask & F2FS_SPEC_mode)
>> +		F2FS_OPTION(sbi).fs_mode = F2FS_CTX_INFO(ctx).fs_mode;
>> +#ifdef CONFIG_F2FS_FAULT_INJECTION
>> +	if (ctx->spec_mask & F2FS_SPEC_fault_injection)
>> +		(void)f2fs_build_fault_attr(sbi,
>> +		F2FS_CTX_INFO(ctx).fault_info.inject_rate, 0, FAULT_RATE);
>> +	if (ctx->spec_mask & F2FS_SPEC_fault_type)
>> +		(void)f2fs_build_fault_attr(sbi, 0,
>> +			F2FS_CTX_INFO(ctx).fault_info.inject_type, FAULT_TYPE);
>> +#endif
>> +	if (ctx->spec_mask & F2FS_SPEC_alloc_mode)
>> +		F2FS_OPTION(sbi).alloc_mode = F2FS_CTX_INFO(ctx).alloc_mode;
>> +	if (ctx->spec_mask & F2FS_SPEC_fsync_mode)
>> +		F2FS_OPTION(sbi).fsync_mode = F2FS_CTX_INFO(ctx).fsync_mode;
>> +	if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap)
>> +		F2FS_OPTION(sbi).unusable_cap = F2FS_CTX_INFO(ctx).unusable_cap;
>> +	if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap_perc)
>> +		F2FS_OPTION(sbi).unusable_cap_perc =
>> +					F2FS_CTX_INFO(ctx).unusable_cap_perc;
>> +	if (ctx->spec_mask & F2FS_SPEC_discard_unit)
>> +		F2FS_OPTION(sbi).discard_unit = F2FS_CTX_INFO(ctx).discard_unit;
>> +	if (ctx->spec_mask & F2FS_SPEC_memory_mode)
>> +		F2FS_OPTION(sbi).memory_mode = F2FS_CTX_INFO(ctx).memory_mode;
>> +	if (ctx->spec_mask & F2FS_SPEC_errors)
>> +		F2FS_OPTION(sbi).errors = F2FS_CTX_INFO(ctx).errors;
>> +
>> +	f2fs_apply_compression(fc, sb);
>> +	f2fs_apply_test_dummy_encryption(fc, sb);
>> +	f2fs_apply_quota_options(fc, sb);
>> +}
>> +
>> +static int f2fs_sanity_check_options(struct f2fs_sb_info *sbi, bool remount)
>> +{
>> +	if (f2fs_sb_has_device_alias(sbi) &&
>> +	    !test_opt(sbi, READ_EXTENT_CACHE)) {
>> +		f2fs_err(sbi, "device aliasing requires extent cache");
>>   		return -EINVAL;
>>   	}
>>   
>> +	if (!remount)
>> +		return 0;
>> +
>> +#ifdef CONFIG_BLK_DEV_ZONED
>> +	if (f2fs_sb_has_blkzoned(sbi) &&
>> +	    sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
>> +		f2fs_err(sbi,
>> +			"zoned: max open zones %u is too small, need at least %u open zones",
>> +				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
>> +		return -EINVAL;
>> +	}
>> +#endif
>> +	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
>> +		f2fs_warn(sbi, "LFS is not compatible with IPU");
>> +		return -EINVAL;
>> +	}
>>   	return 0;
>>   }
>>   
>> @@ -2290,6 +2632,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>   {
>>   	struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>   	struct f2fs_mount_info org_mount_opt;
>> +	struct f2fs_fs_context ctx;
>> +	struct fs_context fc;
>>   	unsigned long old_sb_flags;
>>   	int err;
>>   	bool need_restart_gc = false, need_stop_gc = false;
>> @@ -2346,23 +2690,23 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>   
>>   	default_options(sbi, true);
>>   
>> +	memset(&fc, 0, sizeof(fc));
>> +	memset(&ctx, 0, sizeof(ctx));
>> +	fc.fs_private = &ctx;
>> +	fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
>> +
>>   	/* parse mount options */
>> -	err = parse_options(sbi, data, true);
>> +	err = parse_options(&fc, data);
>>   	if (err)
>>   		goto restore_opts;
>>   
>> -#ifdef CONFIG_BLK_DEV_ZONED
>> -	if (f2fs_sb_has_blkzoned(sbi) &&
>> -		sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
>> -		f2fs_err(sbi,
>> -			"zoned: max open zones %u is too small, need at least %u open zones",
>> -				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
>> -		err = -EINVAL;
>> +	err = f2fs_check_opt_consistency(&fc, sb);
>> +	if (err)
>>   		goto restore_opts;
>> -	}
>> -#endif
>>   
>> -	err = f2fs_validate_options(sbi);
>> +	f2fs_apply_options(&fc, sb);
>> +
>> +	err = f2fs_sanity_check_options(sbi, true);
>>   	if (err)
>>   		goto restore_opts;
>>   
>> @@ -2398,12 +2742,6 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>   		}
>>   	}
>>   #endif
>> -	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
>> -		err = -EINVAL;
>> -		f2fs_warn(sbi, "LFS is not compatible with IPU");
>> -		goto restore_opts;
>> -	}
>> -
>>   	/* disallow enable atgc dynamically */
>>   	if (no_atgc == !!test_opt(sbi, ATGC)) {
>>   		err = -EINVAL;
>> @@ -4483,6 +4821,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>   {
>>   	struct f2fs_sb_info *sbi;
>>   	struct f2fs_super_block *raw_super;
>> +	struct f2fs_fs_context ctx;
>> +	struct fs_context fc;
>>   	struct inode *root;
>>   	int err;
>>   	bool skip_recovery = false, need_fsck = false;
>> @@ -4499,6 +4839,9 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>   	raw_super = NULL;
>>   	valid_super_block = -1;
>>   	recovery = 0;
>> +	memset(&fc, 0, sizeof(fc));
>> +	memset(&ctx, 0, sizeof(ctx));
>> +	fc.fs_private = &ctx;
>>   
>>   	/* allocate memory for f2fs-specific super block info */
>>   	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
>> @@ -4556,11 +4899,17 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>   		goto free_sb_buf;
>>   	}
>>   
>> -	err = parse_options(sbi, options, false);
>> +	err = parse_options(&fc, options);
>>   	if (err)
>>   		goto free_options;
>>   
>> -	err = f2fs_validate_options(sbi);
>> +	err = f2fs_check_opt_consistency(&fc, sb);
>> +	if (err)
>> +		goto free_options;
>> +
>> +	f2fs_apply_options(&fc, sb);
>> +
>> +	err = f2fs_sanity_check_options(sbi, false);
>>   	if (err)
>>   		goto free_options;
>>   
>> @@ -4981,7 +5330,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>   	for (i = 0; i < MAXQUOTAS; i++)
>>   		kfree(F2FS_OPTION(sbi).s_qf_names[i]);
>>   #endif
>> -	fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
>> +	/* no need to free dummy_enc_policy, we just keep it in ctx when failed */
>> +	swap(F2FS_CTX_INFO(&ctx).dummy_enc_policy, F2FS_OPTION(sbi).dummy_enc_policy);
> 
> I can see ext4 will free dummy_enc_policy in error path of fill_super, is
> there any difference?
> 

We can not free dummy_enc_policy in f2fs, due to the try_onemore 
logical. So here we rollback the assign and keep the dummy_enc_policy in 
ctx, and free it only when ctx is no longer used.

Thanks,
Hongbo

> Thanks,
> 
>>   	kvfree(options);
>>   free_sb_buf:
>>   	kfree(raw_super);
> 
> 

Re: [PATCH v4 5/7] f2fs: separate the options parsing and options checking

[Chao Yu]

On 7/8/25 10:56, Hongbo Li wrote:
> On 2025/7/7 20:17, Chao Yu wrote:
>> On 6/2/25 17:02, Hongbo Li wrote:G
>>> The new mount api separates option parsing and super block setup
>>> into two distinct steps and so we need to separate the options
>>> parsing out of the parse_options().
>>>
>>> In order to achieve this, here we handle the mount options with
>>> three steps:
>>>    - Firstly, we move sb/sbi out of handle_mount_opt.
>>>      As the former patch introduced f2fs_fs_context, so we record
>>>      the changed mount options in this context. In handle_mount_opt,
>>>      sb/sbi is null, so we should move all relative code out of
>>>      handle_mount_opt (thus, some check case which use sb/sbi should
>>>      move out).
>>>    - Secondly, we introduce the some check helpers to keep the option
>>>      consistent.
>>>      During filling superblock period, sb/sbi are ready. So we check
>>>      the f2fs_fs_context which holds the mount options base on sb/sbi.
>>>    - Thirdly, we apply the new mount options to sb/sbi.
>>>      After checking the f2fs_fs_context, all changed on mount options
>>>      are valid. So we can apply them to sb/sbi directly.
>>>
>>> After do these, option parsing and super block setting have been
>>> decoupled. Also it should have retained the original execution
>>> flow.
>>>
>>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>>> [sandeen: forward port, minor fixes and updates]
>>> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
>>> [hongbo: minor fixes]
>>> Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
>>> ---
>>>   fs/f2fs/super.c | 736 +++++++++++++++++++++++++++++++++++-------------
>>>   1 file changed, 543 insertions(+), 193 deletions(-)
>>>
>>> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
>>> index 87db6eb9ef07..9835e7cd1071 100644
>>> --- a/fs/f2fs/super.c
>>> +++ b/fs/f2fs/super.c
>>> @@ -362,6 +362,12 @@ static inline void ctx_clear_opt(struct f2fs_fs_context *ctx,
>>>       ctx->opt_mask |= flag;
>>>   }
>>>   +static inline bool ctx_test_opt(struct f2fs_fs_context *ctx,
>>> +                unsigned int flag)
>>> +{
>>> +    return ctx->info.opt & flag;
>>> +}
>>> +
>>>   static inline void ctx_set_flags(struct f2fs_fs_context *ctx,
>>>                    unsigned int flag)
>>>   {
>>> @@ -535,51 +541,6 @@ static int f2fs_unnote_qf_name(struct fs_context *fc, int qtype)
>>>       ctx->qname_mask |= 1 << qtype;
>>>       return 0;
>>>   }
>>> -
>>> -static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
>>> -{
>>> -    /*
>>> -     * We do the test below only for project quotas. 'usrquota' and
>>> -     * 'grpquota' mount options are allowed even without quota feature
>>> -     * to support legacy quotas in quota files.
>>> -     */
>>> -    if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
>>> -        f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
>>> -        return -1;
>>> -    }
>>> -    if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
>>> -            F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
>>> -            F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
>>> -        if (test_opt(sbi, USRQUOTA) &&
>>> -                F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
>>> -            clear_opt(sbi, USRQUOTA);
>>> -
>>> -        if (test_opt(sbi, GRPQUOTA) &&
>>> -                F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
>>> -            clear_opt(sbi, GRPQUOTA);
>>> -
>>> -        if (test_opt(sbi, PRJQUOTA) &&
>>> -                F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
>>> -            clear_opt(sbi, PRJQUOTA);
>>> -
>>> -        if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
>>> -                test_opt(sbi, PRJQUOTA)) {
>>> -            f2fs_err(sbi, "old and new quota format mixing");
>>> -            return -1;
>>> -        }
>>> -
>>> -        if (!F2FS_OPTION(sbi).s_jquota_fmt) {
>>> -            f2fs_err(sbi, "journaled quota format not specified");
>>> -            return -1;
>>> -        }
>>> -    }
>>> -
>>> -    if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
>>> -        f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
>>> -        F2FS_OPTION(sbi).s_jquota_fmt = 0;
>>> -    }
>>> -    return 0;
>>> -}
>>>   #endif
>>>     static int f2fs_parse_test_dummy_encryption(const struct fs_parameter *param,
>>> @@ -638,28 +599,28 @@ static bool is_compress_extension_exist(struct f2fs_mount_info *info,
>>>    * extension will be treated as special cases and will not be compressed.
>>>    * 3. Don't allow the non-compress extension specifies all files.
>>>    */
>>> -static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)
>>> +static int f2fs_test_compress_extension(unsigned char (*noext)[F2FS_EXTENSION_LEN],
>>> +                    int noext_cnt,
>>> +                    unsigned char (*ext)[F2FS_EXTENSION_LEN],
>>> +                    int ext_cnt)
>>>   {
>>> -    unsigned char (*ext)[F2FS_EXTENSION_LEN];
>>> -    unsigned char (*noext)[F2FS_EXTENSION_LEN];
>>> -    int ext_cnt, noext_cnt, index = 0, no_index = 0;
>>> -
>>> -    ext = F2FS_OPTION(sbi).extensions;
>>> -    ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>>> -    noext = F2FS_OPTION(sbi).noextensions;
>>> -    noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>>> +    int index = 0, no_index = 0;
>>>         if (!noext_cnt)
>>>           return 0;
>>>         for (no_index = 0; no_index < noext_cnt; no_index++) {
>>> +        if (strlen(noext[no_index]) == 0)
>>> +            continue;
>>>           if (!strcasecmp("*", noext[no_index])) {
>>> -            f2fs_info(sbi, "Don't allow the nocompress extension specifies all files");
>>> +            f2fs_info(NULL, "Don't allow the nocompress extension specifies all files");
>>>               return -EINVAL;
>>>           }
>>>           for (index = 0; index < ext_cnt; index++) {
>>> +            if (strlen(ext[index]) == 0)
>>> +                continue;
>>>               if (!strcasecmp(ext[index], noext[no_index])) {
>>> -                f2fs_info(sbi, "Don't allow the same extension %s appear in both compress and nocompress extension",
>>> +                f2fs_info(NULL, "Don't allow the same extension %s appear in both compress and nocompress extension",
>>>                           ext[index]);
>>>                   return -EINVAL;
>>>               }
>>> @@ -751,7 +712,6 @@ static int f2fs_set_zstd_level(struct f2fs_fs_context *ctx, const char *str)
>>>   static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>   {
>>>       struct f2fs_fs_context *ctx = fc->fs_private;
>>> -    struct f2fs_sb_info *sbi = fc->s_fs_info;
>>>   #ifdef CONFIG_F2FS_FS_COMPRESSION
>>>       unsigned char (*ext)[F2FS_EXTENSION_LEN];
>>>       unsigned char (*noext)[F2FS_EXTENSION_LEN];
>>> @@ -760,15 +720,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>   #endif
>>>       substring_t args[MAX_OPT_ARGS];
>>>       struct fs_parse_result result;
>>> -    bool is_remount;
>>>       int token, ret, arg;
>>>         token = fs_parse(fc, f2fs_param_specs, param, &result);
>>>       if (token < 0)
>>>           return token;
>>>   -    is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
>>> -
>>>       switch (token) {
>>>       case Opt_gc_background:
>>>           F2FS_CTX_INFO(ctx).bggc_mode = result.uint_32;
>>> @@ -782,19 +739,10 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           ctx_set_opt(ctx, F2FS_MOUNT_NORECOVERY);
>>>           break;
>>>       case Opt_discard:
>>> -        if (result.negated) {
>>> -            if (f2fs_hw_should_discard(sbi)) {
>>> -                f2fs_warn(NULL, "discard is required for zoned block devices");
>>> -                return -EINVAL;
>>> -            }
>>> +        if (result.negated)
>>>               ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
>>> -        } else {
>>> -            if (!f2fs_hw_support_discard(sbi)) {
>>> -                f2fs_warn(NULL, "device does not support discard");
>>> -                break;
>>> -            }
>>> +        else
>>>               ctx_set_opt(ctx, F2FS_MOUNT_DISCARD);
>>> -        }
>>>           break;
>>>       case Opt_noheap:
>>>       case Opt_heap:
>>> @@ -814,6 +762,12 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>               ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR);
>>>           break;
>>>       case Opt_inline_xattr_size:
>>> +        if (result.int_32 < MIN_INLINE_XATTR_SIZE ||
>>> +            result.int_32 > MAX_INLINE_XATTR_SIZE) {
>>> +            f2fs_err(NULL, "inline xattr size is out of range: %lu ~ %lu",
>>> +                MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
>>> +            return -EINVAL;
>>> +        }
>>>           ctx_set_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE);
>>>           F2FS_CTX_INFO(ctx).inline_xattr_size = result.int_32;
>>>           ctx->spec_mask |= F2FS_SPEC_inline_xattr_size;
>>> @@ -875,27 +829,18 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           ctx_set_opt(ctx, F2FS_MOUNT_FASTBOOT);
>>>           break;
>>>       case Opt_extent_cache:
>>> -        if (result.negated) {
>>> -            if (f2fs_sb_has_device_alias(sbi)) {
>>> -                f2fs_err(sbi, "device aliasing requires extent cache");
>>> -                return -EINVAL;
>>> -            }
>>> +        if (result.negated)
>>>               ctx_clear_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
>>> -        } else
>>> +        else
>>>               ctx_set_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE);
>>>           break;
>>>       case Opt_data_flush:
>>>           ctx_set_opt(ctx, F2FS_MOUNT_DATA_FLUSH);
>>>           break;
>>>       case Opt_reserve_root:
>>> -        if (test_opt(sbi, RESERVE_ROOT)) {
>>> -            f2fs_info(NULL, "Preserve previous reserve_root=%u",
>>> -                  F2FS_OPTION(sbi).root_reserved_blocks);
>>> -        } else {
>>> -            ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
>>> -            F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
>>> -            ctx->spec_mask |= F2FS_SPEC_reserve_root;
>>> -        }
>>> +        ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
>>> +        F2FS_CTX_INFO(ctx).root_reserved_blocks = result.uint_32;
>>> +        ctx->spec_mask |= F2FS_SPEC_reserve_root;
>>>           break;
>>>       case Opt_resuid:
>>>           F2FS_CTX_INFO(ctx).s_resuid = result.uid;
>>> @@ -911,15 +856,13 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           break;
>>>   #ifdef CONFIG_F2FS_FAULT_INJECTION
>>>       case Opt_fault_injection:
>>> -        if (f2fs_build_fault_attr(sbi, result.int_32, 0, FAULT_RATE))
>>> -            return -EINVAL;
>>>           F2FS_CTX_INFO(ctx).fault_info.inject_rate = result.int_32;
>>>           ctx->spec_mask |= F2FS_SPEC_fault_injection;
>>>           ctx_set_opt(ctx, F2FS_MOUNT_FAULT_INJECTION);
>>>           break;
>>>         case Opt_fault_type:
>>> -        if (f2fs_build_fault_attr(sbi, 0, result.int_32, FAULT_TYPE))
>>> +        if (result.uint_32 > BIT(FAULT_MAX))
>>>               return -EINVAL;
>>>           F2FS_CTX_INFO(ctx).fault_info.inject_type = result.uint_32;
>>>           ctx->spec_mask |= F2FS_SPEC_fault_type;
>>> @@ -1060,10 +1003,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           break;
>>>   #ifdef CONFIG_F2FS_FS_COMPRESSION
>>>       case Opt_compress_algorithm:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           name = param->string;
>>>           if (!strcmp(name, "lzo")) {
>>>   #ifdef CONFIG_F2FS_FS_LZO
>>> @@ -1107,10 +1046,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>               return -EINVAL;
>>>           break;
>>>       case Opt_compress_log_size:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           if (result.uint_32 < MIN_COMPRESS_LOG_SIZE ||
>>>               result.uint_32 > MAX_COMPRESS_LOG_SIZE) {
>>>               f2fs_err(NULL,
>>> @@ -1121,10 +1056,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           ctx->spec_mask |= F2FS_SPEC_compress_log_size;
>>>           break;
>>>       case Opt_compress_extension:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           name = param->string;
>>>           ext = F2FS_CTX_INFO(ctx).extensions;
>>>           ext_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
>>> @@ -1145,10 +1076,6 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           ctx->spec_mask |= F2FS_SPEC_compress_extension;
>>>           break;
>>>       case Opt_nocompress_extension:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           name = param->string;
>>>           noext = F2FS_CTX_INFO(ctx).noextensions;
>>>           noext_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
>>> @@ -1169,26 +1096,14 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>           ctx->spec_mask |= F2FS_SPEC_nocompress_extension;
>>>           break;
>>>       case Opt_compress_chksum:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           F2FS_CTX_INFO(ctx).compress_chksum = true;
>>>           ctx->spec_mask |= F2FS_SPEC_compress_chksum;
>>>           break;
>>>       case Opt_compress_mode:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           F2FS_CTX_INFO(ctx).compress_mode = result.uint_32;
>>>           ctx->spec_mask |= F2FS_SPEC_compress_mode;
>>>           break;
>>>       case Opt_compress_cache:
>>> -        if (!f2fs_sb_has_compression(sbi)) {
>>> -            f2fs_info(NULL, "Image doesn't support compression");
>>> -            break;
>>> -        }
>>>           ctx_set_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE);
>>>           break;
>>>   #else
>>> @@ -1233,24 +1148,15 @@ static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
>>>       return 0;
>>>   }
>>>   -static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remount)
>>> +static int parse_options(struct fs_context *fc, char *options)
>>>   {
>>>       struct fs_parameter param;
>>> -    struct fs_context fc;
>>> -    struct f2fs_fs_context ctx;
>>>       char *key;
>>>       int ret;
>>>         if (!options)
>>>           return 0;
>>>   -    memset(&fc, 0, sizeof(fc));
>>> -    fc.s_fs_info = sbi;
>>> -    fc.fs_private = &ctx;
>>> -
>>> -    if (is_remount)
>>> -        fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
>>> -
>>>       while ((key = strsep(&options, ",")) != NULL) {
>>>           if (*key) {
>>>               size_t v_len = 0;
>>> @@ -1274,7 +1180,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>>>               param.key = key;
>>>               param.size = v_len;
>>>   -            ret = handle_mount_opt(&fc, &param);
>>> +            ret = handle_mount_opt(fc, &param);
>>>               kfree(param.string);
>>>               if (ret < 0)
>>>                   return ret;
>>> @@ -1283,24 +1189,298 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options, bool is_remoun
>>>       return 0;
>>>   }
>>>   -static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>>> +/*
>>> + * Check quota settings consistency.
>>> + */
>>> +static int f2fs_check_quota_consistency(struct fs_context *fc,
>>> +                    struct super_block *sb)
>>>   {
>>> -#ifdef CONFIG_QUOTA
>>> -    if (f2fs_check_quota_options(sbi))
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> + #ifdef CONFIG_QUOTA
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    bool quota_feature = f2fs_sb_has_quota_ino(sbi);
>>> +    bool quota_turnon = sb_any_quota_loaded(sb);
>>> +    char *old_qname, *new_qname;
>>> +    bool usr_qf_name, grp_qf_name, prj_qf_name, usrquota, grpquota, prjquota;
>>> +    int i;
>>> +
>>> +    /*
>>> +     * We do the test below only for project quotas. 'usrquota' and
>>> +     * 'grpquota' mount options are allowed even without quota feature
>>> +     * to support legacy quotas in quota files.
>>> +     */
>>> +    if (ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA) &&
>>> +            !f2fs_sb_has_project_quota(sbi)) {
>>> +        f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
>>>           return -EINVAL;
>>> +    }
>>> +
>>> +    if (ctx->qname_mask) {
>>> +        for (i = 0; i < MAXQUOTAS; i++) {
>>> +            if (!(ctx->qname_mask & (1 << i)))
>>> +                continue;
>>> +
>>> +            old_qname = F2FS_OPTION(sbi).s_qf_names[i];
>>> +            new_qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
>>> +            if (quota_turnon &&
>>> +                !!old_qname != !!new_qname)
>>> +                goto err_jquota_change;
>>> +
>>> +            if (old_qname) {
>>> +                if (strcmp(old_qname, new_qname) == 0) {
>>> +                    ctx->qname_mask &= ~(1 << i);
>>> +                    continue;
>>> +                }
>>> +                goto err_jquota_specified;
>>> +            }
>>> +
>>> +            if (quota_feature) {
>>> +                f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
>>> +                ctx->qname_mask &= ~(1 << i);
>>> +                kfree(F2FS_CTX_INFO(ctx).s_qf_names[i]);
>>> +                F2FS_CTX_INFO(ctx).s_qf_names[i] = NULL;
>>> +            }
>>> +        }
>>> +    }
>>> +
>>> +    /* Make sure we don't mix old and new quota format */
>>> +    usr_qf_name = F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
>>> +            F2FS_CTX_INFO(ctx).s_qf_names[USRQUOTA];
>>> +    grp_qf_name = F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
>>> +            F2FS_CTX_INFO(ctx).s_qf_names[GRPQUOTA];
>>> +    prj_qf_name = F2FS_OPTION(sbi).s_qf_names[PRJQUOTA] ||
>>> +            F2FS_CTX_INFO(ctx).s_qf_names[PRJQUOTA];
>>> +    usrquota = test_opt(sbi, USRQUOTA) ||
>>> +            ctx_test_opt(ctx, F2FS_MOUNT_USRQUOTA);
>>> +    grpquota = test_opt(sbi, GRPQUOTA) ||
>>> +            ctx_test_opt(ctx, F2FS_MOUNT_GRPQUOTA);
>>> +    prjquota = test_opt(sbi, PRJQUOTA) ||
>>> +            ctx_test_opt(ctx, F2FS_MOUNT_PRJQUOTA);
>>> +
>>> +    if (usr_qf_name) {
>>> +        ctx_clear_opt(ctx, F2FS_MOUNT_USRQUOTA);
>>> +        usrquota = false;
>>> +    }
>>> +    if (grp_qf_name) {
>>> +        ctx_clear_opt(ctx, F2FS_MOUNT_GRPQUOTA);
>>> +        grpquota = false;
>>> +    }
>>> +    if (prj_qf_name) {
>>> +        ctx_clear_opt(ctx, F2FS_MOUNT_PRJQUOTA);
>>> +        prjquota = false;
>>> +    }
>>> +    if (usr_qf_name || grp_qf_name || prj_qf_name) {
>>> +        if (grpquota || usrquota || prjquota) {
>>> +            f2fs_err(sbi, "old and new quota format mixing");
>>> +            return -EINVAL;
>>> +        }
>>> +        if (!(ctx->spec_mask & F2FS_SPEC_jqfmt ||
>>> +                F2FS_OPTION(sbi).s_jquota_fmt)) {
>>> +            f2fs_err(sbi, "journaled quota format not specified");
>>> +            return -EINVAL;
>>> +        }
>>> +    }
>>> +    return 0;
>>> +
>>> +err_jquota_change:
>>> +    f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
>>> +    return -EINVAL;
>>> +err_jquota_specified:
>>> +    f2fs_err(sbi, "%s quota file already specified",
>>> +         QTYPE2NAME(i));
>>> +    return -EINVAL;
>>> +
>>>   #else
>>> -    if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
>>> -        f2fs_info(NULL, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>>> +    if (f2fs_readonly(sbi->sb))
>>> +        return 0;
>>> +    if (f2fs_sb_has_quota_ino(sbi)) {
>>> +        f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>>>           return -EINVAL;
>>>       }
>>> -    if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
>>> -        f2fs_err(NULL, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>>> +    if (f2fs_sb_has_project_quota(sbi)) {
>>> +        f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
>>>           return -EINVAL;
>>>       }
>>> +
>>> +    return 0;
>>>   #endif
>>> +}
>>> +
>>> +static int f2fs_check_test_dummy_encryption(struct fs_context *fc,
>>> +                        struct super_block *sb)
>>> +{
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> +
>>> +    if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy))
>>> +        return 0;
>>> +
>>> +    if (!f2fs_sb_has_encrypt(sbi)) {
>>> +        f2fs_err(sbi, "Encrypt feature is off");
>>> +        return -EINVAL;
>>> +    }
>>> +
>>> +    /*
>>> +     * This mount option is just for testing, and it's not worthwhile to
>>> +     * implement the extra complexity (e.g. RCU protection) that would be
>>> +     * needed to allow it to be set or changed during remount.  We do allow
>>> +     * it to be specified during remount, but only if there is no change.
>>> +     */
>>> +    if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
>>> +        if (fscrypt_dummy_policies_equal(&F2FS_OPTION(sbi).dummy_enc_policy,
>>> +                &F2FS_CTX_INFO(ctx).dummy_enc_policy))
>>> +            return 0;
>>> +        f2fs_warn(sbi, "Can't set or change test_dummy_encryption on remount");
>>> +        return -EINVAL;
>>> +    }
>>> +    return 0;
>>> +}
>>> +
>>> +static inline bool test_compression_spec(unsigned int mask)
>>> +{
>>> +    return mask & (F2FS_SPEC_compress_algorithm
>>> +            | F2FS_SPEC_compress_log_size
>>> +            | F2FS_SPEC_compress_extension
>>> +            | F2FS_SPEC_nocompress_extension
>>> +            | F2FS_SPEC_compress_chksum
>>> +            | F2FS_SPEC_compress_mode);
>>> +}
>>> +
>>> +static inline void clear_compression_spec(struct f2fs_fs_context *ctx)
>>> +{
>>> +    ctx->spec_mask &= ~(F2FS_SPEC_compress_algorithm
>>> +                        | F2FS_SPEC_compress_log_size
>>> +                        | F2FS_SPEC_compress_extension
>>> +                        | F2FS_SPEC_nocompress_extension
>>> +                        | F2FS_SPEC_compress_chksum
>>> +                        | F2FS_SPEC_compress_mode);
>>> +}
>>> +
>>> +static int f2fs_check_compression(struct fs_context *fc,
>>> +                  struct super_block *sb)
>>> +{
>>> +#ifdef CONFIG_F2FS_FS_COMPRESSION
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> +    int i, cnt;
>>> +
>>> +    if (!f2fs_sb_has_compression(sbi)) {
>>> +        if (test_compression_spec(ctx->spec_mask) ||
>>> +            ctx_test_opt(ctx, F2FS_MOUNT_COMPRESS_CACHE))
>>> +            f2fs_info(sbi, "Image doesn't support compression");
>>> +        clear_compression_spec(ctx);
>>> +        ctx->opt_mask &= ~F2FS_MOUNT_COMPRESS_CACHE;
>>> +        return 0;
>>> +    }
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
>>> +        cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
>>> +        for (i = 0; i < F2FS_CTX_INFO(ctx).compress_ext_cnt; i++) {
>>> +            if (is_compress_extension_exist(&F2FS_OPTION(sbi),
>>> +                    F2FS_CTX_INFO(ctx).extensions[i], true)) {
>>> +                F2FS_CTX_INFO(ctx).extensions[i][0] = '\0';
>>> +                cnt--;
>>> +            }
>>> +        }
>>> +        if (F2FS_OPTION(sbi).compress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
>>> +            f2fs_err(sbi, "invalid extension length/number");
>>> +            return -EINVAL;
>>> +        }
>>> +    }
>>> +    if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
>>> +        cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
>>> +        for (i = 0; i < F2FS_CTX_INFO(ctx).nocompress_ext_cnt; i++) {
>>> +            if (is_compress_extension_exist(&F2FS_OPTION(sbi),
>>> +                    F2FS_CTX_INFO(ctx).noextensions[i], false)) {
>>> +                F2FS_CTX_INFO(ctx).noextensions[i][0] = '\0';
>>> +                cnt--;
>>> +            }
>>> +        }
>>> +        if (F2FS_OPTION(sbi).nocompress_ext_cnt + cnt > COMPRESS_EXT_NUM) {
>>> +            f2fs_err(sbi, "invalid noextension length/number");
>>> +            return -EINVAL;
>>> +        }
>>> +    }
>>> +
>>> +    if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
>>> +                F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
>>> +                F2FS_CTX_INFO(ctx).extensions,
>>> +                F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
>>> +        f2fs_err(sbi, "new noextensions conflicts with new extensions");
>>> +        return -EINVAL;
>>> +    }
>>> +    if (f2fs_test_compress_extension(F2FS_CTX_INFO(ctx).noextensions,
>>> +                F2FS_CTX_INFO(ctx).nocompress_ext_cnt,
>>> +                F2FS_OPTION(sbi).extensions,
>>> +                F2FS_OPTION(sbi).compress_ext_cnt)) {
>>> +        f2fs_err(sbi, "new noextensions conflicts with old extensions");
>>> +        return -EINVAL;
>>> +    }
>>> +    if (f2fs_test_compress_extension(F2FS_OPTION(sbi).noextensions,
>>> +                F2FS_OPTION(sbi).nocompress_ext_cnt,
>>> +                F2FS_CTX_INFO(ctx).extensions,
>>> +                F2FS_CTX_INFO(ctx).compress_ext_cnt)) {
>>> +        f2fs_err(sbi, "new extensions conflicts with old noextensions");
>>> +        return -EINVAL;
>>> +    }
>>> +#endif
>>> +    return 0;
>>> +}
>>> +
>>> +static int f2fs_check_opt_consistency(struct fs_context *fc,
>>> +                      struct super_block *sb)
>>> +{
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> +    int err;
>>> +
>>> +    if (ctx_test_opt(ctx, F2FS_MOUNT_NORECOVERY) && !f2fs_readonly(sb))
>>> +        return -EINVAL;
>>> +
>>> +    if (f2fs_hw_should_discard(sbi) &&
>>> +            (ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
>>> +            !ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
>>> +        f2fs_warn(sbi, "discard is required for zoned block devices");
>>> +        return -EINVAL;
>>> +    }
>>> +
>>> +    if (!f2fs_hw_support_discard(sbi) &&
>>> +            (ctx->opt_mask & F2FS_MOUNT_DISCARD) &&
>>> +            ctx_test_opt(ctx, F2FS_MOUNT_DISCARD)) {
>>> +        f2fs_warn(sbi, "device does not support discard");
>>> +        ctx_clear_opt(ctx, F2FS_MOUNT_DISCARD);
>>> +        ctx->opt_mask &= ~F2FS_MOUNT_DISCARD;
>>> +    }
>>> +
>>> +    if (f2fs_sb_has_device_alias(sbi) &&
>>> +            (ctx->opt_mask & F2FS_MOUNT_READ_EXTENT_CACHE) &&
>>> +            !ctx_test_opt(ctx, F2FS_MOUNT_READ_EXTENT_CACHE)) {
>>> +        f2fs_err(sbi, "device aliasing requires extent cache");
>>> +        return -EINVAL;
>>> +    }
>>> +
>>> +    if (test_opt(sbi, RESERVE_ROOT) &&
>>> +            (ctx->opt_mask & F2FS_MOUNT_RESERVE_ROOT) &&
>>> +            ctx_test_opt(ctx, F2FS_MOUNT_RESERVE_ROOT)) {
>>> +        f2fs_info(sbi, "Preserve previous reserve_root=%u",
>>> +            F2FS_OPTION(sbi).root_reserved_blocks);
>>> +        ctx_clear_opt(ctx, F2FS_MOUNT_RESERVE_ROOT);
>>> +        ctx->opt_mask &= ~F2FS_MOUNT_RESERVE_ROOT;
>>> +    }
>>> +
>>> +    err = f2fs_check_test_dummy_encryption(fc, sb);
>>> +    if (err)
>>> +        return err;
>>> +
>>> +    err = f2fs_check_compression(fc, sb);
>>> +    if (err)
>>> +        return err;
>>> +
>>> +    err = f2fs_check_quota_consistency(fc, sb);
>>> +    if (err)
>>> +        return err;
>>>         if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {
>>> -        f2fs_err(NULL,
>>> +        f2fs_err(sbi,
>>>               "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
>>>           return -EINVAL;
>>>       }
>>> @@ -1312,74 +1492,236 @@ static int f2fs_validate_options(struct f2fs_sb_info *sbi)
>>>        */
>>>       if (f2fs_sb_has_blkzoned(sbi)) {
>>>   #ifdef CONFIG_BLK_DEV_ZONED
>>> -        if (F2FS_OPTION(sbi).discard_unit !=
>>> -                        DISCARD_UNIT_SECTION) {
>>> -            f2fs_info(NULL, "Zoned block device doesn't need small discard, set discard_unit=section by default");
>>> -            F2FS_OPTION(sbi).discard_unit =
>>> -                    DISCARD_UNIT_SECTION;
>>> +        if ((ctx->spec_mask & F2FS_SPEC_discard_unit) &&
>>> +        F2FS_CTX_INFO(ctx).discard_unit != DISCARD_UNIT_SECTION) {
>>> +            f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");
>>> +            F2FS_CTX_INFO(ctx).discard_unit = DISCARD_UNIT_SECTION;
>>>           }
>>>   -        if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {
>>> -            f2fs_info(NULL, "Only lfs mode is allowed with zoned block device feature");
>>> +        if ((ctx->spec_mask & F2FS_SPEC_mode) &&
>>> +        F2FS_CTX_INFO(ctx).fs_mode != FS_MODE_LFS) {
>>> +            f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");
>>>               return -EINVAL;
>>>           }
>>>   #else
>>> -        f2fs_err(NULL, "Zoned block device support is not enabled");
>>> +        f2fs_err(sbi, "Zoned block device support is not enabled");
>>>           return -EINVAL;
>>>   #endif
>>>       }
>>>   -#ifdef CONFIG_F2FS_FS_COMPRESSION
>>> -    if (f2fs_test_compress_extension(sbi)) {
>>> -        f2fs_err(NULL, "invalid compress or nocompress extension");
>>> -        return -EINVAL;
>>> -    }
>>> -#endif
>>> -
>>> -    if (test_opt(sbi, INLINE_XATTR_SIZE)) {
>>> -        int min_size, max_size;
>>> -
>>> +    if (ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR_SIZE)) {
>>>           if (!f2fs_sb_has_extra_attr(sbi) ||
>>>               !f2fs_sb_has_flexible_inline_xattr(sbi)) {
>>> -            f2fs_err(NULL, "extra_attr or flexible_inline_xattr feature is off");
>>> +            f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
>>>               return -EINVAL;
>>>           }
>>> -        if (!test_opt(sbi, INLINE_XATTR)) {
>>> -            f2fs_err(NULL, "inline_xattr_size option should be set with inline_xattr option");
>>> -            return -EINVAL;
>>> -        }
>>> -
>>> -        min_size = MIN_INLINE_XATTR_SIZE;
>>> -        max_size = MAX_INLINE_XATTR_SIZE;
>>> -
>>> -        if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
>>> -                F2FS_OPTION(sbi).inline_xattr_size > max_size) {
>>> -            f2fs_err(NULL, "inline xattr size is out of range: %d ~ %d",
>>> -                 min_size, max_size);
>>> +        if (!ctx_test_opt(ctx, F2FS_MOUNT_INLINE_XATTR) && !test_opt(sbi, INLINE_XATTR)) {
>>> +            f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
>>>               return -EINVAL;
>>>           }
>>>       }
>>>   -    if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {
>>> -        f2fs_err(NULL, "LFS is not compatible with ATGC");
>>> +    if (ctx_test_opt(ctx, F2FS_MOUNT_ATGC) &&
>>> +        F2FS_CTX_INFO(ctx).fs_mode == FS_MODE_LFS) {
>>> +        f2fs_err(sbi, "LFS is not compatible with ATGC");
>>>           return -EINVAL;
>>>       }
>>>   -    if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {
>>> -        f2fs_err(NULL, "FLUSH_MERGE not compatible with readonly mode");
>>> +    if (f2fs_is_readonly(sbi) && ctx_test_opt(ctx, F2FS_MOUNT_FLUSH_MERGE)) {
>>> +        f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");
>>>           return -EINVAL;
>>>       }
>>>         if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
>>> -        f2fs_err(NULL, "Allow to mount readonly mode only");
>>> +        f2fs_err(sbi, "Allow to mount readonly mode only");
>>>           return -EROFS;
>>>       }
>>> +    return 0;
>>> +}
>>> +
>>> +static void f2fs_apply_quota_options(struct fs_context *fc,
>>> +                     struct super_block *sb)
>>> +{
>>> +#ifdef CONFIG_QUOTA
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> +    bool quota_feature = f2fs_sb_has_quota_ino(sbi);
>>> +    char *qname;
>>> +    int i;
>>> +
>>> +    if (quota_feature)
>>> +        return;
>>> +
>>> +    for (i = 0; i < MAXQUOTAS; i++) {
>>> +        if (!(ctx->qname_mask & (1 << i)))
>>> +            continue;
>>> +
>>> +        qname = F2FS_CTX_INFO(ctx).s_qf_names[i];
>>> +        if (qname) {
>>> +            qname = kstrdup(F2FS_CTX_INFO(ctx).s_qf_names[i],
>>> +                    GFP_KERNEL | __GFP_NOFAIL);
>>> +            set_opt(sbi, QUOTA);
>>> +        }
>>> +        F2FS_OPTION(sbi).s_qf_names[i] = qname;
>>> +    }
>>> +
>>> +    if (ctx->spec_mask & F2FS_SPEC_jqfmt)
>>> +        F2FS_OPTION(sbi).s_jquota_fmt = F2FS_CTX_INFO(ctx).s_jquota_fmt;
>>> +
>>> +    if (quota_feature && F2FS_OPTION(sbi).s_jquota_fmt) {
>>> +        f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
>>> +        F2FS_OPTION(sbi).s_jquota_fmt = 0;
>>> +    }
>>> +#endif
>>> +}
>>> +
>>> +static void f2fs_apply_test_dummy_encryption(struct fs_context *fc,
>>> +                         struct super_block *sb)
>>> +{
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> +
>>> +    if (!fscrypt_is_dummy_policy_set(&F2FS_CTX_INFO(ctx).dummy_enc_policy) ||
>>> +        /* if already set, it was already verified to be the same */
>>> +        fscrypt_is_dummy_policy_set(&F2FS_OPTION(sbi).dummy_enc_policy))
>>> +        return;
>>> +    swap(F2FS_OPTION(sbi).dummy_enc_policy, F2FS_CTX_INFO(ctx).dummy_enc_policy);
>>> +    f2fs_warn(sbi, "Test dummy encryption mode enabled");
>>> +}
>>> +
>>> +static void f2fs_apply_compression(struct fs_context *fc,
>>> +                   struct super_block *sb)
>>> +{
>>> +#ifdef CONFIG_F2FS_FS_COMPRESSION
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>> +    unsigned char (*ctx_ext)[F2FS_EXTENSION_LEN];
>>> +    unsigned char (*sbi_ext)[F2FS_EXTENSION_LEN];
>>> +    int ctx_cnt, sbi_cnt, i;
>>> +
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_level)
>>> +        F2FS_OPTION(sbi).compress_level =
>>> +                    F2FS_CTX_INFO(ctx).compress_level;
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_algorithm)
>>> +        F2FS_OPTION(sbi).compress_algorithm =
>>> +                    F2FS_CTX_INFO(ctx).compress_algorithm;
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_log_size)
>>> +        F2FS_OPTION(sbi).compress_log_size =
>>> +                    F2FS_CTX_INFO(ctx).compress_log_size;
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_chksum)
>>> +        F2FS_OPTION(sbi).compress_chksum =
>>> +                    F2FS_CTX_INFO(ctx).compress_chksum;
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_mode)
>>> +        F2FS_OPTION(sbi).compress_mode =
>>> +                    F2FS_CTX_INFO(ctx).compress_mode;
>>> +    if (ctx->spec_mask & F2FS_SPEC_compress_extension) {
>>> +        ctx_ext = F2FS_CTX_INFO(ctx).extensions;
>>> +        ctx_cnt = F2FS_CTX_INFO(ctx).compress_ext_cnt;
>>> +        sbi_ext = F2FS_OPTION(sbi).extensions;
>>> +        sbi_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
>>> +        for (i = 0; i < ctx_cnt; i++) {
>>> +            if (strlen(ctx_ext[i]) == 0)
>>> +                continue;
>>> +            strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
>>> +            sbi_cnt++;
>>> +        }
>>> +        F2FS_OPTION(sbi).compress_ext_cnt = sbi_cnt;
>>> +    }
>>> +    if (ctx->spec_mask & F2FS_SPEC_nocompress_extension) {
>>> +        ctx_ext = F2FS_CTX_INFO(ctx).noextensions;
>>> +        ctx_cnt = F2FS_CTX_INFO(ctx).nocompress_ext_cnt;
>>> +        sbi_ext = F2FS_OPTION(sbi).noextensions;
>>> +        sbi_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
>>> +        for (i = 0; i < ctx_cnt; i++) {
>>> +            if (strlen(ctx_ext[i]) == 0)
>>> +                continue;
>>> +            strscpy(sbi_ext[sbi_cnt], ctx_ext[i]);
>>> +            sbi_cnt++;
>>> +        }
>>> +        F2FS_OPTION(sbi).nocompress_ext_cnt = sbi_cnt;
>>> +    }
>>> +#endif
>>> +}
>>> +
>>> +static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
>>> +{
>>> +    struct f2fs_fs_context *ctx = fc->fs_private;
>>> +    struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>>   -    if (test_opt(sbi, NORECOVERY) && !f2fs_readonly(sbi->sb)) {
>>> -        f2fs_err(sbi, "norecovery requires readonly mount");
>>> +    F2FS_OPTION(sbi).opt &= ~ctx->opt_mask;
>>> +    F2FS_OPTION(sbi).opt |= F2FS_CTX_INFO(ctx).opt;
>>> +    sb->s_flags &= ~ctx->sflags_mask;
>>> +    sb->s_flags |= ctx->sflags;
>>> +
>>> +    if (ctx->spec_mask & F2FS_SPEC_background_gc)
>>> +        F2FS_OPTION(sbi).bggc_mode = F2FS_CTX_INFO(ctx).bggc_mode;
>>> +    if (ctx->spec_mask & F2FS_SPEC_inline_xattr_size)
>>> +        F2FS_OPTION(sbi).inline_xattr_size =
>>> +                    F2FS_CTX_INFO(ctx).inline_xattr_size;
>>> +    if (ctx->spec_mask & F2FS_SPEC_active_logs)
>>> +        F2FS_OPTION(sbi).active_logs = F2FS_CTX_INFO(ctx).active_logs;
>>> +    if (ctx->spec_mask & F2FS_SPEC_reserve_root)
>>> +        F2FS_OPTION(sbi).root_reserved_blocks =
>>> +                    F2FS_CTX_INFO(ctx).root_reserved_blocks;
>>> +    if (ctx->spec_mask & F2FS_SPEC_resgid)
>>> +        F2FS_OPTION(sbi).s_resgid = F2FS_CTX_INFO(ctx).s_resgid;
>>> +    if (ctx->spec_mask & F2FS_SPEC_resuid)
>>> +        F2FS_OPTION(sbi).s_resuid = F2FS_CTX_INFO(ctx).s_resuid;
>>> +    if (ctx->spec_mask & F2FS_SPEC_mode)
>>> +        F2FS_OPTION(sbi).fs_mode = F2FS_CTX_INFO(ctx).fs_mode;
>>> +#ifdef CONFIG_F2FS_FAULT_INJECTION
>>> +    if (ctx->spec_mask & F2FS_SPEC_fault_injection)
>>> +        (void)f2fs_build_fault_attr(sbi,
>>> +        F2FS_CTX_INFO(ctx).fault_info.inject_rate, 0, FAULT_RATE);
>>> +    if (ctx->spec_mask & F2FS_SPEC_fault_type)
>>> +        (void)f2fs_build_fault_attr(sbi, 0,
>>> +            F2FS_CTX_INFO(ctx).fault_info.inject_type, FAULT_TYPE);
>>> +#endif
>>> +    if (ctx->spec_mask & F2FS_SPEC_alloc_mode)
>>> +        F2FS_OPTION(sbi).alloc_mode = F2FS_CTX_INFO(ctx).alloc_mode;
>>> +    if (ctx->spec_mask & F2FS_SPEC_fsync_mode)
>>> +        F2FS_OPTION(sbi).fsync_mode = F2FS_CTX_INFO(ctx).fsync_mode;
>>> +    if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap)
>>> +        F2FS_OPTION(sbi).unusable_cap = F2FS_CTX_INFO(ctx).unusable_cap;
>>> +    if (ctx->spec_mask & F2FS_SPEC_checkpoint_disable_cap_perc)
>>> +        F2FS_OPTION(sbi).unusable_cap_perc =
>>> +                    F2FS_CTX_INFO(ctx).unusable_cap_perc;
>>> +    if (ctx->spec_mask & F2FS_SPEC_discard_unit)
>>> +        F2FS_OPTION(sbi).discard_unit = F2FS_CTX_INFO(ctx).discard_unit;
>>> +    if (ctx->spec_mask & F2FS_SPEC_memory_mode)
>>> +        F2FS_OPTION(sbi).memory_mode = F2FS_CTX_INFO(ctx).memory_mode;
>>> +    if (ctx->spec_mask & F2FS_SPEC_errors)
>>> +        F2FS_OPTION(sbi).errors = F2FS_CTX_INFO(ctx).errors;
>>> +
>>> +    f2fs_apply_compression(fc, sb);
>>> +    f2fs_apply_test_dummy_encryption(fc, sb);
>>> +    f2fs_apply_quota_options(fc, sb);
>>> +}
>>> +
>>> +static int f2fs_sanity_check_options(struct f2fs_sb_info *sbi, bool remount)
>>> +{
>>> +    if (f2fs_sb_has_device_alias(sbi) &&
>>> +        !test_opt(sbi, READ_EXTENT_CACHE)) {
>>> +        f2fs_err(sbi, "device aliasing requires extent cache");
>>>           return -EINVAL;
>>>       }
>>>   +    if (!remount)
>>> +        return 0;
>>> +
>>> +#ifdef CONFIG_BLK_DEV_ZONED
>>> +    if (f2fs_sb_has_blkzoned(sbi) &&
>>> +        sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
>>> +        f2fs_err(sbi,
>>> +            "zoned: max open zones %u is too small, need at least %u open zones",
>>> +                 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
>>> +        return -EINVAL;
>>> +    }
>>> +#endif
>>> +    if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
>>> +        f2fs_warn(sbi, "LFS is not compatible with IPU");
>>> +        return -EINVAL;
>>> +    }
>>>       return 0;
>>>   }
>>>   @@ -2290,6 +2632,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>>   {
>>>       struct f2fs_sb_info *sbi = F2FS_SB(sb);
>>>       struct f2fs_mount_info org_mount_opt;
>>> +    struct f2fs_fs_context ctx;
>>> +    struct fs_context fc;
>>>       unsigned long old_sb_flags;
>>>       int err;
>>>       bool need_restart_gc = false, need_stop_gc = false;
>>> @@ -2346,23 +2690,23 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>>         default_options(sbi, true);
>>>   +    memset(&fc, 0, sizeof(fc));
>>> +    memset(&ctx, 0, sizeof(ctx));
>>> +    fc.fs_private = &ctx;
>>> +    fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
>>> +
>>>       /* parse mount options */
>>> -    err = parse_options(sbi, data, true);
>>> +    err = parse_options(&fc, data);
>>>       if (err)
>>>           goto restore_opts;
>>>   -#ifdef CONFIG_BLK_DEV_ZONED
>>> -    if (f2fs_sb_has_blkzoned(sbi) &&
>>> -        sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
>>> -        f2fs_err(sbi,
>>> -            "zoned: max open zones %u is too small, need at least %u open zones",
>>> -                 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
>>> -        err = -EINVAL;
>>> +    err = f2fs_check_opt_consistency(&fc, sb);
>>> +    if (err)
>>>           goto restore_opts;
>>> -    }
>>> -#endif
>>>   -    err = f2fs_validate_options(sbi);
>>> +    f2fs_apply_options(&fc, sb);
>>> +
>>> +    err = f2fs_sanity_check_options(sbi, true);
>>>       if (err)
>>>           goto restore_opts;
>>>   @@ -2398,12 +2742,6 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
>>>           }
>>>       }
>>>   #endif
>>> -    if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
>>> -        err = -EINVAL;
>>> -        f2fs_warn(sbi, "LFS is not compatible with IPU");
>>> -        goto restore_opts;
>>> -    }
>>> -
>>>       /* disallow enable atgc dynamically */
>>>       if (no_atgc == !!test_opt(sbi, ATGC)) {
>>>           err = -EINVAL;
>>> @@ -4483,6 +4821,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>>   {
>>>       struct f2fs_sb_info *sbi;
>>>       struct f2fs_super_block *raw_super;
>>> +    struct f2fs_fs_context ctx;
>>> +    struct fs_context fc;
>>>       struct inode *root;
>>>       int err;
>>>       bool skip_recovery = false, need_fsck = false;
>>> @@ -4499,6 +4839,9 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>>       raw_super = NULL;
>>>       valid_super_block = -1;
>>>       recovery = 0;
>>> +    memset(&fc, 0, sizeof(fc));
>>> +    memset(&ctx, 0, sizeof(ctx));
>>> +    fc.fs_private = &ctx;
>>>         /* allocate memory for f2fs-specific super block info */
>>>       sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
>>> @@ -4556,11 +4899,17 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>>           goto free_sb_buf;
>>>       }
>>>   -    err = parse_options(sbi, options, false);
>>> +    err = parse_options(&fc, options);
>>>       if (err)
>>>           goto free_options;
>>>   -    err = f2fs_validate_options(sbi);
>>> +    err = f2fs_check_opt_consistency(&fc, sb);
>>> +    if (err)
>>> +        goto free_options;
>>> +
>>> +    f2fs_apply_options(&fc, sb);
>>> +
>>> +    err = f2fs_sanity_check_options(sbi, false);
>>>       if (err)
>>>           goto free_options;
>>>   @@ -4981,7 +5330,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>>>       for (i = 0; i < MAXQUOTAS; i++)
>>>           kfree(F2FS_OPTION(sbi).s_qf_names[i]);
>>>   #endif
>>> -    fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
>>> +    /* no need to free dummy_enc_policy, we just keep it in ctx when failed */
>>> +    swap(F2FS_CTX_INFO(&ctx).dummy_enc_policy, F2FS_OPTION(sbi).dummy_enc_policy);
>>
>> I can see ext4 will free dummy_enc_policy in error path of fill_super, is
>> there any difference?
>>
> 
> We can not free dummy_enc_policy in f2fs, due to the try_onemore logical. So here we rollback the assign and keep the dummy_enc_policy in ctx, and free it only when ctx is no longer used.

Got it, thanks for your explanation.

Thanks,

> 
> Thanks,
> Hongbo
> 
>> Thanks,
>>
>>>       kvfree(options);
>>>   free_sb_buf:
>>>       kfree(raw_super);
>>
>>

[PATCH v4 6/7] f2fs: introduce fs_context_operation structure

[Hongbo Li]

The handle_mount_opt() helper is used to parse mount parameters,
and so we can rename this function to f2fs_parse_param() and set
it as .param_param in fs_context_operations.

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
---
 fs/f2fs/super.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 9835e7cd1071..c503b7b92482 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -709,7 +709,7 @@ static int f2fs_set_zstd_level(struct f2fs_fs_context *ctx, const char *str)
 #endif
 #endif
 
-static int handle_mount_opt(struct fs_context *fc, struct fs_parameter *param)
+static int f2fs_parse_param(struct fs_context *fc, struct fs_parameter *param)
 {
 	struct f2fs_fs_context *ctx = fc->fs_private;
 #ifdef CONFIG_F2FS_FS_COMPRESSION
@@ -1180,7 +1180,7 @@ static int parse_options(struct fs_context *fc, char *options)
 			param.key = key;
 			param.size = v_len;
 
-			ret = handle_mount_opt(fc, &param);
+			ret = f2fs_parse_param(fc, &param);
 			kfree(param.string);
 			if (ret < 0)
 				return ret;
@@ -5354,6 +5354,10 @@ static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
 	return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
 }
 
+static const struct fs_context_operations f2fs_context_ops = {
+	.parse_param	= f2fs_parse_param,
+};
+
 static void kill_f2fs_super(struct super_block *sb)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(sb);
-- 
2.33.0

[PATCH v4 7/7] f2fs: switch to the new mount api

[Hongbo Li]

The new mount api will execute .parse_param, .init_fs_context, .get_tree
and will call .remount if remount happened. So we add the necessary
functions for the fs_context_operations. If .init_fs_context is added,
the old .mount should remove.

See Documentation/filesystems/mount_api.rst for more information.

Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
[sandeen: forward port]
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
[hongbo: context modified]
Signed-off-by: Hongbo Li <lihongbo22@huawei.com>
---
 fs/f2fs/super.c | 165 ++++++++++++++++++++----------------------------
 1 file changed, 70 insertions(+), 95 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index c503b7b92482..0a070dadbb42 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -541,6 +541,14 @@ static int f2fs_unnote_qf_name(struct fs_context *fc, int qtype)
 	ctx->qname_mask |= 1 << qtype;
 	return 0;
 }
+
+static void f2fs_unnote_qf_name_all(struct fs_context *fc)
+{
+	int i;
+
+	for (i = 0; i < MAXQUOTAS; i++)
+		f2fs_unnote_qf_name(fc, i);
+}
 #endif
 
 static int f2fs_parse_test_dummy_encryption(const struct fs_parameter *param,
@@ -1148,47 +1156,6 @@ static int f2fs_parse_param(struct fs_context *fc, struct fs_parameter *param)
 	return 0;
 }
 
-static int parse_options(struct fs_context *fc, char *options)
-{
-	struct fs_parameter param;
-	char *key;
-	int ret;
-
-	if (!options)
-		return 0;
-
-	while ((key = strsep(&options, ",")) != NULL) {
-		if (*key) {
-			size_t v_len = 0;
-			char *value = strchr(key, '=');
-
-			param.type = fs_value_is_flag;
-			param.string = NULL;
-
-			if (value) {
-				if (value == key)
-					continue;
-
-				*value++ = 0;
-				v_len = strlen(value);
-				param.string = kmemdup_nul(value, v_len, GFP_KERNEL);
-				if (!param.string)
-					return -ENOMEM;
-				param.type = fs_value_is_string;
-			}
-
-			param.key = key;
-			param.size = v_len;
-
-			ret = f2fs_parse_param(fc, &param);
-			kfree(param.string);
-			if (ret < 0)
-				return ret;
-		}
-	}
-	return 0;
-}
-
 /*
  * Check quota settings consistency.
  */
@@ -2628,13 +2595,12 @@ static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
 	f2fs_flush_ckpt_thread(sbi);
 }
 
-static int f2fs_remount(struct super_block *sb, int *flags, char *data)
+static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(sb);
 	struct f2fs_mount_info org_mount_opt;
-	struct f2fs_fs_context ctx;
-	struct fs_context fc;
 	unsigned long old_sb_flags;
+	unsigned int flags = fc->sb_flags;
 	int err;
 	bool need_restart_gc = false, need_stop_gc = false;
 	bool need_restart_flush = false, need_stop_flush = false;
@@ -2680,7 +2646,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 #endif
 
 	/* recover superblocks we couldn't write due to previous RO mount */
-	if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
+	if (!(flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
 		err = f2fs_commit_super(sbi, false);
 		f2fs_info(sbi, "Try to recover all the superblocks, ret: %d",
 			  err);
@@ -2690,21 +2656,11 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 
 	default_options(sbi, true);
 
-	memset(&fc, 0, sizeof(fc));
-	memset(&ctx, 0, sizeof(ctx));
-	fc.fs_private = &ctx;
-	fc.purpose = FS_CONTEXT_FOR_RECONFIGURE;
-
-	/* parse mount options */
-	err = parse_options(&fc, data);
+	err = f2fs_check_opt_consistency(fc, sb);
 	if (err)
 		goto restore_opts;
 
-	err = f2fs_check_opt_consistency(&fc, sb);
-	if (err)
-		goto restore_opts;
-
-	f2fs_apply_options(&fc, sb);
+	f2fs_apply_options(fc, sb);
 
 	err = f2fs_sanity_check_options(sbi, true);
 	if (err)
@@ -2717,20 +2673,20 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	 * Previous and new state of filesystem is RO,
 	 * so skip checking GC and FLUSH_MERGE conditions.
 	 */
-	if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
+	if (f2fs_readonly(sb) && (flags & SB_RDONLY))
 		goto skip;
 
-	if (f2fs_dev_is_readonly(sbi) && !(*flags & SB_RDONLY)) {
+	if (f2fs_dev_is_readonly(sbi) && !(flags & SB_RDONLY)) {
 		err = -EROFS;
 		goto restore_opts;
 	}
 
 #ifdef CONFIG_QUOTA
-	if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
+	if (!f2fs_readonly(sb) && (flags & SB_RDONLY)) {
 		err = dquot_suspend(sb, -1);
 		if (err < 0)
 			goto restore_opts;
-	} else if (f2fs_readonly(sb) && !(*flags & SB_RDONLY)) {
+	} else if (f2fs_readonly(sb) && !(flags & SB_RDONLY)) {
 		/* dquot_resume needs RW */
 		sb->s_flags &= ~SB_RDONLY;
 		if (sb_any_quota_suspended(sb)) {
@@ -2780,7 +2736,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		goto restore_opts;
 	}
 
-	if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
+	if ((flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
 		err = -EINVAL;
 		f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");
 		goto restore_opts;
@@ -2791,7 +2747,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	 * or if background_gc = off is passed in mount
 	 * option. Also sync the filesystem.
 	 */
-	if ((*flags & SB_RDONLY) ||
+	if ((flags & SB_RDONLY) ||
 			(F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF &&
 			!test_opt(sbi, GC_MERGE))) {
 		if (sbi->gc_thread) {
@@ -2805,7 +2761,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		need_stop_gc = true;
 	}
 
-	if (*flags & SB_RDONLY) {
+	if (flags & SB_RDONLY) {
 		sync_inodes_sb(sb);
 
 		set_sbi_flag(sbi, SBI_IS_DIRTY);
@@ -2818,7 +2774,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	 * We stop issue flush thread if FS is mounted as RO
 	 * or if flush_merge is not passed in mount option.
 	 */
-	if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
+	if ((flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
 		clear_opt(sbi, FLUSH_MERGE);
 		f2fs_destroy_flush_cmd_control(sbi, false);
 		need_restart_flush = true;
@@ -2860,7 +2816,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	 * triggered while remount and we need to take care of it before
 	 * returning from remount.
 	 */
-	if ((*flags & SB_RDONLY) || test_opt(sbi, DISABLE_CHECKPOINT) ||
+	if ((flags & SB_RDONLY) || test_opt(sbi, DISABLE_CHECKPOINT) ||
 			!test_opt(sbi, MERGE_CHECKPOINT)) {
 		f2fs_stop_ckpt_thread(sbi);
 	} else {
@@ -2887,7 +2843,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		(test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
 
 	limit_reserve_root(sbi);
-	*flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
+	fc->sb_flags = (flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
 
 	sbi->umount_lock_holder = NULL;
 	return 0;
@@ -3558,7 +3514,6 @@ static const struct super_operations f2fs_sops = {
 	.freeze_fs	= f2fs_freeze,
 	.unfreeze_fs	= f2fs_unfreeze,
 	.statfs		= f2fs_statfs,
-	.remount_fs	= f2fs_remount,
 	.shutdown	= f2fs_shutdown,
 };
 
@@ -4817,16 +4772,14 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
 	sbi->readdir_ra = true;
 }
 
-static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
+static int f2fs_fill_super(struct super_block *sb, struct fs_context *fc)
 {
+	struct f2fs_fs_context *ctx = fc->fs_private;
 	struct f2fs_sb_info *sbi;
 	struct f2fs_super_block *raw_super;
-	struct f2fs_fs_context ctx;
-	struct fs_context fc;
 	struct inode *root;
 	int err;
 	bool skip_recovery = false, need_fsck = false;
-	char *options = NULL;
 	int recovery, i, valid_super_block;
 	struct curseg_info *seg_i;
 	int retry_cnt = 1;
@@ -4839,9 +4792,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 	raw_super = NULL;
 	valid_super_block = -1;
 	recovery = 0;
-	memset(&fc, 0, sizeof(fc));
-	memset(&ctx, 0, sizeof(ctx));
-	fc.fs_private = &ctx;
 
 	/* allocate memory for f2fs-specific super block info */
 	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
@@ -4892,22 +4842,12 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 						 sizeof(raw_super->uuid));
 
 	default_options(sbi, false);
-	/* parse mount options */
-	options = kstrdup((const char *)data, GFP_KERNEL);
-	if (data && !options) {
-		err = -ENOMEM;
-		goto free_sb_buf;
-	}
 
-	err = parse_options(&fc, options);
+	err = f2fs_check_opt_consistency(fc, sb);
 	if (err)
-		goto free_options;
-
-	err = f2fs_check_opt_consistency(&fc, sb);
-	if (err)
-		goto free_options;
+		goto free_sb_buf;
 
-	f2fs_apply_options(&fc, sb);
+	f2fs_apply_options(fc, sb);
 
 	err = f2fs_sanity_check_options(sbi, false);
 	if (err)
@@ -5236,7 +5176,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 		if (err)
 			goto sync_free_meta;
 	}
-	kvfree(options);
 
 	/* recover broken superblock */
 	if (recovery) {
@@ -5331,8 +5270,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 		kfree(F2FS_OPTION(sbi).s_qf_names[i]);
 #endif
 	/* no need to free dummy_enc_policy, we just keep it in ctx when failed */
-	swap(F2FS_CTX_INFO(&ctx).dummy_enc_policy, F2FS_OPTION(sbi).dummy_enc_policy);
-	kvfree(options);
+	swap(F2FS_CTX_INFO(ctx).dummy_enc_policy, F2FS_OPTION(sbi).dummy_enc_policy);
 free_sb_buf:
 	kfree(raw_super);
 free_sbi:
@@ -5348,14 +5286,37 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
 	return err;
 }
 
-static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
-			const char *dev_name, void *data)
+static int f2fs_get_tree(struct fs_context *fc)
+{
+	return get_tree_bdev(fc, f2fs_fill_super);
+}
+
+static int f2fs_reconfigure(struct fs_context *fc)
+{
+	struct super_block *sb = fc->root->d_sb;
+
+	return __f2fs_remount(fc, sb);
+}
+
+static void f2fs_fc_free(struct fs_context *fc)
 {
-	return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
+	struct f2fs_fs_context *ctx = fc->fs_private;
+
+	if (!ctx)
+		return;
+
+#ifdef CONFIG_QUOTA
+	f2fs_unnote_qf_name_all(fc);
+#endif
+	fscrypt_free_dummy_policy(&F2FS_CTX_INFO(ctx).dummy_enc_policy);
+	kfree(ctx);
 }
 
 static const struct fs_context_operations f2fs_context_ops = {
 	.parse_param	= f2fs_parse_param,
+	.get_tree	= f2fs_get_tree,
+	.reconfigure = f2fs_reconfigure,
+	.free	= f2fs_fc_free,
 };
 
 static void kill_f2fs_super(struct super_block *sb)
@@ -5399,10 +5360,24 @@ static void kill_f2fs_super(struct super_block *sb)
 	}
 }
 
+static int f2fs_init_fs_context(struct fs_context *fc)
+{
+	struct f2fs_fs_context *ctx;
+
+	ctx = kzalloc(sizeof(struct f2fs_fs_context), GFP_KERNEL);
+	if (!ctx)
+		return -ENOMEM;
+
+	fc->fs_private = ctx;
+	fc->ops = &f2fs_context_ops;
+
+	return 0;
+}
+
 static struct file_system_type f2fs_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "f2fs",
-	.mount		= f2fs_mount,
+	.init_fs_context = f2fs_init_fs_context,
 	.kill_sb	= kill_f2fs_super,
 	.fs_flags	= FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
 };
-- 
2.33.0

Re: [PATCH v4 0/7] f2fs: new mount API conversion

[Jaegeuk Kim]

Thanks you, Hongbo.

I just applied this series to the dev-test branch as below, and will
keep testing with incoming patches together. Let's see. :)

https://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git/log/?h=dev-test

On 06/02, Hongbo Li wrote:
> In this version, we have finished the issues pointed in v3.
> First, I'd like to express my sincere thanks to Jaegeuk and Chao
> for reviewing this patch series and providing corrections. I also
> appreciate Eric for rebasing the patches onto the latest branch to
> ensure forward compatibility.
> 
> The latest patch series has addressed all the issues mentioned in
> the previous set. For modified patches, I've re-added Signed-off-by
> tags (SOB) and uniformly removed all Reviewed-by tags.
> 
> v4:
>   - Change is_remount as bool type in patch 2.
>   - Remove the warning reported by Dan for patch 5.
>   - Enhance sanity check and fix some coding style suggested by
>     Jaegeuk in patch 5.
>   - Change the log info when compression option conflicts in patch 5.
>   - Fix the issues reported by code-reviewing in patch 5.
>   - Context modified in patch 7.
> 
> V3: https://lore.kernel.org/all/20250423170926.76007-1-sandeen@redhat.com/
> - Rebase onto git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
>   dev branch
> - Fix up some 0day robot warnings
> 
> (Here is the origianl cover letter:)
> 
> Since many filesystems have done the new mount API conversion,
> we introduce the new mount API conversion in f2fs.
> 
> The series can be applied on top of the current mainline tree
> and the work is based on the patches from Lukas Czerner (has
> done this in ext4[1]). His patch give me a lot of ideas.
> 
> Here is a high level description of the patchset:
> 
> 1. Prepare the f2fs mount parameters required by the new mount
> API and use it for parsing, while still using the old API to
> get mount options string. Split the parameter parsing and
> validation of the parse_options helper into two separate
> helpers.
> 
>   f2fs: Add fs parameter specifications for mount options
>   f2fs: move the option parser into handle_mount_opt
> 
> 2. Remove the use of sb/sbi structure of f2fs from all the
> parsing code, because with the new mount API the parsing is
> going to be done before we even get the super block. In this
> part, we introduce f2fs_fs_context to hold the temporary
> options when parsing. For the simple options check, it has
> to be done during parsing by using f2fs_fs_context structure.
> For the check which needs sb/sbi, we do this during super
> block filling.
> 
>   f2fs: Allow sbi to be NULL in f2fs_printk
>   f2fs: Add f2fs_fs_context to record the mount options
>   f2fs: separate the options parsing and options checking
> 
> 3. Switch the f2fs to use the new mount API for mount and
> remount.
> 
>   f2fs: introduce fs_context_operation structure
>   f2fs: switch to the new mount api
> 
> [1] https://lore.kernel.org/all/20211021114508.21407-1-lczerner@redhat.com/
> 
> Hongbo Li (7):
>   f2fs: Add fs parameter specifications for mount options
>   f2fs: move the option parser into handle_mount_opt
>   f2fs: Allow sbi to be NULL in f2fs_printk
>   f2fs: Add f2fs_fs_context to record the mount options
>   f2fs: separate the options parsing and options checking
>   f2fs: introduce fs_context_operation structure
>   f2fs: switch to the new mount api
> 
>  fs/f2fs/super.c | 2108 +++++++++++++++++++++++++++--------------------
>  1 file changed, 1197 insertions(+), 911 deletions(-)
> 
> -- 
> 2.33.0

Re: [PATCH v4 0/7] f2fs: new mount API conversion

[Hongbo Li]

On 2025/6/3 0:05, Jaegeuk Kim wrote:
> Thanks you, Hongbo.
> 
> I just applied this series to the dev-test branch as below, and will
> keep testing with incoming patches together. Let's see. :)
> 
> https://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git/log/?h=dev-test
> 
Ok, I will keep following up on this work with Eric.

Thanks,
Hongbo

> On 06/02, Hongbo Li wrote:
>> In this version, we have finished the issues pointed in v3.
>> First, I'd like to express my sincere thanks to Jaegeuk and Chao
>> for reviewing this patch series and providing corrections. I also
>> appreciate Eric for rebasing the patches onto the latest branch to
>> ensure forward compatibility.
>>
>> The latest patch series has addressed all the issues mentioned in
>> the previous set. For modified patches, I've re-added Signed-off-by
>> tags (SOB) and uniformly removed all Reviewed-by tags.
>>
>> v4:
>>    - Change is_remount as bool type in patch 2.
>>    - Remove the warning reported by Dan for patch 5.
>>    - Enhance sanity check and fix some coding style suggested by
>>      Jaegeuk in patch 5.
>>    - Change the log info when compression option conflicts in patch 5.
>>    - Fix the issues reported by code-reviewing in patch 5.
>>    - Context modified in patch 7.
>>
>> V3: https://lore.kernel.org/all/20250423170926.76007-1-sandeen@redhat.com/
>> - Rebase onto git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
>>    dev branch
>> - Fix up some 0day robot warnings
>>
>> (Here is the origianl cover letter:)
>>
>> Since many filesystems have done the new mount API conversion,
>> we introduce the new mount API conversion in f2fs.
>>
>> The series can be applied on top of the current mainline tree
>> and the work is based on the patches from Lukas Czerner (has
>> done this in ext4[1]). His patch give me a lot of ideas.
>>
>> Here is a high level description of the patchset:
>>
>> 1. Prepare the f2fs mount parameters required by the new mount
>> API and use it for parsing, while still using the old API to
>> get mount options string. Split the parameter parsing and
>> validation of the parse_options helper into two separate
>> helpers.
>>
>>    f2fs: Add fs parameter specifications for mount options
>>    f2fs: move the option parser into handle_mount_opt
>>
>> 2. Remove the use of sb/sbi structure of f2fs from all the
>> parsing code, because with the new mount API the parsing is
>> going to be done before we even get the super block. In this
>> part, we introduce f2fs_fs_context to hold the temporary
>> options when parsing. For the simple options check, it has
>> to be done during parsing by using f2fs_fs_context structure.
>> For the check which needs sb/sbi, we do this during super
>> block filling.
>>
>>    f2fs: Allow sbi to be NULL in f2fs_printk
>>    f2fs: Add f2fs_fs_context to record the mount options
>>    f2fs: separate the options parsing and options checking
>>
>> 3. Switch the f2fs to use the new mount API for mount and
>> remount.
>>
>>    f2fs: introduce fs_context_operation structure
>>    f2fs: switch to the new mount api
>>
>> [1] https://lore.kernel.org/all/20211021114508.21407-1-lczerner@redhat.com/
>>
>> Hongbo Li (7):
>>    f2fs: Add fs parameter specifications for mount options
>>    f2fs: move the option parser into handle_mount_opt
>>    f2fs: Allow sbi to be NULL in f2fs_printk
>>    f2fs: Add f2fs_fs_context to record the mount options
>>    f2fs: separate the options parsing and options checking
>>    f2fs: introduce fs_context_operation structure
>>    f2fs: switch to the new mount api
>>
>>   fs/f2fs/super.c | 2108 +++++++++++++++++++++++++++--------------------
>>   1 file changed, 1197 insertions(+), 911 deletions(-)
>>
>> -- 
>> 2.33.0