summaryrefslogtreecommitdiff
path: root/fs/bcachefs/opts.h
blob: 53bf06e70cd5115e794d04c2b171a3c602bab5bc (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _BCACHEFS_OPTS_H
#define _BCACHEFS_OPTS_H

#include <linux/bug.h>
#include <linux/log2.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include "bcachefs_format.h"

extern const char * const bch2_error_actions[];
extern const char * const bch2_csum_types[];
extern const char * const bch2_compression_types[];
extern const char * const bch2_str_hash_types[];
extern const char * const bch2_data_types[];
extern const char * const bch2_cache_replacement_policies[];
extern const char * const bch2_cache_modes[];
extern const char * const bch2_dev_state[];

/*
 * Mount options; we also store defaults in the superblock.
 *
 * Also exposed via sysfs: if an option is writeable, and it's also stored in
 * the superblock, changing it via sysfs (currently? might change this) also
 * updates the superblock.
 *
 * We store options as signed integers, where -1 means undefined. This means we
 * can pass the mount options to bch2_fs_alloc() as a whole struct, and then only
 * apply the options from that struct that are defined.
 */

/* dummy option, for options that aren't stored in the superblock */
LE64_BITMASK(NO_SB_OPT,		struct bch_sb, flags[0], 0, 0);

/* When can be set: */
enum opt_mode {
	OPT_FORMAT	= (1 << 0),
	OPT_MOUNT	= (1 << 1),
	OPT_RUNTIME	= (1 << 2),
	OPT_INODE	= (1 << 3),
	OPT_DEVICE	= (1 << 4),
};

enum opt_type {
	BCH_OPT_BOOL,
	BCH_OPT_UINT,
	BCH_OPT_SECTORS,
	BCH_OPT_STR,
	BCH_OPT_FN,
};

/**
 * x(name, shortopt, type, in mem type, mode, sb_opt)
 *
 * @name	- name of mount option, sysfs attribute, and struct bch_opts
 *		  member
 *
 * @mode	- when opt may be set
 *
 * @sb_option	- name of corresponding superblock option
 *
 * @type	- one of OPT_BOOL, OPT_UINT, OPT_STR
 */

/*
 * XXX: add fields for
 *  - default value
 *  - helptext
 */

#define BCH_OPTS()							\
	x(block_size,			u16,				\
	  OPT_FORMAT,							\
	  OPT_SECTORS(1, 128),						\
	  BCH_SB_BLOCK_SIZE,		8,				\
	  "size",	NULL)						\
	x(btree_node_size,		u16,				\
	  OPT_FORMAT,							\
	  OPT_SECTORS(1, 128),						\
	  BCH_SB_BTREE_NODE_SIZE,	512,				\
	  "size",	"Btree node size, default 256k")		\
	x(errors,			u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_STR(bch2_error_actions),					\
	  BCH_SB_ERROR_ACTION,		BCH_ON_ERROR_RO,		\
	  NULL,		"Action to take on filesystem error")		\
	x(metadata_replicas,		u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_UINT(1, BCH_REPLICAS_MAX),				\
	  BCH_SB_META_REPLICAS_WANT,	1,				\
	  "#",		"Number of metadata replicas")			\
	x(data_replicas,		u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_UINT(1, BCH_REPLICAS_MAX),				\
	  BCH_SB_DATA_REPLICAS_WANT,	1,				\
	  "#",		"Number of data replicas")			\
	x(metadata_replicas_required, u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_UINT(1, BCH_REPLICAS_MAX),				\
	  BCH_SB_META_REPLICAS_REQ,	1,				\
	  "#",		NULL)						\
	x(data_replicas_required,	u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_UINT(1, BCH_REPLICAS_MAX),				\
	  BCH_SB_DATA_REPLICAS_REQ,	1,				\
	  "#",		NULL)						\
	x(metadata_checksum,		u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_STR(bch2_csum_types),					\
	  BCH_SB_META_CSUM_TYPE,	BCH_CSUM_OPT_CRC32C,		\
	  NULL,		NULL)						\
	x(data_checksum,		u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_STR(bch2_csum_types),					\
	  BCH_SB_DATA_CSUM_TYPE,	BCH_CSUM_OPT_CRC32C,		\
	  NULL,		NULL)						\
	x(compression,			u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_STR(bch2_compression_types),				\
	  BCH_SB_COMPRESSION_TYPE,	BCH_COMPRESSION_OPT_NONE,	\
	  NULL,		NULL)						\
	x(background_compression,	u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_STR(bch2_compression_types),				\
	  BCH_SB_BACKGROUND_COMPRESSION_TYPE,BCH_COMPRESSION_OPT_NONE,	\
	  NULL,		NULL)						\
	x(str_hash,			u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_STR(bch2_str_hash_types),					\
	  BCH_SB_STR_HASH_TYPE,		BCH_STR_HASH_SIPHASH,		\
	  NULL,		"Hash function for directory entries and xattrs")\
	x(foreground_target,		u16,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_FN(bch2_opt_target),					\
	  BCH_SB_FOREGROUND_TARGET,	0,				\
	  "(target)",	"Device or disk group for foreground writes")	\
	x(background_target,		u16,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_FN(bch2_opt_target),					\
	  BCH_SB_BACKGROUND_TARGET,	0,				\
	  "(target)",	"Device or disk group to move data to in the background")\
	x(promote_target,		u16,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_FN(bch2_opt_target),					\
	  BCH_SB_PROMOTE_TARGET,	0,				\
	  "(target)",	"Device or disk group to promote data to on read")\
	x(erasure_code,			u16,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME|OPT_INODE,			\
	  OPT_BOOL(),							\
	  BCH_SB_ERASURE_CODE,		false,				\
	  NULL,		"Enable erasure coding (DO NOT USE YET)")	\
	x(inodes_32bit,			u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_BOOL(),							\
	  BCH_SB_INODE_32BIT,		false,				\
	  NULL,		"Constrain inode numbers to 32 bits")		\
	x(gc_reserve_percent,		u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_UINT(5, 21),						\
	  BCH_SB_GC_RESERVE,		8,				\
	  "%",		"Percentage of disk space to reserve for copygc")\
	x(gc_reserve_bytes,		u64,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_SECTORS(0, U64_MAX),					\
	  BCH_SB_GC_RESERVE_BYTES,	0,				\
	  "%",		"Amount of disk space to reserve for copygc\n"	\
			"Takes precedence over gc_reserve_percent if set")\
	x(root_reserve_percent,		u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_UINT(0, 100),						\
	  BCH_SB_ROOT_RESERVE,		0,				\
	  "%",		"Percentage of disk space to reserve for superuser")\
	x(wide_macs,			u8,				\
	  OPT_FORMAT|OPT_MOUNT|OPT_RUNTIME,				\
	  OPT_BOOL(),							\
	  BCH_SB_128_BIT_MACS,		false,				\
	  NULL,		"Store full 128 bits of cryptographic MACs, instead of 80")\
	x(acl,				u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_BOOL(),							\
	  BCH_SB_POSIX_ACL,		true,				\
	  NULL,		"Enable POSIX acls")				\
	x(usrquota,			u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_BOOL(),							\
	  BCH_SB_USRQUOTA,		false,				\
	  NULL,		"Enable user quotas")				\
	x(grpquota,			u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_BOOL(),							\
	  BCH_SB_GRPQUOTA,		false,				\
	  NULL,		"Enable group quotas")				\
	x(prjquota,			u8,				\
	  OPT_FORMAT|OPT_MOUNT,						\
	  OPT_BOOL(),							\
	  BCH_SB_PRJQUOTA,		false,				\
	  NULL,		"Enable project quotas")			\
	x(degraded,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Allow mounting in degraded mode")		\
	x(discard,			u8,				\
	  OPT_MOUNT|OPT_DEVICE,						\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Enable discard/TRIM support")			\
	x(verbose,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Extra debugging information during mount/recovery")\
	x(journal_flush_disabled,	u8,				\
	  OPT_MOUNT|OPT_RUNTIME,					\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Disable journal flush on sync/fsync\n"		\
			"If enabled, writes can be lost, but only since the\n"\
			"last journal write (default 1 second)")	\
	x(fsck,				u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			true,				\
	  NULL,		"Run fsck on mount")				\
	x(fix_errors,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Fix errors during fsck without asking")	\
	x(nochanges,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Super read only mode - no writes at all will be issued,\n"\
			"even if we have to replay the journal")	\
	x(noreplay,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Don't replay the journal (only for internal tools)")\
	x(norecovery,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		NULL)						\
	x(noexcl,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Don't open device in exclusive mode")		\
	x(sb,				u64,				\
	  OPT_MOUNT,							\
	  OPT_UINT(0, S64_MAX),						\
	  NO_SB_OPT,			BCH_SB_SECTOR,			\
	  "offset",	"Sector offset of superblock")			\
	x(read_only,			u8,				\
	  0,								\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		NULL)						\
	x(nostart,			u8,				\
	  0,								\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Don\'t start filesystem, only open devices")	\
	x(version_upgrade,		u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Set superblock to latest version,\n"		\
			"allowing any new features to be used")		\
	x(project,			u8,				\
	  OPT_INODE,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		NULL)						\
	x(no_data_io,			u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Skip submit_bio() for data reads and writes, "	\
			"for performance testing purposes")		\
	x(fs_size,			u64,				\
	  OPT_DEVICE,							\
	  OPT_SECTORS(0, S64_MAX),					\
	  NO_SB_OPT,			0,				\
	  "size",	"Size of filesystem on device")			\
	x(bucket,			u32,				\
	  OPT_DEVICE,							\
	  OPT_SECTORS(0, S64_MAX),					\
	  NO_SB_OPT,			0,				\
	  "size",	"Size of filesystem on device")			\
	x(durability,			u8,				\
	  OPT_DEVICE,							\
	  OPT_UINT(0, BCH_REPLICAS_MAX),				\
	  NO_SB_OPT,			1,				\
	  "n",		"Data written to this device will be considered\n"\
			"to have already been replicated n times")	\
	x(new_inode_updates,		u8,				\
	  OPT_MOUNT,							\
	  OPT_BOOL(),							\
	  NO_SB_OPT,			false,				\
	  NULL,		"Enable new btree write-cache for inode updates")


struct bch_opts {
#define x(_name, _bits, ...)	unsigned _name##_defined:1;
	BCH_OPTS()
#undef x

#define x(_name, _bits, ...)	_bits	_name;
	BCH_OPTS()
#undef x
};

static const struct bch_opts bch2_opts_default = {
#define x(_name, _bits, _mode, _type, _sb_opt, _default, ...)		\
	._name##_defined = true,					\
	._name = _default,						\

	BCH_OPTS()
#undef x
};

#define opt_defined(_opts, _name)	((_opts)._name##_defined)

#define opt_get(_opts, _name)						\
	(opt_defined(_opts, _name) ? (_opts)._name : bch2_opts_default._name)

#define opt_set(_opts, _name, _v)					\
do {									\
	(_opts)._name##_defined = true;					\
	(_opts)._name = _v;						\
} while (0)

static inline struct bch_opts bch2_opts_empty(void)
{
	return (struct bch_opts) { 0 };
}

void bch2_opts_apply(struct bch_opts *, struct bch_opts);

enum bch_opt_id {
#define x(_name, ...)	Opt_##_name,
	BCH_OPTS()
#undef x
	bch2_opts_nr
};

struct bch_fs;
struct printbuf;

struct bch_option {
	struct attribute	attr;
	void			(*set_sb)(struct bch_sb *, u64);
	enum opt_mode		mode;
	enum opt_type		type;

	union {
	struct {
		u64		min, max;
	};
	struct {
		const char * const *choices;
	};
	struct {
		int (*parse)(struct bch_fs *, const char *, u64 *);
		void (*to_text)(struct printbuf *, struct bch_fs *, u64);
	};
	};

	const char		*hint;
	const char		*help;

};

extern const struct bch_option bch2_opt_table[];

bool bch2_opt_defined_by_id(const struct bch_opts *, enum bch_opt_id);
u64 bch2_opt_get_by_id(const struct bch_opts *, enum bch_opt_id);
void bch2_opt_set_by_id(struct bch_opts *, enum bch_opt_id, u64);

struct bch_opts bch2_opts_from_sb(struct bch_sb *);

int bch2_opt_lookup(const char *);
int bch2_opt_parse(struct bch_fs *, const struct bch_option *, const char *, u64 *);

#define OPT_SHOW_FULL_LIST	(1 << 0)
#define OPT_SHOW_MOUNT_STYLE	(1 << 1)

void bch2_opt_to_text(struct printbuf *, struct bch_fs *,
		      const struct bch_option *, u64, unsigned);

int bch2_opt_check_may_set(struct bch_fs *, int, u64);
int bch2_opts_check_may_set(struct bch_fs *);
int bch2_parse_mount_opts(struct bch_opts *, char *);

/* inode opts: */

struct bch_io_opts {
#define x(_name, _bits)	unsigned _name##_defined:1;
	BCH_INODE_OPTS()
#undef x

#define x(_name, _bits)	u##_bits _name;
	BCH_INODE_OPTS()
#undef x
};

struct bch_io_opts bch2_opts_to_inode_opts(struct bch_opts);
struct bch_opts bch2_inode_opts_to_opts(struct bch_io_opts);
void bch2_io_opts_apply(struct bch_io_opts *, struct bch_io_opts);
bool bch2_opt_is_inode_opt(enum bch_opt_id);

#endif /* _BCACHEFS_OPTS_H */