super.c 50.7 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"
J
Josef Bacik 已提交
51
#include "xattr.h"
52
#include "volumes.h"
B
Balaji Rao 已提交
53
#include "export.h"
C
Chris Mason 已提交
54
#include "compression.h"
J
Josef Bacik 已提交
55
#include "rcu-string.h"
56
#include "dev-replace.h"
57
#include "free-space-cache.h"
58
#include "backref.h"
59
#include "tests/btrfs-tests.h"
60

61 62 63
#define CREATE_TRACE_POINTS
#include <trace/events/btrfs.h>

64
static const struct super_operations btrfs_super_ops;
65
static struct file_system_type btrfs_fs_type;
C
Chris Mason 已提交
66

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

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

	return errstr;
}

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

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

112
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
liubo 已提交
113
		sb->s_flags |= MS_RDONLY;
114
		btrfs_info(fs_info, "forced readonly");
115 116 117 118 119 120 121 122 123 124
		/*
		 * 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 已提交
125 126 127
	}
}

128
#ifdef CONFIG_PRINTK
L
liubo 已提交
129 130 131 132 133
/*
 * __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 已提交
134
		       unsigned int line, int errno, const char *fmt, ...)
L
liubo 已提交
135 136 137 138 139 140 141 142 143
{
	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 已提交
144 145
  		return;

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

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

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

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

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

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

	va_start(args, fmt);

192 193 194 195 196 197 198
	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 已提交
199 200 201 202 203
	} else
		*lvl = '\0';

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

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

	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 已提交
229
}
230
#endif
L
liubo 已提交
231

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
/*
 * 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)
{
249 250 251 252 253
	/*
	 * Report first abort since mount
	 */
	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,
				&root->fs_info->fs_state)) {
254
		WARN(1, KERN_DEBUG "BTRFS: Transaction aborted (error %d)\n",
255 256
				errno);
	}
257 258 259 260
	trans->aborted = errno;
	/* Nothing used. The other threads that have joined this
	 * transaction may be able to continue. */
	if (!trans->blocks_used) {
261 262
		const char *errstr;

263
		errstr = btrfs_decode_error(errno);
264 265 266
		btrfs_warn(root->fs_info,
		           "%s:%d: Aborting unused transaction(%s).",
		           function, line, errstr);
L
liubo 已提交
267
		return;
268
	}
269
	ACCESS_ONCE(trans->transaction->aborted) = errno;
270 271 272
	/* 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);
273 274
	__btrfs_std_error(root->fs_info, function, line, errno, NULL);
}
J
Jeff Mahoney 已提交
275 276 277 278 279 280 281 282 283 284 285
/*
 * __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 已提交
286

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

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

293
	errstr = btrfs_decode_error(errno);
294
	if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
295 296
		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 已提交
297

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

C
Chris Mason 已提交
304
static void btrfs_put_super(struct super_block *sb)
C
Chris Mason 已提交
305
{
306
	(void)close_ctree(btrfs_sb(sb)->tree_root);
A
Al Viro 已提交
307 308 309 310 311 312
	/* 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 已提交
313 314
}

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

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

379 380 381
/*
 * Regular mount options parser.  Everything that is needed only when
 * reading in a new superblock is parsed here.
382
 * XXX JDM: This needs to be cleaned up for remount.
383 384
 */
int btrfs_parse_options(struct btrfs_root *root, char *options)
385
{
386
	struct btrfs_fs_info *info = root->fs_info;
387
	substring_t args[MAX_OPT_ARGS];
388 389
	char *p, *num, *orig = NULL;
	u64 cache_gen;
390
	int intarg;
S
Sage Weil 已提交
391
	int ret = 0;
392 393
	char *compress_type;
	bool compress_force = false;
394

395
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
396 397 398
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

399
	if (!options)
400
		goto out;
401

402 403 404 405 406 407 408 409
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

410
	orig = options;
411

412
	while ((p = strsep(&options, ",")) != NULL) {
413 414 415 416 417 418
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
419
		case Opt_degraded:
420
			btrfs_info(root->fs_info, "allowing degraded mounts");
421
			btrfs_set_opt(info->mount_opt, DEGRADED);
422
			break;
423
		case Opt_subvol:
424
		case Opt_subvolid:
425
		case Opt_subvolrootid:
426
		case Opt_device:
427
			/*
428
			 * These are parsed by btrfs_parse_early_options
429 430
			 * and can be happily ignored here.
			 */
431 432
			break;
		case Opt_nodatasum:
433
			btrfs_info(root->fs_info, "setting nodatasum");
434
			btrfs_set_opt(info->mount_opt, NODATASUM);
435 436
			break;
		case Opt_nodatacow:
437 438
			if (!btrfs_test_opt(root, COMPRESS) ||
				!btrfs_test_opt(root, FORCE_COMPRESS)) {
439 440
					btrfs_info(root->fs_info,
						"setting nodatacow, compression disabled");
441
			} else {
442
				btrfs_info(root->fs_info, "setting nodatacow");
443 444 445
			}
			btrfs_clear_opt(info->mount_opt, COMPRESS);
			btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
446 447
			btrfs_set_opt(info->mount_opt, NODATACOW);
			btrfs_set_opt(info->mount_opt, NODATASUM);
448
			break;
C
Chris Mason 已提交
449
		case Opt_compress_force:
450 451
		case Opt_compress_force_type:
			compress_force = true;
452
			/* Fallthrough */
453 454 455 456 457 458 459
		case Opt_compress:
		case Opt_compress_type:
			if (token == Opt_compress ||
			    token == Opt_compress_force ||
			    strcmp(args[0].from, "zlib") == 0) {
				compress_type = "zlib";
				info->compress_type = BTRFS_COMPRESS_ZLIB;
460
				btrfs_set_opt(info->mount_opt, COMPRESS);
461 462
				btrfs_clear_opt(info->mount_opt, NODATACOW);
				btrfs_clear_opt(info->mount_opt, NODATASUM);
L
Li Zefan 已提交
463 464 465
			} else if (strcmp(args[0].from, "lzo") == 0) {
				compress_type = "lzo";
				info->compress_type = BTRFS_COMPRESS_LZO;
466
				btrfs_set_opt(info->mount_opt, COMPRESS);
467 468
				btrfs_clear_opt(info->mount_opt, NODATACOW);
				btrfs_clear_opt(info->mount_opt, NODATASUM);
469
				btrfs_set_fs_incompat(info, COMPRESS_LZO);
470 471 472 473 474
			} 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;
475 476 477 478 479 480 481
			} else {
				ret = -EINVAL;
				goto out;
			}

			if (compress_force) {
				btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
482
				btrfs_info(root->fs_info, "force %s compression",
483
					compress_type);
484
			} else if (btrfs_test_opt(root, COMPRESS)) {
485 486
				pr_info("btrfs: use %s compression\n",
					compress_type);
487
			}
C
Chris Mason 已提交
488
			break;
489
		case Opt_ssd:
490
			btrfs_info(root->fs_info, "use ssd allocation scheme");
491
			btrfs_set_opt(info->mount_opt, SSD);
492
			break;
493
		case Opt_ssd_spread:
494
			btrfs_info(root->fs_info, "use spread ssd allocation scheme");
495 496 497
			btrfs_set_opt(info->mount_opt, SSD);
			btrfs_set_opt(info->mount_opt, SSD_SPREAD);
			break;
C
Chris Mason 已提交
498
		case Opt_nossd:
499
			btrfs_info(root->fs_info, "not using ssd allocation scheme");
C
Chris Mason 已提交
500
			btrfs_set_opt(info->mount_opt, NOSSD);
C
Chris Mason 已提交
501
			btrfs_clear_opt(info->mount_opt, SSD);
502
			btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
C
Chris Mason 已提交
503
			break;
504 505 506 507 508
		case Opt_barrier:
			if (btrfs_test_opt(root, NOBARRIER))
				btrfs_info(root->fs_info, "turning on barriers");
			btrfs_clear_opt(info->mount_opt, NOBARRIER);
			break;
509
		case Opt_nobarrier:
510
			btrfs_info(root->fs_info, "turning off barriers");
511
			btrfs_set_opt(info->mount_opt, NOBARRIER);
512
			break;
513
		case Opt_thread_pool:
514 515 516 517
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg > 0) {
518
				info->thread_pool_size = intarg;
519 520 521 522
			} else {
				ret = -EINVAL;
				goto out;
			}
523
			break;
524
		case Opt_max_inline:
525 526
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
527
				info->max_inline = memparse(num, NULL);
528 529
				kfree(num);

C
Chris Mason 已提交
530 531 532 533 534
				if (info->max_inline) {
					info->max_inline = max_t(u64,
						info->max_inline,
						root->sectorsize);
				}
535
				btrfs_info(root->fs_info, "max_inline at %llu",
536
					info->max_inline);
537 538 539
			} else {
				ret = -ENOMEM;
				goto out;
540 541
			}
			break;
542
		case Opt_alloc_start:
543 544
			num = match_strdup(&args[0]);
			if (num) {
M
Miao Xie 已提交
545
				mutex_lock(&info->chunk_mutex);
A
Akinobu Mita 已提交
546
				info->alloc_start = memparse(num, NULL);
M
Miao Xie 已提交
547
				mutex_unlock(&info->chunk_mutex);
548
				kfree(num);
549
				btrfs_info(root->fs_info, "allocations start at %llu",
550
					info->alloc_start);
551 552 553
			} else {
				ret = -ENOMEM;
				goto out;
554 555
			}
			break;
Q
Qu Wenruo 已提交
556 557 558
		case Opt_acl:
			root->fs_info->sb->s_flags |= MS_POSIXACL;
			break;
J
Josef Bacik 已提交
559 560 561
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
562
		case Opt_notreelog:
563
			btrfs_info(root->fs_info, "disabling tree log");
S
Sage Weil 已提交
564 565
			btrfs_set_opt(info->mount_opt, NOTREELOG);
			break;
566
		case Opt_flushoncommit:
567
			btrfs_info(root->fs_info, "turning on flush-on-commit");
568 569
			btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
			break;
570 571 572 573 574
		case Opt_noflushoncommit:
			if (btrfs_test_opt(root, FLUSHONCOMMIT))
				btrfs_info(root->fs_info, "turning off flush-on-commit");
			btrfs_clear_opt(info->mount_opt, FLUSHONCOMMIT);
			break;
575
		case Opt_ratio:
576 577 578 579
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg >= 0) {
580
				info->metadata_ratio = intarg;
581
				btrfs_info(root->fs_info, "metadata ratio %d",
582
				       info->metadata_ratio);
583 584 585
			} else {
				ret = -EINVAL;
				goto out;
586 587
			}
			break;
C
Christoph Hellwig 已提交
588 589 590
		case Opt_discard:
			btrfs_set_opt(info->mount_opt, DISCARD);
			break;
Q
Qu Wenruo 已提交
591 592 593
		case Opt_nodiscard:
			btrfs_clear_opt(info->mount_opt, DISCARD);
			break;
594 595
		case Opt_space_cache:
			btrfs_set_opt(info->mount_opt, SPACE_CACHE);
596
			break;
597 598 599
		case Opt_rescan_uuid_tree:
			btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
			break;
600
		case Opt_no_space_cache:
601
			btrfs_info(root->fs_info, "disabling disk space caching");
602 603
			btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
			break;
C
Chris Mason 已提交
604
		case Opt_inode_cache:
605
			btrfs_info(root->fs_info, "enabling inode map caching");
C
Chris Mason 已提交
606 607
			btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
			break;
608
		case Opt_clear_cache:
609
			btrfs_info(root->fs_info, "force clearing of disk cache");
610
			btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
611
			break;
612 613 614
		case Opt_user_subvol_rm_allowed:
			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
			break;
615 616 617
		case Opt_enospc_debug:
			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
618 619 620
		case Opt_noenospc_debug:
			btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
C
Chris Mason 已提交
621
		case Opt_defrag:
622
			btrfs_info(root->fs_info, "enabling auto defrag");
C
Chris Mason 已提交
623 624
			btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
			break;
625 626 627 628 629
		case Opt_nodefrag:
			if (btrfs_test_opt(root, AUTO_DEFRAG))
				btrfs_info(root->fs_info, "disabling auto defrag");
			btrfs_clear_opt(info->mount_opt, AUTO_DEFRAG);
			break;
C
Chris Mason 已提交
630
		case Opt_recovery:
631
			btrfs_info(root->fs_info, "enabling auto recovery");
C
Chris Mason 已提交
632 633
			btrfs_set_opt(info->mount_opt, RECOVERY);
			break;
634 635 636
		case Opt_skip_balance:
			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
			break;
637 638
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
		case Opt_check_integrity_including_extent_data:
639 640
			btrfs_info(root->fs_info,
				   "enabling check integrity including extent data");
641 642 643 644 645
			btrfs_set_opt(info->mount_opt,
				      CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity:
646
			btrfs_info(root->fs_info, "enabling check integrity");
647 648 649
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity_print_mask:
650 651 652 653
			ret = match_int(&args[0], &intarg);
			if (ret) {
				goto out;
			} else if (intarg >= 0) {
654
				info->check_integrity_print_mask = intarg;
655
				btrfs_info(root->fs_info, "check_integrity_print_mask 0x%x",
656
				       info->check_integrity_print_mask);
657 658 659
			} else {
				ret = -EINVAL;
				goto out;
660 661 662 663 664 665
			}
			break;
#else
		case Opt_check_integrity_including_extent_data:
		case Opt_check_integrity:
		case Opt_check_integrity_print_mask:
666 667
			btrfs_err(root->fs_info,
				"support for check_integrity* not compiled in!");
668 669 670
			ret = -EINVAL;
			goto out;
#endif
J
Jeff Mahoney 已提交
671 672 673 674 675 676 677 678 679 680 681 682
		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;
683 684 685 686
		case Opt_commit_interval:
			intarg = 0;
			ret = match_int(&args[0], &intarg);
			if (ret < 0) {
687
				btrfs_err(root->fs_info, "invalid commit interval");
688 689 690 691 692
				ret = -EINVAL;
				goto out;
			}
			if (intarg > 0) {
				if (intarg > 300) {
693
					btrfs_warn(root->fs_info, "excessive commit interval %d",
694 695 696 697
							intarg);
				}
				info->commit_interval = intarg;
			} else {
698
				btrfs_info(root->fs_info, "using default commit interval %ds",
699 700 701 702
				    BTRFS_DEFAULT_COMMIT_INTERVAL);
				info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
			}
			break;
S
Sage Weil 已提交
703
		case Opt_err:
704
			btrfs_info(root->fs_info, "unrecognized mount option '%s'", p);
S
Sage Weil 已提交
705 706
			ret = -EINVAL;
			goto out;
707
		default:
708
			break;
709 710
		}
	}
S
Sage Weil 已提交
711
out:
712
	if (!ret && btrfs_test_opt(root, SPACE_CACHE))
713
		btrfs_info(root->fs_info, "disk space caching is enabled");
714
	kfree(orig);
S
Sage Weil 已提交
715
	return ret;
716 717 718 719 720 721 722 723
}

/*
 * 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.
 */
724
static int btrfs_parse_early_options(const char *options, fmode_t flags,
725
		void *holder, char **subvol_name, u64 *subvol_objectid,
726
		struct btrfs_fs_devices **fs_devices)
727 728
{
	substring_t args[MAX_OPT_ARGS];
729
	char *device_name, *opts, *orig, *p;
730
	char *num = NULL;
731 732 733
	int error = 0;

	if (!options)
734
		return 0;
735 736 737 738 739 740 741 742

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
743
	orig = opts;
744 745 746 747 748 749 750 751 752

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
753
			kfree(*subvol_name);
754
			*subvol_name = match_strdup(&args[0]);
755 756 757 758
			if (!*subvol_name) {
				error = -ENOMEM;
				goto out;
			}
759
			break;
760
		case Opt_subvolid:
761 762 763 764
			num = match_strdup(&args[0]);
			if (num) {
				*subvol_objectid = memparse(num, NULL);
				kfree(num);
765
				/* we want the original fs_tree */
766
				if (!*subvol_objectid)
767 768
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
769 770 771
			} else {
				error = -EINVAL;
				goto out;
772
			}
773
			break;
774
		case Opt_subvolrootid:
775
			printk(KERN_WARNING
776 777
				"BTRFS: 'subvolrootid' mount option is deprecated and has "
				"no effect\n");
778
			break;
779
		case Opt_device:
780 781 782 783 784 785
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
786
					flags, holder, fs_devices);
787
			kfree(device_name);
788
			if (error)
789
				goto out;
790
			break;
791 792 793 794 795
		default:
			break;
		}
	}

796
out:
797
	kfree(orig);
798
	return error;
799 800
}

801 802 803
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
804 805
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
	struct btrfs_root *new_root;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_key location;
	struct inode *inode;
	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.
	 */
835
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
836
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
837 838
	if (IS_ERR(di)) {
		btrfs_free_path(path);
839
		return ERR_CAST(di);
840
	}
841 842 843 844 845 846 847 848
	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;
849
		new_root = fs_info->fs_root;
850 851 852 853 854 855 856
		goto setup_root;
	}

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

find_root:
857
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
858
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
859
		return ERR_CAST(new_root);
860 861 862 863 864 865 866 867

	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);
868 869
	if (IS_ERR(inode))
		return ERR_CAST(inode);
870 871 872 873 874 875 876 877 878 879 880

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

881
	return d_obtain_alias(inode);
882 883
}

C
Chris Mason 已提交
884
static int btrfs_fill_super(struct super_block *sb,
885
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
886
			    void *data, int silent)
C
Chris Mason 已提交
887
{
C
Chris Mason 已提交
888
	struct inode *inode;
889
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
890
	struct btrfs_key key;
C
Chris Mason 已提交
891
	int err;
892

C
Chris Mason 已提交
893 894 895
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
896
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
897
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
898
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
899
	sb->s_time_gran = 1;
C
Chris Mason 已提交
900
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
901
	sb->s_flags |= MS_POSIXACL;
902
#endif
903
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
904 905
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
906
		printk(KERN_ERR "BTRFS: open_ctree failed\n");
A
Al Viro 已提交
907
		return err;
908 909
	}

910 911 912
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
913
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
914 915
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
916
		goto fail_close;
C
Chris Mason 已提交
917 918
	}

919 920
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
921 922
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
923
	}
924

C
Chris Mason 已提交
925
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
926
	cleancache_init_fs(sb);
927
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
928
	return 0;
C
Chris Mason 已提交
929 930

fail_close:
931
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
932
	return err;
C
Chris Mason 已提交
933 934
}

S
Sage Weil 已提交
935
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
936 937
{
	struct btrfs_trans_handle *trans;
938 939
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
940

941 942
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
943
	if (!wait) {
944
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
945 946
		return 0;
	}
947

948
	btrfs_wait_ordered_roots(fs_info, -1);
949

M
Miao Xie 已提交
950
	trans = btrfs_attach_transaction_barrier(root);
951
	if (IS_ERR(trans)) {
952 953
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
954
			return 0;
955
		return PTR_ERR(trans);
956
	}
957
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
958 959
}

960
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
961
{
962 963
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
964
	char *compress_type;
E
Eric Paris 已提交
965 966 967 968 969 970 971 972 973 974

	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)
975
		seq_printf(seq, ",max_inline=%llu", info->max_inline);
E
Eric Paris 已提交
976
	if (info->alloc_start != 0)
977
		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
E
Eric Paris 已提交
978 979 980
	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 已提交
981 982 983 984 985 986 987 988 989 990
	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 已提交
991 992
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
993 994 995
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
996
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
997
	if (btrfs_test_opt(root, NOTREELOG))
998
		seq_puts(seq, ",notreelog");
999
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
1000
		seq_puts(seq, ",flushoncommit");
1001 1002
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
1003 1004
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
1005 1006
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
1007
	else
1008
		seq_puts(seq, ",nospace_cache");
1009 1010
	if (btrfs_test_opt(root, RESCAN_UUID_TREE))
		seq_puts(seq, ",rescan_uuid_tree");
T
Tsutomu Itoh 已提交
1011 1012 1013 1014
	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");
1015 1016 1017 1018 1019 1020
	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");
1021 1022
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
	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 已提交
1037 1038
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
1039 1040
	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
		seq_printf(seq, ",commit=%d", info->commit_interval);
E
Eric Paris 已提交
1041 1042 1043
	return 0;
}

1044
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
1045
{
1046 1047
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
1048

1049
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
1050 1051
}

1052 1053
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
1054 1055 1056 1057
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
1058 1059
}

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
/*
 * 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;
}

1070 1071 1072 1073 1074 1075 1076
/*
 * 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)
{
1077 1078
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
1079 1080

	/*
1081 1082
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
1083
	 *
1084 1085
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
1086 1087
	 */

1088
	src = strstr(args, "subvol=");
1089
	/* This shouldn't happen, but just in case.. */
1090 1091 1092 1093 1094
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
1095 1096 1097
		return NULL;

	/*
1098 1099
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1100
	 */
1101 1102 1103 1104
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1105 1106
	}

1107 1108
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1109 1110

	/*
1111 1112
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1113
	 */
1114 1115 1116
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1117

1118
	return buf;
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
}

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 已提交
1137
	root = mount_subtree(mnt, subvol_name);
1138

A
Al Viro 已提交
1139 1140 1141 1142 1143
	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);
1144
		printk(KERN_ERR "BTRFS: '%s' is not a valid subvolume\n",
1145 1146 1147
				subvol_name);
	}

1148 1149
	return root;
}
1150

1151 1152 1153 1154 1155 1156
/*
 * 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 已提交
1157
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1158
		const char *device_name, void *data)
Y
Yan 已提交
1159 1160 1161 1162
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1163
	struct btrfs_fs_devices *fs_devices = NULL;
1164
	struct btrfs_fs_info *fs_info = NULL;
1165
	fmode_t mode = FMODE_READ;
1166 1167
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1168 1169
	int error = 0;

1170 1171 1172 1173
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1174
					  &subvol_name, &subvol_objectid,
1175
					  &fs_devices);
1176 1177
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1178
		return ERR_PTR(error);
1179
	}
1180

1181 1182 1183 1184 1185 1186
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1187
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1188
	if (error)
1189
		return ERR_PTR(error);
Y
Yan 已提交
1190

1191 1192 1193 1194 1195 1196 1197
	/*
	 * 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);
1198 1199 1200
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1201 1202
	fs_info->fs_devices = fs_devices;

1203 1204 1205 1206
	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;
1207 1208 1209 1210 1211 1212 1213 1214 1215
		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;
1216 1217 1218
		goto error_close_devices;
	}

1219
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1220 1221
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1222 1223 1224 1225
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1226 1227

	if (s->s_root) {
Y
Yan Zheng 已提交
1228
		btrfs_close_devices(fs_devices);
1229
		free_fs_info(fs_info);
1230 1231
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1232 1233 1234 1235
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1236
		btrfs_sb(s)->bdev_holder = fs_type;
1237 1238
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1239 1240
	}

1241 1242
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1243
		deactivate_locked_super(s);
Y
Yan 已提交
1244

A
Al Viro 已提交
1245
	return root;
Y
Yan 已提交
1246

Y
Yan Zheng 已提交
1247
error_close_devices:
1248
	btrfs_close_devices(fs_devices);
1249
error_fs_info:
1250
	free_fs_info(fs_info);
A
Al Viro 已提交
1251
	return ERR_PTR(error);
Y
Yan 已提交
1252
}
1253

1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
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;

1269
	btrfs_info(fs_info, "resize thread pool %d -> %d",
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
	       old_pool_size, new_pool_size);

	btrfs_set_max_workers(&fs_info->generic_worker, new_pool_size);
	btrfs_set_max_workers(&fs_info->workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->delalloc_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->submit_workers, new_pool_size);
	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);
1285 1286
	btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
			      new_pool_size);
1287 1288
}

1289
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
M
Miao Xie 已提交
1290 1291
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1292
}
M
Miao Xie 已提交
1293

1294 1295 1296
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
				       unsigned long old_opts, int flags)
{
M
Miao Xie 已提交
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
	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 已提交
1324 1325
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1326 1327
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1328 1329 1330 1331 1332 1333 1334
	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 已提交
1335 1336
	int ret;

1337
	btrfs_remount_prepare(fs_info);
M
Miao Xie 已提交
1338

1339
	ret = btrfs_parse_options(root, data);
1340 1341 1342 1343
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1344

1345
	btrfs_remount_begin(fs_info, old_opts, *flags);
1346 1347 1348
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1349
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1350
		goto out;
Y
Yan Zheng 已提交
1351 1352

	if (*flags & MS_RDONLY) {
1353 1354 1355 1356
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
1357 1358 1359 1360 1361 1362

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

1365 1366
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);
1367
		btrfs_pause_balance(fs_info);
1368

1369 1370 1371
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1372
	} else {
1373 1374
		if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
			btrfs_err(fs_info,
1375
				"Remounting read-write after error is not allowed");
1376 1377 1378
			ret = -EINVAL;
			goto restore;
		}
1379
		if (fs_info->fs_devices->rw_devices == 0) {
1380 1381
			ret = -EACCES;
			goto restore;
1382
		}
Y
Yan Zheng 已提交
1383

1384 1385 1386
		if (fs_info->fs_devices->missing_devices >
		     fs_info->num_tolerated_disk_barrier_failures &&
		    !(*flags & MS_RDONLY)) {
1387 1388
			btrfs_warn(fs_info,
				"too many missing devices, writeable remount is not allowed");
1389 1390 1391 1392
			ret = -EACCES;
			goto restore;
		}

1393
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1394 1395
			ret = -EINVAL;
			goto restore;
1396
		}
Y
Yan Zheng 已提交
1397

1398
		ret = btrfs_cleanup_fs_roots(fs_info);
1399 1400
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1401

1402 1403
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1404 1405
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1406

1407 1408 1409 1410
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1411 1412
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
1413
			btrfs_warn(fs_info, "failed to resume dev_replace");
1414 1415
			goto restore;
		}
1416 1417

		if (!fs_info->uuid_root) {
1418
			btrfs_info(fs_info, "creating UUID tree");
1419 1420
			ret = btrfs_create_uuid_tree(fs_info);
			if (ret) {
1421
				btrfs_warn(fs_info, "failed to create the UUID tree %d", ret);
1422 1423 1424
				goto restore;
			}
		}
Y
Yan Zheng 已提交
1425 1426
		sb->s_flags &= ~MS_RDONLY;
	}
M
Miao Xie 已提交
1427 1428
out:
	btrfs_remount_cleanup(fs_info, old_opts);
Y
Yan Zheng 已提交
1429
	return 0;
1430 1431 1432 1433 1434 1435 1436 1437 1438

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 已提交
1439
	mutex_lock(&fs_info->chunk_mutex);
1440
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1441
	mutex_unlock(&fs_info->chunk_mutex);
1442 1443
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1444
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1445
	btrfs_remount_cleanup(fs_info, old_opts);
1446
	return ret;
Y
Yan Zheng 已提交
1447 1448
}

1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
/* 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);
}

1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
/*
 * 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;
1490
	int min_stripes = 1, num_stripes = 1;
1491 1492 1493
	int i = 0, nr_devices;
	int ret;

1494
	nr_devices = fs_info->fs_devices->open_devices;
1495 1496
	BUG_ON(!nr_devices);

1497
	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1498 1499 1500 1501 1502 1503
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1504
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1505
		min_stripes = 2;
1506 1507
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1508
		min_stripes = 2;
1509 1510
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1511
		min_stripes = 4;
1512 1513
		num_stripes = 4;
	}
1514 1515 1516 1517 1518 1519

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

1520
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1521 1522
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
			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) {
1583 1584 1585
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1586 1587 1588 1589
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1590
			avail_space += devices_info[i].max_avail * num_stripes;
1591
			alloc_size = devices_info[i].max_avail;
1592
			for (j = i + 1 - num_stripes; j <= i; j++)
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1604 1605
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1606 1607 1608
	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;
1609 1610
	struct btrfs_space_info *found;
	u64 total_used = 0;
1611
	u64 total_free_data = 0;
1612
	int bits = dentry->d_sb->s_blocksize_bits;
1613
	__be32 *fsid = (__be32 *)fs_info->fsid;
1614
	int ret;
C
Chris Mason 已提交
1615

1616
	/* holding chunk_muext to avoid allocating new chunks */
1617
	mutex_lock(&fs_info->chunk_mutex);
1618
	rcu_read_lock();
J
Josef Bacik 已提交
1619
	list_for_each_entry_rcu(found, head, list) {
1620 1621 1622 1623 1624 1625
		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);
		}

1626
		total_used += found->disk_used;
J
Josef Bacik 已提交
1627
	}
1628 1629
	rcu_read_unlock();

C
Chris Mason 已提交
1630
	buf->f_namelen = BTRFS_NAME_LEN;
1631
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1632
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1633 1634
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1635
	buf->f_bavail = total_free_data;
1636
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1637
	if (ret) {
1638
		mutex_unlock(&fs_info->chunk_mutex);
1639 1640 1641 1642
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1643
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1644

1645
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1646
	   because we want the fsid to come out the same whether mounted
1647 1648 1649
	   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]);
1650 1651 1652 1653
	/* 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 已提交
1654 1655
	return 0;
}
C
Chris Mason 已提交
1656

A
Al Viro 已提交
1657 1658
static void btrfs_kill_super(struct super_block *sb)
{
1659
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1660
	kill_anon_super(sb);
1661
	free_fs_info(fs_info);
A
Al Viro 已提交
1662 1663
}

1664 1665 1666
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1667
	.mount		= btrfs_mount,
A
Al Viro 已提交
1668
	.kill_sb	= btrfs_kill_super,
1669 1670
	.fs_flags	= FS_REQUIRES_DEV,
};
1671
MODULE_ALIAS_FS("btrfs");
1672

C
Chris Mason 已提交
1673 1674 1675
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1676 1677 1678 1679 1680
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;
1681
	int ret = -ENOTTY;
1682

1683 1684 1685
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1686 1687 1688
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1689

1690 1691
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1692
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1693 1694
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1695 1696 1697 1698 1699 1700 1701
	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;
1702
	}
L
Li Zefan 已提交
1703

1704
	kfree(vol);
L
Linda Knippers 已提交
1705
	return ret;
1706 1707
}

1708
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1709
{
1710 1711 1712
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

M
Miao Xie 已提交
1713
	trans = btrfs_attach_transaction_barrier(root);
1714 1715 1716 1717 1718 1719 1720
	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 已提交
1721 1722
}

1723
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1724
{
1725
	return 0;
Y
Yan 已提交
1726
}
1727

J
Josef Bacik 已提交
1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
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) {
1741 1742
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
			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;
}

1761
static const struct super_operations btrfs_super_ops = {
1762
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1763
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1764
	.put_super	= btrfs_put_super,
1765
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1766
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1767
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1768
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1769 1770
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1771
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1772
	.remount_fs	= btrfs_remount,
1773 1774
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1775
};
1776 1777 1778 1779 1780

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1781
	.llseek = noop_llseek,
1782 1783 1784
};

static struct miscdevice btrfs_misc = {
1785
	.minor		= BTRFS_MINOR,
1786 1787 1788 1789
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1790 1791 1792
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1793 1794 1795 1796 1797
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1798
static void btrfs_interface_exit(void)
1799 1800
{
	if (misc_deregister(&btrfs_misc) < 0)
1801
		printk(KERN_INFO "BTRFS: misc_deregister failed for control device\n");
1802 1803
}

1804 1805 1806 1807 1808 1809
static void btrfs_print_info(void)
{
	printk(KERN_INFO "Btrfs loaded"
#ifdef CONFIG_BTRFS_DEBUG
			", debug=on"
#endif
1810 1811 1812
#ifdef CONFIG_BTRFS_ASSERT
			", assert=on"
#endif
1813 1814 1815 1816 1817 1818
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
			", integrity-checker=on"
#endif
			"\n");
}

1819 1820
static int btrfs_run_sanity_tests(void)
{
1821 1822
	int ret;

1823
	ret = btrfs_init_test_fs();
1824 1825
	if (ret)
		return ret;
1826 1827 1828 1829 1830 1831 1832 1833

	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();
1834 1835 1836
	if (ret)
		goto out;
	ret = btrfs_test_inodes();
1837 1838 1839
out:
	btrfs_destroy_test_fs();
	return ret;
1840 1841
}

1842 1843
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1844
	int err;
1845 1846 1847 1848 1849

	err = btrfs_init_sysfs();
	if (err)
		return err;

1850
	btrfs_init_compress();
1851

1852 1853 1854 1855
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1856
	err = extent_io_init();
1857 1858 1859
	if (err)
		goto free_cachep;

1860 1861 1862 1863
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1864
	err = ordered_data_init();
1865 1866
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1867

1868 1869 1870 1871
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1872
	err = btrfs_auto_defrag_init();
1873 1874 1875
	if (err)
		goto free_delayed_inode;

1876
	err = btrfs_delayed_ref_init();
1877 1878 1879
	if (err)
		goto free_auto_defrag;

1880 1881 1882 1883
	err = btrfs_prelim_ref_init();
	if (err)
		goto free_prelim_ref;

1884 1885 1886 1887
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1888 1889
	btrfs_init_lockdep();

1890
	btrfs_print_info();
1891 1892 1893 1894 1895 1896 1897 1898

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

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

1900 1901
	return 0;

1902 1903
unregister_ioctl:
	btrfs_interface_exit();
1904 1905
free_prelim_ref:
	btrfs_prelim_ref_exit();
1906 1907
free_delayed_ref:
	btrfs_delayed_ref_exit();
1908 1909
free_auto_defrag:
	btrfs_auto_defrag_exit();
1910 1911
free_delayed_inode:
	btrfs_delayed_inode_exit();
1912 1913
free_ordered_data:
	ordered_data_exit();
1914 1915
free_extent_map:
	extent_map_exit();
1916 1917
free_extent_io:
	extent_io_exit();
1918 1919
free_cachep:
	btrfs_destroy_cachep();
1920 1921
free_compress:
	btrfs_exit_compress();
1922 1923
	btrfs_exit_sysfs();
	return err;
1924 1925 1926 1927
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1928
	btrfs_destroy_cachep();
1929
	btrfs_delayed_ref_exit();
1930
	btrfs_auto_defrag_exit();
1931
	btrfs_delayed_inode_exit();
1932
	btrfs_prelim_ref_exit();
1933
	ordered_data_exit();
1934
	extent_map_exit();
1935
	extent_io_exit();
1936
	btrfs_interface_exit();
1937
	unregister_filesystem(&btrfs_fs_type);
1938
	btrfs_exit_sysfs();
1939
	btrfs_cleanup_fs_uuids();
1940
	btrfs_exit_compress();
1941 1942 1943 1944 1945 1946
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");