TWxSoftware/twx-linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge tag 'pull-ufs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Browse Source 
Pull UFS updates from Al Viro:
 "The bulk of this is Eric's conversion of UFS to new mount API, with a
  bit of cleanups from me. I hoped to get stricter sanity checks on
  superblock flags into that pile, but... next cycle, hopefully"

* tag 'pull-ufs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  ufs: convert ufs to the new mount API
  ufs: reject multiple conflicting -o ufstype=... on mount
  ufs: split ->s_mount_opt - don't mix flavour and on-error
This commit is contained in:
Linus Torvalds
2025-05-30 15:07:55 -07:00
parent a82ba83991 b70cb45989
commit edb94482e9
2 changed files with 139 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fs/ufs/super.c
+137 -170
View File
@@ -83,11 +83,11 @@
#include <linux/blkdev.h>
#include <linux/backing-dev.h>
#include <linux/init.h>
#include <linux/parser.h>
#include <linux/fs_context.h>
#include <linux/fs_parser.h>
#include <linux/buffer_head.h>
#include <linux/vfs.h>
#include <linux/log2.h>
#include <linux/mount.h>
#include <linux/seq_file.h>
#include <linux/iversion.h>
@@ -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);
@@ -342,124 +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 * mount_options)
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;
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:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_OLD);
break;
case Opt_type_sunx86:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
break;
case Opt_type_sun:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_SUN);
break;
case Opt_type_sunos:
ufs_clear_opt(*mount_options, UFSTYPE);
ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
break;
case Opt_type_44bsd:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_44BSD);
break;
case Opt_type_ufs2:
ufs_clear_opt(*mount_options, UFSTYPE);
ufs_set_opt(*mount_options, UFSTYPE_UFS2);
break;
case Opt_type_hp:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_HP);
break;
case Opt_type_nextstepcd:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
break;
case Opt_type_nextstep:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
break;
case Opt_type_openstep:
ufs_clear_opt (*mount_options, UFSTYPE);
ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
break;
case Opt_onerror_panic:
ufs_clear_opt (*mount_options, ONERROR);
ufs_set_opt (*mount_options, ONERROR_PANIC);
break;
case Opt_onerror_lock:
ufs_clear_opt (*mount_options, ONERROR);
ufs_set_opt (*mount_options, ONERROR_LOCK);
break;
case Opt_onerror_umount:
ufs_clear_opt (*mount_options, ONERROR);
ufs_set_opt (*mount_options, ONERROR_UMOUNT);
break;
case Opt_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);
switch (opt) {
case Opt_type:
if (ctx->flavour == result.uint_32) /* no-op */
return 0;
if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
pr_err("ufstype can't be changed during remount\n");
return -EINVAL;
}
if (!ctx->flavour) {
pr_err("conflicting ufstype options\n");
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;
}
/*
@@ -474,7 +424,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 +530,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;
@@ -764,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;
@@ -803,24 +755,18 @@ 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_mount_opt = 0;
ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {
pr_err("wrong mount options\n");
goto failed;
}
if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
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"
"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 +782,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 +981,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 +1183,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);
@@ -1290,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 new_mount_opt, 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);
@@ -1305,27 +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_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)) {
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) {
pr_err("ufstype can't be changed during remount\n");
mutex_unlock(&UFS_SB(sb)->s_lock);
return -EINVAL;
}
ufstype = UFS_SB(sb)->s_flavour;
if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
UFS_SB(sb)->s_mount_opt = new_mount_opt;
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;
}
@@ -1333,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
@@ -1369,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_mount_opt = new_mount_opt;
UFS_SB(sb)->s_on_err = ctx->on_err;
mutex_unlock(&UFS_SB(sb)->s_lock);
return 0;
}
@@ -1377,19 +1308,19 @@ 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;
const struct match_token *tp = tokens;
unsigned mval = sbi->s_flavour;
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);
mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;
while (tp->token != Opt_err && tp->token != mval)
tp = ufs_param_onerror;
mval = sbi->s_on_err;
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;
}
@@ -1483,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");
fs/ufs/ufs.h
+2 -7
View File
@@ -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
*/