xref: /openbmc/linux/fs/btrfs/super.c (revision f125e2d4)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2007 Oracle.  All rights reserved.
4  */
5 
6 #include <linux/blkdev.h>
7 #include <linux/module.h>
8 #include <linux/fs.h>
9 #include <linux/pagemap.h>
10 #include <linux/highmem.h>
11 #include <linux/time.h>
12 #include <linux/init.h>
13 #include <linux/seq_file.h>
14 #include <linux/string.h>
15 #include <linux/backing-dev.h>
16 #include <linux/mount.h>
17 #include <linux/writeback.h>
18 #include <linux/statfs.h>
19 #include <linux/compat.h>
20 #include <linux/parser.h>
21 #include <linux/ctype.h>
22 #include <linux/namei.h>
23 #include <linux/miscdevice.h>
24 #include <linux/magic.h>
25 #include <linux/slab.h>
26 #include <linux/cleancache.h>
27 #include <linux/ratelimit.h>
28 #include <linux/crc32c.h>
29 #include <linux/btrfs.h>
30 #include "delayed-inode.h"
31 #include "ctree.h"
32 #include "disk-io.h"
33 #include "transaction.h"
34 #include "btrfs_inode.h"
35 #include "print-tree.h"
36 #include "props.h"
37 #include "xattr.h"
38 #include "volumes.h"
39 #include "export.h"
40 #include "compression.h"
41 #include "rcu-string.h"
42 #include "dev-replace.h"
43 #include "free-space-cache.h"
44 #include "backref.h"
45 #include "space-info.h"
46 #include "sysfs.h"
47 #include "tests/btrfs-tests.h"
48 #include "block-group.h"
49 #include "discard.h"
50 
51 #include "qgroup.h"
52 #define CREATE_TRACE_POINTS
53 #include <trace/events/btrfs.h>
54 
55 static const struct super_operations btrfs_super_ops;
56 
57 /*
58  * Types for mounting the default subvolume and a subvolume explicitly
59  * requested by subvol=/path. That way the callchain is straightforward and we
60  * don't have to play tricks with the mount options and recursive calls to
61  * btrfs_mount.
62  *
63  * The new btrfs_root_fs_type also servers as a tag for the bdev_holder.
64  */
65 static struct file_system_type btrfs_fs_type;
66 static struct file_system_type btrfs_root_fs_type;
67 
68 static int btrfs_remount(struct super_block *sb, int *flags, char *data);
69 
70 const char * __attribute_const__ btrfs_decode_error(int errno)
71 {
72 	char *errstr = "unknown";
73 
74 	switch (errno) {
75 	case -EIO:
76 		errstr = "IO failure";
77 		break;
78 	case -ENOMEM:
79 		errstr = "Out of memory";
80 		break;
81 	case -EROFS:
82 		errstr = "Readonly filesystem";
83 		break;
84 	case -EEXIST:
85 		errstr = "Object already exists";
86 		break;
87 	case -ENOSPC:
88 		errstr = "No space left";
89 		break;
90 	case -ENOENT:
91 		errstr = "No such entry";
92 		break;
93 	}
94 
95 	return errstr;
96 }
97 
98 /*
99  * __btrfs_handle_fs_error decodes expected errors from the caller and
100  * invokes the appropriate error response.
101  */
102 __cold
103 void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
104 		       unsigned int line, int errno, const char *fmt, ...)
105 {
106 	struct super_block *sb = fs_info->sb;
107 #ifdef CONFIG_PRINTK
108 	const char *errstr;
109 #endif
110 
111 	/*
112 	 * Special case: if the error is EROFS, and we're already
113 	 * under SB_RDONLY, then it is safe here.
114 	 */
115 	if (errno == -EROFS && sb_rdonly(sb))
116   		return;
117 
118 #ifdef CONFIG_PRINTK
119 	errstr = btrfs_decode_error(errno);
120 	if (fmt) {
121 		struct va_format vaf;
122 		va_list args;
123 
124 		va_start(args, fmt);
125 		vaf.fmt = fmt;
126 		vaf.va = &args;
127 
128 		pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n",
129 			sb->s_id, function, line, errno, errstr, &vaf);
130 		va_end(args);
131 	} else {
132 		pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s\n",
133 			sb->s_id, function, line, errno, errstr);
134 	}
135 #endif
136 
137 	/*
138 	 * Today we only save the error info to memory.  Long term we'll
139 	 * also send it down to the disk
140 	 */
141 	set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
142 
143 	/* Don't go through full error handling during mount */
144 	if (!(sb->s_flags & SB_BORN))
145 		return;
146 
147 	if (sb_rdonly(sb))
148 		return;
149 
150 	btrfs_discard_stop(fs_info);
151 
152 	/* btrfs handle error by forcing the filesystem readonly */
153 	sb->s_flags |= SB_RDONLY;
154 	btrfs_info(fs_info, "forced readonly");
155 	/*
156 	 * Note that a running device replace operation is not canceled here
157 	 * although there is no way to update the progress. It would add the
158 	 * risk of a deadlock, therefore the canceling is omitted. The only
159 	 * penalty is that some I/O remains active until the procedure
160 	 * completes. The next time when the filesystem is mounted writable
161 	 * again, the device replace operation continues.
162 	 */
163 }
164 
165 #ifdef CONFIG_PRINTK
166 static const char * const logtypes[] = {
167 	"emergency",
168 	"alert",
169 	"critical",
170 	"error",
171 	"warning",
172 	"notice",
173 	"info",
174 	"debug",
175 };
176 
177 
178 /*
179  * Use one ratelimit state per log level so that a flood of less important
180  * messages doesn't cause more important ones to be dropped.
181  */
182 static struct ratelimit_state printk_limits[] = {
183 	RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
184 	RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
185 	RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
186 	RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
187 	RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
188 	RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
189 	RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
190 	RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
191 };
192 
193 void __cold btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
194 {
195 	char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
196 	struct va_format vaf;
197 	va_list args;
198 	int kern_level;
199 	const char *type = logtypes[4];
200 	struct ratelimit_state *ratelimit = &printk_limits[4];
201 
202 	va_start(args, fmt);
203 
204 	while ((kern_level = printk_get_level(fmt)) != 0) {
205 		size_t size = printk_skip_level(fmt) - fmt;
206 
207 		if (kern_level >= '0' && kern_level <= '7') {
208 			memcpy(lvl, fmt,  size);
209 			lvl[size] = '\0';
210 			type = logtypes[kern_level - '0'];
211 			ratelimit = &printk_limits[kern_level - '0'];
212 		}
213 		fmt += size;
214 	}
215 
216 	vaf.fmt = fmt;
217 	vaf.va = &args;
218 
219 	if (__ratelimit(ratelimit))
220 		printk("%sBTRFS %s (device %s): %pV\n", lvl, type,
221 			fs_info ? fs_info->sb->s_id : "<unknown>", &vaf);
222 
223 	va_end(args);
224 }
225 #endif
226 
227 /*
228  * We only mark the transaction aborted and then set the file system read-only.
229  * This will prevent new transactions from starting or trying to join this
230  * one.
231  *
232  * This means that error recovery at the call site is limited to freeing
233  * any local memory allocations and passing the error code up without
234  * further cleanup. The transaction should complete as it normally would
235  * in the call path but will return -EIO.
236  *
237  * We'll complete the cleanup in btrfs_end_transaction and
238  * btrfs_commit_transaction.
239  */
240 __cold
241 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
242 			       const char *function,
243 			       unsigned int line, int errno)
244 {
245 	struct btrfs_fs_info *fs_info = trans->fs_info;
246 
247 	trans->aborted = errno;
248 	/* Nothing used. The other threads that have joined this
249 	 * transaction may be able to continue. */
250 	if (!trans->dirty && list_empty(&trans->new_bgs)) {
251 		const char *errstr;
252 
253 		errstr = btrfs_decode_error(errno);
254 		btrfs_warn(fs_info,
255 		           "%s:%d: Aborting unused transaction(%s).",
256 		           function, line, errstr);
257 		return;
258 	}
259 	WRITE_ONCE(trans->transaction->aborted, errno);
260 	/* Wake up anybody who may be waiting on this transaction */
261 	wake_up(&fs_info->transaction_wait);
262 	wake_up(&fs_info->transaction_blocked_wait);
263 	__btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
264 }
265 /*
266  * __btrfs_panic decodes unexpected, fatal errors from the caller,
267  * issues an alert, and either panics or BUGs, depending on mount options.
268  */
269 __cold
270 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
271 		   unsigned int line, int errno, const char *fmt, ...)
272 {
273 	char *s_id = "<unknown>";
274 	const char *errstr;
275 	struct va_format vaf = { .fmt = fmt };
276 	va_list args;
277 
278 	if (fs_info)
279 		s_id = fs_info->sb->s_id;
280 
281 	va_start(args, fmt);
282 	vaf.va = &args;
283 
284 	errstr = btrfs_decode_error(errno);
285 	if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
286 		panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
287 			s_id, function, line, &vaf, errno, errstr);
288 
289 	btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
290 		   function, line, &vaf, errno, errstr);
291 	va_end(args);
292 	/* Caller calls BUG() */
293 }
294 
295 static void btrfs_put_super(struct super_block *sb)
296 {
297 	close_ctree(btrfs_sb(sb));
298 }
299 
300 enum {
301 	Opt_acl, Opt_noacl,
302 	Opt_clear_cache,
303 	Opt_commit_interval,
304 	Opt_compress,
305 	Opt_compress_force,
306 	Opt_compress_force_type,
307 	Opt_compress_type,
308 	Opt_degraded,
309 	Opt_device,
310 	Opt_fatal_errors,
311 	Opt_flushoncommit, Opt_noflushoncommit,
312 	Opt_inode_cache, Opt_noinode_cache,
313 	Opt_max_inline,
314 	Opt_barrier, Opt_nobarrier,
315 	Opt_datacow, Opt_nodatacow,
316 	Opt_datasum, Opt_nodatasum,
317 	Opt_defrag, Opt_nodefrag,
318 	Opt_discard, Opt_nodiscard,
319 	Opt_discard_mode,
320 	Opt_nologreplay,
321 	Opt_norecovery,
322 	Opt_ratio,
323 	Opt_rescan_uuid_tree,
324 	Opt_skip_balance,
325 	Opt_space_cache, Opt_no_space_cache,
326 	Opt_space_cache_version,
327 	Opt_ssd, Opt_nossd,
328 	Opt_ssd_spread, Opt_nossd_spread,
329 	Opt_subvol,
330 	Opt_subvol_empty,
331 	Opt_subvolid,
332 	Opt_thread_pool,
333 	Opt_treelog, Opt_notreelog,
334 	Opt_usebackuproot,
335 	Opt_user_subvol_rm_allowed,
336 
337 	/* Deprecated options */
338 	Opt_alloc_start,
339 	Opt_recovery,
340 	Opt_subvolrootid,
341 
342 	/* Debugging options */
343 	Opt_check_integrity,
344 	Opt_check_integrity_including_extent_data,
345 	Opt_check_integrity_print_mask,
346 	Opt_enospc_debug, Opt_noenospc_debug,
347 #ifdef CONFIG_BTRFS_DEBUG
348 	Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all,
349 #endif
350 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
351 	Opt_ref_verify,
352 #endif
353 	Opt_err,
354 };
355 
356 static const match_table_t tokens = {
357 	{Opt_acl, "acl"},
358 	{Opt_noacl, "noacl"},
359 	{Opt_clear_cache, "clear_cache"},
360 	{Opt_commit_interval, "commit=%u"},
361 	{Opt_compress, "compress"},
362 	{Opt_compress_type, "compress=%s"},
363 	{Opt_compress_force, "compress-force"},
364 	{Opt_compress_force_type, "compress-force=%s"},
365 	{Opt_degraded, "degraded"},
366 	{Opt_device, "device=%s"},
367 	{Opt_fatal_errors, "fatal_errors=%s"},
368 	{Opt_flushoncommit, "flushoncommit"},
369 	{Opt_noflushoncommit, "noflushoncommit"},
370 	{Opt_inode_cache, "inode_cache"},
371 	{Opt_noinode_cache, "noinode_cache"},
372 	{Opt_max_inline, "max_inline=%s"},
373 	{Opt_barrier, "barrier"},
374 	{Opt_nobarrier, "nobarrier"},
375 	{Opt_datacow, "datacow"},
376 	{Opt_nodatacow, "nodatacow"},
377 	{Opt_datasum, "datasum"},
378 	{Opt_nodatasum, "nodatasum"},
379 	{Opt_defrag, "autodefrag"},
380 	{Opt_nodefrag, "noautodefrag"},
381 	{Opt_discard, "discard"},
382 	{Opt_discard_mode, "discard=%s"},
383 	{Opt_nodiscard, "nodiscard"},
384 	{Opt_nologreplay, "nologreplay"},
385 	{Opt_norecovery, "norecovery"},
386 	{Opt_ratio, "metadata_ratio=%u"},
387 	{Opt_rescan_uuid_tree, "rescan_uuid_tree"},
388 	{Opt_skip_balance, "skip_balance"},
389 	{Opt_space_cache, "space_cache"},
390 	{Opt_no_space_cache, "nospace_cache"},
391 	{Opt_space_cache_version, "space_cache=%s"},
392 	{Opt_ssd, "ssd"},
393 	{Opt_nossd, "nossd"},
394 	{Opt_ssd_spread, "ssd_spread"},
395 	{Opt_nossd_spread, "nossd_spread"},
396 	{Opt_subvol, "subvol=%s"},
397 	{Opt_subvol_empty, "subvol="},
398 	{Opt_subvolid, "subvolid=%s"},
399 	{Opt_thread_pool, "thread_pool=%u"},
400 	{Opt_treelog, "treelog"},
401 	{Opt_notreelog, "notreelog"},
402 	{Opt_usebackuproot, "usebackuproot"},
403 	{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
404 
405 	/* Deprecated options */
406 	{Opt_alloc_start, "alloc_start=%s"},
407 	{Opt_recovery, "recovery"},
408 	{Opt_subvolrootid, "subvolrootid=%d"},
409 
410 	/* Debugging options */
411 	{Opt_check_integrity, "check_int"},
412 	{Opt_check_integrity_including_extent_data, "check_int_data"},
413 	{Opt_check_integrity_print_mask, "check_int_print_mask=%u"},
414 	{Opt_enospc_debug, "enospc_debug"},
415 	{Opt_noenospc_debug, "noenospc_debug"},
416 #ifdef CONFIG_BTRFS_DEBUG
417 	{Opt_fragment_data, "fragment=data"},
418 	{Opt_fragment_metadata, "fragment=metadata"},
419 	{Opt_fragment_all, "fragment=all"},
420 #endif
421 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
422 	{Opt_ref_verify, "ref_verify"},
423 #endif
424 	{Opt_err, NULL},
425 };
426 
427 /*
428  * Regular mount options parser.  Everything that is needed only when
429  * reading in a new superblock is parsed here.
430  * XXX JDM: This needs to be cleaned up for remount.
431  */
432 int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
433 			unsigned long new_flags)
434 {
435 	substring_t args[MAX_OPT_ARGS];
436 	char *p, *num;
437 	u64 cache_gen;
438 	int intarg;
439 	int ret = 0;
440 	char *compress_type;
441 	bool compress_force = false;
442 	enum btrfs_compression_type saved_compress_type;
443 	bool saved_compress_force;
444 	int no_compress = 0;
445 
446 	cache_gen = btrfs_super_cache_generation(info->super_copy);
447 	if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
448 		btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE);
449 	else if (cache_gen)
450 		btrfs_set_opt(info->mount_opt, SPACE_CACHE);
451 
452 	/*
453 	 * Even the options are empty, we still need to do extra check
454 	 * against new flags
455 	 */
456 	if (!options)
457 		goto check;
458 
459 	while ((p = strsep(&options, ",")) != NULL) {
460 		int token;
461 		if (!*p)
462 			continue;
463 
464 		token = match_token(p, tokens, args);
465 		switch (token) {
466 		case Opt_degraded:
467 			btrfs_info(info, "allowing degraded mounts");
468 			btrfs_set_opt(info->mount_opt, DEGRADED);
469 			break;
470 		case Opt_subvol:
471 		case Opt_subvol_empty:
472 		case Opt_subvolid:
473 		case Opt_subvolrootid:
474 		case Opt_device:
475 			/*
476 			 * These are parsed by btrfs_parse_subvol_options or
477 			 * btrfs_parse_device_options and can be ignored here.
478 			 */
479 			break;
480 		case Opt_nodatasum:
481 			btrfs_set_and_info(info, NODATASUM,
482 					   "setting nodatasum");
483 			break;
484 		case Opt_datasum:
485 			if (btrfs_test_opt(info, NODATASUM)) {
486 				if (btrfs_test_opt(info, NODATACOW))
487 					btrfs_info(info,
488 						   "setting datasum, datacow enabled");
489 				else
490 					btrfs_info(info, "setting datasum");
491 			}
492 			btrfs_clear_opt(info->mount_opt, NODATACOW);
493 			btrfs_clear_opt(info->mount_opt, NODATASUM);
494 			break;
495 		case Opt_nodatacow:
496 			if (!btrfs_test_opt(info, NODATACOW)) {
497 				if (!btrfs_test_opt(info, COMPRESS) ||
498 				    !btrfs_test_opt(info, FORCE_COMPRESS)) {
499 					btrfs_info(info,
500 						   "setting nodatacow, compression disabled");
501 				} else {
502 					btrfs_info(info, "setting nodatacow");
503 				}
504 			}
505 			btrfs_clear_opt(info->mount_opt, COMPRESS);
506 			btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
507 			btrfs_set_opt(info->mount_opt, NODATACOW);
508 			btrfs_set_opt(info->mount_opt, NODATASUM);
509 			break;
510 		case Opt_datacow:
511 			btrfs_clear_and_info(info, NODATACOW,
512 					     "setting datacow");
513 			break;
514 		case Opt_compress_force:
515 		case Opt_compress_force_type:
516 			compress_force = true;
517 			/* Fallthrough */
518 		case Opt_compress:
519 		case Opt_compress_type:
520 			saved_compress_type = btrfs_test_opt(info,
521 							     COMPRESS) ?
522 				info->compress_type : BTRFS_COMPRESS_NONE;
523 			saved_compress_force =
524 				btrfs_test_opt(info, FORCE_COMPRESS);
525 			if (token == Opt_compress ||
526 			    token == Opt_compress_force ||
527 			    strncmp(args[0].from, "zlib", 4) == 0) {
528 				compress_type = "zlib";
529 
530 				info->compress_type = BTRFS_COMPRESS_ZLIB;
531 				info->compress_level = BTRFS_ZLIB_DEFAULT_LEVEL;
532 				/*
533 				 * args[0] contains uninitialized data since
534 				 * for these tokens we don't expect any
535 				 * parameter.
536 				 */
537 				if (token != Opt_compress &&
538 				    token != Opt_compress_force)
539 					info->compress_level =
540 					  btrfs_compress_str2level(
541 							BTRFS_COMPRESS_ZLIB,
542 							args[0].from + 4);
543 				btrfs_set_opt(info->mount_opt, COMPRESS);
544 				btrfs_clear_opt(info->mount_opt, NODATACOW);
545 				btrfs_clear_opt(info->mount_opt, NODATASUM);
546 				no_compress = 0;
547 			} else if (strncmp(args[0].from, "lzo", 3) == 0) {
548 				compress_type = "lzo";
549 				info->compress_type = BTRFS_COMPRESS_LZO;
550 				btrfs_set_opt(info->mount_opt, COMPRESS);
551 				btrfs_clear_opt(info->mount_opt, NODATACOW);
552 				btrfs_clear_opt(info->mount_opt, NODATASUM);
553 				btrfs_set_fs_incompat(info, COMPRESS_LZO);
554 				no_compress = 0;
555 			} else if (strncmp(args[0].from, "zstd", 4) == 0) {
556 				compress_type = "zstd";
557 				info->compress_type = BTRFS_COMPRESS_ZSTD;
558 				info->compress_level =
559 					btrfs_compress_str2level(
560 							 BTRFS_COMPRESS_ZSTD,
561 							 args[0].from + 4);
562 				btrfs_set_opt(info->mount_opt, COMPRESS);
563 				btrfs_clear_opt(info->mount_opt, NODATACOW);
564 				btrfs_clear_opt(info->mount_opt, NODATASUM);
565 				btrfs_set_fs_incompat(info, COMPRESS_ZSTD);
566 				no_compress = 0;
567 			} else if (strncmp(args[0].from, "no", 2) == 0) {
568 				compress_type = "no";
569 				btrfs_clear_opt(info->mount_opt, COMPRESS);
570 				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
571 				compress_force = false;
572 				no_compress++;
573 			} else {
574 				ret = -EINVAL;
575 				goto out;
576 			}
577 
578 			if (compress_force) {
579 				btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
580 			} else {
581 				/*
582 				 * If we remount from compress-force=xxx to
583 				 * compress=xxx, we need clear FORCE_COMPRESS
584 				 * flag, otherwise, there is no way for users
585 				 * to disable forcible compression separately.
586 				 */
587 				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
588 			}
589 			if ((btrfs_test_opt(info, COMPRESS) &&
590 			     (info->compress_type != saved_compress_type ||
591 			      compress_force != saved_compress_force)) ||
592 			    (!btrfs_test_opt(info, COMPRESS) &&
593 			     no_compress == 1)) {
594 				btrfs_info(info, "%s %s compression, level %d",
595 					   (compress_force) ? "force" : "use",
596 					   compress_type, info->compress_level);
597 			}
598 			compress_force = false;
599 			break;
600 		case Opt_ssd:
601 			btrfs_set_and_info(info, SSD,
602 					   "enabling ssd optimizations");
603 			btrfs_clear_opt(info->mount_opt, NOSSD);
604 			break;
605 		case Opt_ssd_spread:
606 			btrfs_set_and_info(info, SSD,
607 					   "enabling ssd optimizations");
608 			btrfs_set_and_info(info, SSD_SPREAD,
609 					   "using spread ssd allocation scheme");
610 			btrfs_clear_opt(info->mount_opt, NOSSD);
611 			break;
612 		case Opt_nossd:
613 			btrfs_set_opt(info->mount_opt, NOSSD);
614 			btrfs_clear_and_info(info, SSD,
615 					     "not using ssd optimizations");
616 			/* Fallthrough */
617 		case Opt_nossd_spread:
618 			btrfs_clear_and_info(info, SSD_SPREAD,
619 					     "not using spread ssd allocation scheme");
620 			break;
621 		case Opt_barrier:
622 			btrfs_clear_and_info(info, NOBARRIER,
623 					     "turning on barriers");
624 			break;
625 		case Opt_nobarrier:
626 			btrfs_set_and_info(info, NOBARRIER,
627 					   "turning off barriers");
628 			break;
629 		case Opt_thread_pool:
630 			ret = match_int(&args[0], &intarg);
631 			if (ret) {
632 				goto out;
633 			} else if (intarg == 0) {
634 				ret = -EINVAL;
635 				goto out;
636 			}
637 			info->thread_pool_size = intarg;
638 			break;
639 		case Opt_max_inline:
640 			num = match_strdup(&args[0]);
641 			if (num) {
642 				info->max_inline = memparse(num, NULL);
643 				kfree(num);
644 
645 				if (info->max_inline) {
646 					info->max_inline = min_t(u64,
647 						info->max_inline,
648 						info->sectorsize);
649 				}
650 				btrfs_info(info, "max_inline at %llu",
651 					   info->max_inline);
652 			} else {
653 				ret = -ENOMEM;
654 				goto out;
655 			}
656 			break;
657 		case Opt_alloc_start:
658 			btrfs_info(info,
659 				"option alloc_start is obsolete, ignored");
660 			break;
661 		case Opt_acl:
662 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
663 			info->sb->s_flags |= SB_POSIXACL;
664 			break;
665 #else
666 			btrfs_err(info, "support for ACL not compiled in!");
667 			ret = -EINVAL;
668 			goto out;
669 #endif
670 		case Opt_noacl:
671 			info->sb->s_flags &= ~SB_POSIXACL;
672 			break;
673 		case Opt_notreelog:
674 			btrfs_set_and_info(info, NOTREELOG,
675 					   "disabling tree log");
676 			break;
677 		case Opt_treelog:
678 			btrfs_clear_and_info(info, NOTREELOG,
679 					     "enabling tree log");
680 			break;
681 		case Opt_norecovery:
682 		case Opt_nologreplay:
683 			btrfs_set_and_info(info, NOLOGREPLAY,
684 					   "disabling log replay at mount time");
685 			break;
686 		case Opt_flushoncommit:
687 			btrfs_set_and_info(info, FLUSHONCOMMIT,
688 					   "turning on flush-on-commit");
689 			break;
690 		case Opt_noflushoncommit:
691 			btrfs_clear_and_info(info, FLUSHONCOMMIT,
692 					     "turning off flush-on-commit");
693 			break;
694 		case Opt_ratio:
695 			ret = match_int(&args[0], &intarg);
696 			if (ret)
697 				goto out;
698 			info->metadata_ratio = intarg;
699 			btrfs_info(info, "metadata ratio %u",
700 				   info->metadata_ratio);
701 			break;
702 		case Opt_discard:
703 		case Opt_discard_mode:
704 			if (token == Opt_discard ||
705 			    strcmp(args[0].from, "sync") == 0) {
706 				btrfs_clear_opt(info->mount_opt, DISCARD_ASYNC);
707 				btrfs_set_and_info(info, DISCARD_SYNC,
708 						   "turning on sync discard");
709 			} else if (strcmp(args[0].from, "async") == 0) {
710 				btrfs_clear_opt(info->mount_opt, DISCARD_SYNC);
711 				btrfs_set_and_info(info, DISCARD_ASYNC,
712 						   "turning on async discard");
713 			} else {
714 				ret = -EINVAL;
715 				goto out;
716 			}
717 			break;
718 		case Opt_nodiscard:
719 			btrfs_clear_and_info(info, DISCARD_SYNC,
720 					     "turning off discard");
721 			btrfs_clear_and_info(info, DISCARD_ASYNC,
722 					     "turning off async discard");
723 			break;
724 		case Opt_space_cache:
725 		case Opt_space_cache_version:
726 			if (token == Opt_space_cache ||
727 			    strcmp(args[0].from, "v1") == 0) {
728 				btrfs_clear_opt(info->mount_opt,
729 						FREE_SPACE_TREE);
730 				btrfs_set_and_info(info, SPACE_CACHE,
731 					   "enabling disk space caching");
732 			} else if (strcmp(args[0].from, "v2") == 0) {
733 				btrfs_clear_opt(info->mount_opt,
734 						SPACE_CACHE);
735 				btrfs_set_and_info(info, FREE_SPACE_TREE,
736 						   "enabling free space tree");
737 			} else {
738 				ret = -EINVAL;
739 				goto out;
740 			}
741 			break;
742 		case Opt_rescan_uuid_tree:
743 			btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
744 			break;
745 		case Opt_no_space_cache:
746 			if (btrfs_test_opt(info, SPACE_CACHE)) {
747 				btrfs_clear_and_info(info, SPACE_CACHE,
748 					     "disabling disk space caching");
749 			}
750 			if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
751 				btrfs_clear_and_info(info, FREE_SPACE_TREE,
752 					     "disabling free space tree");
753 			}
754 			break;
755 		case Opt_inode_cache:
756 			btrfs_set_pending_and_info(info, INODE_MAP_CACHE,
757 					   "enabling inode map caching");
758 			break;
759 		case Opt_noinode_cache:
760 			btrfs_clear_pending_and_info(info, INODE_MAP_CACHE,
761 					     "disabling inode map caching");
762 			break;
763 		case Opt_clear_cache:
764 			btrfs_set_and_info(info, CLEAR_CACHE,
765 					   "force clearing of disk cache");
766 			break;
767 		case Opt_user_subvol_rm_allowed:
768 			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
769 			break;
770 		case Opt_enospc_debug:
771 			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
772 			break;
773 		case Opt_noenospc_debug:
774 			btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
775 			break;
776 		case Opt_defrag:
777 			btrfs_set_and_info(info, AUTO_DEFRAG,
778 					   "enabling auto defrag");
779 			break;
780 		case Opt_nodefrag:
781 			btrfs_clear_and_info(info, AUTO_DEFRAG,
782 					     "disabling auto defrag");
783 			break;
784 		case Opt_recovery:
785 			btrfs_warn(info,
786 				   "'recovery' is deprecated, use 'usebackuproot' instead");
787 			/* fall through */
788 		case Opt_usebackuproot:
789 			btrfs_info(info,
790 				   "trying to use backup root at mount time");
791 			btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
792 			break;
793 		case Opt_skip_balance:
794 			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
795 			break;
796 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
797 		case Opt_check_integrity_including_extent_data:
798 			btrfs_info(info,
799 				   "enabling check integrity including extent data");
800 			btrfs_set_opt(info->mount_opt,
801 				      CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
802 			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
803 			break;
804 		case Opt_check_integrity:
805 			btrfs_info(info, "enabling check integrity");
806 			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
807 			break;
808 		case Opt_check_integrity_print_mask:
809 			ret = match_int(&args[0], &intarg);
810 			if (ret)
811 				goto out;
812 			info->check_integrity_print_mask = intarg;
813 			btrfs_info(info, "check_integrity_print_mask 0x%x",
814 				   info->check_integrity_print_mask);
815 			break;
816 #else
817 		case Opt_check_integrity_including_extent_data:
818 		case Opt_check_integrity:
819 		case Opt_check_integrity_print_mask:
820 			btrfs_err(info,
821 				  "support for check_integrity* not compiled in!");
822 			ret = -EINVAL;
823 			goto out;
824 #endif
825 		case Opt_fatal_errors:
826 			if (strcmp(args[0].from, "panic") == 0)
827 				btrfs_set_opt(info->mount_opt,
828 					      PANIC_ON_FATAL_ERROR);
829 			else if (strcmp(args[0].from, "bug") == 0)
830 				btrfs_clear_opt(info->mount_opt,
831 					      PANIC_ON_FATAL_ERROR);
832 			else {
833 				ret = -EINVAL;
834 				goto out;
835 			}
836 			break;
837 		case Opt_commit_interval:
838 			intarg = 0;
839 			ret = match_int(&args[0], &intarg);
840 			if (ret)
841 				goto out;
842 			if (intarg == 0) {
843 				btrfs_info(info,
844 					   "using default commit interval %us",
845 					   BTRFS_DEFAULT_COMMIT_INTERVAL);
846 				intarg = BTRFS_DEFAULT_COMMIT_INTERVAL;
847 			} else if (intarg > 300) {
848 				btrfs_warn(info, "excessive commit interval %d",
849 					   intarg);
850 			}
851 			info->commit_interval = intarg;
852 			break;
853 #ifdef CONFIG_BTRFS_DEBUG
854 		case Opt_fragment_all:
855 			btrfs_info(info, "fragmenting all space");
856 			btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
857 			btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA);
858 			break;
859 		case Opt_fragment_metadata:
860 			btrfs_info(info, "fragmenting metadata");
861 			btrfs_set_opt(info->mount_opt,
862 				      FRAGMENT_METADATA);
863 			break;
864 		case Opt_fragment_data:
865 			btrfs_info(info, "fragmenting data");
866 			btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
867 			break;
868 #endif
869 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
870 		case Opt_ref_verify:
871 			btrfs_info(info, "doing ref verification");
872 			btrfs_set_opt(info->mount_opt, REF_VERIFY);
873 			break;
874 #endif
875 		case Opt_err:
876 			btrfs_info(info, "unrecognized mount option '%s'", p);
877 			ret = -EINVAL;
878 			goto out;
879 		default:
880 			break;
881 		}
882 	}
883 check:
884 	/*
885 	 * Extra check for current option against current flag
886 	 */
887 	if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & SB_RDONLY)) {
888 		btrfs_err(info,
889 			  "nologreplay must be used with ro mount option");
890 		ret = -EINVAL;
891 	}
892 out:
893 	if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE) &&
894 	    !btrfs_test_opt(info, FREE_SPACE_TREE) &&
895 	    !btrfs_test_opt(info, CLEAR_CACHE)) {
896 		btrfs_err(info, "cannot disable free space tree");
897 		ret = -EINVAL;
898 
899 	}
900 	if (!ret && btrfs_test_opt(info, SPACE_CACHE))
901 		btrfs_info(info, "disk space caching is enabled");
902 	if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))
903 		btrfs_info(info, "using free space tree");
904 	return ret;
905 }
906 
907 /*
908  * Parse mount options that are required early in the mount process.
909  *
910  * All other options will be parsed on much later in the mount process and
911  * only when we need to allocate a new super block.
912  */
913 static int btrfs_parse_device_options(const char *options, fmode_t flags,
914 				      void *holder)
915 {
916 	substring_t args[MAX_OPT_ARGS];
917 	char *device_name, *opts, *orig, *p;
918 	struct btrfs_device *device = NULL;
919 	int error = 0;
920 
921 	lockdep_assert_held(&uuid_mutex);
922 
923 	if (!options)
924 		return 0;
925 
926 	/*
927 	 * strsep changes the string, duplicate it because btrfs_parse_options
928 	 * gets called later
929 	 */
930 	opts = kstrdup(options, GFP_KERNEL);
931 	if (!opts)
932 		return -ENOMEM;
933 	orig = opts;
934 
935 	while ((p = strsep(&opts, ",")) != NULL) {
936 		int token;
937 
938 		if (!*p)
939 			continue;
940 
941 		token = match_token(p, tokens, args);
942 		if (token == Opt_device) {
943 			device_name = match_strdup(&args[0]);
944 			if (!device_name) {
945 				error = -ENOMEM;
946 				goto out;
947 			}
948 			device = btrfs_scan_one_device(device_name, flags,
949 					holder);
950 			kfree(device_name);
951 			if (IS_ERR(device)) {
952 				error = PTR_ERR(device);
953 				goto out;
954 			}
955 		}
956 	}
957 
958 out:
959 	kfree(orig);
960 	return error;
961 }
962 
963 /*
964  * Parse mount options that are related to subvolume id
965  *
966  * The value is later passed to mount_subvol()
967  */
968 static int btrfs_parse_subvol_options(const char *options, char **subvol_name,
969 		u64 *subvol_objectid)
970 {
971 	substring_t args[MAX_OPT_ARGS];
972 	char *opts, *orig, *p;
973 	int error = 0;
974 	u64 subvolid;
975 
976 	if (!options)
977 		return 0;
978 
979 	/*
980 	 * strsep changes the string, duplicate it because
981 	 * btrfs_parse_device_options gets called later
982 	 */
983 	opts = kstrdup(options, GFP_KERNEL);
984 	if (!opts)
985 		return -ENOMEM;
986 	orig = opts;
987 
988 	while ((p = strsep(&opts, ",")) != NULL) {
989 		int token;
990 		if (!*p)
991 			continue;
992 
993 		token = match_token(p, tokens, args);
994 		switch (token) {
995 		case Opt_subvol:
996 			kfree(*subvol_name);
997 			*subvol_name = match_strdup(&args[0]);
998 			if (!*subvol_name) {
999 				error = -ENOMEM;
1000 				goto out;
1001 			}
1002 			break;
1003 		case Opt_subvolid:
1004 			error = match_u64(&args[0], &subvolid);
1005 			if (error)
1006 				goto out;
1007 
1008 			/* we want the original fs_tree */
1009 			if (subvolid == 0)
1010 				subvolid = BTRFS_FS_TREE_OBJECTID;
1011 
1012 			*subvol_objectid = subvolid;
1013 			break;
1014 		case Opt_subvolrootid:
1015 			pr_warn("BTRFS: 'subvolrootid' mount option is deprecated and has no effect\n");
1016 			break;
1017 		default:
1018 			break;
1019 		}
1020 	}
1021 
1022 out:
1023 	kfree(orig);
1024 	return error;
1025 }
1026 
1027 static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
1028 					   u64 subvol_objectid)
1029 {
1030 	struct btrfs_root *root = fs_info->tree_root;
1031 	struct btrfs_root *fs_root;
1032 	struct btrfs_root_ref *root_ref;
1033 	struct btrfs_inode_ref *inode_ref;
1034 	struct btrfs_key key;
1035 	struct btrfs_path *path = NULL;
1036 	char *name = NULL, *ptr;
1037 	u64 dirid;
1038 	int len;
1039 	int ret;
1040 
1041 	path = btrfs_alloc_path();
1042 	if (!path) {
1043 		ret = -ENOMEM;
1044 		goto err;
1045 	}
1046 	path->leave_spinning = 1;
1047 
1048 	name = kmalloc(PATH_MAX, GFP_KERNEL);
1049 	if (!name) {
1050 		ret = -ENOMEM;
1051 		goto err;
1052 	}
1053 	ptr = name + PATH_MAX - 1;
1054 	ptr[0] = '\0';
1055 
1056 	/*
1057 	 * Walk up the subvolume trees in the tree of tree roots by root
1058 	 * backrefs until we hit the top-level subvolume.
1059 	 */
1060 	while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) {
1061 		key.objectid = subvol_objectid;
1062 		key.type = BTRFS_ROOT_BACKREF_KEY;
1063 		key.offset = (u64)-1;
1064 
1065 		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1066 		if (ret < 0) {
1067 			goto err;
1068 		} else if (ret > 0) {
1069 			ret = btrfs_previous_item(root, path, subvol_objectid,
1070 						  BTRFS_ROOT_BACKREF_KEY);
1071 			if (ret < 0) {
1072 				goto err;
1073 			} else if (ret > 0) {
1074 				ret = -ENOENT;
1075 				goto err;
1076 			}
1077 		}
1078 
1079 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1080 		subvol_objectid = key.offset;
1081 
1082 		root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1083 					  struct btrfs_root_ref);
1084 		len = btrfs_root_ref_name_len(path->nodes[0], root_ref);
1085 		ptr -= len + 1;
1086 		if (ptr < name) {
1087 			ret = -ENAMETOOLONG;
1088 			goto err;
1089 		}
1090 		read_extent_buffer(path->nodes[0], ptr + 1,
1091 				   (unsigned long)(root_ref + 1), len);
1092 		ptr[0] = '/';
1093 		dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
1094 		btrfs_release_path(path);
1095 
1096 		key.objectid = subvol_objectid;
1097 		key.type = BTRFS_ROOT_ITEM_KEY;
1098 		key.offset = (u64)-1;
1099 		fs_root = btrfs_read_fs_root_no_name(fs_info, &key);
1100 		if (IS_ERR(fs_root)) {
1101 			ret = PTR_ERR(fs_root);
1102 			goto err;
1103 		}
1104 
1105 		/*
1106 		 * Walk up the filesystem tree by inode refs until we hit the
1107 		 * root directory.
1108 		 */
1109 		while (dirid != BTRFS_FIRST_FREE_OBJECTID) {
1110 			key.objectid = dirid;
1111 			key.type = BTRFS_INODE_REF_KEY;
1112 			key.offset = (u64)-1;
1113 
1114 			ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0);
1115 			if (ret < 0) {
1116 				goto err;
1117 			} else if (ret > 0) {
1118 				ret = btrfs_previous_item(fs_root, path, dirid,
1119 							  BTRFS_INODE_REF_KEY);
1120 				if (ret < 0) {
1121 					goto err;
1122 				} else if (ret > 0) {
1123 					ret = -ENOENT;
1124 					goto err;
1125 				}
1126 			}
1127 
1128 			btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1129 			dirid = key.offset;
1130 
1131 			inode_ref = btrfs_item_ptr(path->nodes[0],
1132 						   path->slots[0],
1133 						   struct btrfs_inode_ref);
1134 			len = btrfs_inode_ref_name_len(path->nodes[0],
1135 						       inode_ref);
1136 			ptr -= len + 1;
1137 			if (ptr < name) {
1138 				ret = -ENAMETOOLONG;
1139 				goto err;
1140 			}
1141 			read_extent_buffer(path->nodes[0], ptr + 1,
1142 					   (unsigned long)(inode_ref + 1), len);
1143 			ptr[0] = '/';
1144 			btrfs_release_path(path);
1145 		}
1146 	}
1147 
1148 	btrfs_free_path(path);
1149 	if (ptr == name + PATH_MAX - 1) {
1150 		name[0] = '/';
1151 		name[1] = '\0';
1152 	} else {
1153 		memmove(name, ptr, name + PATH_MAX - ptr);
1154 	}
1155 	return name;
1156 
1157 err:
1158 	btrfs_free_path(path);
1159 	kfree(name);
1160 	return ERR_PTR(ret);
1161 }
1162 
1163 static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)
1164 {
1165 	struct btrfs_root *root = fs_info->tree_root;
1166 	struct btrfs_dir_item *di;
1167 	struct btrfs_path *path;
1168 	struct btrfs_key location;
1169 	u64 dir_id;
1170 
1171 	path = btrfs_alloc_path();
1172 	if (!path)
1173 		return -ENOMEM;
1174 	path->leave_spinning = 1;
1175 
1176 	/*
1177 	 * Find the "default" dir item which points to the root item that we
1178 	 * will mount by default if we haven't been given a specific subvolume
1179 	 * to mount.
1180 	 */
1181 	dir_id = btrfs_super_root_dir(fs_info->super_copy);
1182 	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
1183 	if (IS_ERR(di)) {
1184 		btrfs_free_path(path);
1185 		return PTR_ERR(di);
1186 	}
1187 	if (!di) {
1188 		/*
1189 		 * Ok the default dir item isn't there.  This is weird since
1190 		 * it's always been there, but don't freak out, just try and
1191 		 * mount the top-level subvolume.
1192 		 */
1193 		btrfs_free_path(path);
1194 		*objectid = BTRFS_FS_TREE_OBJECTID;
1195 		return 0;
1196 	}
1197 
1198 	btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
1199 	btrfs_free_path(path);
1200 	*objectid = location.objectid;
1201 	return 0;
1202 }
1203 
1204 static int btrfs_fill_super(struct super_block *sb,
1205 			    struct btrfs_fs_devices *fs_devices,
1206 			    void *data)
1207 {
1208 	struct inode *inode;
1209 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1210 	struct btrfs_key key;
1211 	int err;
1212 
1213 	sb->s_maxbytes = MAX_LFS_FILESIZE;
1214 	sb->s_magic = BTRFS_SUPER_MAGIC;
1215 	sb->s_op = &btrfs_super_ops;
1216 	sb->s_d_op = &btrfs_dentry_operations;
1217 	sb->s_export_op = &btrfs_export_ops;
1218 	sb->s_xattr = btrfs_xattr_handlers;
1219 	sb->s_time_gran = 1;
1220 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
1221 	sb->s_flags |= SB_POSIXACL;
1222 #endif
1223 	sb->s_flags |= SB_I_VERSION;
1224 	sb->s_iflags |= SB_I_CGROUPWB;
1225 
1226 	err = super_setup_bdi(sb);
1227 	if (err) {
1228 		btrfs_err(fs_info, "super_setup_bdi failed");
1229 		return err;
1230 	}
1231 
1232 	err = open_ctree(sb, fs_devices, (char *)data);
1233 	if (err) {
1234 		btrfs_err(fs_info, "open_ctree failed");
1235 		return err;
1236 	}
1237 
1238 	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
1239 	key.type = BTRFS_INODE_ITEM_KEY;
1240 	key.offset = 0;
1241 	inode = btrfs_iget(sb, &key, fs_info->fs_root);
1242 	if (IS_ERR(inode)) {
1243 		err = PTR_ERR(inode);
1244 		goto fail_close;
1245 	}
1246 
1247 	sb->s_root = d_make_root(inode);
1248 	if (!sb->s_root) {
1249 		err = -ENOMEM;
1250 		goto fail_close;
1251 	}
1252 
1253 	cleancache_init_fs(sb);
1254 	sb->s_flags |= SB_ACTIVE;
1255 	return 0;
1256 
1257 fail_close:
1258 	close_ctree(fs_info);
1259 	return err;
1260 }
1261 
1262 int btrfs_sync_fs(struct super_block *sb, int wait)
1263 {
1264 	struct btrfs_trans_handle *trans;
1265 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1266 	struct btrfs_root *root = fs_info->tree_root;
1267 
1268 	trace_btrfs_sync_fs(fs_info, wait);
1269 
1270 	if (!wait) {
1271 		filemap_flush(fs_info->btree_inode->i_mapping);
1272 		return 0;
1273 	}
1274 
1275 	btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
1276 
1277 	trans = btrfs_attach_transaction_barrier(root);
1278 	if (IS_ERR(trans)) {
1279 		/* no transaction, don't bother */
1280 		if (PTR_ERR(trans) == -ENOENT) {
1281 			/*
1282 			 * Exit unless we have some pending changes
1283 			 * that need to go through commit
1284 			 */
1285 			if (fs_info->pending_changes == 0)
1286 				return 0;
1287 			/*
1288 			 * A non-blocking test if the fs is frozen. We must not
1289 			 * start a new transaction here otherwise a deadlock
1290 			 * happens. The pending operations are delayed to the
1291 			 * next commit after thawing.
1292 			 */
1293 			if (sb_start_write_trylock(sb))
1294 				sb_end_write(sb);
1295 			else
1296 				return 0;
1297 			trans = btrfs_start_transaction(root, 0);
1298 		}
1299 		if (IS_ERR(trans))
1300 			return PTR_ERR(trans);
1301 	}
1302 	return btrfs_commit_transaction(trans);
1303 }
1304 
1305 static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
1306 {
1307 	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
1308 	const char *compress_type;
1309 
1310 	if (btrfs_test_opt(info, DEGRADED))
1311 		seq_puts(seq, ",degraded");
1312 	if (btrfs_test_opt(info, NODATASUM))
1313 		seq_puts(seq, ",nodatasum");
1314 	if (btrfs_test_opt(info, NODATACOW))
1315 		seq_puts(seq, ",nodatacow");
1316 	if (btrfs_test_opt(info, NOBARRIER))
1317 		seq_puts(seq, ",nobarrier");
1318 	if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)
1319 		seq_printf(seq, ",max_inline=%llu", info->max_inline);
1320 	if (info->thread_pool_size !=  min_t(unsigned long,
1321 					     num_online_cpus() + 2, 8))
1322 		seq_printf(seq, ",thread_pool=%u", info->thread_pool_size);
1323 	if (btrfs_test_opt(info, COMPRESS)) {
1324 		compress_type = btrfs_compress_type2str(info->compress_type);
1325 		if (btrfs_test_opt(info, FORCE_COMPRESS))
1326 			seq_printf(seq, ",compress-force=%s", compress_type);
1327 		else
1328 			seq_printf(seq, ",compress=%s", compress_type);
1329 		if (info->compress_level)
1330 			seq_printf(seq, ":%d", info->compress_level);
1331 	}
1332 	if (btrfs_test_opt(info, NOSSD))
1333 		seq_puts(seq, ",nossd");
1334 	if (btrfs_test_opt(info, SSD_SPREAD))
1335 		seq_puts(seq, ",ssd_spread");
1336 	else if (btrfs_test_opt(info, SSD))
1337 		seq_puts(seq, ",ssd");
1338 	if (btrfs_test_opt(info, NOTREELOG))
1339 		seq_puts(seq, ",notreelog");
1340 	if (btrfs_test_opt(info, NOLOGREPLAY))
1341 		seq_puts(seq, ",nologreplay");
1342 	if (btrfs_test_opt(info, FLUSHONCOMMIT))
1343 		seq_puts(seq, ",flushoncommit");
1344 	if (btrfs_test_opt(info, DISCARD_SYNC))
1345 		seq_puts(seq, ",discard");
1346 	if (btrfs_test_opt(info, DISCARD_ASYNC))
1347 		seq_puts(seq, ",discard=async");
1348 	if (!(info->sb->s_flags & SB_POSIXACL))
1349 		seq_puts(seq, ",noacl");
1350 	if (btrfs_test_opt(info, SPACE_CACHE))
1351 		seq_puts(seq, ",space_cache");
1352 	else if (btrfs_test_opt(info, FREE_SPACE_TREE))
1353 		seq_puts(seq, ",space_cache=v2");
1354 	else
1355 		seq_puts(seq, ",nospace_cache");
1356 	if (btrfs_test_opt(info, RESCAN_UUID_TREE))
1357 		seq_puts(seq, ",rescan_uuid_tree");
1358 	if (btrfs_test_opt(info, CLEAR_CACHE))
1359 		seq_puts(seq, ",clear_cache");
1360 	if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED))
1361 		seq_puts(seq, ",user_subvol_rm_allowed");
1362 	if (btrfs_test_opt(info, ENOSPC_DEBUG))
1363 		seq_puts(seq, ",enospc_debug");
1364 	if (btrfs_test_opt(info, AUTO_DEFRAG))
1365 		seq_puts(seq, ",autodefrag");
1366 	if (btrfs_test_opt(info, INODE_MAP_CACHE))
1367 		seq_puts(seq, ",inode_cache");
1368 	if (btrfs_test_opt(info, SKIP_BALANCE))
1369 		seq_puts(seq, ",skip_balance");
1370 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1371 	if (btrfs_test_opt(info, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
1372 		seq_puts(seq, ",check_int_data");
1373 	else if (btrfs_test_opt(info, CHECK_INTEGRITY))
1374 		seq_puts(seq, ",check_int");
1375 	if (info->check_integrity_print_mask)
1376 		seq_printf(seq, ",check_int_print_mask=%d",
1377 				info->check_integrity_print_mask);
1378 #endif
1379 	if (info->metadata_ratio)
1380 		seq_printf(seq, ",metadata_ratio=%u", info->metadata_ratio);
1381 	if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR))
1382 		seq_puts(seq, ",fatal_errors=panic");
1383 	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
1384 		seq_printf(seq, ",commit=%u", info->commit_interval);
1385 #ifdef CONFIG_BTRFS_DEBUG
1386 	if (btrfs_test_opt(info, FRAGMENT_DATA))
1387 		seq_puts(seq, ",fragment=data");
1388 	if (btrfs_test_opt(info, FRAGMENT_METADATA))
1389 		seq_puts(seq, ",fragment=metadata");
1390 #endif
1391 	if (btrfs_test_opt(info, REF_VERIFY))
1392 		seq_puts(seq, ",ref_verify");
1393 	seq_printf(seq, ",subvolid=%llu",
1394 		  BTRFS_I(d_inode(dentry))->root->root_key.objectid);
1395 	seq_puts(seq, ",subvol=");
1396 	seq_dentry(seq, dentry, " \t\n\\");
1397 	return 0;
1398 }
1399 
1400 static int btrfs_test_super(struct super_block *s, void *data)
1401 {
1402 	struct btrfs_fs_info *p = data;
1403 	struct btrfs_fs_info *fs_info = btrfs_sb(s);
1404 
1405 	return fs_info->fs_devices == p->fs_devices;
1406 }
1407 
1408 static int btrfs_set_super(struct super_block *s, void *data)
1409 {
1410 	int err = set_anon_super(s, data);
1411 	if (!err)
1412 		s->s_fs_info = data;
1413 	return err;
1414 }
1415 
1416 /*
1417  * subvolumes are identified by ino 256
1418  */
1419 static inline int is_subvolume_inode(struct inode *inode)
1420 {
1421 	if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
1422 		return 1;
1423 	return 0;
1424 }
1425 
1426 static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid,
1427 				   struct vfsmount *mnt)
1428 {
1429 	struct dentry *root;
1430 	int ret;
1431 
1432 	if (!subvol_name) {
1433 		if (!subvol_objectid) {
1434 			ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb),
1435 							  &subvol_objectid);
1436 			if (ret) {
1437 				root = ERR_PTR(ret);
1438 				goto out;
1439 			}
1440 		}
1441 		subvol_name = get_subvol_name_from_objectid(btrfs_sb(mnt->mnt_sb),
1442 							    subvol_objectid);
1443 		if (IS_ERR(subvol_name)) {
1444 			root = ERR_CAST(subvol_name);
1445 			subvol_name = NULL;
1446 			goto out;
1447 		}
1448 
1449 	}
1450 
1451 	root = mount_subtree(mnt, subvol_name);
1452 	/* mount_subtree() drops our reference on the vfsmount. */
1453 	mnt = NULL;
1454 
1455 	if (!IS_ERR(root)) {
1456 		struct super_block *s = root->d_sb;
1457 		struct btrfs_fs_info *fs_info = btrfs_sb(s);
1458 		struct inode *root_inode = d_inode(root);
1459 		u64 root_objectid = BTRFS_I(root_inode)->root->root_key.objectid;
1460 
1461 		ret = 0;
1462 		if (!is_subvolume_inode(root_inode)) {
1463 			btrfs_err(fs_info, "'%s' is not a valid subvolume",
1464 			       subvol_name);
1465 			ret = -EINVAL;
1466 		}
1467 		if (subvol_objectid && root_objectid != subvol_objectid) {
1468 			/*
1469 			 * This will also catch a race condition where a
1470 			 * subvolume which was passed by ID is renamed and
1471 			 * another subvolume is renamed over the old location.
1472 			 */
1473 			btrfs_err(fs_info,
1474 				  "subvol '%s' does not match subvolid %llu",
1475 				  subvol_name, subvol_objectid);
1476 			ret = -EINVAL;
1477 		}
1478 		if (ret) {
1479 			dput(root);
1480 			root = ERR_PTR(ret);
1481 			deactivate_locked_super(s);
1482 		}
1483 	}
1484 
1485 out:
1486 	mntput(mnt);
1487 	kfree(subvol_name);
1488 	return root;
1489 }
1490 
1491 /*
1492  * Find a superblock for the given device / mount point.
1493  *
1494  * Note: This is based on mount_bdev from fs/super.c with a few additions
1495  *       for multiple device setup.  Make sure to keep it in sync.
1496  */
1497 static struct dentry *btrfs_mount_root(struct file_system_type *fs_type,
1498 		int flags, const char *device_name, void *data)
1499 {
1500 	struct block_device *bdev = NULL;
1501 	struct super_block *s;
1502 	struct btrfs_device *device = NULL;
1503 	struct btrfs_fs_devices *fs_devices = NULL;
1504 	struct btrfs_fs_info *fs_info = NULL;
1505 	void *new_sec_opts = NULL;
1506 	fmode_t mode = FMODE_READ;
1507 	int error = 0;
1508 
1509 	if (!(flags & SB_RDONLY))
1510 		mode |= FMODE_WRITE;
1511 
1512 	if (data) {
1513 		error = security_sb_eat_lsm_opts(data, &new_sec_opts);
1514 		if (error)
1515 			return ERR_PTR(error);
1516 	}
1517 
1518 	/*
1519 	 * Setup a dummy root and fs_info for test/set super.  This is because
1520 	 * we don't actually fill this stuff out until open_ctree, but we need
1521 	 * it for searching for existing supers, so this lets us do that and
1522 	 * then open_ctree will properly initialize everything later.
1523 	 */
1524 	fs_info = kvzalloc(sizeof(struct btrfs_fs_info), GFP_KERNEL);
1525 	if (!fs_info) {
1526 		error = -ENOMEM;
1527 		goto error_sec_opts;
1528 	}
1529 
1530 	fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
1531 	fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
1532 	if (!fs_info->super_copy || !fs_info->super_for_commit) {
1533 		error = -ENOMEM;
1534 		goto error_fs_info;
1535 	}
1536 
1537 	mutex_lock(&uuid_mutex);
1538 	error = btrfs_parse_device_options(data, mode, fs_type);
1539 	if (error) {
1540 		mutex_unlock(&uuid_mutex);
1541 		goto error_fs_info;
1542 	}
1543 
1544 	device = btrfs_scan_one_device(device_name, mode, fs_type);
1545 	if (IS_ERR(device)) {
1546 		mutex_unlock(&uuid_mutex);
1547 		error = PTR_ERR(device);
1548 		goto error_fs_info;
1549 	}
1550 
1551 	fs_devices = device->fs_devices;
1552 	fs_info->fs_devices = fs_devices;
1553 
1554 	error = btrfs_open_devices(fs_devices, mode, fs_type);
1555 	mutex_unlock(&uuid_mutex);
1556 	if (error)
1557 		goto error_fs_info;
1558 
1559 	if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) {
1560 		error = -EACCES;
1561 		goto error_close_devices;
1562 	}
1563 
1564 	bdev = fs_devices->latest_bdev;
1565 	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | SB_NOSEC,
1566 		 fs_info);
1567 	if (IS_ERR(s)) {
1568 		error = PTR_ERR(s);
1569 		goto error_close_devices;
1570 	}
1571 
1572 	if (s->s_root) {
1573 		btrfs_close_devices(fs_devices);
1574 		free_fs_info(fs_info);
1575 		if ((flags ^ s->s_flags) & SB_RDONLY)
1576 			error = -EBUSY;
1577 	} else {
1578 		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1579 		btrfs_sb(s)->bdev_holder = fs_type;
1580 		if (!strstr(crc32c_impl(), "generic"))
1581 			set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
1582 		error = btrfs_fill_super(s, fs_devices, data);
1583 	}
1584 	if (!error)
1585 		error = security_sb_set_mnt_opts(s, new_sec_opts, 0, NULL);
1586 	security_free_mnt_opts(&new_sec_opts);
1587 	if (error) {
1588 		deactivate_locked_super(s);
1589 		return ERR_PTR(error);
1590 	}
1591 
1592 	return dget(s->s_root);
1593 
1594 error_close_devices:
1595 	btrfs_close_devices(fs_devices);
1596 error_fs_info:
1597 	free_fs_info(fs_info);
1598 error_sec_opts:
1599 	security_free_mnt_opts(&new_sec_opts);
1600 	return ERR_PTR(error);
1601 }
1602 
1603 /*
1604  * Mount function which is called by VFS layer.
1605  *
1606  * In order to allow mounting a subvolume directly, btrfs uses mount_subtree()
1607  * which needs vfsmount* of device's root (/).  This means device's root has to
1608  * be mounted internally in any case.
1609  *
1610  * Operation flow:
1611  *   1. Parse subvol id related options for later use in mount_subvol().
1612  *
1613  *   2. Mount device's root (/) by calling vfs_kern_mount().
1614  *
1615  *      NOTE: vfs_kern_mount() is used by VFS to call btrfs_mount() in the
1616  *      first place. In order to avoid calling btrfs_mount() again, we use
1617  *      different file_system_type which is not registered to VFS by
1618  *      register_filesystem() (btrfs_root_fs_type). As a result,
1619  *      btrfs_mount_root() is called. The return value will be used by
1620  *      mount_subtree() in mount_subvol().
1621  *
1622  *   3. Call mount_subvol() to get the dentry of subvolume. Since there is
1623  *      "btrfs subvolume set-default", mount_subvol() is called always.
1624  */
1625 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1626 		const char *device_name, void *data)
1627 {
1628 	struct vfsmount *mnt_root;
1629 	struct dentry *root;
1630 	char *subvol_name = NULL;
1631 	u64 subvol_objectid = 0;
1632 	int error = 0;
1633 
1634 	error = btrfs_parse_subvol_options(data, &subvol_name,
1635 					&subvol_objectid);
1636 	if (error) {
1637 		kfree(subvol_name);
1638 		return ERR_PTR(error);
1639 	}
1640 
1641 	/* mount device's root (/) */
1642 	mnt_root = vfs_kern_mount(&btrfs_root_fs_type, flags, device_name, data);
1643 	if (PTR_ERR_OR_ZERO(mnt_root) == -EBUSY) {
1644 		if (flags & SB_RDONLY) {
1645 			mnt_root = vfs_kern_mount(&btrfs_root_fs_type,
1646 				flags & ~SB_RDONLY, device_name, data);
1647 		} else {
1648 			mnt_root = vfs_kern_mount(&btrfs_root_fs_type,
1649 				flags | SB_RDONLY, device_name, data);
1650 			if (IS_ERR(mnt_root)) {
1651 				root = ERR_CAST(mnt_root);
1652 				kfree(subvol_name);
1653 				goto out;
1654 			}
1655 
1656 			down_write(&mnt_root->mnt_sb->s_umount);
1657 			error = btrfs_remount(mnt_root->mnt_sb, &flags, NULL);
1658 			up_write(&mnt_root->mnt_sb->s_umount);
1659 			if (error < 0) {
1660 				root = ERR_PTR(error);
1661 				mntput(mnt_root);
1662 				kfree(subvol_name);
1663 				goto out;
1664 			}
1665 		}
1666 	}
1667 	if (IS_ERR(mnt_root)) {
1668 		root = ERR_CAST(mnt_root);
1669 		kfree(subvol_name);
1670 		goto out;
1671 	}
1672 
1673 	/* mount_subvol() will free subvol_name and mnt_root */
1674 	root = mount_subvol(subvol_name, subvol_objectid, mnt_root);
1675 
1676 out:
1677 	return root;
1678 }
1679 
1680 static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
1681 				     u32 new_pool_size, u32 old_pool_size)
1682 {
1683 	if (new_pool_size == old_pool_size)
1684 		return;
1685 
1686 	fs_info->thread_pool_size = new_pool_size;
1687 
1688 	btrfs_info(fs_info, "resize thread pool %d -> %d",
1689 	       old_pool_size, new_pool_size);
1690 
1691 	btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
1692 	btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
1693 	btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);
1694 	btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size);
1695 	btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size);
1696 	btrfs_workqueue_set_max(fs_info->endio_meta_write_workers,
1697 				new_pool_size);
1698 	btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);
1699 	btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);
1700 	btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);
1701 	btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size);
1702 	btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers,
1703 				new_pool_size);
1704 }
1705 
1706 static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
1707 {
1708 	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1709 }
1710 
1711 static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
1712 				       unsigned long old_opts, int flags)
1713 {
1714 	if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1715 	    (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1716 	     (flags & SB_RDONLY))) {
1717 		/* wait for any defraggers to finish */
1718 		wait_event(fs_info->transaction_wait,
1719 			   (atomic_read(&fs_info->defrag_running) == 0));
1720 		if (flags & SB_RDONLY)
1721 			sync_filesystem(fs_info->sb);
1722 	}
1723 }
1724 
1725 static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
1726 					 unsigned long old_opts)
1727 {
1728 	/*
1729 	 * We need to cleanup all defragable inodes if the autodefragment is
1730 	 * close or the filesystem is read only.
1731 	 */
1732 	if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1733 	    (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) {
1734 		btrfs_cleanup_defrag_inodes(fs_info);
1735 	}
1736 
1737 	/* If we toggled discard async */
1738 	if (!btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) &&
1739 	    btrfs_test_opt(fs_info, DISCARD_ASYNC))
1740 		btrfs_discard_resume(fs_info);
1741 	else if (btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) &&
1742 		 !btrfs_test_opt(fs_info, DISCARD_ASYNC))
1743 		btrfs_discard_cleanup(fs_info);
1744 
1745 	clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1746 }
1747 
1748 static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1749 {
1750 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1751 	struct btrfs_root *root = fs_info->tree_root;
1752 	unsigned old_flags = sb->s_flags;
1753 	unsigned long old_opts = fs_info->mount_opt;
1754 	unsigned long old_compress_type = fs_info->compress_type;
1755 	u64 old_max_inline = fs_info->max_inline;
1756 	u32 old_thread_pool_size = fs_info->thread_pool_size;
1757 	u32 old_metadata_ratio = fs_info->metadata_ratio;
1758 	int ret;
1759 
1760 	sync_filesystem(sb);
1761 	btrfs_remount_prepare(fs_info);
1762 
1763 	if (data) {
1764 		void *new_sec_opts = NULL;
1765 
1766 		ret = security_sb_eat_lsm_opts(data, &new_sec_opts);
1767 		if (!ret)
1768 			ret = security_sb_remount(sb, new_sec_opts);
1769 		security_free_mnt_opts(&new_sec_opts);
1770 		if (ret)
1771 			goto restore;
1772 	}
1773 
1774 	ret = btrfs_parse_options(fs_info, data, *flags);
1775 	if (ret)
1776 		goto restore;
1777 
1778 	btrfs_remount_begin(fs_info, old_opts, *flags);
1779 	btrfs_resize_thread_pool(fs_info,
1780 		fs_info->thread_pool_size, old_thread_pool_size);
1781 
1782 	if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
1783 		goto out;
1784 
1785 	if (*flags & SB_RDONLY) {
1786 		/*
1787 		 * this also happens on 'umount -rf' or on shutdown, when
1788 		 * the filesystem is busy.
1789 		 */
1790 		cancel_work_sync(&fs_info->async_reclaim_work);
1791 
1792 		btrfs_discard_cleanup(fs_info);
1793 
1794 		/* wait for the uuid_scan task to finish */
1795 		down(&fs_info->uuid_tree_rescan_sem);
1796 		/* avoid complains from lockdep et al. */
1797 		up(&fs_info->uuid_tree_rescan_sem);
1798 
1799 		sb->s_flags |= SB_RDONLY;
1800 
1801 		/*
1802 		 * Setting SB_RDONLY will put the cleaner thread to
1803 		 * sleep at the next loop if it's already active.
1804 		 * If it's already asleep, we'll leave unused block
1805 		 * groups on disk until we're mounted read-write again
1806 		 * unless we clean them up here.
1807 		 */
1808 		btrfs_delete_unused_bgs(fs_info);
1809 
1810 		btrfs_dev_replace_suspend_for_unmount(fs_info);
1811 		btrfs_scrub_cancel(fs_info);
1812 		btrfs_pause_balance(fs_info);
1813 
1814 		ret = btrfs_commit_super(fs_info);
1815 		if (ret)
1816 			goto restore;
1817 	} else {
1818 		if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
1819 			btrfs_err(fs_info,
1820 				"Remounting read-write after error is not allowed");
1821 			ret = -EINVAL;
1822 			goto restore;
1823 		}
1824 		if (fs_info->fs_devices->rw_devices == 0) {
1825 			ret = -EACCES;
1826 			goto restore;
1827 		}
1828 
1829 		if (!btrfs_check_rw_degradable(fs_info, NULL)) {
1830 			btrfs_warn(fs_info,
1831 		"too many missing devices, writable remount is not allowed");
1832 			ret = -EACCES;
1833 			goto restore;
1834 		}
1835 
1836 		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1837 			btrfs_warn(fs_info,
1838 		"mount required to replay tree-log, cannot remount read-write");
1839 			ret = -EINVAL;
1840 			goto restore;
1841 		}
1842 
1843 		ret = btrfs_cleanup_fs_roots(fs_info);
1844 		if (ret)
1845 			goto restore;
1846 
1847 		/* recover relocation */
1848 		mutex_lock(&fs_info->cleaner_mutex);
1849 		ret = btrfs_recover_relocation(root);
1850 		mutex_unlock(&fs_info->cleaner_mutex);
1851 		if (ret)
1852 			goto restore;
1853 
1854 		ret = btrfs_resume_balance_async(fs_info);
1855 		if (ret)
1856 			goto restore;
1857 
1858 		ret = btrfs_resume_dev_replace_async(fs_info);
1859 		if (ret) {
1860 			btrfs_warn(fs_info, "failed to resume dev_replace");
1861 			goto restore;
1862 		}
1863 
1864 		btrfs_qgroup_rescan_resume(fs_info);
1865 
1866 		if (!fs_info->uuid_root) {
1867 			btrfs_info(fs_info, "creating UUID tree");
1868 			ret = btrfs_create_uuid_tree(fs_info);
1869 			if (ret) {
1870 				btrfs_warn(fs_info,
1871 					   "failed to create the UUID tree %d",
1872 					   ret);
1873 				goto restore;
1874 			}
1875 		}
1876 		sb->s_flags &= ~SB_RDONLY;
1877 
1878 		set_bit(BTRFS_FS_OPEN, &fs_info->flags);
1879 	}
1880 out:
1881 	wake_up_process(fs_info->transaction_kthread);
1882 	btrfs_remount_cleanup(fs_info, old_opts);
1883 	return 0;
1884 
1885 restore:
1886 	/* We've hit an error - don't reset SB_RDONLY */
1887 	if (sb_rdonly(sb))
1888 		old_flags |= SB_RDONLY;
1889 	sb->s_flags = old_flags;
1890 	fs_info->mount_opt = old_opts;
1891 	fs_info->compress_type = old_compress_type;
1892 	fs_info->max_inline = old_max_inline;
1893 	btrfs_resize_thread_pool(fs_info,
1894 		old_thread_pool_size, fs_info->thread_pool_size);
1895 	fs_info->metadata_ratio = old_metadata_ratio;
1896 	btrfs_remount_cleanup(fs_info, old_opts);
1897 	return ret;
1898 }
1899 
1900 /* Used to sort the devices by max_avail(descending sort) */
1901 static inline int btrfs_cmp_device_free_bytes(const void *dev_info1,
1902 				       const void *dev_info2)
1903 {
1904 	if (((struct btrfs_device_info *)dev_info1)->max_avail >
1905 	    ((struct btrfs_device_info *)dev_info2)->max_avail)
1906 		return -1;
1907 	else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1908 		 ((struct btrfs_device_info *)dev_info2)->max_avail)
1909 		return 1;
1910 	else
1911 	return 0;
1912 }
1913 
1914 /*
1915  * sort the devices by max_avail, in which max free extent size of each device
1916  * is stored.(Descending Sort)
1917  */
1918 static inline void btrfs_descending_sort_devices(
1919 					struct btrfs_device_info *devices,
1920 					size_t nr_devices)
1921 {
1922 	sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1923 	     btrfs_cmp_device_free_bytes, NULL);
1924 }
1925 
1926 /*
1927  * The helper to calc the free space on the devices that can be used to store
1928  * file data.
1929  */
1930 static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,
1931 					      u64 *free_bytes)
1932 {
1933 	struct btrfs_device_info *devices_info;
1934 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1935 	struct btrfs_device *device;
1936 	u64 type;
1937 	u64 avail_space;
1938 	u64 min_stripe_size;
1939 	int num_stripes = 1;
1940 	int i = 0, nr_devices;
1941 	const struct btrfs_raid_attr *rattr;
1942 
1943 	/*
1944 	 * We aren't under the device list lock, so this is racy-ish, but good
1945 	 * enough for our purposes.
1946 	 */
1947 	nr_devices = fs_info->fs_devices->open_devices;
1948 	if (!nr_devices) {
1949 		smp_mb();
1950 		nr_devices = fs_info->fs_devices->open_devices;
1951 		ASSERT(nr_devices);
1952 		if (!nr_devices) {
1953 			*free_bytes = 0;
1954 			return 0;
1955 		}
1956 	}
1957 
1958 	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1959 			       GFP_KERNEL);
1960 	if (!devices_info)
1961 		return -ENOMEM;
1962 
1963 	/* calc min stripe number for data space allocation */
1964 	type = btrfs_data_alloc_profile(fs_info);
1965 	rattr = &btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)];
1966 
1967 	if (type & BTRFS_BLOCK_GROUP_RAID0)
1968 		num_stripes = nr_devices;
1969 	else if (type & BTRFS_BLOCK_GROUP_RAID1)
1970 		num_stripes = 2;
1971 	else if (type & BTRFS_BLOCK_GROUP_RAID1C3)
1972 		num_stripes = 3;
1973 	else if (type & BTRFS_BLOCK_GROUP_RAID1C4)
1974 		num_stripes = 4;
1975 	else if (type & BTRFS_BLOCK_GROUP_RAID10)
1976 		num_stripes = 4;
1977 
1978 	/* Adjust for more than 1 stripe per device */
1979 	min_stripe_size = rattr->dev_stripes * BTRFS_STRIPE_LEN;
1980 
1981 	rcu_read_lock();
1982 	list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
1983 		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA,
1984 						&device->dev_state) ||
1985 		    !device->bdev ||
1986 		    test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state))
1987 			continue;
1988 
1989 		if (i >= nr_devices)
1990 			break;
1991 
1992 		avail_space = device->total_bytes - device->bytes_used;
1993 
1994 		/* align with stripe_len */
1995 		avail_space = rounddown(avail_space, BTRFS_STRIPE_LEN);
1996 
1997 		/*
1998 		 * In order to avoid overwriting the superblock on the drive,
1999 		 * btrfs starts at an offset of at least 1MB when doing chunk
2000 		 * allocation.
2001 		 *
2002 		 * This ensures we have at least min_stripe_size free space
2003 		 * after excluding 1MB.
2004 		 */
2005 		if (avail_space <= SZ_1M + min_stripe_size)
2006 			continue;
2007 
2008 		avail_space -= SZ_1M;
2009 
2010 		devices_info[i].dev = device;
2011 		devices_info[i].max_avail = avail_space;
2012 
2013 		i++;
2014 	}
2015 	rcu_read_unlock();
2016 
2017 	nr_devices = i;
2018 
2019 	btrfs_descending_sort_devices(devices_info, nr_devices);
2020 
2021 	i = nr_devices - 1;
2022 	avail_space = 0;
2023 	while (nr_devices >= rattr->devs_min) {
2024 		num_stripes = min(num_stripes, nr_devices);
2025 
2026 		if (devices_info[i].max_avail >= min_stripe_size) {
2027 			int j;
2028 			u64 alloc_size;
2029 
2030 			avail_space += devices_info[i].max_avail * num_stripes;
2031 			alloc_size = devices_info[i].max_avail;
2032 			for (j = i + 1 - num_stripes; j <= i; j++)
2033 				devices_info[j].max_avail -= alloc_size;
2034 		}
2035 		i--;
2036 		nr_devices--;
2037 	}
2038 
2039 	kfree(devices_info);
2040 	*free_bytes = avail_space;
2041 	return 0;
2042 }
2043 
2044 /*
2045  * Calculate numbers for 'df', pessimistic in case of mixed raid profiles.
2046  *
2047  * If there's a redundant raid level at DATA block groups, use the respective
2048  * multiplier to scale the sizes.
2049  *
2050  * Unused device space usage is based on simulating the chunk allocator
2051  * algorithm that respects the device sizes and order of allocations.  This is
2052  * a close approximation of the actual use but there are other factors that may
2053  * change the result (like a new metadata chunk).
2054  *
2055  * If metadata is exhausted, f_bavail will be 0.
2056  */
2057 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
2058 {
2059 	struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
2060 	struct btrfs_super_block *disk_super = fs_info->super_copy;
2061 	struct btrfs_space_info *found;
2062 	u64 total_used = 0;
2063 	u64 total_free_data = 0;
2064 	u64 total_free_meta = 0;
2065 	int bits = dentry->d_sb->s_blocksize_bits;
2066 	__be32 *fsid = (__be32 *)fs_info->fs_devices->fsid;
2067 	unsigned factor = 1;
2068 	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
2069 	int ret;
2070 	u64 thresh = 0;
2071 	int mixed = 0;
2072 
2073 	rcu_read_lock();
2074 	list_for_each_entry_rcu(found, &fs_info->space_info, list) {
2075 		if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
2076 			int i;
2077 
2078 			total_free_data += found->disk_total - found->disk_used;
2079 			total_free_data -=
2080 				btrfs_account_ro_block_groups_free_space(found);
2081 
2082 			for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
2083 				if (!list_empty(&found->block_groups[i]))
2084 					factor = btrfs_bg_type_to_factor(
2085 						btrfs_raid_array[i].bg_flag);
2086 			}
2087 		}
2088 
2089 		/*
2090 		 * Metadata in mixed block goup profiles are accounted in data
2091 		 */
2092 		if (!mixed && found->flags & BTRFS_BLOCK_GROUP_METADATA) {
2093 			if (found->flags & BTRFS_BLOCK_GROUP_DATA)
2094 				mixed = 1;
2095 			else
2096 				total_free_meta += found->disk_total -
2097 					found->disk_used;
2098 		}
2099 
2100 		total_used += found->disk_used;
2101 	}
2102 
2103 	rcu_read_unlock();
2104 
2105 	buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor);
2106 	buf->f_blocks >>= bits;
2107 	buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits);
2108 
2109 	/* Account global block reserve as used, it's in logical size already */
2110 	spin_lock(&block_rsv->lock);
2111 	/* Mixed block groups accounting is not byte-accurate, avoid overflow */
2112 	if (buf->f_bfree >= block_rsv->size >> bits)
2113 		buf->f_bfree -= block_rsv->size >> bits;
2114 	else
2115 		buf->f_bfree = 0;
2116 	spin_unlock(&block_rsv->lock);
2117 
2118 	buf->f_bavail = div_u64(total_free_data, factor);
2119 	ret = btrfs_calc_avail_data_space(fs_info, &total_free_data);
2120 	if (ret)
2121 		return ret;
2122 	buf->f_bavail += div_u64(total_free_data, factor);
2123 	buf->f_bavail = buf->f_bavail >> bits;
2124 
2125 	/*
2126 	 * We calculate the remaining metadata space minus global reserve. If
2127 	 * this is (supposedly) smaller than zero, there's no space. But this
2128 	 * does not hold in practice, the exhausted state happens where's still
2129 	 * some positive delta. So we apply some guesswork and compare the
2130 	 * delta to a 4M threshold.  (Practically observed delta was ~2M.)
2131 	 *
2132 	 * We probably cannot calculate the exact threshold value because this
2133 	 * depends on the internal reservations requested by various
2134 	 * operations, so some operations that consume a few metadata will
2135 	 * succeed even if the Avail is zero. But this is better than the other
2136 	 * way around.
2137 	 */
2138 	thresh = SZ_4M;
2139 
2140 	/*
2141 	 * We only want to claim there's no available space if we can no longer
2142 	 * allocate chunks for our metadata profile and our global reserve will
2143 	 * not fit in the free metadata space.  If we aren't ->full then we
2144 	 * still can allocate chunks and thus are fine using the currently
2145 	 * calculated f_bavail.
2146 	 */
2147 	if (!mixed && block_rsv->space_info->full &&
2148 	    total_free_meta - thresh < block_rsv->size)
2149 		buf->f_bavail = 0;
2150 
2151 	buf->f_type = BTRFS_SUPER_MAGIC;
2152 	buf->f_bsize = dentry->d_sb->s_blocksize;
2153 	buf->f_namelen = BTRFS_NAME_LEN;
2154 
2155 	/* We treat it as constant endianness (it doesn't matter _which_)
2156 	   because we want the fsid to come out the same whether mounted
2157 	   on a big-endian or little-endian host */
2158 	buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
2159 	buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
2160 	/* Mask in the root object ID too, to disambiguate subvols */
2161 	buf->f_fsid.val[0] ^=
2162 		BTRFS_I(d_inode(dentry))->root->root_key.objectid >> 32;
2163 	buf->f_fsid.val[1] ^=
2164 		BTRFS_I(d_inode(dentry))->root->root_key.objectid;
2165 
2166 	return 0;
2167 }
2168 
2169 static void btrfs_kill_super(struct super_block *sb)
2170 {
2171 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2172 	kill_anon_super(sb);
2173 	free_fs_info(fs_info);
2174 }
2175 
2176 static struct file_system_type btrfs_fs_type = {
2177 	.owner		= THIS_MODULE,
2178 	.name		= "btrfs",
2179 	.mount		= btrfs_mount,
2180 	.kill_sb	= btrfs_kill_super,
2181 	.fs_flags	= FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
2182 };
2183 
2184 static struct file_system_type btrfs_root_fs_type = {
2185 	.owner		= THIS_MODULE,
2186 	.name		= "btrfs",
2187 	.mount		= btrfs_mount_root,
2188 	.kill_sb	= btrfs_kill_super,
2189 	.fs_flags	= FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
2190 };
2191 
2192 MODULE_ALIAS_FS("btrfs");
2193 
2194 static int btrfs_control_open(struct inode *inode, struct file *file)
2195 {
2196 	/*
2197 	 * The control file's private_data is used to hold the
2198 	 * transaction when it is started and is used to keep
2199 	 * track of whether a transaction is already in progress.
2200 	 */
2201 	file->private_data = NULL;
2202 	return 0;
2203 }
2204 
2205 /*
2206  * used by btrfsctl to scan devices when no FS is mounted
2207  */
2208 static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
2209 				unsigned long arg)
2210 {
2211 	struct btrfs_ioctl_vol_args *vol;
2212 	struct btrfs_device *device = NULL;
2213 	int ret = -ENOTTY;
2214 
2215 	if (!capable(CAP_SYS_ADMIN))
2216 		return -EPERM;
2217 
2218 	vol = memdup_user((void __user *)arg, sizeof(*vol));
2219 	if (IS_ERR(vol))
2220 		return PTR_ERR(vol);
2221 	vol->name[BTRFS_PATH_NAME_MAX] = '\0';
2222 
2223 	switch (cmd) {
2224 	case BTRFS_IOC_SCAN_DEV:
2225 		mutex_lock(&uuid_mutex);
2226 		device = btrfs_scan_one_device(vol->name, FMODE_READ,
2227 					       &btrfs_root_fs_type);
2228 		ret = PTR_ERR_OR_ZERO(device);
2229 		mutex_unlock(&uuid_mutex);
2230 		break;
2231 	case BTRFS_IOC_FORGET_DEV:
2232 		ret = btrfs_forget_devices(vol->name);
2233 		break;
2234 	case BTRFS_IOC_DEVICES_READY:
2235 		mutex_lock(&uuid_mutex);
2236 		device = btrfs_scan_one_device(vol->name, FMODE_READ,
2237 					       &btrfs_root_fs_type);
2238 		if (IS_ERR(device)) {
2239 			mutex_unlock(&uuid_mutex);
2240 			ret = PTR_ERR(device);
2241 			break;
2242 		}
2243 		ret = !(device->fs_devices->num_devices ==
2244 			device->fs_devices->total_devices);
2245 		mutex_unlock(&uuid_mutex);
2246 		break;
2247 	case BTRFS_IOC_GET_SUPPORTED_FEATURES:
2248 		ret = btrfs_ioctl_get_supported_features((void __user*)arg);
2249 		break;
2250 	}
2251 
2252 	kfree(vol);
2253 	return ret;
2254 }
2255 
2256 static int btrfs_freeze(struct super_block *sb)
2257 {
2258 	struct btrfs_trans_handle *trans;
2259 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2260 	struct btrfs_root *root = fs_info->tree_root;
2261 
2262 	set_bit(BTRFS_FS_FROZEN, &fs_info->flags);
2263 	/*
2264 	 * We don't need a barrier here, we'll wait for any transaction that
2265 	 * could be in progress on other threads (and do delayed iputs that
2266 	 * we want to avoid on a frozen filesystem), or do the commit
2267 	 * ourselves.
2268 	 */
2269 	trans = btrfs_attach_transaction_barrier(root);
2270 	if (IS_ERR(trans)) {
2271 		/* no transaction, don't bother */
2272 		if (PTR_ERR(trans) == -ENOENT)
2273 			return 0;
2274 		return PTR_ERR(trans);
2275 	}
2276 	return btrfs_commit_transaction(trans);
2277 }
2278 
2279 static int btrfs_unfreeze(struct super_block *sb)
2280 {
2281 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2282 
2283 	clear_bit(BTRFS_FS_FROZEN, &fs_info->flags);
2284 	return 0;
2285 }
2286 
2287 static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
2288 {
2289 	struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
2290 	struct btrfs_fs_devices *cur_devices;
2291 	struct btrfs_device *dev, *first_dev = NULL;
2292 	struct list_head *head;
2293 
2294 	/*
2295 	 * Lightweight locking of the devices. We should not need
2296 	 * device_list_mutex here as we only read the device data and the list
2297 	 * is protected by RCU.  Even if a device is deleted during the list
2298 	 * traversals, we'll get valid data, the freeing callback will wait at
2299 	 * least until the rcu_read_unlock.
2300 	 */
2301 	rcu_read_lock();
2302 	cur_devices = fs_info->fs_devices;
2303 	while (cur_devices) {
2304 		head = &cur_devices->devices;
2305 		list_for_each_entry_rcu(dev, head, dev_list) {
2306 			if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
2307 				continue;
2308 			if (!dev->name)
2309 				continue;
2310 			if (!first_dev || dev->devid < first_dev->devid)
2311 				first_dev = dev;
2312 		}
2313 		cur_devices = cur_devices->seed;
2314 	}
2315 
2316 	if (first_dev)
2317 		seq_escape(m, rcu_str_deref(first_dev->name), " \t\n\\");
2318 	else
2319 		WARN_ON(1);
2320 	rcu_read_unlock();
2321 	return 0;
2322 }
2323 
2324 static const struct super_operations btrfs_super_ops = {
2325 	.drop_inode	= btrfs_drop_inode,
2326 	.evict_inode	= btrfs_evict_inode,
2327 	.put_super	= btrfs_put_super,
2328 	.sync_fs	= btrfs_sync_fs,
2329 	.show_options	= btrfs_show_options,
2330 	.show_devname	= btrfs_show_devname,
2331 	.alloc_inode	= btrfs_alloc_inode,
2332 	.destroy_inode	= btrfs_destroy_inode,
2333 	.free_inode	= btrfs_free_inode,
2334 	.statfs		= btrfs_statfs,
2335 	.remount_fs	= btrfs_remount,
2336 	.freeze_fs	= btrfs_freeze,
2337 	.unfreeze_fs	= btrfs_unfreeze,
2338 };
2339 
2340 static const struct file_operations btrfs_ctl_fops = {
2341 	.open = btrfs_control_open,
2342 	.unlocked_ioctl	 = btrfs_control_ioctl,
2343 	.compat_ioctl = compat_ptr_ioctl,
2344 	.owner	 = THIS_MODULE,
2345 	.llseek = noop_llseek,
2346 };
2347 
2348 static struct miscdevice btrfs_misc = {
2349 	.minor		= BTRFS_MINOR,
2350 	.name		= "btrfs-control",
2351 	.fops		= &btrfs_ctl_fops
2352 };
2353 
2354 MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
2355 MODULE_ALIAS("devname:btrfs-control");
2356 
2357 static int __init btrfs_interface_init(void)
2358 {
2359 	return misc_register(&btrfs_misc);
2360 }
2361 
2362 static __cold void btrfs_interface_exit(void)
2363 {
2364 	misc_deregister(&btrfs_misc);
2365 }
2366 
2367 static void __init btrfs_print_mod_info(void)
2368 {
2369 	static const char options[] = ""
2370 #ifdef CONFIG_BTRFS_DEBUG
2371 			", debug=on"
2372 #endif
2373 #ifdef CONFIG_BTRFS_ASSERT
2374 			", assert=on"
2375 #endif
2376 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2377 			", integrity-checker=on"
2378 #endif
2379 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
2380 			", ref-verify=on"
2381 #endif
2382 			;
2383 	pr_info("Btrfs loaded, crc32c=%s%s\n", crc32c_impl(), options);
2384 }
2385 
2386 static int __init init_btrfs_fs(void)
2387 {
2388 	int err;
2389 
2390 	btrfs_props_init();
2391 
2392 	err = btrfs_init_sysfs();
2393 	if (err)
2394 		return err;
2395 
2396 	btrfs_init_compress();
2397 
2398 	err = btrfs_init_cachep();
2399 	if (err)
2400 		goto free_compress;
2401 
2402 	err = extent_io_init();
2403 	if (err)
2404 		goto free_cachep;
2405 
2406 	err = extent_state_cache_init();
2407 	if (err)
2408 		goto free_extent_io;
2409 
2410 	err = extent_map_init();
2411 	if (err)
2412 		goto free_extent_state_cache;
2413 
2414 	err = ordered_data_init();
2415 	if (err)
2416 		goto free_extent_map;
2417 
2418 	err = btrfs_delayed_inode_init();
2419 	if (err)
2420 		goto free_ordered_data;
2421 
2422 	err = btrfs_auto_defrag_init();
2423 	if (err)
2424 		goto free_delayed_inode;
2425 
2426 	err = btrfs_delayed_ref_init();
2427 	if (err)
2428 		goto free_auto_defrag;
2429 
2430 	err = btrfs_prelim_ref_init();
2431 	if (err)
2432 		goto free_delayed_ref;
2433 
2434 	err = btrfs_end_io_wq_init();
2435 	if (err)
2436 		goto free_prelim_ref;
2437 
2438 	err = btrfs_interface_init();
2439 	if (err)
2440 		goto free_end_io_wq;
2441 
2442 	btrfs_init_lockdep();
2443 
2444 	btrfs_print_mod_info();
2445 
2446 	err = btrfs_run_sanity_tests();
2447 	if (err)
2448 		goto unregister_ioctl;
2449 
2450 	err = register_filesystem(&btrfs_fs_type);
2451 	if (err)
2452 		goto unregister_ioctl;
2453 
2454 	return 0;
2455 
2456 unregister_ioctl:
2457 	btrfs_interface_exit();
2458 free_end_io_wq:
2459 	btrfs_end_io_wq_exit();
2460 free_prelim_ref:
2461 	btrfs_prelim_ref_exit();
2462 free_delayed_ref:
2463 	btrfs_delayed_ref_exit();
2464 free_auto_defrag:
2465 	btrfs_auto_defrag_exit();
2466 free_delayed_inode:
2467 	btrfs_delayed_inode_exit();
2468 free_ordered_data:
2469 	ordered_data_exit();
2470 free_extent_map:
2471 	extent_map_exit();
2472 free_extent_state_cache:
2473 	extent_state_cache_exit();
2474 free_extent_io:
2475 	extent_io_exit();
2476 free_cachep:
2477 	btrfs_destroy_cachep();
2478 free_compress:
2479 	btrfs_exit_compress();
2480 	btrfs_exit_sysfs();
2481 
2482 	return err;
2483 }
2484 
2485 static void __exit exit_btrfs_fs(void)
2486 {
2487 	btrfs_destroy_cachep();
2488 	btrfs_delayed_ref_exit();
2489 	btrfs_auto_defrag_exit();
2490 	btrfs_delayed_inode_exit();
2491 	btrfs_prelim_ref_exit();
2492 	ordered_data_exit();
2493 	extent_map_exit();
2494 	extent_state_cache_exit();
2495 	extent_io_exit();
2496 	btrfs_interface_exit();
2497 	btrfs_end_io_wq_exit();
2498 	unregister_filesystem(&btrfs_fs_type);
2499 	btrfs_exit_sysfs();
2500 	btrfs_cleanup_fs_uuids();
2501 	btrfs_exit_compress();
2502 }
2503 
2504 late_initcall(init_btrfs_fs);
2505 module_exit(exit_btrfs_fs)
2506 
2507 MODULE_LICENSE("GPL");
2508 MODULE_SOFTDEP("pre: crc32c");
2509 MODULE_SOFTDEP("pre: xxhash64");
2510 MODULE_SOFTDEP("pre: sha256");
2511 MODULE_SOFTDEP("pre: blake2b-256");
2512