From f8e77914dac472d6a8a2f4e2d3da67f056581630 Mon Sep 17 00:00:00 2001 From: Al Viro Date: Thu, 16 Jan 2025 23:47:14 -0500 Subject: [PATCH 1/3] ufs: split ->s_mount_opt - don't mix flavour and on-error Signed-off-by: Al Viro --- fs/ufs/super.c | 95 +++++++++++++++++++++----------------------------- fs/ufs/ufs.h | 9 ++--- 2 files changed, 42 insertions(+), 62 deletions(-) diff --git a/fs/ufs/super.c b/fs/ufs/super.c index 762699c1bcf6..6a3a11c7e8ca 100644 --- a/fs/ufs/super.c +++ b/fs/ufs/super.c @@ -289,7 +289,7 @@ void ufs_error (struct super_block * sb, const char * function, va_start(args, fmt); vaf.fmt = fmt; vaf.va = &args; - switch (UFS_SB(sb)->s_mount_opt & UFS_MOUNT_ONERROR) { + switch (UFS_SB(sb)->s_on_err) { case UFS_MOUNT_ONERROR_PANIC: panic("panic (device %s): %s: %pV\n", sb->s_id, function, &vaf); @@ -380,7 +380,7 @@ static const match_table_t tokens = { {Opt_err, NULL} }; -static int ufs_parse_options (char * options, unsigned * mount_options) +static int ufs_parse_options(char *options, unsigned *flavour, unsigned *on_err) { char * p; @@ -398,61 +398,47 @@ static int ufs_parse_options (char * options, unsigned * mount_options) token = match_token(p, tokens, args); switch (token) { case Opt_type_old: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_OLD); + *flavour = UFS_MOUNT_UFSTYPE_OLD; break; case Opt_type_sunx86: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_SUNx86); + *flavour = UFS_MOUNT_UFSTYPE_SUNx86; break; case Opt_type_sun: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_SUN); + *flavour = UFS_MOUNT_UFSTYPE_SUN; break; case Opt_type_sunos: - ufs_clear_opt(*mount_options, UFSTYPE); - ufs_set_opt(*mount_options, UFSTYPE_SUNOS); + *flavour = UFS_MOUNT_UFSTYPE_SUNOS; break; case Opt_type_44bsd: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_44BSD); + *flavour = UFS_MOUNT_UFSTYPE_44BSD; break; case Opt_type_ufs2: - ufs_clear_opt(*mount_options, UFSTYPE); - ufs_set_opt(*mount_options, UFSTYPE_UFS2); + *flavour = UFS_MOUNT_UFSTYPE_UFS2; break; case Opt_type_hp: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_HP); + *flavour = UFS_MOUNT_UFSTYPE_HP; break; case Opt_type_nextstepcd: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD); + *flavour = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD; break; case Opt_type_nextstep: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP); + *flavour = UFS_MOUNT_UFSTYPE_NEXTSTEP; break; case Opt_type_openstep: - ufs_clear_opt (*mount_options, UFSTYPE); - ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP); + *flavour = UFS_MOUNT_UFSTYPE_OPENSTEP; break; case Opt_onerror_panic: - ufs_clear_opt (*mount_options, ONERROR); - ufs_set_opt (*mount_options, ONERROR_PANIC); + *on_err = UFS_MOUNT_ONERROR_PANIC; break; case Opt_onerror_lock: - ufs_clear_opt (*mount_options, ONERROR); - ufs_set_opt (*mount_options, ONERROR_LOCK); + *on_err = UFS_MOUNT_ONERROR_LOCK; break; case Opt_onerror_umount: - ufs_clear_opt (*mount_options, ONERROR); - ufs_set_opt (*mount_options, ONERROR_UMOUNT); + *on_err = UFS_MOUNT_ONERROR_UMOUNT; break; case Opt_onerror_repair: + *on_err = UFS_MOUNT_ONERROR_REPAIR; pr_err("Unable to do repair on error, will lock lock instead\n"); - ufs_clear_opt (*mount_options, ONERROR); - ufs_set_opt (*mount_options, ONERROR_REPAIR); break; default: pr_err("Invalid option: \"%s\" or missing value\n", p); @@ -474,7 +460,7 @@ static void ufs_setup_cstotal(struct super_block *sb) struct ufs_super_block_first *usb1; struct ufs_super_block_second *usb2; struct ufs_super_block_third *usb3; - unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE; + unsigned mtype = sbi->s_flavour; UFSD("ENTER, mtype=%u\n", mtype); usb1 = ubh_get_usb_first(uspi); @@ -580,7 +566,7 @@ failed: */ static void ufs_put_cstotal(struct super_block *sb) { - unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE; + unsigned mtype = UFS_SB(sb)->s_flavour; struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi; struct ufs_super_block_first *usb1; struct ufs_super_block_second *usb2; @@ -807,20 +793,20 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) * Set default mount options * Parse mount options */ - sbi->s_mount_opt = 0; - ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK); - if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) { + sbi->s_flavour = 0; + sbi->s_on_err = UFS_MOUNT_ONERROR_LOCK; + if (!ufs_parse_options(data, &sbi->s_flavour, &sbi->s_on_err)) { pr_err("wrong mount options\n"); goto failed; } - if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) { + if (!sbi->s_flavour) { if (!silent) pr_err("You didn't specify the type of your ufs filesystem\n\n" "mount -t ufs -o ufstype=" "sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n" ">>>WARNING<<< Wrong ufstype may corrupt your filesystem, " "default is ufstype=old\n"); - ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD); + sbi->s_flavour = UFS_MOUNT_UFSTYPE_OLD; } uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL); @@ -836,7 +822,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) sb->s_time_min = S32_MIN; sb->s_time_max = S32_MAX; - switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) { + switch (sbi->s_flavour) { case UFS_MOUNT_UFSTYPE_44BSD: UFSD("ufstype=44bsd\n"); uspi->s_fsize = block_size = 512; @@ -1035,9 +1021,9 @@ again: goto magic_found; } - if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP) - || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD) - || ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP)) + if ((sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP + || sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD + || sbi->s_flavour == UFS_MOUNT_UFSTYPE_OPENSTEP) && uspi->s_sbbase < 256) { ubh_brelse_uspi(uspi); ubh = NULL; @@ -1237,8 +1223,8 @@ magic_found: uspi->s_bpf = uspi->s_fsize << 3; uspi->s_bpfshift = uspi->s_fshift + 3; uspi->s_bpfmask = uspi->s_bpf - 1; - if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD || - (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2) + if (sbi->s_flavour == UFS_MOUNT_UFSTYPE_44BSD || + sbi->s_flavour == UFS_MOUNT_UFSTYPE_UFS2) uspi->s_maxsymlinklen = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen); @@ -1295,7 +1281,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) struct ufs_sb_private_info * uspi; struct ufs_super_block_first * usb1; struct ufs_super_block_third * usb3; - unsigned new_mount_opt, ufstype; + unsigned on_err, ufstype; unsigned flags; sync_filesystem(sb); @@ -1309,23 +1295,22 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) * Allow the "check" option to be passed as a remount option. * It is not possible to change ufstype option during remount */ - ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE; - new_mount_opt = 0; - ufs_set_opt (new_mount_opt, ONERROR_LOCK); - if (!ufs_parse_options (data, &new_mount_opt)) { + ufstype = 0; + on_err = UFS_MOUNT_ONERROR_LOCK; + if (!ufs_parse_options(data, &ufstype, &on_err)) { mutex_unlock(&UFS_SB(sb)->s_lock); return -EINVAL; } - if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) { - new_mount_opt |= ufstype; - } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) { + if (!ufstype) + ufstype = UFS_SB(sb)->s_flavour; + else if (ufstype != UFS_SB(sb)->s_flavour) { pr_err("ufstype can't be changed during remount\n"); mutex_unlock(&UFS_SB(sb)->s_lock); return -EINVAL; } if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) { - UFS_SB(sb)->s_mount_opt = new_mount_opt; + UFS_SB(sb)->s_on_err = on_err; mutex_unlock(&UFS_SB(sb)->s_lock); return 0; } @@ -1369,7 +1354,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) sb->s_flags &= ~SB_RDONLY; #endif } - UFS_SB(sb)->s_mount_opt = new_mount_opt; + UFS_SB(sb)->s_on_err = on_err; mutex_unlock(&UFS_SB(sb)->s_lock); return 0; } @@ -1377,7 +1362,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) static int ufs_show_options(struct seq_file *seq, struct dentry *root) { struct ufs_sb_info *sbi = UFS_SB(root->d_sb); - unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE; + unsigned mval = sbi->s_flavour; const struct match_token *tp = tokens; while (tp->token != Opt_onerror_panic && tp->token != mval) @@ -1385,7 +1370,7 @@ static int ufs_show_options(struct seq_file *seq, struct dentry *root) BUG_ON(tp->token == Opt_onerror_panic); seq_printf(seq, ",%s", tp->pattern); - mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR; + mval = sbi->s_on_err; while (tp->token != Opt_err && tp->token != mval) ++tp; BUG_ON(tp->token == Opt_err); diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h index e7df65dd4351..788e025056b2 100644 --- a/fs/ufs/ufs.h +++ b/fs/ufs/ufs.h @@ -24,7 +24,8 @@ struct ufs_sb_info { struct ufs_cg_private_info * s_ucpi[UFS_MAX_GROUP_LOADED]; unsigned s_cgno[UFS_MAX_GROUP_LOADED]; unsigned short s_cg_loaded; - unsigned s_mount_opt; + unsigned s_flavour; + unsigned s_on_err; struct super_block *sb; int work_queued; /* non-zero if the delayed work is queued */ struct delayed_work sync_work; /* FS sync delayed work */ @@ -52,13 +53,11 @@ struct ufs_inode_info { }; /* mount options */ -#define UFS_MOUNT_ONERROR 0x0000000F #define UFS_MOUNT_ONERROR_PANIC 0x00000001 #define UFS_MOUNT_ONERROR_LOCK 0x00000002 #define UFS_MOUNT_ONERROR_UMOUNT 0x00000004 #define UFS_MOUNT_ONERROR_REPAIR 0x00000008 -#define UFS_MOUNT_UFSTYPE 0x0000FFF0 #define UFS_MOUNT_UFSTYPE_OLD 0x00000010 #define UFS_MOUNT_UFSTYPE_44BSD 0x00000020 #define UFS_MOUNT_UFSTYPE_SUN 0x00000040 @@ -70,10 +69,6 @@ struct ufs_inode_info { #define UFS_MOUNT_UFSTYPE_UFS2 0x00001000 #define UFS_MOUNT_UFSTYPE_SUNOS 0x00002000 -#define ufs_clear_opt(o,opt) o &= ~UFS_MOUNT_##opt -#define ufs_set_opt(o,opt) o |= UFS_MOUNT_##opt -#define ufs_test_opt(o,opt) ((o) & UFS_MOUNT_##opt) - /* * Debug code */ From 20be746bbc18698a8252f0be4fa7dcfb0ed48f90 Mon Sep 17 00:00:00 2001 From: Al Viro Date: Fri, 17 Jan 2025 00:53:37 -0500 Subject: [PATCH 2/3] ufs: reject multiple conflicting -o ufstype=... on mount Have ufs_parse_options() refuse to change an already set flavour, and move the "can't change the flavour" logics on remount there, while we are at it - the only difference is that flavour is already set. Signed-off-by: Al Viro --- fs/ufs/super.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/fs/ufs/super.c b/fs/ufs/super.c index 6a3a11c7e8ca..33704b8d769d 100644 --- a/fs/ufs/super.c +++ b/fs/ufs/super.c @@ -380,7 +380,7 @@ static const match_table_t tokens = { {Opt_err, NULL} }; -static int ufs_parse_options(char *options, unsigned *flavour, unsigned *on_err) +static int ufs_parse_options(char *options, unsigned *flavour, unsigned *on_err, bool remount) { char * p; @@ -392,6 +392,7 @@ static int ufs_parse_options(char *options, unsigned *flavour, unsigned *on_err) while ((p = strsep(&options, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; + unsigned int old = *flavour; if (!*p) continue; @@ -444,6 +445,15 @@ static int ufs_parse_options(char *options, unsigned *flavour, unsigned *on_err) pr_err("Invalid option: \"%s\" or missing value\n", p); return 0; } + if (*flavour == old) + continue; + if (!old) + continue; + if (remount) + pr_err("ufstype can't be changed during remount\n"); + else + pr_err("conflicting ufstype options\n"); + return 0; } return 1; } @@ -795,7 +805,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) */ sbi->s_flavour = 0; sbi->s_on_err = UFS_MOUNT_ONERROR_LOCK; - if (!ufs_parse_options(data, &sbi->s_flavour, &sbi->s_on_err)) { + if (!ufs_parse_options(data, &sbi->s_flavour, &sbi->s_on_err, false)) { pr_err("wrong mount options\n"); goto failed; } @@ -1295,16 +1305,9 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) * Allow the "check" option to be passed as a remount option. * It is not possible to change ufstype option during remount */ - ufstype = 0; + ufstype = UFS_SB(sb)->s_flavour; on_err = UFS_MOUNT_ONERROR_LOCK; - if (!ufs_parse_options(data, &ufstype, &on_err)) { - mutex_unlock(&UFS_SB(sb)->s_lock); - return -EINVAL; - } - if (!ufstype) - ufstype = UFS_SB(sb)->s_flavour; - else if (ufstype != UFS_SB(sb)->s_flavour) { - pr_err("ufstype can't be changed during remount\n"); + if (!ufs_parse_options(data, &ufstype, &on_err, true)) { mutex_unlock(&UFS_SB(sb)->s_lock); return -EINVAL; } From b70cb459890b7590c6d909da8c1e7ecfaf6535fb Mon Sep 17 00:00:00 2001 From: Eric Sandeen Date: Thu, 16 Jan 2025 12:49:32 -0600 Subject: [PATCH 3/3] ufs: convert ufs to the new mount API Convert ufs to the new mount API Removed a BUG_ON from show_options(); worst case, it prints a null string where the BUG_ON would have fired. Signed-off-by: Eric Sandeen Signed-off-by: Al Viro --- fs/ufs/super.c | 265 +++++++++++++++++++++++-------------------------- 1 file changed, 122 insertions(+), 143 deletions(-) diff --git a/fs/ufs/super.c b/fs/ufs/super.c index 33704b8d769d..eea718ac66b4 100644 --- a/fs/ufs/super.c +++ b/fs/ufs/super.c @@ -83,11 +83,11 @@ #include #include #include -#include +#include +#include #include #include #include -#include #include #include @@ -342,120 +342,74 @@ void ufs_warning (struct super_block * sb, const char * function, va_end(args); } -enum { - Opt_type_old = UFS_MOUNT_UFSTYPE_OLD, - Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86, - Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN, - Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS, - Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD, - Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2, - Opt_type_hp = UFS_MOUNT_UFSTYPE_HP, - Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD, - Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP, - Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP, - Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC, - Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK, - Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT, - Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR, - Opt_err +enum { Opt_type, Opt_onerror }; + +static const struct constant_table ufs_param_ufstype[] = { + {"old", UFS_MOUNT_UFSTYPE_OLD}, + {"sunx86", UFS_MOUNT_UFSTYPE_SUNx86}, + {"sun", UFS_MOUNT_UFSTYPE_SUN}, + {"sunos", UFS_MOUNT_UFSTYPE_SUNOS}, + {"44bsd", UFS_MOUNT_UFSTYPE_44BSD}, + {"ufs2", UFS_MOUNT_UFSTYPE_UFS2}, + {"5xbsd", UFS_MOUNT_UFSTYPE_UFS2}, + {"hp", UFS_MOUNT_UFSTYPE_HP}, + {"nextstep-cd", UFS_MOUNT_UFSTYPE_NEXTSTEP_CD}, + {"nextstep", UFS_MOUNT_UFSTYPE_NEXTSTEP}, + {"openstep", UFS_MOUNT_UFSTYPE_OPENSTEP}, + {} }; -static const match_table_t tokens = { - {Opt_type_old, "ufstype=old"}, - {Opt_type_sunx86, "ufstype=sunx86"}, - {Opt_type_sun, "ufstype=sun"}, - {Opt_type_sunos, "ufstype=sunos"}, - {Opt_type_44bsd, "ufstype=44bsd"}, - {Opt_type_ufs2, "ufstype=ufs2"}, - {Opt_type_ufs2, "ufstype=5xbsd"}, - {Opt_type_hp, "ufstype=hp"}, - {Opt_type_nextstepcd, "ufstype=nextstep-cd"}, - {Opt_type_nextstep, "ufstype=nextstep"}, - {Opt_type_openstep, "ufstype=openstep"}, -/*end of possible ufs types */ - {Opt_onerror_panic, "onerror=panic"}, - {Opt_onerror_lock, "onerror=lock"}, - {Opt_onerror_umount, "onerror=umount"}, - {Opt_onerror_repair, "onerror=repair"}, - {Opt_err, NULL} +static const struct constant_table ufs_param_onerror[] = { + {"panic", UFS_MOUNT_ONERROR_PANIC}, + {"lock", UFS_MOUNT_ONERROR_LOCK}, + {"umount", UFS_MOUNT_ONERROR_UMOUNT}, + {"repair", UFS_MOUNT_ONERROR_REPAIR}, + {} }; -static int ufs_parse_options(char *options, unsigned *flavour, unsigned *on_err, bool remount) +static const struct fs_parameter_spec ufs_param_spec[] = { + fsparam_enum ("ufstype", Opt_type, ufs_param_ufstype), + fsparam_enum ("onerror", Opt_onerror, ufs_param_onerror), + {} +}; + +struct ufs_fs_context { + unsigned int flavour, on_err; +}; + +static int ufs_parse_param(struct fs_context *fc, struct fs_parameter *param) { - char * p; - + struct ufs_fs_context *ctx = fc->fs_private; + struct fs_parse_result result; + int opt; + UFSD("ENTER\n"); - - if (!options) - return 1; - while ((p = strsep(&options, ",")) != NULL) { - substring_t args[MAX_OPT_ARGS]; - int token; - unsigned int old = *flavour; - if (!*p) - continue; + opt = fs_parse(fc, ufs_param_spec, param, &result); + if (opt < 0) + return opt; - token = match_token(p, tokens, args); - switch (token) { - case Opt_type_old: - *flavour = UFS_MOUNT_UFSTYPE_OLD; - break; - case Opt_type_sunx86: - *flavour = UFS_MOUNT_UFSTYPE_SUNx86; - break; - case Opt_type_sun: - *flavour = UFS_MOUNT_UFSTYPE_SUN; - break; - case Opt_type_sunos: - *flavour = UFS_MOUNT_UFSTYPE_SUNOS; - break; - case Opt_type_44bsd: - *flavour = UFS_MOUNT_UFSTYPE_44BSD; - break; - case Opt_type_ufs2: - *flavour = UFS_MOUNT_UFSTYPE_UFS2; - break; - case Opt_type_hp: - *flavour = UFS_MOUNT_UFSTYPE_HP; - break; - case Opt_type_nextstepcd: - *flavour = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD; - break; - case Opt_type_nextstep: - *flavour = UFS_MOUNT_UFSTYPE_NEXTSTEP; - break; - case Opt_type_openstep: - *flavour = UFS_MOUNT_UFSTYPE_OPENSTEP; - break; - case Opt_onerror_panic: - *on_err = UFS_MOUNT_ONERROR_PANIC; - break; - case Opt_onerror_lock: - *on_err = UFS_MOUNT_ONERROR_LOCK; - break; - case Opt_onerror_umount: - *on_err = UFS_MOUNT_ONERROR_UMOUNT; - break; - case Opt_onerror_repair: - *on_err = UFS_MOUNT_ONERROR_REPAIR; - pr_err("Unable to do repair on error, will lock lock instead\n"); - break; - default: - pr_err("Invalid option: \"%s\" or missing value\n", p); + switch (opt) { + case Opt_type: + if (ctx->flavour == result.uint_32) /* no-op */ return 0; - } - if (*flavour == old) - continue; - if (!old) - continue; - if (remount) + if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) { pr_err("ufstype can't be changed during remount\n"); - else + return -EINVAL; + } + if (!ctx->flavour) { pr_err("conflicting ufstype options\n"); - return 0; + return -EINVAL; + } + ctx->flavour = result.uint_32; + break; + case Opt_onerror: + ctx->on_err = result.uint_32; + break; + default: + return -EINVAL; } - return 1; + return 0; } /* @@ -760,8 +714,10 @@ static u64 ufs_max_bytes(struct super_block *sb) return res << uspi->s_bshift; } -static int ufs_fill_super(struct super_block *sb, void *data, int silent) +static int ufs_fill_super(struct super_block *sb, struct fs_context *fc) { + struct ufs_fs_context *ctx = fc->fs_private; + int silent = fc->sb_flags & SB_SILENT; struct ufs_sb_info * sbi; struct ufs_sb_private_info * uspi; struct ufs_super_block_first * usb1; @@ -799,16 +755,10 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent) mutex_init(&sbi->s_lock); spin_lock_init(&sbi->work_lock); INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs); - /* - * Set default mount options - * Parse mount options - */ - sbi->s_flavour = 0; - sbi->s_on_err = UFS_MOUNT_ONERROR_LOCK; - if (!ufs_parse_options(data, &sbi->s_flavour, &sbi->s_on_err, false)) { - pr_err("wrong mount options\n"); - goto failed; - } + + sbi->s_flavour = ctx->flavour; + sbi->s_on_err = ctx->on_err; + if (!sbi->s_flavour) { if (!silent) pr_err("You didn't specify the type of your ufs filesystem\n\n" @@ -1286,13 +1236,15 @@ failed_nomem: return -ENOMEM; } -static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) +static int ufs_reconfigure(struct fs_context *fc) { struct ufs_sb_private_info * uspi; struct ufs_super_block_first * usb1; struct ufs_super_block_third * usb3; - unsigned on_err, ufstype; - unsigned flags; + struct ufs_fs_context *ctx = fc->fs_private; + struct super_block *sb = fc->root->d_sb; + unsigned int ufstype; + unsigned int flags; sync_filesystem(sb); mutex_lock(&UFS_SB(sb)->s_lock); @@ -1301,19 +1253,10 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) usb1 = ubh_get_usb_first(uspi); usb3 = ubh_get_usb_third(uspi); - /* - * Allow the "check" option to be passed as a remount option. - * It is not possible to change ufstype option during remount - */ ufstype = UFS_SB(sb)->s_flavour; - on_err = UFS_MOUNT_ONERROR_LOCK; - if (!ufs_parse_options(data, &ufstype, &on_err, true)) { - mutex_unlock(&UFS_SB(sb)->s_lock); - return -EINVAL; - } - if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) { - UFS_SB(sb)->s_on_err = on_err; + if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb)) { + UFS_SB(sb)->s_on_err = ctx->on_err; mutex_unlock(&UFS_SB(sb)->s_lock); return 0; } @@ -1321,7 +1264,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) /* * fs was mouted as rw, remounting ro */ - if (*mount_flags & SB_RDONLY) { + if (fc->sb_flags & SB_RDONLY) { ufs_put_super_internal(sb); usb1->fs_time = ufs_get_seconds(sb); if ((flags & UFS_ST_MASK) == UFS_ST_SUN @@ -1357,7 +1300,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data) sb->s_flags &= ~SB_RDONLY; #endif } - UFS_SB(sb)->s_on_err = on_err; + UFS_SB(sb)->s_on_err = ctx->on_err; mutex_unlock(&UFS_SB(sb)->s_lock); return 0; } @@ -1366,18 +1309,18 @@ static int ufs_show_options(struct seq_file *seq, struct dentry *root) { struct ufs_sb_info *sbi = UFS_SB(root->d_sb); unsigned mval = sbi->s_flavour; - const struct match_token *tp = tokens; + const struct constant_table *tp; - while (tp->token != Opt_onerror_panic && tp->token != mval) + tp = ufs_param_ufstype; + while (tp->value && tp->value != mval) ++tp; - BUG_ON(tp->token == Opt_onerror_panic); - seq_printf(seq, ",%s", tp->pattern); + seq_printf(seq, ",ufstype=%s", tp->name); + tp = ufs_param_onerror; mval = sbi->s_on_err; - while (tp->token != Opt_err && tp->token != mval) + while (tp->value && tp->value != mval) ++tp; - BUG_ON(tp->token == Opt_err); - seq_printf(seq, ",%s", tp->pattern); + seq_printf(seq, ",onerror=%s", tp->name); return 0; } @@ -1471,21 +1414,57 @@ static const struct super_operations ufs_super_ops = { .put_super = ufs_put_super, .sync_fs = ufs_sync_fs, .statfs = ufs_statfs, - .remount_fs = ufs_remount, .show_options = ufs_show_options, }; -static struct dentry *ufs_mount(struct file_system_type *fs_type, - int flags, const char *dev_name, void *data) +static int ufs_get_tree(struct fs_context *fc) { - return mount_bdev(fs_type, flags, dev_name, data, ufs_fill_super); + return get_tree_bdev(fc, ufs_fill_super); +} + +static void ufs_free_fc(struct fs_context *fc) +{ + kfree(fc->fs_private); +} + +static const struct fs_context_operations ufs_context_ops = { + .parse_param = ufs_parse_param, + .get_tree = ufs_get_tree, + .reconfigure = ufs_reconfigure, + .free = ufs_free_fc, +}; + +static int ufs_init_fs_context(struct fs_context *fc) +{ + struct ufs_fs_context *ctx; + + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) { + struct super_block *sb = fc->root->d_sb; + struct ufs_sb_info *sbi = UFS_SB(sb); + + ctx->flavour = sbi->s_flavour; + ctx->on_err = sbi->s_on_err; + } else { + ctx->flavour = 0; + ctx->on_err = UFS_MOUNT_ONERROR_LOCK; + } + + fc->fs_private = ctx; + fc->ops = &ufs_context_ops; + + return 0; } static struct file_system_type ufs_fs_type = { .owner = THIS_MODULE, .name = "ufs", - .mount = ufs_mount, .kill_sb = kill_block_super, + .init_fs_context = ufs_init_fs_context, + .parameters = ufs_param_spec, .fs_flags = FS_REQUIRES_DEV, }; MODULE_ALIAS_FS("ufs");