super.c 65.1 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

Y
Yan 已提交
19
#include <linux/blkdev.h>
20
#include <linux/module.h>
C
Chris Mason 已提交
21
#include <linux/buffer_head.h>
22 23 24 25 26
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
E
Eric Paris 已提交
27
#include <linux/seq_file.h>
28 29
#include <linux/string.h>
#include <linux/backing-dev.h>
Y
Yan 已提交
30
#include <linux/mount.h>
C
Chris Mason 已提交
31
#include <linux/mpage.h>
C
Chris Mason 已提交
32 33
#include <linux/swap.h>
#include <linux/writeback.h>
C
Chris Mason 已提交
34
#include <linux/statfs.h>
C
Chris Mason 已提交
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>
D
Dan Magenheimer 已提交
42
#include <linux/cleancache.h>
43
#include <linux/ratelimit.h>
44
#include <linux/btrfs.h>
45
#include "delayed-inode.h"
46
#include "ctree.h"
C
Chris Mason 已提交
47
#include "disk-io.h"
48
#include "transaction.h"
C
Chris Mason 已提交
49
#include "btrfs_inode.h"
C
Chris Mason 已提交
50
#include "print-tree.h"
51
#include "hash.h"
52
#include "props.h"
J
Josef Bacik 已提交
53
#include "xattr.h"
54
#include "volumes.h"
B
Balaji Rao 已提交
55
#include "export.h"
C
Chris Mason 已提交
56
#include "compression.h"
J
Josef Bacik 已提交
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 65 66
#define CREATE_TRACE_POINTS
#include <trace/events/btrfs.h>

67
static const struct super_operations btrfs_super_ops;
68
static struct file_system_type btrfs_fs_type;
C
Chris Mason 已提交
69

70 71
static int btrfs_remount(struct super_block *sb, int *flags, char *data);

72
const char *btrfs_decode_error(int errno)
L
liubo 已提交
73
{
74
	char *errstr = "unknown";
L
liubo 已提交
75 76 77 78 79 80 81 82 83 84 85

	switch (errno) {
	case -EIO:
		errstr = "IO failure";
		break;
	case -ENOMEM:
		errstr = "Out of memory";
		break;
	case -EROFS:
		errstr = "Readonly filesystem";
		break;
J
Jeff Mahoney 已提交
86 87 88
	case -EEXIST:
		errstr = "Object already exists";
		break;
89 90 91 92 93 94
	case -ENOSPC:
		errstr = "No space left";
		break;
	case -ENOENT:
		errstr = "No such entry";
		break;
L
liubo 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107
	}

	return errstr;
}

/* btrfs handle error by forcing the filesystem readonly */
static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
{
	struct super_block *sb = fs_info->sb;

	if (sb->s_flags & MS_RDONLY)
		return;

108
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
liubo 已提交
109
		sb->s_flags |= MS_RDONLY;
110
		btrfs_info(fs_info, "forced readonly");
111 112 113 114
		/*
		 * Note that a running device replace operation is not
		 * canceled here although there is no way to update
		 * the progress. It would add the risk of a deadlock,
115
		 * therefore the canceling is omitted. The only penalty
116 117 118 119 120
		 * is that some I/O remains active until the procedure
		 * completes. The next time when the filesystem is
		 * mounted writeable again, the device replace
		 * operation continues.
		 */
L
liubo 已提交
121 122 123 124
	}
}

/*
125
 * __btrfs_handle_fs_error decodes expected errors from the caller and
L
liubo 已提交
126 127
 * invokes the approciate error response.
 */
128
__cold
129
void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
J
Jeff Mahoney 已提交
130
		       unsigned int line, int errno, const char *fmt, ...)
L
liubo 已提交
131 132
{
	struct super_block *sb = fs_info->sb;
133
#ifdef CONFIG_PRINTK
L
liubo 已提交
134
	const char *errstr;
135
#endif
L
liubo 已提交
136 137 138 139 140 141

	/*
	 * Special case: if the error is EROFS, and we're already
	 * under MS_RDONLY, then it is safe here.
	 */
	if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
J
Jeff Mahoney 已提交
142 143
  		return;

144
#ifdef CONFIG_PRINTK
145
	errstr = btrfs_decode_error(errno);
J
Jeff Mahoney 已提交
146
	if (fmt) {
147 148 149 150 151 152
		struct va_format vaf;
		va_list args;

		va_start(args, fmt);
		vaf.fmt = fmt;
		vaf.va = &args;
J
Jeff Mahoney 已提交
153

154
		pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n",
155
			sb->s_id, function, line, errno, errstr, &vaf);
156
		va_end(args);
J
Jeff Mahoney 已提交
157
	} else {
158
		pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s\n",
159
			sb->s_id, function, line, errno, errstr);
J
Jeff Mahoney 已提交
160
	}
161
#endif
L
liubo 已提交
162

A
Anand Jain 已提交
163 164 165 166 167 168
	/*
	 * Today we only save the error info to memory.  Long term we'll
	 * also send it down to the disk
	 */
	set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);

J
Jeff Mahoney 已提交
169
	/* Don't go through full error handling during mount */
170
	if (sb->s_flags & MS_BORN)
J
Jeff Mahoney 已提交
171 172
		btrfs_handle_error(fs_info);
}
L
liubo 已提交
173

174
#ifdef CONFIG_PRINTK
175
static const char * const logtypes[] = {
J
Jeff Mahoney 已提交
176 177 178 179 180 181 182 183 184 185
	"emergency",
	"alert",
	"critical",
	"error",
	"warning",
	"notice",
	"info",
	"debug",
};

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201

/*
 * Use one ratelimit state per log level so that a flood of less important
 * messages doesn't cause more important ones to be dropped.
 */
static struct ratelimit_state printk_limits[] = {
	RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
};

202
void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
J
Jeff Mahoney 已提交
203 204 205 206 207 208
{
	struct super_block *sb = fs_info->sb;
	char lvl[4];
	struct va_format vaf;
	va_list args;
	const char *type = logtypes[4];
209
	int kern_level;
210
	struct ratelimit_state *ratelimit;
J
Jeff Mahoney 已提交
211 212 213

	va_start(args, fmt);

214 215 216 217 218 219 220
	kern_level = printk_get_level(fmt);
	if (kern_level) {
		size_t size = printk_skip_level(fmt) - fmt;
		memcpy(lvl, fmt,  size);
		lvl[size] = '\0';
		fmt += size;
		type = logtypes[kern_level - '0'];
221 222
		ratelimit = &printk_limits[kern_level - '0'];
	} else {
J
Jeff Mahoney 已提交
223
		*lvl = '\0';
224 225 226
		/* Default to debug output */
		ratelimit = &printk_limits[7];
	}
J
Jeff Mahoney 已提交
227 228 229

	vaf.fmt = fmt;
	vaf.va = &args;
230

231 232
	if (__ratelimit(ratelimit))
		printk("%sBTRFS %s (device %s): %pV\n", lvl, type, sb->s_id, &vaf);
233 234 235 236

	va_end(args);
}
#endif
L
liubo 已提交
237

238 239 240 241 242 243 244 245 246 247 248 249 250
/*
 * We only mark the transaction aborted and then set the file system read-only.
 * This will prevent new transactions from starting or trying to join this
 * one.
 *
 * This means that error recovery at the call site is limited to freeing
 * any local memory allocations and passing the error code up without
 * further cleanup. The transaction should complete as it normally would
 * in the call path but will return -EIO.
 *
 * We'll complete the cleanup in btrfs_end_transaction and
 * btrfs_commit_transaction.
 */
251
__cold
252
void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
253
			       const char *function,
254 255
			       unsigned int line, int errno)
{
256 257
	struct btrfs_fs_info *fs_info = trans->fs_info;

258 259 260
	trans->aborted = errno;
	/* Nothing used. The other threads that have joined this
	 * transaction may be able to continue. */
261
	if (!trans->dirty && list_empty(&trans->new_bgs)) {
262 263
		const char *errstr;

264
		errstr = btrfs_decode_error(errno);
265
		btrfs_warn(fs_info,
266 267
		           "%s:%d: Aborting unused transaction(%s).",
		           function, line, errstr);
L
liubo 已提交
268
		return;
269
	}
270
	ACCESS_ONCE(trans->transaction->aborted) = errno;
271
	/* Wake up anybody who may be waiting on this transaction */
272 273 274
	wake_up(&fs_info->transaction_wait);
	wake_up(&fs_info->transaction_blocked_wait);
	__btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
275
}
J
Jeff Mahoney 已提交
276 277 278 279
/*
 * __btrfs_panic decodes unexpected, fatal errors from the caller,
 * issues an alert, and either panics or BUGs, depending on mount options.
 */
280
__cold
J
Jeff Mahoney 已提交
281 282 283 284 285 286 287
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
		   unsigned int line, int errno, const char *fmt, ...)
{
	char *s_id = "<unknown>";
	const char *errstr;
	struct va_format vaf = { .fmt = fmt };
	va_list args;
L
liubo 已提交
288

J
Jeff Mahoney 已提交
289 290
	if (fs_info)
		s_id = fs_info->sb->s_id;
L
liubo 已提交
291

J
Jeff Mahoney 已提交
292 293 294
	va_start(args, fmt);
	vaf.va = &args;

295
	errstr = btrfs_decode_error(errno);
296
	if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
297 298
		panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
			s_id, function, line, &vaf, errno, errstr);
J
Jeff Mahoney 已提交
299

300 301
	btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
		   function, line, &vaf, errno, errstr);
J
Jeff Mahoney 已提交
302 303
	va_end(args);
	/* Caller calls BUG() */
L
liubo 已提交
304 305
}

C
Chris Mason 已提交
306
static void btrfs_put_super(struct super_block *sb)
C
Chris Mason 已提交
307
{
308
	close_ctree(btrfs_sb(sb)->tree_root);
C
Chris Mason 已提交
309 310
}

311
enum {
312
	Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
313 314
	Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
	Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
315 316
	Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
	Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
317 318 319 320 321
	Opt_space_cache, Opt_space_cache_version, Opt_clear_cache,
	Opt_user_subvol_rm_allowed, Opt_enospc_debug, Opt_subvolrootid,
	Opt_defrag, Opt_inode_cache, Opt_no_space_cache, Opt_recovery,
	Opt_skip_balance, Opt_check_integrity,
	Opt_check_integrity_including_extent_data,
322
	Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree,
Q
Qu Wenruo 已提交
323
	Opt_commit_interval, Opt_barrier, Opt_nodefrag, Opt_nodiscard,
Q
Qu Wenruo 已提交
324
	Opt_noenospc_debug, Opt_noflushoncommit, Opt_acl, Opt_datacow,
325
	Opt_datasum, Opt_treelog, Opt_noinode_cache, Opt_usebackuproot,
326
	Opt_nologreplay, Opt_norecovery,
327 328 329
#ifdef CONFIG_BTRFS_DEBUG
	Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all,
#endif
330
	Opt_err,
331 332
};

D
David Sterba 已提交
333
static const match_table_t tokens = {
334
	{Opt_degraded, "degraded"},
335
	{Opt_subvol, "subvol=%s"},
336
	{Opt_subvolid, "subvolid=%s"},
337
	{Opt_device, "device=%s"},
338
	{Opt_nodatasum, "nodatasum"},
Q
Qu Wenruo 已提交
339
	{Opt_datasum, "datasum"},
340
	{Opt_nodatacow, "nodatacow"},
Q
Qu Wenruo 已提交
341
	{Opt_datacow, "datacow"},
342
	{Opt_nobarrier, "nobarrier"},
343
	{Opt_barrier, "barrier"},
344
	{Opt_max_inline, "max_inline=%s"},
345
	{Opt_alloc_start, "alloc_start=%s"},
346
	{Opt_thread_pool, "thread_pool=%d"},
C
Chris Mason 已提交
347
	{Opt_compress, "compress"},
348
	{Opt_compress_type, "compress=%s"},
C
Chris Mason 已提交
349
	{Opt_compress_force, "compress-force"},
350
	{Opt_compress_force_type, "compress-force=%s"},
351
	{Opt_ssd, "ssd"},
352
	{Opt_ssd_spread, "ssd_spread"},
C
Chris Mason 已提交
353
	{Opt_nossd, "nossd"},
Q
Qu Wenruo 已提交
354
	{Opt_acl, "acl"},
J
Josef Bacik 已提交
355
	{Opt_noacl, "noacl"},
S
Sage Weil 已提交
356
	{Opt_notreelog, "notreelog"},
Q
Qu Wenruo 已提交
357
	{Opt_treelog, "treelog"},
358
	{Opt_nologreplay, "nologreplay"},
359
	{Opt_norecovery, "norecovery"},
360
	{Opt_flushoncommit, "flushoncommit"},
361
	{Opt_noflushoncommit, "noflushoncommit"},
362
	{Opt_ratio, "metadata_ratio=%d"},
C
Christoph Hellwig 已提交
363
	{Opt_discard, "discard"},
Q
Qu Wenruo 已提交
364
	{Opt_nodiscard, "nodiscard"},
365
	{Opt_space_cache, "space_cache"},
366
	{Opt_space_cache_version, "space_cache=%s"},
367
	{Opt_clear_cache, "clear_cache"},
368
	{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
369
	{Opt_enospc_debug, "enospc_debug"},
370
	{Opt_noenospc_debug, "noenospc_debug"},
371
	{Opt_subvolrootid, "subvolrootid=%d"},
C
Chris Mason 已提交
372
	{Opt_defrag, "autodefrag"},
373
	{Opt_nodefrag, "noautodefrag"},
C
Chris Mason 已提交
374
	{Opt_inode_cache, "inode_cache"},
375
	{Opt_noinode_cache, "noinode_cache"},
376
	{Opt_no_space_cache, "nospace_cache"},
377 378
	{Opt_recovery, "recovery"}, /* deprecated */
	{Opt_usebackuproot, "usebackuproot"},
379
	{Opt_skip_balance, "skip_balance"},
380 381 382
	{Opt_check_integrity, "check_int"},
	{Opt_check_integrity_including_extent_data, "check_int_data"},
	{Opt_check_integrity_print_mask, "check_int_print_mask=%d"},
383
	{Opt_rescan_uuid_tree, "rescan_uuid_tree"},
J
Jeff Mahoney 已提交
384
	{Opt_fatal_errors, "fatal_errors=%s"},
385
	{Opt_commit_interval, "commit=%d"},
386 387 388 389 390
#ifdef CONFIG_BTRFS_DEBUG
	{Opt_fragment_data, "fragment=data"},
	{Opt_fragment_metadata, "fragment=metadata"},
	{Opt_fragment_all, "fragment=all"},
#endif
J
Josef Bacik 已提交
391
	{Opt_err, NULL},
392 393
};

394 395 396
/*
 * Regular mount options parser.  Everything that is needed only when
 * reading in a new superblock is parsed here.
397
 * XXX JDM: This needs to be cleaned up for remount.
398
 */
399 400
int btrfs_parse_options(struct btrfs_root *root, char *options,
			unsigned long new_flags)
401
{
402
	struct btrfs_fs_info *info = root->fs_info;
403
	substring_t args[MAX_OPT_ARGS];
404 405
	char *p, *num, *orig = NULL;
	u64 cache_gen;
406
	int intarg;
S
Sage Weil 已提交
407
	int ret = 0;
408 409
	char *compress_type;
	bool compress_force = false;
410 411 412
	enum btrfs_compression_type saved_compress_type;
	bool saved_compress_force;
	int no_compress = 0;
413

414
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
415 416 417
	if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE))
		btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE);
	else if (cache_gen)
418 419
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

420 421 422 423
	/*
	 * Even the options are empty, we still need to do extra check
	 * against new flags
	 */
424
	if (!options)
425
		goto check;
426

427 428 429 430 431 432 433 434
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

435
	orig = options;
436

437
	while ((p = strsep(&options, ",")) != NULL) {
438 439 440 441 442 443
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
444
		case Opt_degraded:
445
			btrfs_info(root->fs_info, "allowing degraded mounts");
446
			btrfs_set_opt(info->mount_opt, DEGRADED);
447
			break;
448
		case Opt_subvol:
449
		case Opt_subvolid:
450
		case Opt_subvolrootid:
451
		case Opt_device:
452
			/*
453
			 * These are parsed by btrfs_parse_early_options
454 455
			 * and can be happily ignored here.
			 */
456 457
			break;
		case Opt_nodatasum:
458
			btrfs_set_and_info(info, NODATASUM,
459
					   "setting nodatasum");
460
			break;
Q
Qu Wenruo 已提交
461
		case Opt_datasum:
462 463
			if (btrfs_test_opt(info, NODATASUM)) {
				if (btrfs_test_opt(info, NODATACOW))
J
Jeff Mahoney 已提交
464 465
					btrfs_info(root->fs_info,
						   "setting datasum, datacow enabled");
466
				else
J
Jeff Mahoney 已提交
467 468
					btrfs_info(root->fs_info,
						   "setting datasum");
469
			}
Q
Qu Wenruo 已提交
470 471 472
			btrfs_clear_opt(info->mount_opt, NODATACOW);
			btrfs_clear_opt(info->mount_opt, NODATASUM);
			break;
473
		case Opt_nodatacow:
474 475 476
			if (!btrfs_test_opt(info, NODATACOW)) {
				if (!btrfs_test_opt(info, COMPRESS) ||
				    !btrfs_test_opt(info, FORCE_COMPRESS)) {
477
					btrfs_info(root->fs_info,
478 479
						   "setting nodatacow, compression disabled");
				} else {
J
Jeff Mahoney 已提交
480 481
					btrfs_info(root->fs_info,
						   "setting nodatacow");
482
				}
483 484 485
			}
			btrfs_clear_opt(info->mount_opt, COMPRESS);
			btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
486 487
			btrfs_set_opt(info->mount_opt, NODATACOW);
			btrfs_set_opt(info->mount_opt, NODATASUM);
488
			break;
Q
Qu Wenruo 已提交
489
		case Opt_datacow:
490
			btrfs_clear_and_info(info, NODATACOW,
491
					     "setting datacow");
Q
Qu Wenruo 已提交
492
			break;
C
Chris Mason 已提交
493
		case Opt_compress_force:
494 495
		case Opt_compress_force_type:
			compress_force = true;
496
			/* Fallthrough */
497 498
		case Opt_compress:
		case Opt_compress_type:
499 500
			saved_compress_type = btrfs_test_opt(info,
							     COMPRESS) ?
501 502
				info->compress_type : BTRFS_COMPRESS_NONE;
			saved_compress_force =
503
				btrfs_test_opt(info, FORCE_COMPRESS);
504 505 506 507 508
			if (token == Opt_compress ||
			    token == Opt_compress_force ||
			    strcmp(args[0].from, "zlib") == 0) {
				compress_type = "zlib";
				info->compress_type = BTRFS_COMPRESS_ZLIB;
509
				btrfs_set_opt(info->mount_opt, COMPRESS);
510 511
				btrfs_clear_opt(info->mount_opt, NODATACOW);
				btrfs_clear_opt(info->mount_opt, NODATASUM);
512
				no_compress = 0;
L
Li Zefan 已提交
513 514 515
			} else if (strcmp(args[0].from, "lzo") == 0) {
				compress_type = "lzo";
				info->compress_type = BTRFS_COMPRESS_LZO;
516
				btrfs_set_opt(info->mount_opt, COMPRESS);
517 518
				btrfs_clear_opt(info->mount_opt, NODATACOW);
				btrfs_clear_opt(info->mount_opt, NODATASUM);
519
				btrfs_set_fs_incompat(info, COMPRESS_LZO);
520
				no_compress = 0;
521 522 523 524 525
			} else if (strncmp(args[0].from, "no", 2) == 0) {
				compress_type = "no";
				btrfs_clear_opt(info->mount_opt, COMPRESS);
				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
				compress_force = false;
526
				no_compress++;
527 528 529 530 531 532
			} else {
				ret = -EINVAL;
				goto out;
			}

			if (compress_force) {
533
				btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
534
			} else {
535 536 537 538 539 540 541
				/*
				 * If we remount from compress-force=xxx to
				 * compress=xxx, we need clear FORCE_COMPRESS
				 * flag, otherwise, there is no way for users
				 * to disable forcible compression separately.
				 */
				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
542
			}
543
			if ((btrfs_test_opt(info, COMPRESS) &&
544 545
			     (info->compress_type != saved_compress_type ||
			      compress_force != saved_compress_force)) ||
546
			    (!btrfs_test_opt(info, COMPRESS) &&
547 548 549 550 551 552 553
			     no_compress == 1)) {
				btrfs_info(root->fs_info,
					   "%s %s compression",
					   (compress_force) ? "force" : "use",
					   compress_type);
			}
			compress_force = false;
C
Chris Mason 已提交
554
			break;
555
		case Opt_ssd:
556
			btrfs_set_and_info(info, SSD,
557
					   "use ssd allocation scheme");
558
			break;
559
		case Opt_ssd_spread:
560
			btrfs_set_and_info(info, SSD_SPREAD,
561
					   "use spread ssd allocation scheme");
562
			btrfs_set_opt(info->mount_opt, SSD);
563
			break;
C
Chris Mason 已提交
564
		case Opt_nossd:
565
			btrfs_set_and_info(info, NOSSD,
566
					     "not using ssd allocation scheme");
C
Chris Mason 已提交
567 568
			btrfs_clear_opt(info->mount_opt, SSD);
			break;
569
		case Opt_barrier:
570
			btrfs_clear_and_info(info, NOBARRIER,
571
					     "turning on barriers");
572
			break;
573
		case Opt_nobarrier:
574
			btrfs_set_and_info(info, NOBARRIER,
575
					   "turning off barriers");
576
			break;
577
		case Opt_thread_pool:
578 579 580 581
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg > 0) {
582
				info->thread_pool_size = intarg;
583 584 585 586
			} else {
				ret = -EINVAL;
				goto out;
			}
587
			break;
588
		case Opt_max_inline:
589 590
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
591
				info->max_inline = memparse(num, NULL);
592 593
				kfree(num);

C
Chris Mason 已提交
594
				if (info->max_inline) {
595
					info->max_inline = min_t(u64,
C
Chris Mason 已提交
596 597 598
						info->max_inline,
						root->sectorsize);
				}
599
				btrfs_info(root->fs_info, "max_inline at %llu",
600
					info->max_inline);
601 602 603
			} else {
				ret = -ENOMEM;
				goto out;
604 605
			}
			break;
606
		case Opt_alloc_start:
607 608
			num = match_strdup(&args[0]);
			if (num) {
M
Miao Xie 已提交
609
				mutex_lock(&info->chunk_mutex);
A
Akinobu Mita 已提交
610
				info->alloc_start = memparse(num, NULL);
M
Miao Xie 已提交
611
				mutex_unlock(&info->chunk_mutex);
612
				kfree(num);
J
Jeff Mahoney 已提交
613 614 615
				btrfs_info(root->fs_info,
					   "allocations start at %llu",
					   info->alloc_start);
616 617 618
			} else {
				ret = -ENOMEM;
				goto out;
619 620
			}
			break;
Q
Qu Wenruo 已提交
621
		case Opt_acl:
622
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
Q
Qu Wenruo 已提交
623 624
			root->fs_info->sb->s_flags |= MS_POSIXACL;
			break;
625 626 627 628 629 630
#else
			btrfs_err(root->fs_info,
				"support for ACL not compiled in!");
			ret = -EINVAL;
			goto out;
#endif
J
Josef Bacik 已提交
631 632 633
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
634
		case Opt_notreelog:
635
			btrfs_set_and_info(info, NOTREELOG,
636
					   "disabling tree log");
Q
Qu Wenruo 已提交
637 638
			break;
		case Opt_treelog:
639
			btrfs_clear_and_info(info, NOTREELOG,
640
					     "enabling tree log");
S
Sage Weil 已提交
641
			break;
642
		case Opt_norecovery:
643
		case Opt_nologreplay:
644
			btrfs_set_and_info(info, NOLOGREPLAY,
645 646
					   "disabling log replay at mount time");
			break;
647
		case Opt_flushoncommit:
648
			btrfs_set_and_info(info, FLUSHONCOMMIT,
649
					   "turning on flush-on-commit");
650
			break;
651
		case Opt_noflushoncommit:
652
			btrfs_clear_and_info(info, FLUSHONCOMMIT,
653
					     "turning off flush-on-commit");
654
			break;
655
		case Opt_ratio:
656 657 658 659
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg >= 0) {
660
				info->metadata_ratio = intarg;
661
				btrfs_info(root->fs_info, "metadata ratio %d",
662
				       info->metadata_ratio);
663 664 665
			} else {
				ret = -EINVAL;
				goto out;
666 667
			}
			break;
C
Christoph Hellwig 已提交
668
		case Opt_discard:
669
			btrfs_set_and_info(info, DISCARD,
670
					   "turning on discard");
C
Christoph Hellwig 已提交
671
			break;
Q
Qu Wenruo 已提交
672
		case Opt_nodiscard:
673
			btrfs_clear_and_info(info, DISCARD,
674
					     "turning off discard");
Q
Qu Wenruo 已提交
675
			break;
676
		case Opt_space_cache:
677 678 679 680 681
		case Opt_space_cache_version:
			if (token == Opt_space_cache ||
			    strcmp(args[0].from, "v1") == 0) {
				btrfs_clear_opt(root->fs_info->mount_opt,
						FREE_SPACE_TREE);
682
				btrfs_set_and_info(info, SPACE_CACHE,
683 684 685 686
						   "enabling disk space caching");
			} else if (strcmp(args[0].from, "v2") == 0) {
				btrfs_clear_opt(root->fs_info->mount_opt,
						SPACE_CACHE);
687 688
				btrfs_set_and_info(info,
						   FREE_SPACE_TREE,
689 690 691 692 693
						   "enabling free space tree");
			} else {
				ret = -EINVAL;
				goto out;
			}
694
			break;
695 696 697
		case Opt_rescan_uuid_tree:
			btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
			break;
698
		case Opt_no_space_cache:
699 700 701
			if (btrfs_test_opt(info, SPACE_CACHE)) {
				btrfs_clear_and_info(info,
						     SPACE_CACHE,
702 703
						     "disabling disk space caching");
			}
704 705 706
			if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
				btrfs_clear_and_info(info,
						     FREE_SPACE_TREE,
707 708
						     "disabling free space tree");
			}
709
			break;
C
Chris Mason 已提交
710
		case Opt_inode_cache:
711
			btrfs_set_pending_and_info(info, INODE_MAP_CACHE,
712
					   "enabling inode map caching");
713 714
			break;
		case Opt_noinode_cache:
715
			btrfs_clear_pending_and_info(info, INODE_MAP_CACHE,
716
					     "disabling inode map caching");
C
Chris Mason 已提交
717
			break;
718
		case Opt_clear_cache:
719
			btrfs_set_and_info(info, CLEAR_CACHE,
720
					   "force clearing of disk cache");
721
			break;
722 723 724
		case Opt_user_subvol_rm_allowed:
			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
			break;
725 726 727
		case Opt_enospc_debug:
			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
728 729 730
		case Opt_noenospc_debug:
			btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
C
Chris Mason 已提交
731
		case Opt_defrag:
732
			btrfs_set_and_info(info, AUTO_DEFRAG,
733
					   "enabling auto defrag");
C
Chris Mason 已提交
734
			break;
735
		case Opt_nodefrag:
736
			btrfs_clear_and_info(info, AUTO_DEFRAG,
737
					     "disabling auto defrag");
738
			break;
C
Chris Mason 已提交
739
		case Opt_recovery:
740 741 742 743 744 745
			btrfs_warn(root->fs_info,
				   "'recovery' is deprecated, use 'usebackuproot' instead");
		case Opt_usebackuproot:
			btrfs_info(root->fs_info,
				   "trying to use backup root at mount time");
			btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
C
Chris Mason 已提交
746
			break;
747 748 749
		case Opt_skip_balance:
			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
			break;
750 751
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
		case Opt_check_integrity_including_extent_data:
752 753
			btrfs_info(root->fs_info,
				   "enabling check integrity including extent data");
754 755 756 757 758
			btrfs_set_opt(info->mount_opt,
				      CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity:
759
			btrfs_info(root->fs_info, "enabling check integrity");
760 761 762
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity_print_mask:
763 764 765 766
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg >= 0) {
767
				info->check_integrity_print_mask = intarg;
J
Jeff Mahoney 已提交
768 769 770
				btrfs_info(root->fs_info,
					   "check_integrity_print_mask 0x%x",
					   info->check_integrity_print_mask);
771 772 773
			} else {
				ret = -EINVAL;
				goto out;
774 775 776 777 778 779
			}
			break;
#else
		case Opt_check_integrity_including_extent_data:
		case Opt_check_integrity:
		case Opt_check_integrity_print_mask:
780 781
			btrfs_err(root->fs_info,
				"support for check_integrity* not compiled in!");
782 783 784
			ret = -EINVAL;
			goto out;
#endif
J
Jeff Mahoney 已提交
785 786 787 788 789 790 791 792 793 794 795 796
		case Opt_fatal_errors:
			if (strcmp(args[0].from, "panic") == 0)
				btrfs_set_opt(info->mount_opt,
					      PANIC_ON_FATAL_ERROR);
			else if (strcmp(args[0].from, "bug") == 0)
				btrfs_clear_opt(info->mount_opt,
					      PANIC_ON_FATAL_ERROR);
			else {
				ret = -EINVAL;
				goto out;
			}
			break;
797 798 799 800
		case Opt_commit_interval:
			intarg = 0;
			ret = match_int(&args[0], &intarg);
			if (ret < 0) {
J
Jeff Mahoney 已提交
801 802
				btrfs_err(root->fs_info,
					  "invalid commit interval");
803 804 805 806 807
				ret = -EINVAL;
				goto out;
			}
			if (intarg > 0) {
				if (intarg > 300) {
J
Jeff Mahoney 已提交
808 809 810
					btrfs_warn(root->fs_info,
						"excessive commit interval %d",
						intarg);
811 812 813
				}
				info->commit_interval = intarg;
			} else {
J
Jeff Mahoney 已提交
814 815 816
				btrfs_info(root->fs_info,
					   "using default commit interval %ds",
					   BTRFS_DEFAULT_COMMIT_INTERVAL);
817 818 819
				info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
			}
			break;
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
#ifdef CONFIG_BTRFS_DEBUG
		case Opt_fragment_all:
			btrfs_info(root->fs_info, "fragmenting all space");
			btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
			btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA);
			break;
		case Opt_fragment_metadata:
			btrfs_info(root->fs_info, "fragmenting metadata");
			btrfs_set_opt(info->mount_opt,
				      FRAGMENT_METADATA);
			break;
		case Opt_fragment_data:
			btrfs_info(root->fs_info, "fragmenting data");
			btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
			break;
#endif
S
Sage Weil 已提交
836
		case Opt_err:
J
Jeff Mahoney 已提交
837 838
			btrfs_info(root->fs_info,
				   "unrecognized mount option '%s'", p);
S
Sage Weil 已提交
839 840
			ret = -EINVAL;
			goto out;
841
		default:
842
			break;
843 844
		}
	}
845 846 847 848
check:
	/*
	 * Extra check for current option against current flag
	 */
849
	if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) {
850 851 852 853
		btrfs_err(root->fs_info,
			  "nologreplay must be used with ro mount option");
		ret = -EINVAL;
	}
S
Sage Weil 已提交
854
out:
855
	if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE) &&
856 857
	    !btrfs_test_opt(info, FREE_SPACE_TREE) &&
	    !btrfs_test_opt(info, CLEAR_CACHE)) {
858 859 860 861
		btrfs_err(root->fs_info, "cannot disable free space tree");
		ret = -EINVAL;

	}
862
	if (!ret && btrfs_test_opt(info, SPACE_CACHE))
863
		btrfs_info(root->fs_info, "disk space caching is enabled");
864
	if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))
865
		btrfs_info(root->fs_info, "using free space tree");
866
	kfree(orig);
S
Sage Weil 已提交
867
	return ret;
868 869 870 871 872 873 874 875
}

/*
 * Parse mount options that are required early in the mount process.
 *
 * All other options will be parsed on much later in the mount process and
 * only when we need to allocate a new super block.
 */
876
static int btrfs_parse_early_options(const char *options, fmode_t flags,
877
		void *holder, char **subvol_name, u64 *subvol_objectid,
878
		struct btrfs_fs_devices **fs_devices)
879 880
{
	substring_t args[MAX_OPT_ARGS];
881
	char *device_name, *opts, *orig, *p;
882
	char *num = NULL;
883 884 885
	int error = 0;

	if (!options)
886
		return 0;
887 888 889 890 891 892 893 894

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
895
	orig = opts;
896 897 898 899 900 901 902 903 904

	while ((p = strsep(&opts, ",")) != NULL) {
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
905
			kfree(*subvol_name);
906
			*subvol_name = match_strdup(&args[0]);
907 908 909 910
			if (!*subvol_name) {
				error = -ENOMEM;
				goto out;
			}
911
			break;
912
		case Opt_subvolid:
913 914 915 916
			num = match_strdup(&args[0]);
			if (num) {
				*subvol_objectid = memparse(num, NULL);
				kfree(num);
917
				/* we want the original fs_tree */
918
				if (!*subvol_objectid)
919 920
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
921 922 923
			} else {
				error = -EINVAL;
				goto out;
924
			}
925
			break;
926
		case Opt_subvolrootid:
927
			pr_warn("BTRFS: 'subvolrootid' mount option is deprecated and has no effect\n");
928
			break;
929
		case Opt_device:
930 931 932 933 934 935
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
936
					flags, holder, fs_devices);
937
			kfree(device_name);
938
			if (error)
939
				goto out;
940
			break;
941 942 943 944 945
		default:
			break;
		}
	}

946
out:
947
	kfree(orig);
948
	return error;
949 950
}

951 952
static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
					   u64 subvol_objectid)
953
{
954
	struct btrfs_root *root = fs_info->tree_root;
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
	struct btrfs_root *fs_root;
	struct btrfs_root_ref *root_ref;
	struct btrfs_inode_ref *inode_ref;
	struct btrfs_key key;
	struct btrfs_path *path = NULL;
	char *name = NULL, *ptr;
	u64 dirid;
	int len;
	int ret;

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto err;
	}
	path->leave_spinning = 1;

	name = kmalloc(PATH_MAX, GFP_NOFS);
	if (!name) {
		ret = -ENOMEM;
		goto err;
	}
	ptr = name + PATH_MAX - 1;
	ptr[0] = '\0';
979 980

	/*
981 982
	 * Walk up the subvolume trees in the tree of tree roots by root
	 * backrefs until we hit the top-level subvolume.
983
	 */
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
	while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) {
		key.objectid = subvol_objectid;
		key.type = BTRFS_ROOT_BACKREF_KEY;
		key.offset = (u64)-1;

		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		if (ret < 0) {
			goto err;
		} else if (ret > 0) {
			ret = btrfs_previous_item(root, path, subvol_objectid,
						  BTRFS_ROOT_BACKREF_KEY);
			if (ret < 0) {
				goto err;
			} else if (ret > 0) {
				ret = -ENOENT;
				goto err;
			}
		}

		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
		subvol_objectid = key.offset;

		root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
					  struct btrfs_root_ref);
		len = btrfs_root_ref_name_len(path->nodes[0], root_ref);
		ptr -= len + 1;
		if (ptr < name) {
			ret = -ENAMETOOLONG;
			goto err;
		}
		read_extent_buffer(path->nodes[0], ptr + 1,
				   (unsigned long)(root_ref + 1), len);
		ptr[0] = '/';
		dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
		btrfs_release_path(path);

		key.objectid = subvol_objectid;
		key.type = BTRFS_ROOT_ITEM_KEY;
		key.offset = (u64)-1;
		fs_root = btrfs_read_fs_root_no_name(fs_info, &key);
		if (IS_ERR(fs_root)) {
			ret = PTR_ERR(fs_root);
			goto err;
		}

		/*
		 * Walk up the filesystem tree by inode refs until we hit the
		 * root directory.
		 */
		while (dirid != BTRFS_FIRST_FREE_OBJECTID) {
			key.objectid = dirid;
			key.type = BTRFS_INODE_REF_KEY;
			key.offset = (u64)-1;

			ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0);
			if (ret < 0) {
				goto err;
			} else if (ret > 0) {
				ret = btrfs_previous_item(fs_root, path, dirid,
							  BTRFS_INODE_REF_KEY);
				if (ret < 0) {
					goto err;
				} else if (ret > 0) {
					ret = -ENOENT;
					goto err;
				}
			}

			btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
			dirid = key.offset;

			inode_ref = btrfs_item_ptr(path->nodes[0],
						   path->slots[0],
						   struct btrfs_inode_ref);
			len = btrfs_inode_ref_name_len(path->nodes[0],
						       inode_ref);
			ptr -= len + 1;
			if (ptr < name) {
				ret = -ENAMETOOLONG;
				goto err;
			}
			read_extent_buffer(path->nodes[0], ptr + 1,
					   (unsigned long)(inode_ref + 1), len);
			ptr[0] = '/';
			btrfs_release_path(path);
		}
1070 1071
	}

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
	btrfs_free_path(path);
	if (ptr == name + PATH_MAX - 1) {
		name[0] = '/';
		name[1] = '\0';
	} else {
		memmove(name, ptr, name + PATH_MAX - ptr);
	}
	return name;

err:
	btrfs_free_path(path);
	kfree(name);
	return ERR_PTR(ret);
}

static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)
{
	struct btrfs_root *root = fs_info->tree_root;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_key location;
	u64 dir_id;

1095 1096
	path = btrfs_alloc_path();
	if (!path)
1097
		return -ENOMEM;
1098 1099 1100 1101 1102 1103 1104
	path->leave_spinning = 1;

	/*
	 * Find the "default" dir item which points to the root item that we
	 * will mount by default if we haven't been given a specific subvolume
	 * to mount.
	 */
1105
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
1106
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
1107 1108
	if (IS_ERR(di)) {
		btrfs_free_path(path);
1109
		return PTR_ERR(di);
1110
	}
1111 1112 1113 1114
	if (!di) {
		/*
		 * Ok the default dir item isn't there.  This is weird since
		 * it's always been there, but don't freak out, just try and
1115
		 * mount the top-level subvolume.
1116 1117
		 */
		btrfs_free_path(path);
1118 1119
		*objectid = BTRFS_FS_TREE_OBJECTID;
		return 0;
1120 1121 1122 1123
	}

	btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
	btrfs_free_path(path);
1124 1125
	*objectid = location.objectid;
	return 0;
1126 1127
}

C
Chris Mason 已提交
1128
static int btrfs_fill_super(struct super_block *sb,
1129
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
1130
			    void *data, int silent)
C
Chris Mason 已提交
1131
{
C
Chris Mason 已提交
1132
	struct inode *inode;
1133
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1134
	struct btrfs_key key;
C
Chris Mason 已提交
1135
	int err;
1136

C
Chris Mason 已提交
1137 1138 1139
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
1140
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
1141
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
1142
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
1143
	sb->s_time_gran = 1;
C
Chris Mason 已提交
1144
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
1145
	sb->s_flags |= MS_POSIXACL;
1146
#endif
1147
	sb->s_flags |= MS_I_VERSION;
1148
	sb->s_iflags |= SB_I_CGROUPWB;
A
Al Viro 已提交
1149 1150
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
1151
		pr_err("BTRFS: open_ctree failed\n");
A
Al Viro 已提交
1152
		return err;
1153 1154
	}

1155 1156 1157
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
1158
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
1159 1160
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
1161
		goto fail_close;
C
Chris Mason 已提交
1162 1163
	}

1164 1165
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
1166 1167
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
1168
	}
1169

C
Chris Mason 已提交
1170
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
1171
	cleancache_init_fs(sb);
1172
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
1173
	return 0;
C
Chris Mason 已提交
1174 1175

fail_close:
1176
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
1177
	return err;
C
Chris Mason 已提交
1178 1179
}

S
Sage Weil 已提交
1180
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
1181 1182
{
	struct btrfs_trans_handle *trans;
1183 1184
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
1185

1186
	trace_btrfs_sync_fs(fs_info, wait);
1187

C
Chris Mason 已提交
1188
	if (!wait) {
1189
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
1190 1191
		return 0;
	}
1192

1193
	btrfs_wait_ordered_roots(fs_info, -1, 0, (u64)-1);
1194

M
Miao Xie 已提交
1195
	trans = btrfs_attach_transaction_barrier(root);
1196
	if (IS_ERR(trans)) {
1197
		/* no transaction, don't bother */
1198 1199 1200 1201 1202 1203 1204
		if (PTR_ERR(trans) == -ENOENT) {
			/*
			 * Exit unless we have some pending changes
			 * that need to go through commit
			 */
			if (fs_info->pending_changes == 0)
				return 0;
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
			/*
			 * A non-blocking test if the fs is frozen. We must not
			 * start a new transaction here otherwise a deadlock
			 * happens. The pending operations are delayed to the
			 * next commit after thawing.
			 */
			if (__sb_start_write(sb, SB_FREEZE_WRITE, false))
				__sb_end_write(sb, SB_FREEZE_WRITE);
			else
				return 0;
1215 1216
			trans = btrfs_start_transaction(root, 0);
		}
1217 1218
		if (IS_ERR(trans))
			return PTR_ERR(trans);
1219
	}
1220
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
1221 1222
}

1223
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
1224
{
1225 1226
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
1227
	char *compress_type;
E
Eric Paris 已提交
1228

1229
	if (btrfs_test_opt(info, DEGRADED))
E
Eric Paris 已提交
1230
		seq_puts(seq, ",degraded");
1231
	if (btrfs_test_opt(info, NODATASUM))
E
Eric Paris 已提交
1232
		seq_puts(seq, ",nodatasum");
1233
	if (btrfs_test_opt(info, NODATACOW))
E
Eric Paris 已提交
1234
		seq_puts(seq, ",nodatacow");
1235
	if (btrfs_test_opt(info, NOBARRIER))
E
Eric Paris 已提交
1236
		seq_puts(seq, ",nobarrier");
1237
	if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)
1238
		seq_printf(seq, ",max_inline=%llu", info->max_inline);
E
Eric Paris 已提交
1239
	if (info->alloc_start != 0)
1240
		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
E
Eric Paris 已提交
1241 1242 1243
	if (info->thread_pool_size !=  min_t(unsigned long,
					     num_online_cpus() + 2, 8))
		seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
1244
	if (btrfs_test_opt(info, COMPRESS)) {
T
Tsutomu Itoh 已提交
1245 1246 1247 1248
		if (info->compress_type == BTRFS_COMPRESS_ZLIB)
			compress_type = "zlib";
		else
			compress_type = "lzo";
1249
		if (btrfs_test_opt(info, FORCE_COMPRESS))
T
Tsutomu Itoh 已提交
1250 1251 1252 1253
			seq_printf(seq, ",compress-force=%s", compress_type);
		else
			seq_printf(seq, ",compress=%s", compress_type);
	}
1254
	if (btrfs_test_opt(info, NOSSD))
C
Chris Mason 已提交
1255
		seq_puts(seq, ",nossd");
1256
	if (btrfs_test_opt(info, SSD_SPREAD))
1257
		seq_puts(seq, ",ssd_spread");
1258
	else if (btrfs_test_opt(info, SSD))
E
Eric Paris 已提交
1259
		seq_puts(seq, ",ssd");
1260
	if (btrfs_test_opt(info, NOTREELOG))
1261
		seq_puts(seq, ",notreelog");
1262
	if (btrfs_test_opt(info, NOLOGREPLAY))
1263
		seq_puts(seq, ",nologreplay");
1264
	if (btrfs_test_opt(info, FLUSHONCOMMIT))
1265
		seq_puts(seq, ",flushoncommit");
1266
	if (btrfs_test_opt(info, DISCARD))
1267
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
1268 1269
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
1270
	if (btrfs_test_opt(info, SPACE_CACHE))
T
Tsutomu Itoh 已提交
1271
		seq_puts(seq, ",space_cache");
1272
	else if (btrfs_test_opt(info, FREE_SPACE_TREE))
1273
		seq_puts(seq, ",space_cache=v2");
1274
	else
1275
		seq_puts(seq, ",nospace_cache");
1276
	if (btrfs_test_opt(info, RESCAN_UUID_TREE))
1277
		seq_puts(seq, ",rescan_uuid_tree");
1278
	if (btrfs_test_opt(info, CLEAR_CACHE))
T
Tsutomu Itoh 已提交
1279
		seq_puts(seq, ",clear_cache");
1280
	if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED))
T
Tsutomu Itoh 已提交
1281
		seq_puts(seq, ",user_subvol_rm_allowed");
1282
	if (btrfs_test_opt(info, ENOSPC_DEBUG))
1283
		seq_puts(seq, ",enospc_debug");
1284
	if (btrfs_test_opt(info, AUTO_DEFRAG))
1285
		seq_puts(seq, ",autodefrag");
1286
	if (btrfs_test_opt(info, INODE_MAP_CACHE))
1287
		seq_puts(seq, ",inode_cache");
1288
	if (btrfs_test_opt(info, SKIP_BALANCE))
1289
		seq_puts(seq, ",skip_balance");
1290
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1291
	if (btrfs_test_opt(info, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
1292
		seq_puts(seq, ",check_int_data");
1293
	else if (btrfs_test_opt(info, CHECK_INTEGRITY))
1294 1295 1296 1297 1298 1299 1300 1301
		seq_puts(seq, ",check_int");
	if (info->check_integrity_print_mask)
		seq_printf(seq, ",check_int_print_mask=%d",
				info->check_integrity_print_mask);
#endif
	if (info->metadata_ratio)
		seq_printf(seq, ",metadata_ratio=%d",
				info->metadata_ratio);
1302
	if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR))
J
Jeff Mahoney 已提交
1303
		seq_puts(seq, ",fatal_errors=panic");
1304 1305
	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
		seq_printf(seq, ",commit=%d", info->commit_interval);
1306
#ifdef CONFIG_BTRFS_DEBUG
1307
	if (btrfs_test_opt(info, FRAGMENT_DATA))
1308
		seq_puts(seq, ",fragment=data");
1309
	if (btrfs_test_opt(info, FRAGMENT_METADATA))
1310 1311
		seq_puts(seq, ",fragment=metadata");
#endif
1312 1313 1314 1315
	seq_printf(seq, ",subvolid=%llu",
		  BTRFS_I(d_inode(dentry))->root->root_key.objectid);
	seq_puts(seq, ",subvol=");
	seq_dentry(seq, dentry, " \t\n\\");
E
Eric Paris 已提交
1316 1317 1318
	return 0;
}

1319
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
1320
{
1321 1322
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
1323

1324
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
1325 1326
}

1327 1328
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
1329 1330 1331 1332
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
1333 1334
}

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
/*
 * subvolumes are identified by ino 256
 */
static inline int is_subvolume_inode(struct inode *inode)
{
	if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
		return 1;
	return 0;
}

1345
/*
1346 1347 1348
 * This will add subvolid=0 to the argument string while removing any subvol=
 * and subvolid= arguments to make sure we get the top-level root for path
 * walking to the subvol we want.
1349 1350 1351
 */
static char *setup_root_args(char *args)
{
1352
	char *buf, *dst, *sep;
1353

1354 1355
	if (!args)
		return kstrdup("subvolid=0", GFP_NOFS);
1356

1357 1358
	/* The worst case is that we add ",subvolid=0" to the end. */
	buf = dst = kmalloc(strlen(args) + strlen(",subvolid=0") + 1, GFP_NOFS);
1359
	if (!buf)
1360 1361
		return NULL;

1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
	while (1) {
		sep = strchrnul(args, ',');
		if (!strstarts(args, "subvol=") &&
		    !strstarts(args, "subvolid=")) {
			memcpy(dst, args, sep - args);
			dst += sep - args;
			*dst++ = ',';
		}
		if (*sep)
			args = sep + 1;
		else
			break;
1374
	}
1375
	strcpy(dst, "subvolid=0");
1376

1377
	return buf;
1378 1379
}

1380 1381 1382
static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid,
				   int flags, const char *device_name,
				   char *data)
1383 1384
{
	struct dentry *root;
1385
	struct vfsmount *mnt = NULL;
1386
	char *newargs;
1387
	int ret;
1388 1389

	newargs = setup_root_args(data);
1390 1391 1392 1393
	if (!newargs) {
		root = ERR_PTR(-ENOMEM);
		goto out;
	}
1394

1395 1396
	mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs);
	if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) {
1397
		if (flags & MS_RDONLY) {
1398 1399
			mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY,
					     device_name, newargs);
1400
		} else {
1401 1402
			mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY,
					     device_name, newargs);
1403
			if (IS_ERR(mnt)) {
1404 1405 1406
				root = ERR_CAST(mnt);
				mnt = NULL;
				goto out;
1407
			}
1408

1409
			down_write(&mnt->mnt_sb->s_umount);
1410
			ret = btrfs_remount(mnt->mnt_sb, &flags, NULL);
1411
			up_write(&mnt->mnt_sb->s_umount);
1412 1413 1414
			if (ret < 0) {
				root = ERR_PTR(ret);
				goto out;
1415 1416 1417
			}
		}
	}
1418 1419 1420 1421 1422
	if (IS_ERR(mnt)) {
		root = ERR_CAST(mnt);
		mnt = NULL;
		goto out;
	}
1423

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
	if (!subvol_name) {
		if (!subvol_objectid) {
			ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb),
							  &subvol_objectid);
			if (ret) {
				root = ERR_PTR(ret);
				goto out;
			}
		}
		subvol_name = get_subvol_name_from_objectid(btrfs_sb(mnt->mnt_sb),
							    subvol_objectid);
		if (IS_ERR(subvol_name)) {
			root = ERR_CAST(subvol_name);
			subvol_name = NULL;
			goto out;
		}

	}

A
Al Viro 已提交
1443
	root = mount_subtree(mnt, subvol_name);
1444 1445
	/* mount_subtree() drops our reference on the vfsmount. */
	mnt = NULL;
1446

1447
	if (!IS_ERR(root)) {
A
Al Viro 已提交
1448
		struct super_block *s = root->d_sb;
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
		struct inode *root_inode = d_inode(root);
		u64 root_objectid = BTRFS_I(root_inode)->root->root_key.objectid;

		ret = 0;
		if (!is_subvolume_inode(root_inode)) {
			pr_err("BTRFS: '%s' is not a valid subvolume\n",
			       subvol_name);
			ret = -EINVAL;
		}
		if (subvol_objectid && root_objectid != subvol_objectid) {
1459 1460 1461 1462 1463
			/*
			 * This will also catch a race condition where a
			 * subvolume which was passed by ID is renamed and
			 * another subvolume is renamed over the old location.
			 */
1464 1465 1466 1467 1468 1469 1470 1471 1472
			pr_err("BTRFS: subvol '%s' does not match subvolid %llu\n",
			       subvol_name, subvol_objectid);
			ret = -EINVAL;
		}
		if (ret) {
			dput(root);
			root = ERR_PTR(ret);
			deactivate_locked_super(s);
		}
1473 1474
	}

1475 1476 1477 1478
out:
	mntput(mnt);
	kfree(newargs);
	kfree(subvol_name);
1479 1480
	return root;
}
1481

1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
static int parse_security_options(char *orig_opts,
				  struct security_mnt_opts *sec_opts)
{
	char *secdata = NULL;
	int ret = 0;

	secdata = alloc_secdata();
	if (!secdata)
		return -ENOMEM;
	ret = security_sb_copy_data(orig_opts, secdata);
	if (ret) {
		free_secdata(secdata);
		return ret;
	}
	ret = security_sb_parse_opts_str(secdata, sec_opts);
	free_secdata(secdata);
	return ret;
}

static int setup_security_options(struct btrfs_fs_info *fs_info,
				  struct super_block *sb,
				  struct security_mnt_opts *sec_opts)
{
	int ret = 0;

	/*
	 * Call security_sb_set_mnt_opts() to check whether new sec_opts
	 * is valid.
	 */
	ret = security_sb_set_mnt_opts(sb, sec_opts, 0, NULL);
	if (ret)
		return ret;

1515
#ifdef CONFIG_SECURITY
1516 1517 1518 1519 1520
	if (!fs_info->security_opts.num_mnt_opts) {
		/* first time security setup, copy sec_opts to fs_info */
		memcpy(&fs_info->security_opts, sec_opts, sizeof(*sec_opts));
	} else {
		/*
1521 1522 1523 1524
		 * Since SELinux (the only one supporting security_mnt_opts)
		 * does NOT support changing context during remount/mount of
		 * the same sb, this must be the same or part of the same
		 * security options, just free it.
1525 1526 1527
		 */
		security_free_mnt_opts(sec_opts);
	}
1528
#endif
1529 1530 1531
	return ret;
}

1532 1533 1534 1535 1536 1537
/*
 * Find a superblock for the given device / mount point.
 *
 * Note:  This is based on get_sb_bdev from fs/super.c with a few additions
 *	  for multiple device setup.  Make sure to keep it in sync.
 */
A
Al Viro 已提交
1538
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1539
		const char *device_name, void *data)
Y
Yan 已提交
1540 1541 1542
{
	struct block_device *bdev = NULL;
	struct super_block *s;
1543
	struct btrfs_fs_devices *fs_devices = NULL;
1544
	struct btrfs_fs_info *fs_info = NULL;
1545
	struct security_mnt_opts new_sec_opts;
1546
	fmode_t mode = FMODE_READ;
1547 1548
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1549 1550
	int error = 0;

1551 1552 1553 1554
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1555
					  &subvol_name, &subvol_objectid,
1556
					  &fs_devices);
1557 1558
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1559
		return ERR_PTR(error);
1560
	}
1561

1562
	if (subvol_name || subvol_objectid != BTRFS_FS_TREE_OBJECTID) {
1563
		/* mount_subvol() will free subvol_name. */
1564 1565
		return mount_subvol(subvol_name, subvol_objectid, flags,
				    device_name, data);
1566 1567
	}

1568 1569 1570 1571 1572 1573 1574
	security_init_mnt_opts(&new_sec_opts);
	if (data) {
		error = parse_security_options(data, &new_sec_opts);
		if (error)
			return ERR_PTR(error);
	}

1575
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1576
	if (error)
1577
		goto error_sec_opts;
Y
Yan 已提交
1578

1579 1580 1581 1582 1583 1584 1585
	/*
	 * Setup a dummy root and fs_info for test/set super.  This is because
	 * we don't actually fill this stuff out until open_ctree, but we need
	 * it for searching for existing supers, so this lets us do that and
	 * then open_ctree will properly initialize everything later.
	 */
	fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
1586 1587 1588 1589
	if (!fs_info) {
		error = -ENOMEM;
		goto error_sec_opts;
	}
1590

1591 1592
	fs_info->fs_devices = fs_devices;

1593 1594
	fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
	fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1595
	security_init_mnt_opts(&fs_info->security_opts);
1596 1597
	if (!fs_info->super_copy || !fs_info->super_for_commit) {
		error = -ENOMEM;
1598 1599 1600 1601 1602 1603 1604 1605 1606
		goto error_fs_info;
	}

	error = btrfs_open_devices(fs_devices, mode, fs_type);
	if (error)
		goto error_fs_info;

	if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
		error = -EACCES;
1607 1608 1609
		goto error_close_devices;
	}

1610
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1611 1612
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1613 1614 1615 1616
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1617 1618

	if (s->s_root) {
Y
Yan Zheng 已提交
1619
		btrfs_close_devices(fs_devices);
1620
		free_fs_info(fs_info);
1621 1622
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1623
	} else {
1624
		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1625
		btrfs_sb(s)->bdev_holder = fs_type;
1626 1627
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1628
	}
1629
	if (error) {
1630 1631 1632 1633 1634 1635 1636
		deactivate_locked_super(s);
		goto error_sec_opts;
	}

	fs_info = btrfs_sb(s);
	error = setup_security_options(fs_info, s, &new_sec_opts);
	if (error) {
1637
		deactivate_locked_super(s);
1638 1639
		goto error_sec_opts;
	}
Y
Yan 已提交
1640

1641
	return dget(s->s_root);
Y
Yan 已提交
1642

Y
Yan Zheng 已提交
1643
error_close_devices:
1644
	btrfs_close_devices(fs_devices);
1645
error_fs_info:
1646
	free_fs_info(fs_info);
1647 1648
error_sec_opts:
	security_free_mnt_opts(&new_sec_opts);
A
Al Viro 已提交
1649
	return ERR_PTR(error);
Y
Yan 已提交
1650
}
1651

1652 1653 1654 1655 1656 1657 1658 1659
static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
				     int new_pool_size, int old_pool_size)
{
	if (new_pool_size == old_pool_size)
		return;

	fs_info->thread_pool_size = new_pool_size;

1660
	btrfs_info(fs_info, "resize thread pool %d -> %d",
1661 1662
	       old_pool_size, new_pool_size);

1663
	btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
1664
	btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
1665
	btrfs_workqueue_set_max(fs_info->submit_workers, new_pool_size);
1666
	btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);
1667 1668 1669 1670 1671 1672
	btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_meta_write_workers,
				new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);
1673
	btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);
1674
	btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size);
1675 1676
	btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers,
				new_pool_size);
1677 1678
}

1679
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
M
Miao Xie 已提交
1680 1681
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1682
}
M
Miao Xie 已提交
1683

1684 1685 1686
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
				       unsigned long old_opts, int flags)
{
M
Miao Xie 已提交
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
	if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
	    (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
	     (flags & MS_RDONLY))) {
		/* wait for any defraggers to finish */
		wait_event(fs_info->transaction_wait,
			   (atomic_read(&fs_info->defrag_running) == 0));
		if (flags & MS_RDONLY)
			sync_filesystem(fs_info->sb);
	}
}

static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
					 unsigned long old_opts)
{
	/*
1702 1703
	 * We need to cleanup all defragable inodes if the autodefragment is
	 * close or the filesystem is read only.
M
Miao Xie 已提交
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
	 */
	if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
	    (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
	     (fs_info->sb->s_flags & MS_RDONLY))) {
		btrfs_cleanup_defrag_inodes(fs_info);
	}

	clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
}

Y
Yan Zheng 已提交
1714 1715
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1716 1717
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1718 1719 1720 1721 1722 1723 1724
	unsigned old_flags = sb->s_flags;
	unsigned long old_opts = fs_info->mount_opt;
	unsigned long old_compress_type = fs_info->compress_type;
	u64 old_max_inline = fs_info->max_inline;
	u64 old_alloc_start = fs_info->alloc_start;
	int old_thread_pool_size = fs_info->thread_pool_size;
	unsigned int old_metadata_ratio = fs_info->metadata_ratio;
Y
Yan Zheng 已提交
1725 1726
	int ret;

1727
	sync_filesystem(sb);
1728
	btrfs_remount_prepare(fs_info);
M
Miao Xie 已提交
1729

1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
	if (data) {
		struct security_mnt_opts new_sec_opts;

		security_init_mnt_opts(&new_sec_opts);
		ret = parse_security_options(data, &new_sec_opts);
		if (ret)
			goto restore;
		ret = setup_security_options(fs_info, sb,
					     &new_sec_opts);
		if (ret) {
			security_free_mnt_opts(&new_sec_opts);
			goto restore;
		}
	}

1745
	ret = btrfs_parse_options(root, data, *flags);
1746 1747 1748 1749
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1750

1751
	btrfs_remount_begin(fs_info, old_opts, *flags);
1752 1753 1754
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1755
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1756
		goto out;
Y
Yan Zheng 已提交
1757 1758

	if (*flags & MS_RDONLY) {
1759 1760 1761 1762
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
1763
		cancel_work_sync(&fs_info->async_reclaim_work);
1764 1765 1766 1767 1768 1769

		/* wait for the uuid_scan task to finish */
		down(&fs_info->uuid_tree_rescan_sem);
		/* avoid complains from lockdep et al. */
		up(&fs_info->uuid_tree_rescan_sem);

Y
Yan Zheng 已提交
1770 1771
		sb->s_flags |= MS_RDONLY;

1772 1773 1774 1775 1776 1777 1778 1779 1780
		/*
		 * Setting MS_RDONLY will put the cleaner thread to
		 * sleep at the next loop if it's already active.
		 * If it's already asleep, we'll leave unused block
		 * groups on disk until we're mounted read-write again
		 * unless we clean them up here.
		 */
		btrfs_delete_unused_bgs(fs_info);

1781 1782
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);
1783
		btrfs_pause_balance(fs_info);
1784

1785 1786 1787
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1788
	} else {
1789 1790
		if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
			btrfs_err(fs_info,
1791
				"Remounting read-write after error is not allowed");
1792 1793 1794
			ret = -EINVAL;
			goto restore;
		}
1795
		if (fs_info->fs_devices->rw_devices == 0) {
1796 1797
			ret = -EACCES;
			goto restore;
1798
		}
Y
Yan Zheng 已提交
1799

1800 1801 1802
		if (fs_info->fs_devices->missing_devices >
		     fs_info->num_tolerated_disk_barrier_failures &&
		    !(*flags & MS_RDONLY)) {
1803 1804
			btrfs_warn(fs_info,
				"too many missing devices, writeable remount is not allowed");
1805 1806 1807 1808
			ret = -EACCES;
			goto restore;
		}

1809
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1810 1811
			ret = -EINVAL;
			goto restore;
1812
		}
Y
Yan Zheng 已提交
1813

1814
		ret = btrfs_cleanup_fs_roots(fs_info);
1815 1816
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1817

1818
		/* recover relocation */
1819
		mutex_lock(&fs_info->cleaner_mutex);
1820
		ret = btrfs_recover_relocation(root);
1821
		mutex_unlock(&fs_info->cleaner_mutex);
1822 1823
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1824

1825 1826 1827 1828
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1829 1830
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
1831
			btrfs_warn(fs_info, "failed to resume dev_replace");
1832 1833
			goto restore;
		}
1834 1835

		if (!fs_info->uuid_root) {
1836
			btrfs_info(fs_info, "creating UUID tree");
1837 1838
			ret = btrfs_create_uuid_tree(fs_info);
			if (ret) {
J
Jeff Mahoney 已提交
1839 1840 1841
				btrfs_warn(fs_info,
					   "failed to create the UUID tree %d",
					   ret);
1842 1843 1844
				goto restore;
			}
		}
Y
Yan Zheng 已提交
1845
		sb->s_flags &= ~MS_RDONLY;
1846

1847
		set_bit(BTRFS_FS_OPEN, &fs_info->flags);
Y
Yan Zheng 已提交
1848
	}
M
Miao Xie 已提交
1849
out:
1850
	wake_up_process(fs_info->transaction_kthread);
M
Miao Xie 已提交
1851
	btrfs_remount_cleanup(fs_info, old_opts);
Y
Yan Zheng 已提交
1852
	return 0;
1853 1854 1855 1856 1857 1858 1859 1860 1861

restore:
	/* We've hit an error - don't reset MS_RDONLY */
	if (sb->s_flags & MS_RDONLY)
		old_flags |= MS_RDONLY;
	sb->s_flags = old_flags;
	fs_info->mount_opt = old_opts;
	fs_info->compress_type = old_compress_type;
	fs_info->max_inline = old_max_inline;
M
Miao Xie 已提交
1862
	mutex_lock(&fs_info->chunk_mutex);
1863
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1864
	mutex_unlock(&fs_info->chunk_mutex);
1865 1866
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1867
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1868
	btrfs_remount_cleanup(fs_info, old_opts);
1869
	return ret;
Y
Yan Zheng 已提交
1870 1871
}

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
/* Used to sort the devices by max_avail(descending sort) */
static int btrfs_cmp_device_free_bytes(const void *dev_info1,
				       const void *dev_info2)
{
	if (((struct btrfs_device_info *)dev_info1)->max_avail >
	    ((struct btrfs_device_info *)dev_info2)->max_avail)
		return -1;
	else if (((struct btrfs_device_info *)dev_info1)->max_avail <
		 ((struct btrfs_device_info *)dev_info2)->max_avail)
		return 1;
	else
	return 0;
}

/*
 * sort the devices by max_avail, in which max free extent size of each device
 * is stored.(Descending Sort)
 */
static inline void btrfs_descending_sort_devices(
					struct btrfs_device_info *devices,
					size_t nr_devices)
{
	sort(devices, nr_devices, sizeof(struct btrfs_device_info),
	     btrfs_cmp_device_free_bytes, NULL);
}

1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
/*
 * The helper to calc the free space on the devices that can be used to store
 * file data.
 */
static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct btrfs_device_info *devices_info;
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
	struct btrfs_device *device;
	u64 skip_space;
	u64 type;
	u64 avail_space;
	u64 used_space;
	u64 min_stripe_size;
1913
	int min_stripes = 1, num_stripes = 1;
1914 1915 1916
	int i = 0, nr_devices;
	int ret;

1917
	/*
1918
	 * We aren't under the device list lock, so this is racy-ish, but good
1919 1920
	 * enough for our purposes.
	 */
1921
	nr_devices = fs_info->fs_devices->open_devices;
1922 1923 1924 1925 1926 1927 1928 1929 1930
	if (!nr_devices) {
		smp_mb();
		nr_devices = fs_info->fs_devices->open_devices;
		ASSERT(nr_devices);
		if (!nr_devices) {
			*free_bytes = 0;
			return 0;
		}
	}
1931

1932
	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1933 1934 1935 1936
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

1937
	/* calc min stripe number for data space allocation */
1938
	type = btrfs_get_alloc_profile(root, 1);
1939
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1940
		min_stripes = 2;
1941 1942
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1943
		min_stripes = 2;
1944 1945
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1946
		min_stripes = 4;
1947 1948
		num_stripes = 4;
	}
1949 1950 1951 1952 1953 1954

	if (type & BTRFS_BLOCK_GROUP_DUP)
		min_stripe_size = 2 * BTRFS_STRIPE_LEN;
	else
		min_stripe_size = BTRFS_STRIPE_LEN;

1955 1956 1957 1958
	if (fs_info->alloc_start)
		mutex_lock(&fs_devices->device_list_mutex);
	rcu_read_lock();
	list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
1959 1960
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1961 1962
			continue;

1963 1964 1965
		if (i >= nr_devices)
			break;

1966 1967 1968
		avail_space = device->total_bytes - device->bytes_used;

		/* align with stripe_len */
1969
		avail_space = div_u64(avail_space, BTRFS_STRIPE_LEN);
1970 1971 1972
		avail_space *= BTRFS_STRIPE_LEN;

		/*
1973
		 * In order to avoid overwriting the superblock on the drive,
1974 1975 1976
		 * btrfs starts at an offset of at least 1MB when doing chunk
		 * allocation.
		 */
1977
		skip_space = SZ_1M;
1978 1979

		/* user can set the offset in fs_info->alloc_start. */
1980 1981 1982 1983
		if (fs_info->alloc_start &&
		    fs_info->alloc_start + BTRFS_STRIPE_LEN <=
		    device->total_bytes) {
			rcu_read_unlock();
1984 1985
			skip_space = max(fs_info->alloc_start, skip_space);

1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
			/*
			 * btrfs can not use the free space in
			 * [0, skip_space - 1], we must subtract it from the
			 * total. In order to implement it, we account the used
			 * space in this range first.
			 */
			ret = btrfs_account_dev_extents_size(device, 0,
							     skip_space - 1,
							     &used_space);
			if (ret) {
				kfree(devices_info);
				mutex_unlock(&fs_devices->device_list_mutex);
				return ret;
			}

			rcu_read_lock();
2002

2003 2004 2005
			/* calc the free space in [0, skip_space - 1] */
			skip_space -= used_space;
		}
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023

		/*
		 * we can use the free space in [0, skip_space - 1], subtract
		 * it from the total.
		 */
		if (avail_space && avail_space >= skip_space)
			avail_space -= skip_space;
		else
			avail_space = 0;

		if (avail_space < min_stripe_size)
			continue;

		devices_info[i].dev = device;
		devices_info[i].max_avail = avail_space;

		i++;
	}
2024 2025 2026
	rcu_read_unlock();
	if (fs_info->alloc_start)
		mutex_unlock(&fs_devices->device_list_mutex);
2027 2028 2029 2030 2031 2032 2033 2034

	nr_devices = i;

	btrfs_descending_sort_devices(devices_info, nr_devices);

	i = nr_devices - 1;
	avail_space = 0;
	while (nr_devices >= min_stripes) {
2035 2036 2037
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

2038 2039 2040 2041
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

2042
			avail_space += devices_info[i].max_avail * num_stripes;
2043
			alloc_size = devices_info[i].max_avail;
2044
			for (j = i + 1 - num_stripes; j <= i; j++)
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

	kfree(devices_info);
	*free_bytes = avail_space;
	return 0;
}

2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
/*
 * Calculate numbers for 'df', pessimistic in case of mixed raid profiles.
 *
 * If there's a redundant raid level at DATA block groups, use the respective
 * multiplier to scale the sizes.
 *
 * Unused device space usage is based on simulating the chunk allocator
 * algorithm that respects the device sizes, order of allocations and the
 * 'alloc_start' value, this is a close approximation of the actual use but
 * there are other factors that may change the result (like a new metadata
 * chunk).
 *
2068
 * If metadata is exhausted, f_bavail will be 0.
2069
 */
C
Chris Mason 已提交
2070 2071
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
2072 2073 2074
	struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
	struct btrfs_super_block *disk_super = fs_info->super_copy;
	struct list_head *head = &fs_info->space_info;
2075 2076
	struct btrfs_space_info *found;
	u64 total_used = 0;
2077
	u64 total_free_data = 0;
2078
	u64 total_free_meta = 0;
2079
	int bits = dentry->d_sb->s_blocksize_bits;
2080
	__be32 *fsid = (__be32 *)fs_info->fsid;
2081 2082
	unsigned factor = 1;
	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
2083
	int ret;
2084
	u64 thresh = 0;
2085
	int mixed = 0;
C
Chris Mason 已提交
2086

2087
	/*
2088
	 * holding chunk_mutex to avoid allocating new chunks, holding
2089 2090
	 * device_list_mutex to avoid the device being removed
	 */
2091
	rcu_read_lock();
J
Josef Bacik 已提交
2092
	list_for_each_entry_rcu(found, head, list) {
2093
		if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
2094 2095
			int i;

2096 2097 2098
			total_free_data += found->disk_total - found->disk_used;
			total_free_data -=
				btrfs_account_ro_block_groups_free_space(found);
2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109

			for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
				if (!list_empty(&found->block_groups[i])) {
					switch (i) {
					case BTRFS_RAID_DUP:
					case BTRFS_RAID_RAID1:
					case BTRFS_RAID_RAID10:
						factor = 2;
					}
				}
			}
2110
		}
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121

		/*
		 * Metadata in mixed block goup profiles are accounted in data
		 */
		if (!mixed && found->flags & BTRFS_BLOCK_GROUP_METADATA) {
			if (found->flags & BTRFS_BLOCK_GROUP_DATA)
				mixed = 1;
			else
				total_free_meta += found->disk_total -
					found->disk_used;
		}
2122

2123
		total_used += found->disk_used;
J
Josef Bacik 已提交
2124
	}
2125

2126 2127
	rcu_read_unlock();

2128 2129 2130 2131 2132 2133
	buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor);
	buf->f_blocks >>= bits;
	buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits);

	/* Account global block reserve as used, it's in logical size already */
	spin_lock(&block_rsv->lock);
2134 2135 2136 2137 2138
	/* Mixed block groups accounting is not byte-accurate, avoid overflow */
	if (buf->f_bfree >= block_rsv->size >> bits)
		buf->f_bfree -= block_rsv->size >> bits;
	else
		buf->f_bfree = 0;
2139 2140
	spin_unlock(&block_rsv->lock);

2141
	buf->f_bavail = div_u64(total_free_data, factor);
2142
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
2143
	if (ret)
2144
		return ret;
2145
	buf->f_bavail += div_u64(total_free_data, factor);
2146
	buf->f_bavail = buf->f_bavail >> bits;
C
Chris Mason 已提交
2147

2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
	/*
	 * We calculate the remaining metadata space minus global reserve. If
	 * this is (supposedly) smaller than zero, there's no space. But this
	 * does not hold in practice, the exhausted state happens where's still
	 * some positive delta. So we apply some guesswork and compare the
	 * delta to a 4M threshold.  (Practically observed delta was ~2M.)
	 *
	 * We probably cannot calculate the exact threshold value because this
	 * depends on the internal reservations requested by various
	 * operations, so some operations that consume a few metadata will
	 * succeed even if the Avail is zero. But this is better than the other
	 * way around.
	 */
	thresh = 4 * 1024 * 1024;

2163
	if (!mixed && total_free_meta - thresh < block_rsv->size)
2164 2165
		buf->f_bavail = 0;

2166 2167 2168 2169
	buf->f_type = BTRFS_SUPER_MAGIC;
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_namelen = BTRFS_NAME_LEN;

2170
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
2171
	   because we want the fsid to come out the same whether mounted
2172 2173 2174
	   on a big-endian or little-endian host */
	buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
	buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
2175
	/* Mask in the root object ID too, to disambiguate subvols */
2176 2177
	buf->f_fsid.val[0] ^= BTRFS_I(d_inode(dentry))->root->objectid >> 32;
	buf->f_fsid.val[1] ^= BTRFS_I(d_inode(dentry))->root->objectid;
2178

C
Chris Mason 已提交
2179 2180
	return 0;
}
C
Chris Mason 已提交
2181

A
Al Viro 已提交
2182 2183
static void btrfs_kill_super(struct super_block *sb)
{
2184
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
2185
	kill_anon_super(sb);
2186
	free_fs_info(fs_info);
A
Al Viro 已提交
2187 2188
}

2189 2190 2191
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
2192
	.mount		= btrfs_mount,
A
Al Viro 已提交
2193
	.kill_sb	= btrfs_kill_super,
2194
	.fs_flags	= FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
2195
};
2196
MODULE_ALIAS_FS("btrfs");
2197

2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
static int btrfs_control_open(struct inode *inode, struct file *file)
{
	/*
	 * The control file's private_data is used to hold the
	 * transaction when it is started and is used to keep
	 * track of whether a transaction is already in progress.
	 */
	file->private_data = NULL;
	return 0;
}

C
Chris Mason 已提交
2209 2210 2211
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
2212 2213 2214 2215 2216
static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
				unsigned long arg)
{
	struct btrfs_ioctl_vol_args *vol;
	struct btrfs_fs_devices *fs_devices;
2217
	int ret = -ENOTTY;
2218

2219 2220 2221
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
2222 2223 2224
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
2225

2226 2227
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
2228
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
2229 2230
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
2231 2232 2233 2234 2235 2236 2237
	case BTRFS_IOC_DEVICES_READY:
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
					    &btrfs_fs_type, &fs_devices);
		if (ret)
			break;
		ret = !(fs_devices->num_devices == fs_devices->total_devices);
		break;
2238
	case BTRFS_IOC_GET_SUPPORTED_FEATURES:
2239
		ret = btrfs_ioctl_get_supported_features((void __user*)arg);
2240
		break;
2241
	}
L
Li Zefan 已提交
2242

2243
	kfree(vol);
L
Linda Knippers 已提交
2244
	return ret;
2245 2246
}

2247
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
2248
{
2249 2250 2251
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

2252 2253 2254 2255 2256 2257 2258
	root->fs_info->fs_frozen = 1;
	/*
	 * We don't need a barrier here, we'll wait for any transaction that
	 * could be in progress on other threads (and do delayed iputs that
	 * we want to avoid on a frozen filesystem), or do the commit
	 * ourselves.
	 */
M
Miao Xie 已提交
2259
	trans = btrfs_attach_transaction_barrier(root);
2260 2261 2262 2263 2264 2265 2266
	if (IS_ERR(trans)) {
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
			return 0;
		return PTR_ERR(trans);
	}
	return btrfs_commit_transaction(trans, root);
Y
Yan 已提交
2267 2268
}

2269 2270 2271 2272 2273 2274 2275 2276
static int btrfs_unfreeze(struct super_block *sb)
{
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

	root->fs_info->fs_frozen = 0;
	return 0;
}

J
Josef Bacik 已提交
2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289
static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
{
	struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
	struct btrfs_fs_devices *cur_devices;
	struct btrfs_device *dev, *first_dev = NULL;
	struct list_head *head;
	struct rcu_string *name;

	mutex_lock(&fs_info->fs_devices->device_list_mutex);
	cur_devices = fs_info->fs_devices;
	while (cur_devices) {
		head = &cur_devices->devices;
		list_for_each_entry(dev, head, dev_list) {
2290 2291
			if (dev->missing)
				continue;
2292 2293
			if (!dev->name)
				continue;
J
Josef Bacik 已提交
2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
			if (!first_dev || dev->devid < first_dev->devid)
				first_dev = dev;
		}
		cur_devices = cur_devices->seed;
	}

	if (first_dev) {
		rcu_read_lock();
		name = rcu_dereference(first_dev->name);
		seq_escape(m, name->str, " \t\n\\");
		rcu_read_unlock();
	} else {
		WARN_ON(1);
	}
	mutex_unlock(&fs_info->fs_devices->device_list_mutex);
	return 0;
}

2312
static const struct super_operations btrfs_super_ops = {
2313
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
2314
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
2315
	.put_super	= btrfs_put_super,
2316
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
2317
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
2318
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
2319
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
2320 2321
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
2322
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
2323
	.remount_fs	= btrfs_remount,
2324
	.freeze_fs	= btrfs_freeze,
2325
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
2326
};
2327 2328

static const struct file_operations btrfs_ctl_fops = {
2329
	.open = btrfs_control_open,
2330 2331 2332
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
2333
	.llseek = noop_llseek,
2334 2335 2336
};

static struct miscdevice btrfs_misc = {
2337
	.minor		= BTRFS_MINOR,
2338 2339 2340 2341
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

2342 2343 2344
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

2345 2346 2347 2348 2349
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

2350
static void btrfs_interface_exit(void)
2351
{
2352
	misc_deregister(&btrfs_misc);
2353 2354
}

2355
static void btrfs_print_mod_info(void)
2356
{
2357
	pr_info("Btrfs loaded, crc32c=%s"
2358 2359 2360
#ifdef CONFIG_BTRFS_DEBUG
			", debug=on"
#endif
2361 2362 2363
#ifdef CONFIG_BTRFS_ASSERT
			", assert=on"
#endif
2364 2365 2366
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
			", integrity-checker=on"
#endif
2367 2368
			"\n",
			btrfs_crc32c_impl());
2369 2370
}

2371 2372
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
2373
	int err;
2374

2375 2376 2377 2378
	err = btrfs_hash_init();
	if (err)
		return err;

2379 2380
	btrfs_props_init();

2381 2382
	err = btrfs_init_sysfs();
	if (err)
2383
		goto free_hash;
2384

2385
	btrfs_init_compress();
2386

2387 2388 2389 2390
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

2391
	err = extent_io_init();
2392 2393 2394
	if (err)
		goto free_cachep;

2395 2396 2397 2398
	err = extent_map_init();
	if (err)
		goto free_extent_io;

2399
	err = ordered_data_init();
2400 2401
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
2402

2403 2404 2405 2406
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

2407
	err = btrfs_auto_defrag_init();
2408 2409 2410
	if (err)
		goto free_delayed_inode;

2411
	err = btrfs_delayed_ref_init();
2412 2413 2414
	if (err)
		goto free_auto_defrag;

2415 2416
	err = btrfs_prelim_ref_init();
	if (err)
2417
		goto free_delayed_ref;
2418

2419
	err = btrfs_end_io_wq_init();
2420
	if (err)
2421
		goto free_prelim_ref;
2422

2423 2424 2425 2426
	err = btrfs_interface_init();
	if (err)
		goto free_end_io_wq;

2427 2428
	btrfs_init_lockdep();

2429
	btrfs_print_mod_info();
2430 2431 2432 2433 2434 2435 2436 2437

	err = btrfs_run_sanity_tests();
	if (err)
		goto unregister_ioctl;

	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
2438

2439 2440
	return 0;

2441 2442
unregister_ioctl:
	btrfs_interface_exit();
2443 2444
free_end_io_wq:
	btrfs_end_io_wq_exit();
2445 2446
free_prelim_ref:
	btrfs_prelim_ref_exit();
2447 2448
free_delayed_ref:
	btrfs_delayed_ref_exit();
2449 2450
free_auto_defrag:
	btrfs_auto_defrag_exit();
2451 2452
free_delayed_inode:
	btrfs_delayed_inode_exit();
2453 2454
free_ordered_data:
	ordered_data_exit();
2455 2456
free_extent_map:
	extent_map_exit();
2457 2458
free_extent_io:
	extent_io_exit();
2459 2460
free_cachep:
	btrfs_destroy_cachep();
2461 2462
free_compress:
	btrfs_exit_compress();
2463
	btrfs_exit_sysfs();
2464 2465
free_hash:
	btrfs_hash_exit();
2466
	return err;
2467 2468 2469 2470
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
2471
	btrfs_destroy_cachep();
2472
	btrfs_delayed_ref_exit();
2473
	btrfs_auto_defrag_exit();
2474
	btrfs_delayed_inode_exit();
2475
	btrfs_prelim_ref_exit();
2476
	ordered_data_exit();
2477
	extent_map_exit();
2478
	extent_io_exit();
2479
	btrfs_interface_exit();
2480
	btrfs_end_io_wq_exit();
2481
	unregister_filesystem(&btrfs_fs_type);
2482
	btrfs_exit_sysfs();
2483
	btrfs_cleanup_fs_uuids();
2484
	btrfs_exit_compress();
2485
	btrfs_hash_exit();
2486 2487
}

2488
late_initcall(init_btrfs_fs);
2489 2490 2491
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");