X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libbcachefs%2Fopts.c;h=71bf26eb13d5dbcc767cced43f14f55a4cfa9b5c;hb=dafd26afd98f92d8f66346aca7b6361d15f4dd3c;hp=afe25cd26c063b5038002bd1fa3583e1b352b41d;hpb=e76352087b8fef64155d44a3c34e8ab7516f2a4a;p=bcachefs-tools-debian

diff --git a/libbcachefs/opts.c b/libbcachefs/opts.c
index afe25cd..71bf26e 100644
--- a/libbcachefs/opts.c
+++ b/libbcachefs/opts.c
@@ -9,73 +9,93 @@
 #include "super-io.h"
 #include "util.h"
 
+#define x(t, n) #t,
+
 const char * const bch2_error_actions[] = {
-	"continue",
-	"remount-ro",
-	"panic",
+	BCH_ERROR_ACTIONS()
 	NULL
 };
 
 const char * const bch2_sb_features[] = {
-#define x(f, n) #f,
 	BCH_SB_FEATURES()
-#undef x
+	NULL
+};
+
+const char * const bch2_sb_compat[] = {
+	BCH_SB_COMPAT()
+	NULL
+};
+
+const char * const bch2_btree_ids[] = {
+	BCH_BTREE_IDS()
+	NULL
+};
+
+const char * const bch2_csum_types[] = {
+	BCH_CSUM_TYPES()
 	NULL
 };
 
 const char * const bch2_csum_opts[] = {
-	"none",
-	"crc32c",
-	"crc64",
+	BCH_CSUM_OPTS()
+	NULL
+};
+
+const char * const bch2_compression_types[] = {
+	BCH_COMPRESSION_TYPES()
 	NULL
 };
 
 const char * const bch2_compression_opts[] = {
-#define x(t, n) #t,
 	BCH_COMPRESSION_OPTS()
-#undef x
 	NULL
 };
 
 const char * const bch2_str_hash_types[] = {
-	"crc32c",
-	"crc64",
-	"siphash",
+	BCH_STR_HASH_TYPES()
+	NULL
+};
+
+const char * const bch2_str_hash_opts[] = {
+	BCH_STR_HASH_OPTS()
 	NULL
 };
 
 const char * const bch2_data_types[] = {
-#define x(t, n) #t,
 	BCH_DATA_TYPES()
-#undef x
 	NULL
 };
 
-const char * const bch2_cache_replacement_policies[] = {
-	"lru",
-	"fifo",
-	"random",
+const char * const bch2_member_states[] = {
+	BCH_MEMBER_STATES()
 	NULL
 };
 
-/* Default is -1; we skip past it for struct cached_dev's cache mode */
-const char * const bch2_cache_modes[] = {
-	"default",
-	"writethrough",
-	"writeback",
-	"writearound",
-	"none",
+const char * const bch2_jset_entry_types[] = {
+	BCH_JSET_ENTRY_TYPES()
 	NULL
 };
 
-const char * const bch2_dev_state[] = {
-	"readwrite",
-	"readonly",
-	"failed",
-	"spare",
+const char * const bch2_fs_usage_types[] = {
+	BCH_FS_USAGE_TYPES()
 	NULL
 };
 
+#undef x
+
+const char * const bch2_d_types[BCH_DT_MAX] = {
+	[DT_UNKNOWN]	= "unknown",
+	[DT_FIFO]	= "fifo",
+	[DT_CHR]	= "chr",
+	[DT_DIR]	= "dir",
+	[DT_BLK]	= "blk",
+	[DT_REG]	= "reg",
+	[DT_LNK]	= "lnk",
+	[DT_SOCK]	= "sock",
+	[DT_WHT]	= "whiteout",
+	[DT_SUBVOL]	= "subvol",
+};
+
 void bch2_opts_apply(struct bch_opts *dst, struct bch_opts src)
 {
 #define x(_name, ...)						\
@@ -126,41 +146,27 @@ void bch2_opt_set_by_id(struct bch_opts *opts, enum bch_opt_id id, u64 v)
 	}
 }
 
-/*
- * Initial options from superblock - here we don't want any options undefined,
- * any options the superblock doesn't specify are set to 0:
- */
-struct bch_opts bch2_opts_from_sb(struct bch_sb *sb)
-{
-	struct bch_opts opts = bch2_opts_empty();
-
-#define x(_name, _bits, _mode, _type, _sb_opt, ...)			\
-	if (_sb_opt != NO_SB_OPT)					\
-		opt_set(opts, _name, _sb_opt(sb));
-	BCH_OPTS()
-#undef x
-
-	return opts;
-}
-
 const struct bch_option bch2_opt_table[] = {
-#define OPT_BOOL()		.type = BCH_OPT_BOOL
-#define OPT_UINT(_min, _max)	.type = BCH_OPT_UINT, .min = _min, .max = _max
-#define OPT_SECTORS(_min, _max)	.type = BCH_OPT_SECTORS, .min = _min, .max = _max
-#define OPT_STR(_choices)	.type = BCH_OPT_STR, .choices = _choices
+#define OPT_BOOL()		.type = BCH_OPT_BOOL, .min = 0, .max = 2
+#define OPT_UINT(_min, _max)	.type = BCH_OPT_UINT,			\
+				.min = _min, .max = _max
+#define OPT_STR(_choices)	.type = BCH_OPT_STR,			\
+				.min = 0, .max = ARRAY_SIZE(_choices),\
+				.choices = _choices
 #define OPT_FN(_fn)		.type = BCH_OPT_FN,			\
 				.parse = _fn##_parse,			\
 				.to_text = _fn##_to_text
 
-#define x(_name, _bits, _mode, _type, _sb_opt, _default, _hint, _help)	\
+#define x(_name, _bits, _flags, _type, _sb_opt, _default, _hint, _help)	\
 	[Opt_##_name] = {						\
 		.attr	= {						\
 			.name	= #_name,				\
-			.mode = (_mode) & OPT_RUNTIME ? 0644 : 0444,	\
+			.mode = (_flags) & OPT_RUNTIME ? 0644 : 0444,	\
 		},							\
-		.mode	= _mode,					\
+		.flags	= _flags,					\
 		.hint	= _hint,					\
 		.help	= _help,					\
+		.get_sb = _sb_opt,					\
 		.set_sb	= SET_##_sb_opt,				\
 		_type							\
 	},
@@ -203,7 +209,41 @@ static int bch2_mount_opt_lookup(const char *name)
 	return bch2_opt_lookup(name);
 }
 
-int bch2_opt_parse(struct bch_fs *c, const struct bch_option *opt,
+static int bch2_opt_validate(const struct bch_option *opt, const char *msg, u64 v)
+{
+	if (v < opt->min) {
+		if (msg)
+			pr_err("invalid %s%s: too small (min %llu)",
+			       msg, opt->attr.name, opt->min);
+		return -ERANGE;
+	}
+
+	if (opt->max && v >= opt->max) {
+		if (msg)
+			pr_err("invalid %s%s: too big (max %llu)",
+			       msg, opt->attr.name, opt->max);
+		return -ERANGE;
+	}
+
+	if ((opt->flags & OPT_SB_FIELD_SECTORS) && (v & 511)) {
+		if (msg)
+			pr_err("invalid %s %s: not a multiple of 512",
+			       msg, opt->attr.name);
+		return -EINVAL;
+	}
+
+	if ((opt->flags & OPT_MUST_BE_POW_2) && !is_power_of_2(v)) {
+		if (msg)
+			pr_err("invalid %s%s: must be a power of two",
+			       msg, opt->attr.name);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+int bch2_opt_parse(struct bch_fs *c, const char *msg,
+		   const struct bch_option *opt,
 		   const char *val, u64 *res)
 {
 	ssize_t ret;
@@ -213,30 +253,13 @@ int bch2_opt_parse(struct bch_fs *c, const struct bch_option *opt,
 		ret = kstrtou64(val, 10, res);
 		if (ret < 0)
 			return ret;
-
-		if (*res > 1)
-			return -ERANGE;
 		break;
 	case BCH_OPT_UINT:
-		ret = kstrtou64(val, 10, res);
+		ret = opt->flags & OPT_HUMAN_READABLE
+			? bch2_strtou64_h(val, res)
+			: kstrtou64(val, 10, res);
 		if (ret < 0)
 			return ret;
-
-		if (*res < opt->min || *res >= opt->max)
-			return -ERANGE;
-		break;
-	case BCH_OPT_SECTORS:
-		ret = bch2_strtou64_h(val, res);
-		if (ret < 0)
-			return ret;
-
-		if (*res & 511)
-			return -EINVAL;
-
-		*res >>= 9;
-
-		if (*res < opt->min || *res >= opt->max)
-			return -ERANGE;
 		break;
 	case BCH_OPT_STR:
 		ret = match_string(opt->choices, -1, val);
@@ -247,12 +270,14 @@ int bch2_opt_parse(struct bch_fs *c, const struct bch_option *opt,
 		break;
 	case BCH_OPT_FN:
 		if (!c)
-			return -EINVAL;
+			return 0;
 
-		return opt->parse(c, val, res);
+		ret = opt->parse(c, val, res);
+		if (ret < 0)
+			return ret;
 	}
 
-	return 0;
+	return bch2_opt_validate(opt, msg, *res);
 }
 
 void bch2_opt_to_text(struct printbuf *out, struct bch_fs *c,
@@ -273,10 +298,10 @@ void bch2_opt_to_text(struct printbuf *out, struct bch_fs *c,
 	switch (opt->type) {
 	case BCH_OPT_BOOL:
 	case BCH_OPT_UINT:
-		pr_buf(out, "%lli", v);
-		break;
-	case BCH_OPT_SECTORS:
-		bch2_hprint(out, v);
+		if (opt->flags & OPT_HUMAN_READABLE)
+			bch2_hprint(out, v);
+		else
+			pr_buf(out, "%lli", v);
 		break;
 	case BCH_OPT_STR:
 		if (flags & OPT_SHOW_FULL_LIST)
@@ -325,13 +350,23 @@ int bch2_opts_check_may_set(struct bch_fs *c)
 	return 0;
 }
 
-int bch2_parse_mount_opts(struct bch_opts *opts, char *options)
+int bch2_parse_mount_opts(struct bch_fs *c, struct bch_opts *opts,
+			  char *options)
 {
+	char *copied_opts, *copied_opts_start;
 	char *opt, *name, *val;
 	int ret, id;
 	u64 v;
 
-	while ((opt = strsep(&options, ",")) != NULL) {
+	if (!options)
+		return 0;
+
+	copied_opts = kstrdup(options, GFP_KERNEL);
+	if (!copied_opts)
+		return -1;
+	copied_opts_start = copied_opts;
+
+	while ((opt = strsep(&copied_opts, ",")) != NULL) {
 		name	= strsep(&opt, "=");
 		val	= opt;
 
@@ -340,7 +375,8 @@ int bch2_parse_mount_opts(struct bch_opts *opts, char *options)
 			if (id < 0)
 				goto bad_opt;
 
-			ret = bch2_opt_parse(NULL, &bch2_opt_table[id], val, &v);
+			ret = bch2_opt_parse(c, "mount option ",
+					     &bch2_opt_table[id], val, &v);
 			if (ret < 0)
 				goto bad_val;
 		} else {
@@ -360,7 +396,7 @@ int bch2_parse_mount_opts(struct bch_opts *opts, char *options)
 				goto no_val;
 		}
 
-		if (!(bch2_opt_table[id].mode & OPT_MOUNT))
+		if (!(bch2_opt_table[id].flags & OPT_MOUNT))
 			goto bad_opt;
 
 		if (id == Opt_acl &&
@@ -375,16 +411,83 @@ int bch2_parse_mount_opts(struct bch_opts *opts, char *options)
 		bch2_opt_set_by_id(opts, id, v);
 	}
 
-	return 0;
+	ret = 0;
+	goto out;
+
 bad_opt:
 	pr_err("Bad mount option %s", name);
-	return -1;
+	ret = -1;
+	goto out;
 bad_val:
 	pr_err("Invalid value %s for mount option %s", val, name);
-	return -1;
+	ret = -1;
+	goto out;
 no_val:
 	pr_err("Mount option %s requires a value", name);
-	return -1;
+	ret = -1;
+	goto out;
+out:
+	kfree(copied_opts_start);
+	return ret;
+}
+
+/*
+ * Initial options from superblock - here we don't want any options undefined,
+ * any options the superblock doesn't specify are set to 0:
+ */
+int bch2_opts_from_sb(struct bch_opts *opts, struct bch_sb *sb)
+{
+	unsigned id;
+	int ret;
+
+	for (id = 0; id < bch2_opts_nr; id++) {
+		const struct bch_option *opt = bch2_opt_table + id;
+		u64 v;
+
+		if (opt->get_sb == NO_SB_OPT)
+			continue;
+
+		v = opt->get_sb(sb);
+
+		if (opt->flags & OPT_SB_FIELD_ILOG2)
+			v = 1ULL << v;
+
+		if (opt->flags & OPT_SB_FIELD_SECTORS)
+			v <<= 9;
+
+		ret = bch2_opt_validate(opt, "superblock option ", v);
+		if (ret)
+			return ret;
+
+		bch2_opt_set_by_id(opts, id, v);
+	}
+
+	return 0;
+}
+
+void __bch2_opt_set_sb(struct bch_sb *sb, const struct bch_option *opt, u64 v)
+{
+	if (opt->set_sb == SET_NO_SB_OPT)
+		return;
+
+	if (opt->flags & OPT_SB_FIELD_SECTORS)
+		v >>= 9;
+
+	if (opt->flags & OPT_SB_FIELD_ILOG2)
+		v = ilog2(v);
+
+	opt->set_sb(sb, v);
+}
+
+void bch2_opt_set_sb(struct bch_fs *c, const struct bch_option *opt, u64 v)
+{
+	if (opt->set_sb == SET_NO_SB_OPT)
+		return;
+
+	mutex_lock(&c->sb_lock);
+	__bch2_opt_set_sb(c->disk_sb.sb, opt, v);
+	bch2_write_super(c);
+	mutex_unlock(&c->sb_lock);
 }
 
 /* io opts: */