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