GNU Linux-libre 6.9-gnu
[releases.git] / fs / bcachefs / opts.c
1 // SPDX-License-Identifier: GPL-2.0
2
3 #include <linux/kernel.h>
4
5 #include "bcachefs.h"
6 #include "compress.h"
7 #include "disk_groups.h"
8 #include "error.h"
9 #include "opts.h"
10 #include "recovery_passes.h"
11 #include "super-io.h"
12 #include "util.h"
13
14 #define x(t, n, ...) [n] = #t,
15
16 const char * const bch2_error_actions[] = {
17         BCH_ERROR_ACTIONS()
18         NULL
19 };
20
21 const char * const bch2_fsck_fix_opts[] = {
22         BCH_FIX_ERRORS_OPTS()
23         NULL
24 };
25
26 const char * const bch2_version_upgrade_opts[] = {
27         BCH_VERSION_UPGRADE_OPTS()
28         NULL
29 };
30
31 const char * const bch2_sb_features[] = {
32         BCH_SB_FEATURES()
33         NULL
34 };
35
36 const char * const bch2_sb_compat[] = {
37         BCH_SB_COMPAT()
38         NULL
39 };
40
41 const char * const __bch2_btree_ids[] = {
42         BCH_BTREE_IDS()
43         NULL
44 };
45
46 static const char * const __bch2_csum_types[] = {
47         BCH_CSUM_TYPES()
48         NULL
49 };
50
51 const char * const bch2_csum_opts[] = {
52         BCH_CSUM_OPTS()
53         NULL
54 };
55
56 static const char * const __bch2_compression_types[] = {
57         BCH_COMPRESSION_TYPES()
58         NULL
59 };
60
61 const char * const bch2_compression_opts[] = {
62         BCH_COMPRESSION_OPTS()
63         NULL
64 };
65
66 const char * const bch2_str_hash_types[] = {
67         BCH_STR_HASH_TYPES()
68         NULL
69 };
70
71 const char * const bch2_str_hash_opts[] = {
72         BCH_STR_HASH_OPTS()
73         NULL
74 };
75
76 const char * const __bch2_data_types[] = {
77         BCH_DATA_TYPES()
78         NULL
79 };
80
81 const char * const bch2_member_states[] = {
82         BCH_MEMBER_STATES()
83         NULL
84 };
85
86 static const char * const __bch2_jset_entry_types[] = {
87         BCH_JSET_ENTRY_TYPES()
88         NULL
89 };
90
91 static const char * const __bch2_fs_usage_types[] = {
92         BCH_FS_USAGE_TYPES()
93         NULL
94 };
95
96 #undef x
97
98 static void prt_str_opt_boundscheck(struct printbuf *out, const char * const opts[],
99                                     unsigned nr, const char *type, unsigned idx)
100 {
101         if (idx < nr)
102                 prt_str(out, opts[idx]);
103         else
104                 prt_printf(out, "(unknown %s %u)", type, idx);
105 }
106
107 #define PRT_STR_OPT_BOUNDSCHECKED(name, type)                                   \
108 void bch2_prt_##name(struct printbuf *out, type t)                              \
109 {                                                                               \
110         prt_str_opt_boundscheck(out, __bch2_##name##s, ARRAY_SIZE(__bch2_##name##s) - 1, #name, t);\
111 }
112
113 PRT_STR_OPT_BOUNDSCHECKED(jset_entry_type,      enum bch_jset_entry_type);
114 PRT_STR_OPT_BOUNDSCHECKED(fs_usage_type,        enum bch_fs_usage_type);
115 PRT_STR_OPT_BOUNDSCHECKED(data_type,            enum bch_data_type);
116 PRT_STR_OPT_BOUNDSCHECKED(csum_type,            enum bch_csum_type);
117 PRT_STR_OPT_BOUNDSCHECKED(compression_type,     enum bch_compression_type);
118
119 static int bch2_opt_fix_errors_parse(struct bch_fs *c, const char *val, u64 *res,
120                                      struct printbuf *err)
121 {
122         if (!val) {
123                 *res = FSCK_FIX_yes;
124         } else {
125                 int ret = match_string(bch2_fsck_fix_opts, -1, val);
126
127                 if (ret < 0 && err)
128                         prt_str(err, "fix_errors: invalid selection");
129                 if (ret < 0)
130                         return ret;
131                 *res = ret;
132         }
133
134         return 0;
135 }
136
137 static void bch2_opt_fix_errors_to_text(struct printbuf *out,
138                                         struct bch_fs *c,
139                                         struct bch_sb *sb,
140                                         u64 v)
141 {
142         prt_str(out, bch2_fsck_fix_opts[v]);
143 }
144
145 #define bch2_opt_fix_errors (struct bch_opt_fn) {       \
146         .parse = bch2_opt_fix_errors_parse,             \
147         .to_text = bch2_opt_fix_errors_to_text,         \
148 }
149
150 const char * const bch2_d_types[BCH_DT_MAX] = {
151         [DT_UNKNOWN]    = "unknown",
152         [DT_FIFO]       = "fifo",
153         [DT_CHR]        = "chr",
154         [DT_DIR]        = "dir",
155         [DT_BLK]        = "blk",
156         [DT_REG]        = "reg",
157         [DT_LNK]        = "lnk",
158         [DT_SOCK]       = "sock",
159         [DT_WHT]        = "whiteout",
160         [DT_SUBVOL]     = "subvol",
161 };
162
163 u64 BCH2_NO_SB_OPT(const struct bch_sb *sb)
164 {
165         BUG();
166 }
167
168 void SET_BCH2_NO_SB_OPT(struct bch_sb *sb, u64 v)
169 {
170         BUG();
171 }
172
173 void bch2_opts_apply(struct bch_opts *dst, struct bch_opts src)
174 {
175 #define x(_name, ...)                                           \
176         if (opt_defined(src, _name))                                    \
177                 opt_set(*dst, _name, src._name);
178
179         BCH_OPTS()
180 #undef x
181 }
182
183 bool bch2_opt_defined_by_id(const struct bch_opts *opts, enum bch_opt_id id)
184 {
185         switch (id) {
186 #define x(_name, ...)                                           \
187         case Opt_##_name:                                               \
188                 return opt_defined(*opts, _name);
189         BCH_OPTS()
190 #undef x
191         default:
192                 BUG();
193         }
194 }
195
196 u64 bch2_opt_get_by_id(const struct bch_opts *opts, enum bch_opt_id id)
197 {
198         switch (id) {
199 #define x(_name, ...)                                           \
200         case Opt_##_name:                                               \
201                 return opts->_name;
202         BCH_OPTS()
203 #undef x
204         default:
205                 BUG();
206         }
207 }
208
209 void bch2_opt_set_by_id(struct bch_opts *opts, enum bch_opt_id id, u64 v)
210 {
211         switch (id) {
212 #define x(_name, ...)                                           \
213         case Opt_##_name:                                               \
214                 opt_set(*opts, _name, v);                               \
215                 break;
216         BCH_OPTS()
217 #undef x
218         default:
219                 BUG();
220         }
221 }
222
223 const struct bch_option bch2_opt_table[] = {
224 #define OPT_BOOL()              .type = BCH_OPT_BOOL, .min = 0, .max = 2
225 #define OPT_UINT(_min, _max)    .type = BCH_OPT_UINT,                   \
226                                 .min = _min, .max = _max
227 #define OPT_STR(_choices)       .type = BCH_OPT_STR,                    \
228                                 .min = 0, .max = ARRAY_SIZE(_choices),  \
229                                 .choices = _choices
230 #define OPT_STR_NOLIMIT(_choices)       .type = BCH_OPT_STR,            \
231                                 .min = 0, .max = U64_MAX,               \
232                                 .choices = _choices
233 #define OPT_FN(_fn)             .type = BCH_OPT_FN, .fn = _fn
234
235 #define x(_name, _bits, _flags, _type, _sb_opt, _default, _hint, _help) \
236         [Opt_##_name] = {                                               \
237                 .attr   = {                                             \
238                         .name   = #_name,                               \
239                         .mode = (_flags) & OPT_RUNTIME ? 0644 : 0444,   \
240                 },                                                      \
241                 .flags  = _flags,                                       \
242                 .hint   = _hint,                                        \
243                 .help   = _help,                                        \
244                 .get_sb = _sb_opt,                                      \
245                 .set_sb = SET_##_sb_opt,                                \
246                 _type                                                   \
247         },
248
249         BCH_OPTS()
250 #undef x
251 };
252
253 int bch2_opt_lookup(const char *name)
254 {
255         const struct bch_option *i;
256
257         for (i = bch2_opt_table;
258              i < bch2_opt_table + ARRAY_SIZE(bch2_opt_table);
259              i++)
260                 if (!strcmp(name, i->attr.name))
261                         return i - bch2_opt_table;
262
263         return -1;
264 }
265
266 struct synonym {
267         const char      *s1, *s2;
268 };
269
270 static const struct synonym bch_opt_synonyms[] = {
271         { "quota",      "usrquota" },
272 };
273
274 static int bch2_mount_opt_lookup(const char *name)
275 {
276         const struct synonym *i;
277
278         for (i = bch_opt_synonyms;
279              i < bch_opt_synonyms + ARRAY_SIZE(bch_opt_synonyms);
280              i++)
281                 if (!strcmp(name, i->s1))
282                         name = i->s2;
283
284         return bch2_opt_lookup(name);
285 }
286
287 int bch2_opt_validate(const struct bch_option *opt, u64 v, struct printbuf *err)
288 {
289         if (v < opt->min) {
290                 if (err)
291                         prt_printf(err, "%s: too small (min %llu)",
292                                opt->attr.name, opt->min);
293                 return -BCH_ERR_ERANGE_option_too_small;
294         }
295
296         if (opt->max && v >= opt->max) {
297                 if (err)
298                         prt_printf(err, "%s: too big (max %llu)",
299                                opt->attr.name, opt->max);
300                 return -BCH_ERR_ERANGE_option_too_big;
301         }
302
303         if ((opt->flags & OPT_SB_FIELD_SECTORS) && (v & 511)) {
304                 if (err)
305                         prt_printf(err, "%s: not a multiple of 512",
306                                opt->attr.name);
307                 return -BCH_ERR_opt_parse_error;
308         }
309
310         if ((opt->flags & OPT_MUST_BE_POW_2) && !is_power_of_2(v)) {
311                 if (err)
312                         prt_printf(err, "%s: must be a power of two",
313                                opt->attr.name);
314                 return -BCH_ERR_opt_parse_error;
315         }
316
317         if (opt->fn.validate)
318                 return opt->fn.validate(v, err);
319
320         return 0;
321 }
322
323 int bch2_opt_parse(struct bch_fs *c,
324                    const struct bch_option *opt,
325                    const char *val, u64 *res,
326                    struct printbuf *err)
327 {
328         ssize_t ret;
329
330         switch (opt->type) {
331         case BCH_OPT_BOOL:
332                 if (val) {
333                         ret = kstrtou64(val, 10, res);
334                 } else {
335                         ret = 0;
336                         *res = 1;
337                 }
338
339                 if (ret < 0 || (*res != 0 && *res != 1)) {
340                         if (err)
341                                 prt_printf(err, "%s: must be bool", opt->attr.name);
342                         return ret < 0 ? ret : -BCH_ERR_option_not_bool;
343                 }
344                 break;
345         case BCH_OPT_UINT:
346                 if (!val) {
347                         prt_printf(err, "%s: required value",
348                                    opt->attr.name);
349                         return -EINVAL;
350                 }
351
352                 ret = opt->flags & OPT_HUMAN_READABLE
353                         ? bch2_strtou64_h(val, res)
354                         : kstrtou64(val, 10, res);
355                 if (ret < 0) {
356                         if (err)
357                                 prt_printf(err, "%s: must be a number",
358                                            opt->attr.name);
359                         return ret;
360                 }
361                 break;
362         case BCH_OPT_STR:
363                 if (!val) {
364                         prt_printf(err, "%s: required value",
365                                    opt->attr.name);
366                         return -EINVAL;
367                 }
368
369                 ret = match_string(opt->choices, -1, val);
370                 if (ret < 0) {
371                         if (err)
372                                 prt_printf(err, "%s: invalid selection",
373                                            opt->attr.name);
374                         return ret;
375                 }
376
377                 *res = ret;
378                 break;
379         case BCH_OPT_FN:
380                 ret = opt->fn.parse(c, val, res, err);
381                 if (ret < 0) {
382                         if (err)
383                                 prt_printf(err, "%s: parse error",
384                                            opt->attr.name);
385                         return ret;
386                 }
387         }
388
389         return bch2_opt_validate(opt, *res, err);
390 }
391
392 void bch2_opt_to_text(struct printbuf *out,
393                       struct bch_fs *c, struct bch_sb *sb,
394                       const struct bch_option *opt, u64 v,
395                       unsigned flags)
396 {
397         if (flags & OPT_SHOW_MOUNT_STYLE) {
398                 if (opt->type == BCH_OPT_BOOL) {
399                         prt_printf(out, "%s%s",
400                                v ? "" : "no",
401                                opt->attr.name);
402                         return;
403                 }
404
405                 prt_printf(out, "%s=", opt->attr.name);
406         }
407
408         switch (opt->type) {
409         case BCH_OPT_BOOL:
410         case BCH_OPT_UINT:
411                 if (opt->flags & OPT_HUMAN_READABLE)
412                         prt_human_readable_u64(out, v);
413                 else
414                         prt_printf(out, "%lli", v);
415                 break;
416         case BCH_OPT_STR:
417                 if (flags & OPT_SHOW_FULL_LIST)
418                         prt_string_option(out, opt->choices, v);
419                 else
420                         prt_str(out, opt->choices[v]);
421                 break;
422         case BCH_OPT_FN:
423                 opt->fn.to_text(out, c, sb, v);
424                 break;
425         default:
426                 BUG();
427         }
428 }
429
430 int bch2_opt_check_may_set(struct bch_fs *c, int id, u64 v)
431 {
432         int ret = 0;
433
434         switch (id) {
435         case Opt_compression:
436         case Opt_background_compression:
437                 ret = bch2_check_set_has_compressed_data(c, v);
438                 break;
439         case Opt_erasure_code:
440                 if (v)
441                         bch2_check_set_feature(c, BCH_FEATURE_ec);
442                 break;
443         }
444
445         return ret;
446 }
447
448 int bch2_opts_check_may_set(struct bch_fs *c)
449 {
450         unsigned i;
451         int ret;
452
453         for (i = 0; i < bch2_opts_nr; i++) {
454                 ret = bch2_opt_check_may_set(c, i,
455                                 bch2_opt_get_by_id(&c->opts, i));
456                 if (ret)
457                         return ret;
458         }
459
460         return 0;
461 }
462
463 int bch2_parse_mount_opts(struct bch_fs *c, struct bch_opts *opts,
464                           char *options)
465 {
466         char *copied_opts, *copied_opts_start;
467         char *opt, *name, *val;
468         int ret, id;
469         struct printbuf err = PRINTBUF;
470         u64 v;
471
472         if (!options)
473                 return 0;
474
475         /*
476          * sys_fsconfig() is now occasionally providing us with option lists
477          * starting with a comma - weird.
478          */
479         if (*options == ',')
480                 options++;
481
482         copied_opts = kstrdup(options, GFP_KERNEL);
483         if (!copied_opts)
484                 return -ENOMEM;
485         copied_opts_start = copied_opts;
486
487         while ((opt = strsep(&copied_opts, ",")) != NULL) {
488                 name    = strsep(&opt, "=");
489                 val     = opt;
490
491                 id = bch2_mount_opt_lookup(name);
492
493                 /* Check for the form "noopt", negation of a boolean opt: */
494                 if (id < 0 &&
495                     !val &&
496                     !strncmp("no", name, 2)) {
497                         id = bch2_mount_opt_lookup(name + 2);
498                         val = "0";
499                 }
500
501                 /* Unknown options are ignored: */
502                 if (id < 0)
503                         continue;
504
505                 if (!(bch2_opt_table[id].flags & OPT_MOUNT))
506                         goto bad_opt;
507
508                 if (id == Opt_acl &&
509                     !IS_ENABLED(CONFIG_BCACHEFS_POSIX_ACL))
510                         goto bad_opt;
511
512                 if ((id == Opt_usrquota ||
513                      id == Opt_grpquota) &&
514                     !IS_ENABLED(CONFIG_BCACHEFS_QUOTA))
515                         goto bad_opt;
516
517                 ret = bch2_opt_parse(c, &bch2_opt_table[id], val, &v, &err);
518                 if (ret < 0)
519                         goto bad_val;
520
521                 bch2_opt_set_by_id(opts, id, v);
522         }
523
524         ret = 0;
525         goto out;
526
527 bad_opt:
528         pr_err("Bad mount option %s", name);
529         ret = -BCH_ERR_option_name;
530         goto out;
531 bad_val:
532         pr_err("Invalid mount option %s", err.buf);
533         ret = -BCH_ERR_option_value;
534         goto out;
535 out:
536         kfree(copied_opts_start);
537         printbuf_exit(&err);
538         return ret;
539 }
540
541 u64 bch2_opt_from_sb(struct bch_sb *sb, enum bch_opt_id id)
542 {
543         const struct bch_option *opt = bch2_opt_table + id;
544         u64 v;
545
546         v = opt->get_sb(sb);
547
548         if (opt->flags & OPT_SB_FIELD_ILOG2)
549                 v = 1ULL << v;
550
551         if (opt->flags & OPT_SB_FIELD_SECTORS)
552                 v <<= 9;
553
554         return v;
555 }
556
557 /*
558  * Initial options from superblock - here we don't want any options undefined,
559  * any options the superblock doesn't specify are set to 0:
560  */
561 int bch2_opts_from_sb(struct bch_opts *opts, struct bch_sb *sb)
562 {
563         unsigned id;
564
565         for (id = 0; id < bch2_opts_nr; id++) {
566                 const struct bch_option *opt = bch2_opt_table + id;
567
568                 if (opt->get_sb == BCH2_NO_SB_OPT)
569                         continue;
570
571                 bch2_opt_set_by_id(opts, id, bch2_opt_from_sb(sb, id));
572         }
573
574         return 0;
575 }
576
577 void __bch2_opt_set_sb(struct bch_sb *sb, const struct bch_option *opt, u64 v)
578 {
579         if (opt->set_sb == SET_BCH2_NO_SB_OPT)
580                 return;
581
582         if (opt->flags & OPT_SB_FIELD_SECTORS)
583                 v >>= 9;
584
585         if (opt->flags & OPT_SB_FIELD_ILOG2)
586                 v = ilog2(v);
587
588         opt->set_sb(sb, v);
589 }
590
591 void bch2_opt_set_sb(struct bch_fs *c, const struct bch_option *opt, u64 v)
592 {
593         if (opt->set_sb == SET_BCH2_NO_SB_OPT)
594                 return;
595
596         mutex_lock(&c->sb_lock);
597         __bch2_opt_set_sb(c->disk_sb.sb, opt, v);
598         bch2_write_super(c);
599         mutex_unlock(&c->sb_lock);
600 }
601
602 /* io opts: */
603
604 struct bch_io_opts bch2_opts_to_inode_opts(struct bch_opts src)
605 {
606         return (struct bch_io_opts) {
607 #define x(_name, _bits) ._name = src._name,
608         BCH_INODE_OPTS()
609 #undef x
610         };
611 }
612
613 bool bch2_opt_is_inode_opt(enum bch_opt_id id)
614 {
615         static const enum bch_opt_id inode_opt_list[] = {
616 #define x(_name, _bits) Opt_##_name,
617         BCH_INODE_OPTS()
618 #undef x
619         };
620         unsigned i;
621
622         for (i = 0; i < ARRAY_SIZE(inode_opt_list); i++)
623                 if (inode_opt_list[i] == id)
624                         return true;
625
626         return false;
627 }