super.c 52.0 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 64 65
#define CREATE_TRACE_POINTS
#include <trace/events/btrfs.h>

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

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

	switch (errno) {
	case -EIO:
		errstr = "IO failure";
		break;
	case -ENOMEM:
		errstr = "Out of memory";
		break;
	case -EROFS:
		errstr = "Readonly filesystem";
		break;
J
Jeff Mahoney 已提交
83 84 85
	case -EEXIST:
		errstr = "Object already exists";
		break;
86 87 88 89 90 91
	case -ENOSPC:
		errstr = "No space left";
		break;
	case -ENOENT:
		errstr = "No such entry";
		break;
L
liubo 已提交
92 93 94 95 96
	}

	return errstr;
}

97
static void save_error_info(struct btrfs_fs_info *fs_info)
L
liubo 已提交
98 99 100 101 102
{
	/*
	 * today we only save the error info into ram.  Long term we'll
	 * also send it down to the disk
	 */
103
	set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
L
liubo 已提交
104 105 106 107 108 109 110 111 112 113
}

/* 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;

114
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
liubo 已提交
115
		sb->s_flags |= MS_RDONLY;
116
		btrfs_info(fs_info, "forced readonly");
117 118 119 120 121 122 123 124 125 126
		/*
		 * 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,
		 * therefore the canceling is ommited. The only penalty
		 * 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 已提交
127 128 129
	}
}

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

	/*
	 * 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 已提交
146 147
  		return;

148
	errstr = btrfs_decode_error(errno);
J
Jeff Mahoney 已提交
149
	if (fmt) {
150 151 152 153 154 155
		struct va_format vaf;
		va_list args;

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

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

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

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

183
void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
J
Jeff Mahoney 已提交
184 185 186 187 188 189
{
	struct super_block *sb = fs_info->sb;
	char lvl[4];
	struct va_format vaf;
	va_list args;
	const char *type = logtypes[4];
190
	int kern_level;
J
Jeff Mahoney 已提交
191 192 193

	va_start(args, fmt);

194 195 196 197 198 199 200
	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'];
J
Jeff Mahoney 已提交
201 202 203 204 205
	} else
		*lvl = '\0';

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

207
	printk("%sBTRFS %s (device %s): %pV\n", lvl, type, sb->s_id, &vaf);
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

	va_end(args);
}

#else

void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
		       unsigned int line, int errno, const char *fmt, ...)
{
	struct super_block *sb = fs_info->sb;

	/*
	 * 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))
		return;

	/* Don't go through full error handling during mount */
	if (sb->s_flags & MS_BORN) {
		save_error_info(fs_info);
		btrfs_handle_error(fs_info);
	}
L
liubo 已提交
231
}
232
#endif
L
liubo 已提交
233

234 235 236 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.
 */
void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root, const char *function,
			       unsigned int line, int errno)
{
251 252 253 254 255
	/*
	 * Report first abort since mount
	 */
	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,
				&root->fs_info->fs_state)) {
256
		WARN(1, KERN_DEBUG "BTRFS: Transaction aborted (error %d)\n",
257 258
				errno);
	}
259 260 261 262
	trans->aborted = errno;
	/* Nothing used. The other threads that have joined this
	 * transaction may be able to continue. */
	if (!trans->blocks_used) {
263 264
		const char *errstr;

265
		errstr = btrfs_decode_error(errno);
266 267 268
		btrfs_warn(root->fs_info,
		           "%s:%d: Aborting unused transaction(%s).",
		           function, line, errstr);
L
liubo 已提交
269
		return;
270
	}
271
	ACCESS_ONCE(trans->transaction->aborted) = errno;
272 273 274
	/* Wake up anybody who may be waiting on this transaction */
	wake_up(&root->fs_info->transaction_wait);
	wake_up(&root->fs_info->transaction_blocked_wait);
275 276
	__btrfs_std_error(root->fs_info, function, line, errno, NULL);
}
J
Jeff Mahoney 已提交
277 278 279 280 281 282 283 284 285 286 287
/*
 * __btrfs_panic decodes unexpected, fatal errors from the caller,
 * issues an alert, and either panics or BUGs, depending on mount options.
 */
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
	(void)close_ctree(btrfs_sb(sb)->tree_root);
A
Al Viro 已提交
309 310 311 312 313 314
	/* FIXME: need to fix VFS to return error? */
	/* AV: return it _where_?  ->put_super() can be triggered by any number
	 * of async events, up to and including delivery of SIGKILL to the
	 * last process that kept it busy.  Or segfault in the aforementioned
	 * process...  Whom would you report that to?
	 */
C
Chris Mason 已提交
315 316
}

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

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

386 387 388 389 390 391 392 393 394 395 396 397 398 399
#define btrfs_set_and_info(root, opt, fmt, args...)			\
{									\
	if (!btrfs_test_opt(root, opt))					\
		btrfs_info(root->fs_info, fmt, ##args);			\
	btrfs_set_opt(root->fs_info->mount_opt, opt);			\
}

#define btrfs_clear_and_info(root, opt, fmt, args...)			\
{									\
	if (btrfs_test_opt(root, opt))					\
		btrfs_info(root->fs_info, fmt, ##args);			\
	btrfs_clear_opt(root->fs_info->mount_opt, opt);			\
}

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

417
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
418 419 420
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

421
	if (!options)
422
		goto out;
423

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

432
	orig = options;
433

434
	while ((p = strsep(&options, ",")) != NULL) {
435 436 437 438 439 440
		int token;
		if (!*p)
			continue;

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

			if (compress_force) {
520 521 522 523 524 525 526 527
				btrfs_set_and_info(root, FORCE_COMPRESS,
						   "force %s compression",
						   compress_type);
			} else if (compress) {
				if (!btrfs_test_opt(root, COMPRESS))
					btrfs_info(root->fs_info,
						   "btrfs: use %s compression\n",
						   compress_type);
528
			}
C
Chris Mason 已提交
529
			break;
530
		case Opt_ssd:
531 532
			btrfs_set_and_info(root, SSD,
					   "use ssd allocation scheme");
533
			break;
534
		case Opt_ssd_spread:
535 536
			btrfs_set_and_info(root, SSD_SPREAD,
					   "use spread ssd allocation scheme");
537
			break;
C
Chris Mason 已提交
538
		case Opt_nossd:
539 540
			btrfs_clear_and_info(root, NOSSD,
					     "not using ssd allocation scheme");
C
Chris Mason 已提交
541 542
			btrfs_clear_opt(info->mount_opt, SSD);
			break;
543
		case Opt_barrier:
544 545
			btrfs_clear_and_info(root, NOBARRIER,
					     "turning on barriers");
546
			break;
547
		case Opt_nobarrier:
548 549
			btrfs_set_and_info(root, NOBARRIER,
					   "turning off barriers");
550
			break;
551
		case Opt_thread_pool:
552 553 554 555
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg > 0) {
556
				info->thread_pool_size = intarg;
557 558 559 560
			} else {
				ret = -EINVAL;
				goto out;
			}
561
			break;
562
		case Opt_max_inline:
563 564
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
565
				info->max_inline = memparse(num, NULL);
566 567
				kfree(num);

C
Chris Mason 已提交
568
				if (info->max_inline) {
569
					info->max_inline = min_t(u64,
C
Chris Mason 已提交
570 571 572
						info->max_inline,
						root->sectorsize);
				}
573
				btrfs_info(root->fs_info, "max_inline at %llu",
574
					info->max_inline);
575 576 577
			} else {
				ret = -ENOMEM;
				goto out;
578 579
			}
			break;
580
		case Opt_alloc_start:
581 582
			num = match_strdup(&args[0]);
			if (num) {
M
Miao Xie 已提交
583
				mutex_lock(&info->chunk_mutex);
A
Akinobu Mita 已提交
584
				info->alloc_start = memparse(num, NULL);
M
Miao Xie 已提交
585
				mutex_unlock(&info->chunk_mutex);
586
				kfree(num);
587
				btrfs_info(root->fs_info, "allocations start at %llu",
588
					info->alloc_start);
589 590 591
			} else {
				ret = -ENOMEM;
				goto out;
592 593
			}
			break;
Q
Qu Wenruo 已提交
594 595 596
		case Opt_acl:
			root->fs_info->sb->s_flags |= MS_POSIXACL;
			break;
J
Josef Bacik 已提交
597 598 599
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
600
		case Opt_notreelog:
601 602
			btrfs_set_and_info(root, NOTREELOG,
					   "disabling tree log");
Q
Qu Wenruo 已提交
603 604
			break;
		case Opt_treelog:
605 606
			btrfs_clear_and_info(root, NOTREELOG,
					     "enabling tree log");
S
Sage Weil 已提交
607
			break;
608
		case Opt_flushoncommit:
609 610
			btrfs_set_and_info(root, FLUSHONCOMMIT,
					   "turning on flush-on-commit");
611
			break;
612
		case Opt_noflushoncommit:
613 614
			btrfs_clear_and_info(root, FLUSHONCOMMIT,
					     "turning off flush-on-commit");
615
			break;
616
		case Opt_ratio:
617 618 619 620
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg >= 0) {
621
				info->metadata_ratio = intarg;
622
				btrfs_info(root->fs_info, "metadata ratio %d",
623
				       info->metadata_ratio);
624 625 626
			} else {
				ret = -EINVAL;
				goto out;
627 628
			}
			break;
C
Christoph Hellwig 已提交
629
		case Opt_discard:
630 631
			btrfs_set_and_info(root, DISCARD,
					   "turning on discard");
C
Christoph Hellwig 已提交
632
			break;
Q
Qu Wenruo 已提交
633
		case Opt_nodiscard:
634 635
			btrfs_clear_and_info(root, DISCARD,
					     "turning off discard");
Q
Qu Wenruo 已提交
636
			break;
637
		case Opt_space_cache:
638 639
			btrfs_set_and_info(root, SPACE_CACHE,
					   "enabling disk space caching");
640
			break;
641 642 643
		case Opt_rescan_uuid_tree:
			btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
			break;
644
		case Opt_no_space_cache:
645 646
			btrfs_clear_and_info(root, SPACE_CACHE,
					     "disabling disk space caching");
647
			break;
C
Chris Mason 已提交
648
		case Opt_inode_cache:
649 650
			btrfs_set_and_info(root, CHANGE_INODE_CACHE,
					   "enabling inode map caching");
651 652
			break;
		case Opt_noinode_cache:
653 654
			btrfs_clear_and_info(root, CHANGE_INODE_CACHE,
					     "disabling inode map caching");
C
Chris Mason 已提交
655
			break;
656
		case Opt_clear_cache:
657 658
			btrfs_set_and_info(root, CLEAR_CACHE,
					   "force clearing of disk cache");
659
			break;
660 661 662
		case Opt_user_subvol_rm_allowed:
			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
			break;
663 664 665
		case Opt_enospc_debug:
			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
666 667 668
		case Opt_noenospc_debug:
			btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
C
Chris Mason 已提交
669
		case Opt_defrag:
670 671
			btrfs_set_and_info(root, AUTO_DEFRAG,
					   "enabling auto defrag");
C
Chris Mason 已提交
672
			break;
673
		case Opt_nodefrag:
674 675
			btrfs_clear_and_info(root, AUTO_DEFRAG,
					     "disabling auto defrag");
676
			break;
C
Chris Mason 已提交
677
		case Opt_recovery:
678
			btrfs_info(root->fs_info, "enabling auto recovery");
C
Chris Mason 已提交
679 680
			btrfs_set_opt(info->mount_opt, RECOVERY);
			break;
681 682 683
		case Opt_skip_balance:
			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
			break;
684 685
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
		case Opt_check_integrity_including_extent_data:
686 687
			btrfs_info(root->fs_info,
				   "enabling check integrity including extent data");
688 689 690 691 692
			btrfs_set_opt(info->mount_opt,
				      CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity:
693
			btrfs_info(root->fs_info, "enabling check integrity");
694 695 696
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity_print_mask:
697 698 699 700
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg >= 0) {
701
				info->check_integrity_print_mask = intarg;
702
				btrfs_info(root->fs_info, "check_integrity_print_mask 0x%x",
703
				       info->check_integrity_print_mask);
704 705 706
			} else {
				ret = -EINVAL;
				goto out;
707 708 709 710 711 712
			}
			break;
#else
		case Opt_check_integrity_including_extent_data:
		case Opt_check_integrity:
		case Opt_check_integrity_print_mask:
713 714
			btrfs_err(root->fs_info,
				"support for check_integrity* not compiled in!");
715 716 717
			ret = -EINVAL;
			goto out;
#endif
J
Jeff Mahoney 已提交
718 719 720 721 722 723 724 725 726 727 728 729
		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;
730 731 732 733
		case Opt_commit_interval:
			intarg = 0;
			ret = match_int(&args[0], &intarg);
			if (ret < 0) {
734
				btrfs_err(root->fs_info, "invalid commit interval");
735 736 737 738 739
				ret = -EINVAL;
				goto out;
			}
			if (intarg > 0) {
				if (intarg > 300) {
740
					btrfs_warn(root->fs_info, "excessive commit interval %d",
741 742 743 744
							intarg);
				}
				info->commit_interval = intarg;
			} else {
745
				btrfs_info(root->fs_info, "using default commit interval %ds",
746 747 748 749
				    BTRFS_DEFAULT_COMMIT_INTERVAL);
				info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
			}
			break;
S
Sage Weil 已提交
750
		case Opt_err:
751
			btrfs_info(root->fs_info, "unrecognized mount option '%s'", p);
S
Sage Weil 已提交
752 753
			ret = -EINVAL;
			goto out;
754
		default:
755
			break;
756 757
		}
	}
S
Sage Weil 已提交
758
out:
759
	if (!ret && btrfs_test_opt(root, SPACE_CACHE))
760
		btrfs_info(root->fs_info, "disk space caching is enabled");
761
	kfree(orig);
S
Sage Weil 已提交
762
	return ret;
763 764 765 766 767 768 769 770
}

/*
 * 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.
 */
771
static int btrfs_parse_early_options(const char *options, fmode_t flags,
772
		void *holder, char **subvol_name, u64 *subvol_objectid,
773
		struct btrfs_fs_devices **fs_devices)
774 775
{
	substring_t args[MAX_OPT_ARGS];
776
	char *device_name, *opts, *orig, *p;
777
	char *num = NULL;
778 779 780
	int error = 0;

	if (!options)
781
		return 0;
782 783 784 785 786 787 788 789

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
790
	orig = opts;
791 792 793 794 795 796 797 798 799

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
800
			kfree(*subvol_name);
801
			*subvol_name = match_strdup(&args[0]);
802 803 804 805
			if (!*subvol_name) {
				error = -ENOMEM;
				goto out;
			}
806
			break;
807
		case Opt_subvolid:
808 809 810 811
			num = match_strdup(&args[0]);
			if (num) {
				*subvol_objectid = memparse(num, NULL);
				kfree(num);
812
				/* we want the original fs_tree */
813
				if (!*subvol_objectid)
814 815
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
816 817 818
			} else {
				error = -EINVAL;
				goto out;
819
			}
820
			break;
821
		case Opt_subvolrootid:
822
			printk(KERN_WARNING
823 824
				"BTRFS: 'subvolrootid' mount option is deprecated and has "
				"no effect\n");
825
			break;
826
		case Opt_device:
827 828 829 830 831 832
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
833
					flags, holder, fs_devices);
834
			kfree(device_name);
835
			if (error)
836
				goto out;
837
			break;
838 839 840 841 842
		default:
			break;
		}
	}

843
out:
844
	kfree(orig);
845
	return error;
846 847
}

848 849 850
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
851 852
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
853 854 855 856 857
	struct btrfs_root *new_root;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_key location;
	struct inode *inode;
858
	struct dentry *dentry;
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
	u64 dir_id;
	int new = 0;

	/*
	 * We have a specific subvol we want to mount, just setup location and
	 * go look up the root.
	 */
	if (subvol_objectid) {
		location.objectid = subvol_objectid;
		location.type = BTRFS_ROOT_ITEM_KEY;
		location.offset = (u64)-1;
		goto find_root;
	}

	path = btrfs_alloc_path();
	if (!path)
		return ERR_PTR(-ENOMEM);
	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.
	 */
883
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
884
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
885 886
	if (IS_ERR(di)) {
		btrfs_free_path(path);
887
		return ERR_CAST(di);
888
	}
889 890 891 892 893 894 895 896
	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
		 * mount to root most subvolume.
		 */
		btrfs_free_path(path);
		dir_id = BTRFS_FIRST_FREE_OBJECTID;
897
		new_root = fs_info->fs_root;
898 899 900 901 902 903 904
		goto setup_root;
	}

	btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
	btrfs_free_path(path);

find_root:
905
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
906
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
907
		return ERR_CAST(new_root);
908 909 910 911 912 913 914 915

	dir_id = btrfs_root_dirid(&new_root->root_item);
setup_root:
	location.objectid = dir_id;
	location.type = BTRFS_INODE_ITEM_KEY;
	location.offset = 0;

	inode = btrfs_iget(sb, &location, new_root, &new);
916 917
	if (IS_ERR(inode))
		return ERR_CAST(inode);
918 919 920 921 922 923 924 925 926 927 928

	/*
	 * If we're just mounting the root most subvol put the inode and return
	 * a reference to the dentry.  We will have already gotten a reference
	 * to the inode in btrfs_fill_super so we're good to go.
	 */
	if (!new && sb->s_root->d_inode == inode) {
		iput(inode);
		return dget(sb->s_root);
	}

929 930 931 932 933 934 935
	dentry = d_obtain_alias(inode);
	if (!IS_ERR(dentry)) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags &= ~DCACHE_DISCONNECTED;
		spin_unlock(&dentry->d_lock);
	}
	return dentry;
936 937
}

C
Chris Mason 已提交
938
static int btrfs_fill_super(struct super_block *sb,
939
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
940
			    void *data, int silent)
C
Chris Mason 已提交
941
{
C
Chris Mason 已提交
942
	struct inode *inode;
943
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
944
	struct btrfs_key key;
C
Chris Mason 已提交
945
	int err;
946

C
Chris Mason 已提交
947 948 949
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
950
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
951
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
952
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
953
	sb->s_time_gran = 1;
C
Chris Mason 已提交
954
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
955
	sb->s_flags |= MS_POSIXACL;
956
#endif
957
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
958 959
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
960
		printk(KERN_ERR "BTRFS: open_ctree failed\n");
A
Al Viro 已提交
961
		return err;
962 963
	}

964 965 966
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
967
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
968 969
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
970
		goto fail_close;
C
Chris Mason 已提交
971 972
	}

973 974
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
975 976
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
977
	}
978

C
Chris Mason 已提交
979
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
980
	cleancache_init_fs(sb);
981
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
982
	return 0;
C
Chris Mason 已提交
983 984

fail_close:
985
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
986
	return err;
C
Chris Mason 已提交
987 988
}

S
Sage Weil 已提交
989
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
990 991
{
	struct btrfs_trans_handle *trans;
992 993
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
994

995 996
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
997
	if (!wait) {
998
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
999 1000
		return 0;
	}
1001

1002
	btrfs_wait_ordered_roots(fs_info, -1);
1003

M
Miao Xie 已提交
1004
	trans = btrfs_attach_transaction_barrier(root);
1005
	if (IS_ERR(trans)) {
1006 1007
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
1008
			return 0;
1009
		return PTR_ERR(trans);
1010
	}
1011
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
1012 1013
}

1014
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
1015
{
1016 1017
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
1018
	char *compress_type;
E
Eric Paris 已提交
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028

	if (btrfs_test_opt(root, DEGRADED))
		seq_puts(seq, ",degraded");
	if (btrfs_test_opt(root, NODATASUM))
		seq_puts(seq, ",nodatasum");
	if (btrfs_test_opt(root, NODATACOW))
		seq_puts(seq, ",nodatacow");
	if (btrfs_test_opt(root, NOBARRIER))
		seq_puts(seq, ",nobarrier");
	if (info->max_inline != 8192 * 1024)
1029
		seq_printf(seq, ",max_inline=%llu", info->max_inline);
E
Eric Paris 已提交
1030
	if (info->alloc_start != 0)
1031
		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
E
Eric Paris 已提交
1032 1033 1034
	if (info->thread_pool_size !=  min_t(unsigned long,
					     num_online_cpus() + 2, 8))
		seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
T
Tsutomu Itoh 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
	if (btrfs_test_opt(root, COMPRESS)) {
		if (info->compress_type == BTRFS_COMPRESS_ZLIB)
			compress_type = "zlib";
		else
			compress_type = "lzo";
		if (btrfs_test_opt(root, FORCE_COMPRESS))
			seq_printf(seq, ",compress-force=%s", compress_type);
		else
			seq_printf(seq, ",compress=%s", compress_type);
	}
C
Chris Mason 已提交
1045 1046
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
1047 1048 1049
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
1050
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
1051
	if (btrfs_test_opt(root, NOTREELOG))
1052
		seq_puts(seq, ",notreelog");
1053
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
1054
		seq_puts(seq, ",flushoncommit");
1055 1056
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
1057 1058
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
1059 1060
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
1061
	else
1062
		seq_puts(seq, ",nospace_cache");
1063 1064
	if (btrfs_test_opt(root, RESCAN_UUID_TREE))
		seq_puts(seq, ",rescan_uuid_tree");
T
Tsutomu Itoh 已提交
1065 1066 1067 1068
	if (btrfs_test_opt(root, CLEAR_CACHE))
		seq_puts(seq, ",clear_cache");
	if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
		seq_puts(seq, ",user_subvol_rm_allowed");
1069 1070 1071 1072 1073 1074
	if (btrfs_test_opt(root, ENOSPC_DEBUG))
		seq_puts(seq, ",enospc_debug");
	if (btrfs_test_opt(root, AUTO_DEFRAG))
		seq_puts(seq, ",autodefrag");
	if (btrfs_test_opt(root, INODE_MAP_CACHE))
		seq_puts(seq, ",inode_cache");
1075 1076
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
	if (btrfs_test_opt(root, RECOVERY))
		seq_puts(seq, ",recovery");
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
		seq_puts(seq, ",check_int_data");
	else if (btrfs_test_opt(root, CHECK_INTEGRITY))
		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);
J
Jeff Mahoney 已提交
1091 1092
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
1093 1094
	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
		seq_printf(seq, ",commit=%d", info->commit_interval);
E
Eric Paris 已提交
1095 1096 1097
	return 0;
}

1098
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
1099
{
1100 1101
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
1102

1103
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
1104 1105
}

1106 1107
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
1108 1109 1110 1111
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
1112 1113
}

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
/*
 * 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;
}

1124 1125 1126 1127 1128 1129 1130
/*
 * This will strip out the subvol=%s argument for an argument string and add
 * subvolid=0 to make sure we get the actual tree root for path walking to the
 * subvol we want.
 */
static char *setup_root_args(char *args)
{
1131 1132
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
1133 1134

	/*
1135 1136
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
1137
	 *
1138 1139
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
1140 1141
	 */

1142
	src = strstr(args, "subvol=");
1143
	/* This shouldn't happen, but just in case.. */
1144 1145 1146 1147 1148
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
1149 1150 1151
		return NULL;

	/*
1152 1153
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1154
	 */
1155 1156 1157 1158
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1159 1160
	}

1161 1162
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1163 1164

	/*
1165 1166
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1167
	 */
1168 1169 1170
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1171

1172
	return buf;
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
}

static struct dentry *mount_subvol(const char *subvol_name, int flags,
				   const char *device_name, char *data)
{
	struct dentry *root;
	struct vfsmount *mnt;
	char *newargs;

	newargs = setup_root_args(data);
	if (!newargs)
		return ERR_PTR(-ENOMEM);
	mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
			     newargs);
	kfree(newargs);
	if (IS_ERR(mnt))
		return ERR_CAST(mnt);

A
Al Viro 已提交
1191
	root = mount_subtree(mnt, subvol_name);
1192

A
Al Viro 已提交
1193 1194 1195 1196 1197
	if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
		struct super_block *s = root->d_sb;
		dput(root);
		root = ERR_PTR(-EINVAL);
		deactivate_locked_super(s);
1198
		printk(KERN_ERR "BTRFS: '%s' is not a valid subvolume\n",
1199 1200 1201
				subvol_name);
	}

1202 1203
	return root;
}
1204

1205 1206 1207 1208 1209 1210
/*
 * 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 已提交
1211
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1212
		const char *device_name, void *data)
Y
Yan 已提交
1213 1214 1215 1216
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1217
	struct btrfs_fs_devices *fs_devices = NULL;
1218
	struct btrfs_fs_info *fs_info = NULL;
1219
	fmode_t mode = FMODE_READ;
1220 1221
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1222 1223
	int error = 0;

1224 1225 1226 1227
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1228
					  &subvol_name, &subvol_objectid,
1229
					  &fs_devices);
1230 1231
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1232
		return ERR_PTR(error);
1233
	}
1234

1235 1236 1237 1238 1239 1240
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1241
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1242
	if (error)
1243
		return ERR_PTR(error);
Y
Yan 已提交
1244

1245 1246 1247 1248 1249 1250 1251
	/*
	 * 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);
1252 1253 1254
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1255 1256
	fs_info->fs_devices = fs_devices;

1257 1258 1259 1260
	fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
	fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
	if (!fs_info->super_copy || !fs_info->super_for_commit) {
		error = -ENOMEM;
1261 1262 1263 1264 1265 1266 1267 1268 1269
		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;
1270 1271 1272
		goto error_close_devices;
	}

1273
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1274 1275
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1276 1277 1278 1279
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1280 1281

	if (s->s_root) {
Y
Yan Zheng 已提交
1282
		btrfs_close_devices(fs_devices);
1283
		free_fs_info(fs_info);
1284 1285
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1286 1287 1288 1289
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1290
		btrfs_sb(s)->bdev_holder = fs_type;
1291 1292
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1293 1294
	}

1295 1296
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1297
		deactivate_locked_super(s);
Y
Yan 已提交
1298

A
Al Viro 已提交
1299
	return root;
Y
Yan 已提交
1300

Y
Yan Zheng 已提交
1301
error_close_devices:
1302
	btrfs_close_devices(fs_devices);
1303
error_fs_info:
1304
	free_fs_info(fs_info);
A
Al Viro 已提交
1305
	return ERR_PTR(error);
Y
Yan 已提交
1306
}
1307

1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
static void btrfs_set_max_workers(struct btrfs_workers *workers, int new_limit)
{
	spin_lock_irq(&workers->lock);
	workers->max_workers = new_limit;
	spin_unlock_irq(&workers->lock);
}

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;

1323
	btrfs_info(fs_info, "resize thread pool %d -> %d",
1324 1325 1326
	       old_pool_size, new_pool_size);

	btrfs_set_max_workers(&fs_info->generic_worker, new_pool_size);
1327
	btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
1328
	btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
1329
	btrfs_workqueue_set_max(fs_info->submit_workers, new_pool_size);
1330 1331 1332 1333 1334 1335 1336 1337 1338
	btrfs_set_max_workers(&fs_info->caching_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->fixup_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_meta_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_meta_write_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_write_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_freespace_worker, new_pool_size);
	btrfs_set_max_workers(&fs_info->delayed_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->readahead_workers, new_pool_size);
1339 1340
	btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
			      new_pool_size);
1341 1342
}

1343
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
M
Miao Xie 已提交
1344 1345
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1346
}
M
Miao Xie 已提交
1347

1348 1349 1350
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
				       unsigned long old_opts, int flags)
{
M
Miao Xie 已提交
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
	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)
{
	/*
	 * We need cleanup all defragable inodes if the autodefragment is
	 * close or the fs is R/O.
	 */
	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 已提交
1378 1379
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1380 1381
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1382 1383 1384 1385 1386 1387 1388
	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 已提交
1389 1390
	int ret;

1391
	btrfs_remount_prepare(fs_info);
M
Miao Xie 已提交
1392

1393
	ret = btrfs_parse_options(root, data);
1394 1395 1396 1397
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1398

1399
	btrfs_remount_begin(fs_info, old_opts, *flags);
1400 1401 1402
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1403
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1404
		goto out;
Y
Yan Zheng 已提交
1405 1406

	if (*flags & MS_RDONLY) {
1407 1408 1409 1410
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
1411 1412 1413 1414 1415 1416

		/* 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 已提交
1417 1418
		sb->s_flags |= MS_RDONLY;

1419 1420
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);
1421
		btrfs_pause_balance(fs_info);
1422

1423 1424 1425
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1426
	} else {
1427 1428
		if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
			btrfs_err(fs_info,
1429
				"Remounting read-write after error is not allowed");
1430 1431 1432
			ret = -EINVAL;
			goto restore;
		}
1433
		if (fs_info->fs_devices->rw_devices == 0) {
1434 1435
			ret = -EACCES;
			goto restore;
1436
		}
Y
Yan Zheng 已提交
1437

1438 1439 1440
		if (fs_info->fs_devices->missing_devices >
		     fs_info->num_tolerated_disk_barrier_failures &&
		    !(*flags & MS_RDONLY)) {
1441 1442
			btrfs_warn(fs_info,
				"too many missing devices, writeable remount is not allowed");
1443 1444 1445 1446
			ret = -EACCES;
			goto restore;
		}

1447
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1448 1449
			ret = -EINVAL;
			goto restore;
1450
		}
Y
Yan Zheng 已提交
1451

1452
		ret = btrfs_cleanup_fs_roots(fs_info);
1453 1454
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1455

1456 1457
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1458 1459
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1460

1461 1462 1463 1464
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1465 1466
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
1467
			btrfs_warn(fs_info, "failed to resume dev_replace");
1468 1469
			goto restore;
		}
1470 1471

		if (!fs_info->uuid_root) {
1472
			btrfs_info(fs_info, "creating UUID tree");
1473 1474
			ret = btrfs_create_uuid_tree(fs_info);
			if (ret) {
1475
				btrfs_warn(fs_info, "failed to create the UUID tree %d", ret);
1476 1477 1478
				goto restore;
			}
		}
Y
Yan Zheng 已提交
1479 1480
		sb->s_flags &= ~MS_RDONLY;
	}
M
Miao Xie 已提交
1481
out:
1482
	wake_up_process(fs_info->transaction_kthread);
M
Miao Xie 已提交
1483
	btrfs_remount_cleanup(fs_info, old_opts);
Y
Yan Zheng 已提交
1484
	return 0;
1485 1486 1487 1488 1489 1490 1491 1492 1493

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 已提交
1494
	mutex_lock(&fs_info->chunk_mutex);
1495
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1496
	mutex_unlock(&fs_info->chunk_mutex);
1497 1498
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1499
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1500
	btrfs_remount_cleanup(fs_info, old_opts);
1501
	return ret;
Y
Yan Zheng 已提交
1502 1503
}

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
/* 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);
}

1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544
/*
 * 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;
1545
	int min_stripes = 1, num_stripes = 1;
1546 1547 1548
	int i = 0, nr_devices;
	int ret;

1549
	nr_devices = fs_info->fs_devices->open_devices;
1550 1551
	BUG_ON(!nr_devices);

1552
	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1553 1554 1555 1556 1557 1558
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1559
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1560
		min_stripes = 2;
1561 1562
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1563
		min_stripes = 2;
1564 1565
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1566
		min_stripes = 4;
1567 1568
		num_stripes = 4;
	}
1569 1570 1571 1572 1573 1574

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

1575
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1576 1577
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
			continue;

		avail_space = device->total_bytes - device->bytes_used;

		/* align with stripe_len */
		do_div(avail_space, BTRFS_STRIPE_LEN);
		avail_space *= BTRFS_STRIPE_LEN;

		/*
		 * In order to avoid overwritting the superblock on the drive,
		 * btrfs starts at an offset of at least 1MB when doing chunk
		 * allocation.
		 */
		skip_space = 1024 * 1024;

		/* user can set the offset in fs_info->alloc_start. */
		if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
		    device->total_bytes)
			skip_space = max(fs_info->alloc_start, skip_space);

		/*
		 * 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);
			return ret;
		}

		/* calc the free space in [0, skip_space - 1] */
		skip_space -= used_space;

		/*
		 * 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++;
	}

	nr_devices = i;

	btrfs_descending_sort_devices(devices_info, nr_devices);

	i = nr_devices - 1;
	avail_space = 0;
	while (nr_devices >= min_stripes) {
1638 1639 1640
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1641 1642 1643 1644
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1645
			avail_space += devices_info[i].max_avail * num_stripes;
1646
			alloc_size = devices_info[i].max_avail;
1647
			for (j = i + 1 - num_stripes; j <= i; j++)
1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1659 1660
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1661 1662 1663
	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;
1664 1665
	struct btrfs_space_info *found;
	u64 total_used = 0;
1666
	u64 total_free_data = 0;
1667
	int bits = dentry->d_sb->s_blocksize_bits;
1668
	__be32 *fsid = (__be32 *)fs_info->fsid;
1669
	int ret;
C
Chris Mason 已提交
1670

1671
	/* holding chunk_muext to avoid allocating new chunks */
1672
	mutex_lock(&fs_info->chunk_mutex);
1673
	rcu_read_lock();
J
Josef Bacik 已提交
1674
	list_for_each_entry_rcu(found, head, list) {
1675 1676 1677 1678 1679 1680
		if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
			total_free_data += found->disk_total - found->disk_used;
			total_free_data -=
				btrfs_account_ro_block_groups_free_space(found);
		}

1681
		total_used += found->disk_used;
J
Josef Bacik 已提交
1682
	}
1683 1684
	rcu_read_unlock();

C
Chris Mason 已提交
1685
	buf->f_namelen = BTRFS_NAME_LEN;
1686
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1687
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1688 1689
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1690
	buf->f_bavail = total_free_data;
1691
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1692
	if (ret) {
1693
		mutex_unlock(&fs_info->chunk_mutex);
1694 1695 1696 1697
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1698
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1699

1700
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1701
	   because we want the fsid to come out the same whether mounted
1702 1703 1704
	   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]);
1705 1706 1707 1708
	/* Mask in the root object ID too, to disambiguate subvols */
	buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
	buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;

C
Chris Mason 已提交
1709 1710
	return 0;
}
C
Chris Mason 已提交
1711

A
Al Viro 已提交
1712 1713
static void btrfs_kill_super(struct super_block *sb)
{
1714
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1715
	kill_anon_super(sb);
1716
	free_fs_info(fs_info);
A
Al Viro 已提交
1717 1718
}

1719 1720 1721
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1722
	.mount		= btrfs_mount,
A
Al Viro 已提交
1723
	.kill_sb	= btrfs_kill_super,
1724 1725
	.fs_flags	= FS_REQUIRES_DEV,
};
1726
MODULE_ALIAS_FS("btrfs");
1727

C
Chris Mason 已提交
1728 1729 1730
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1731 1732 1733 1734 1735
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;
1736
	int ret = -ENOTTY;
1737

1738 1739 1740
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1741 1742 1743
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1744

1745 1746
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1747
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1748 1749
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1750 1751 1752 1753 1754 1755 1756
	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;
1757
	}
L
Li Zefan 已提交
1758

1759
	kfree(vol);
L
Linda Knippers 已提交
1760
	return ret;
1761 1762
}

1763
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1764
{
1765 1766 1767
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

M
Miao Xie 已提交
1768
	trans = btrfs_attach_transaction_barrier(root);
1769 1770 1771 1772 1773 1774 1775
	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 已提交
1776 1777
}

1778
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1779
{
1780
	return 0;
Y
Yan 已提交
1781
}
1782

J
Josef Bacik 已提交
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
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) {
1796 1797
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
			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;
}

1816
static const struct super_operations btrfs_super_ops = {
1817
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1818
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1819
	.put_super	= btrfs_put_super,
1820
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1821
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1822
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1823
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1824 1825
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1826
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1827
	.remount_fs	= btrfs_remount,
1828 1829
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1830
};
1831 1832 1833 1834 1835

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1836
	.llseek = noop_llseek,
1837 1838 1839
};

static struct miscdevice btrfs_misc = {
1840
	.minor		= BTRFS_MINOR,
1841 1842 1843 1844
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1845 1846 1847
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1848 1849 1850 1851 1852
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1853
static void btrfs_interface_exit(void)
1854 1855
{
	if (misc_deregister(&btrfs_misc) < 0)
1856
		printk(KERN_INFO "BTRFS: misc_deregister failed for control device\n");
1857 1858
}

1859 1860 1861 1862 1863 1864
static void btrfs_print_info(void)
{
	printk(KERN_INFO "Btrfs loaded"
#ifdef CONFIG_BTRFS_DEBUG
			", debug=on"
#endif
1865 1866 1867
#ifdef CONFIG_BTRFS_ASSERT
			", assert=on"
#endif
1868 1869 1870 1871 1872 1873
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
			", integrity-checker=on"
#endif
			"\n");
}

1874 1875
static int btrfs_run_sanity_tests(void)
{
1876 1877
	int ret;

1878
	ret = btrfs_init_test_fs();
1879 1880
	if (ret)
		return ret;
1881 1882 1883 1884 1885 1886 1887 1888

	ret = btrfs_test_free_space_cache();
	if (ret)
		goto out;
	ret = btrfs_test_extent_buffer_operations();
	if (ret)
		goto out;
	ret = btrfs_test_extent_io();
1889 1890 1891
	if (ret)
		goto out;
	ret = btrfs_test_inodes();
1892 1893 1894
out:
	btrfs_destroy_test_fs();
	return ret;
1895 1896
}

1897 1898
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1899
	int err;
1900

1901 1902 1903 1904
	err = btrfs_hash_init();
	if (err)
		return err;

1905 1906
	btrfs_props_init();

1907 1908
	err = btrfs_init_sysfs();
	if (err)
1909
		goto free_hash;
1910

1911
	btrfs_init_compress();
1912

1913 1914 1915 1916
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1917
	err = extent_io_init();
1918 1919 1920
	if (err)
		goto free_cachep;

1921 1922 1923 1924
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1925
	err = ordered_data_init();
1926 1927
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1928

1929 1930 1931 1932
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1933
	err = btrfs_auto_defrag_init();
1934 1935 1936
	if (err)
		goto free_delayed_inode;

1937
	err = btrfs_delayed_ref_init();
1938 1939 1940
	if (err)
		goto free_auto_defrag;

1941 1942 1943 1944
	err = btrfs_prelim_ref_init();
	if (err)
		goto free_prelim_ref;

1945 1946 1947 1948
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1949 1950
	btrfs_init_lockdep();

1951
	btrfs_print_info();
1952 1953 1954 1955 1956 1957 1958 1959

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

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

1961 1962
	return 0;

1963 1964
unregister_ioctl:
	btrfs_interface_exit();
1965 1966
free_prelim_ref:
	btrfs_prelim_ref_exit();
1967 1968
free_delayed_ref:
	btrfs_delayed_ref_exit();
1969 1970
free_auto_defrag:
	btrfs_auto_defrag_exit();
1971 1972
free_delayed_inode:
	btrfs_delayed_inode_exit();
1973 1974
free_ordered_data:
	ordered_data_exit();
1975 1976
free_extent_map:
	extent_map_exit();
1977 1978
free_extent_io:
	extent_io_exit();
1979 1980
free_cachep:
	btrfs_destroy_cachep();
1981 1982
free_compress:
	btrfs_exit_compress();
1983
	btrfs_exit_sysfs();
1984 1985
free_hash:
	btrfs_hash_exit();
1986
	return err;
1987 1988 1989 1990
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1991
	btrfs_destroy_cachep();
1992
	btrfs_delayed_ref_exit();
1993
	btrfs_auto_defrag_exit();
1994
	btrfs_delayed_inode_exit();
1995
	btrfs_prelim_ref_exit();
1996
	ordered_data_exit();
1997
	extent_map_exit();
1998
	extent_io_exit();
1999
	btrfs_interface_exit();
2000
	unregister_filesystem(&btrfs_fs_type);
2001
	btrfs_exit_sysfs();
2002
	btrfs_cleanup_fs_uuids();
2003
	btrfs_exit_compress();
2004
	btrfs_hash_exit();
2005 2006
}

2007
late_initcall(init_btrfs_fs);
2008 2009 2010
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");