super.c 49.8 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",
			sb->s_id, function, line, errno, errstr, &vaf);
157
		va_end(args);
J
Jeff Mahoney 已提交
158
	} else {
159 160
		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s\n",
			sb->s_id, function, line, errno, errstr);
J
Jeff Mahoney 已提交
161
	}
L
liubo 已提交
162

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

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

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

	va_start(args, fmt);

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

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

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

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

231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
/*
 * 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)
{
248 249 250 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)) {
		WARN(1, KERN_DEBUG "btrfs: Transaction aborted (error %d)\n",
				errno);
	}
256 257 258 259
	trans->aborted = errno;
	/* Nothing used. The other threads that have joined this
	 * transaction may be able to continue. */
	if (!trans->blocks_used) {
260 261
		const char *errstr;

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

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

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

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

297 298
	printk(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
	va_end(args);
	/* Caller calls BUG() */
L
liubo 已提交
301 302
}

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

314
enum {
315
	Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
316 317
	Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
	Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
318 319
	Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
	Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
320
	Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
321 322
	Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache,
	Opt_no_space_cache, Opt_recovery, Opt_skip_balance,
323
	Opt_check_integrity, Opt_check_integrity_including_extent_data,
324
	Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree,
325
	Opt_commit_interval,
326
	Opt_err,
327 328 329
};

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

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

387
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
388 389 390
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

391
	if (!options)
392
		goto out;
393

394 395 396 397 398 399 400 401
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

402
	orig = options;
403

404
	while ((p = strsep(&options, ",")) != NULL) {
405 406 407 408 409 410
		int token;
		if (!*p)
			continue;

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

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

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

/*
 * 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.
 */
700
static int btrfs_parse_early_options(const char *options, fmode_t flags,
701
		void *holder, char **subvol_name, u64 *subvol_objectid,
702
		struct btrfs_fs_devices **fs_devices)
703 704
{
	substring_t args[MAX_OPT_ARGS];
705
	char *device_name, *opts, *orig, *p;
706
	char *num = NULL;
707 708 709
	int error = 0;

	if (!options)
710
		return 0;
711 712 713 714 715 716 717 718

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
719
	orig = opts;
720 721 722 723 724 725 726 727 728

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
729
			kfree(*subvol_name);
730
			*subvol_name = match_strdup(&args[0]);
731 732 733 734
			if (!*subvol_name) {
				error = -ENOMEM;
				goto out;
			}
735
			break;
736
		case Opt_subvolid:
737 738 739 740
			num = match_strdup(&args[0]);
			if (num) {
				*subvol_objectid = memparse(num, NULL);
				kfree(num);
741
				/* we want the original fs_tree */
742
				if (!*subvol_objectid)
743 744
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
745 746 747
			} else {
				error = -EINVAL;
				goto out;
748
			}
749
			break;
750
		case Opt_subvolrootid:
751 752
			printk(KERN_WARNING
				"btrfs: 'subvolrootid' mount option is deprecated and has no effect\n");
753
			break;
754
		case Opt_device:
755 756 757 758 759 760
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
761
					flags, holder, fs_devices);
762
			kfree(device_name);
763
			if (error)
764
				goto out;
765
			break;
766 767 768 769 770
		default:
			break;
		}
	}

771
out:
772
	kfree(orig);
773
	return error;
774 775
}

776 777 778
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
779 780
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
	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.
	 */
810
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
811
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
812 813
	if (IS_ERR(di)) {
		btrfs_free_path(path);
814
		return ERR_CAST(di);
815
	}
816 817 818 819 820 821 822 823
	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;
824
		new_root = fs_info->fs_root;
825 826 827 828 829 830 831
		goto setup_root;
	}

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

find_root:
832
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
833
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
834
		return ERR_CAST(new_root);
835 836 837 838 839 840 841 842

	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);
843 844
	if (IS_ERR(inode))
		return ERR_CAST(inode);
845 846 847 848 849 850 851 852 853 854 855

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

856
	return d_obtain_alias(inode);
857 858
}

C
Chris Mason 已提交
859
static int btrfs_fill_super(struct super_block *sb,
860
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
861
			    void *data, int silent)
C
Chris Mason 已提交
862
{
C
Chris Mason 已提交
863
	struct inode *inode;
864
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
865
	struct btrfs_key key;
C
Chris Mason 已提交
866
	int err;
867

C
Chris Mason 已提交
868 869 870
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
871
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
872
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
873
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
874
	sb->s_time_gran = 1;
C
Chris Mason 已提交
875
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
876
	sb->s_flags |= MS_POSIXACL;
877
#endif
878
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
879 880
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
C
Chris Mason 已提交
881
		printk("btrfs: open_ctree failed\n");
A
Al Viro 已提交
882
		return err;
883 884
	}

885 886 887
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
888
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
889 890
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
891
		goto fail_close;
C
Chris Mason 已提交
892 893
	}

894 895
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
896 897
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
898
	}
899

C
Chris Mason 已提交
900
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
901
	cleancache_init_fs(sb);
902
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
903
	return 0;
C
Chris Mason 已提交
904 905

fail_close:
906
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
907
	return err;
C
Chris Mason 已提交
908 909
}

S
Sage Weil 已提交
910
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
911 912
{
	struct btrfs_trans_handle *trans;
913 914
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
915

916 917
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
918
	if (!wait) {
919
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
920 921
		return 0;
	}
922

923
	btrfs_wait_all_ordered_extents(fs_info);
924

M
Miao Xie 已提交
925
	trans = btrfs_attach_transaction_barrier(root);
926
	if (IS_ERR(trans)) {
927 928
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
929
			return 0;
930
		return PTR_ERR(trans);
931
	}
932
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
933 934
}

935
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
936
{
937 938
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
939
	char *compress_type;
E
Eric Paris 已提交
940 941 942 943 944 945 946 947 948 949

	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)
950
		seq_printf(seq, ",max_inline=%llu", info->max_inline);
E
Eric Paris 已提交
951
	if (info->alloc_start != 0)
952
		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
E
Eric Paris 已提交
953 954 955
	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 已提交
956 957 958 959 960 961 962 963 964 965
	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 已提交
966 967
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
968 969 970
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
971
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
972
	if (btrfs_test_opt(root, NOTREELOG))
973
		seq_puts(seq, ",notreelog");
974
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
975
		seq_puts(seq, ",flushoncommit");
976 977
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
978 979
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
980 981
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
982
	else
983
		seq_puts(seq, ",nospace_cache");
984 985
	if (btrfs_test_opt(root, RESCAN_UUID_TREE))
		seq_puts(seq, ",rescan_uuid_tree");
T
Tsutomu Itoh 已提交
986 987 988 989
	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");
990 991 992 993 994 995
	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");
996 997
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
	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 已提交
1012 1013
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
1014 1015
	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
		seq_printf(seq, ",commit=%d", info->commit_interval);
E
Eric Paris 已提交
1016 1017 1018
	return 0;
}

1019
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
1020
{
1021 1022
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
1023

1024
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
1025 1026
}

1027 1028
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
1029 1030 1031 1032
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
1033 1034
}

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
/*
 * 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;
}

1045 1046 1047 1048 1049 1050 1051
/*
 * 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)
{
1052 1053
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
1054 1055

	/*
1056 1057
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
1058
	 *
1059 1060
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
1061 1062
	 */

1063
	src = strstr(args, "subvol=");
1064
	/* This shouldn't happen, but just in case.. */
1065 1066 1067 1068 1069
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
1070 1071 1072
		return NULL;

	/*
1073 1074
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1075
	 */
1076 1077 1078 1079
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1080 1081
	}

1082 1083
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1084 1085

	/*
1086 1087
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1088
	 */
1089 1090 1091
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1092

1093
	return buf;
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
}

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

A
Al Viro 已提交
1114 1115 1116 1117 1118
	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);
1119 1120 1121 1122
		printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
				subvol_name);
	}

1123 1124
	return root;
}
1125

1126 1127 1128 1129 1130 1131
/*
 * 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 已提交
1132
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1133
		const char *device_name, void *data)
Y
Yan 已提交
1134 1135 1136 1137
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1138
	struct btrfs_fs_devices *fs_devices = NULL;
1139
	struct btrfs_fs_info *fs_info = NULL;
1140
	fmode_t mode = FMODE_READ;
1141 1142
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1143 1144
	int error = 0;

1145 1146 1147 1148
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1149
					  &subvol_name, &subvol_objectid,
1150
					  &fs_devices);
1151 1152
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1153
		return ERR_PTR(error);
1154
	}
1155

1156 1157 1158 1159 1160 1161
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1162
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1163
	if (error)
1164
		return ERR_PTR(error);
Y
Yan 已提交
1165

1166 1167 1168 1169 1170 1171 1172
	/*
	 * 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);
1173 1174 1175
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1176 1177
	fs_info->fs_devices = fs_devices;

1178 1179 1180 1181
	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;
1182 1183 1184 1185 1186 1187 1188 1189 1190
		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;
1191 1192 1193
		goto error_close_devices;
	}

1194
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1195 1196
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1197 1198 1199 1200
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1201 1202

	if (s->s_root) {
Y
Yan Zheng 已提交
1203
		btrfs_close_devices(fs_devices);
1204
		free_fs_info(fs_info);
1205 1206
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1207 1208 1209 1210
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1211
		btrfs_sb(s)->bdev_holder = fs_type;
1212 1213
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1214 1215
	}

1216 1217
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1218
		deactivate_locked_super(s);
Y
Yan 已提交
1219

A
Al Viro 已提交
1220
	return root;
Y
Yan 已提交
1221

Y
Yan Zheng 已提交
1222
error_close_devices:
1223
	btrfs_close_devices(fs_devices);
1224
error_fs_info:
1225
	free_fs_info(fs_info);
A
Al Viro 已提交
1226
	return ERR_PTR(error);
Y
Yan 已提交
1227
}
1228

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
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;

	printk(KERN_INFO "btrfs: resize thread pool %d -> %d\n",
	       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);
1260 1261
	btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
			      new_pool_size);
1262 1263
}

1264
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
M
Miao Xie 已提交
1265 1266
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1267
}
M
Miao Xie 已提交
1268

1269 1270 1271
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
				       unsigned long old_opts, int flags)
{
M
Miao Xie 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
	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 已提交
1299 1300
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1301 1302
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1303 1304 1305 1306 1307 1308 1309
	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 已提交
1310 1311
	int ret;

1312
	btrfs_remount_prepare(fs_info);
M
Miao Xie 已提交
1313

1314
	ret = btrfs_parse_options(root, data);
1315 1316 1317 1318
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1319

1320
	btrfs_remount_begin(fs_info, old_opts, *flags);
1321 1322 1323
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1324
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1325
		goto out;
Y
Yan Zheng 已提交
1326 1327

	if (*flags & MS_RDONLY) {
1328 1329 1330 1331
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
1332 1333 1334 1335 1336 1337

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

1340 1341
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);
1342
		btrfs_pause_balance(fs_info);
1343

1344 1345 1346
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1347
	} else {
1348 1349 1350 1351 1352 1353
		if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
			btrfs_err(fs_info,
				"Remounting read-write after error is not allowed\n");
			ret = -EINVAL;
			goto restore;
		}
1354
		if (fs_info->fs_devices->rw_devices == 0) {
1355 1356
			ret = -EACCES;
			goto restore;
1357
		}
Y
Yan Zheng 已提交
1358

1359 1360 1361 1362 1363 1364 1365 1366 1367
		if (fs_info->fs_devices->missing_devices >
		     fs_info->num_tolerated_disk_barrier_failures &&
		    !(*flags & MS_RDONLY)) {
			printk(KERN_WARNING
			       "Btrfs: too many missing devices, writeable remount is not allowed\n");
			ret = -EACCES;
			goto restore;
		}

1368
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1369 1370
			ret = -EINVAL;
			goto restore;
1371
		}
Y
Yan Zheng 已提交
1372

1373
		ret = btrfs_cleanup_fs_roots(fs_info);
1374 1375
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1376

1377 1378
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1379 1380
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1381

1382 1383 1384 1385
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1386 1387 1388 1389 1390
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
			pr_warn("btrfs: failed to resume dev_replace\n");
			goto restore;
		}
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400

		if (!fs_info->uuid_root) {
			pr_info("btrfs: creating UUID tree\n");
			ret = btrfs_create_uuid_tree(fs_info);
			if (ret) {
				pr_warn("btrfs: failed to create the uuid tree"
					"%d\n", ret);
				goto restore;
			}
		}
Y
Yan Zheng 已提交
1401 1402
		sb->s_flags &= ~MS_RDONLY;
	}
M
Miao Xie 已提交
1403 1404
out:
	btrfs_remount_cleanup(fs_info, old_opts);
Y
Yan Zheng 已提交
1405
	return 0;
1406 1407 1408 1409 1410 1411 1412 1413 1414

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 已提交
1415
	mutex_lock(&fs_info->chunk_mutex);
1416
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1417
	mutex_unlock(&fs_info->chunk_mutex);
1418 1419
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1420
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1421
	btrfs_remount_cleanup(fs_info, old_opts);
1422
	return ret;
Y
Yan Zheng 已提交
1423 1424
}

1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
/* 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);
}

1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
/*
 * 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;
1466
	int min_stripes = 1, num_stripes = 1;
1467 1468 1469
	int i = 0, nr_devices;
	int ret;

1470
	nr_devices = fs_info->fs_devices->open_devices;
1471 1472
	BUG_ON(!nr_devices);

1473
	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1474 1475 1476 1477 1478 1479
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1480
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1481
		min_stripes = 2;
1482 1483
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1484
		min_stripes = 2;
1485 1486
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1487
		min_stripes = 4;
1488 1489
		num_stripes = 4;
	}
1490 1491 1492 1493 1494 1495

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

1496
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1497 1498
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1499 1500 1501 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 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
			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) {
1559 1560 1561
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1562 1563 1564 1565
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1566
			avail_space += devices_info[i].max_avail * num_stripes;
1567
			alloc_size = devices_info[i].max_avail;
1568
			for (j = i + 1 - num_stripes; j <= i; j++)
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1580 1581
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1582 1583 1584
	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;
1585 1586
	struct btrfs_space_info *found;
	u64 total_used = 0;
1587
	u64 total_free_data = 0;
1588
	int bits = dentry->d_sb->s_blocksize_bits;
1589
	__be32 *fsid = (__be32 *)fs_info->fsid;
1590
	int ret;
C
Chris Mason 已提交
1591

1592
	/* holding chunk_muext to avoid allocating new chunks */
1593
	mutex_lock(&fs_info->chunk_mutex);
1594
	rcu_read_lock();
J
Josef Bacik 已提交
1595
	list_for_each_entry_rcu(found, head, list) {
1596 1597 1598 1599 1600 1601
		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);
		}

1602
		total_used += found->disk_used;
J
Josef Bacik 已提交
1603
	}
1604 1605
	rcu_read_unlock();

C
Chris Mason 已提交
1606
	buf->f_namelen = BTRFS_NAME_LEN;
1607
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1608
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1609 1610
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1611
	buf->f_bavail = total_free_data;
1612
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1613
	if (ret) {
1614
		mutex_unlock(&fs_info->chunk_mutex);
1615 1616 1617 1618
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1619
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1620

1621
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1622
	   because we want the fsid to come out the same whether mounted
1623 1624 1625
	   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]);
1626 1627 1628 1629
	/* 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 已提交
1630 1631
	return 0;
}
C
Chris Mason 已提交
1632

A
Al Viro 已提交
1633 1634
static void btrfs_kill_super(struct super_block *sb)
{
1635
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1636
	kill_anon_super(sb);
1637
	free_fs_info(fs_info);
A
Al Viro 已提交
1638 1639
}

1640 1641 1642
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1643
	.mount		= btrfs_mount,
A
Al Viro 已提交
1644
	.kill_sb	= btrfs_kill_super,
1645 1646
	.fs_flags	= FS_REQUIRES_DEV,
};
1647
MODULE_ALIAS_FS("btrfs");
1648

C
Chris Mason 已提交
1649 1650 1651
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1652 1653 1654 1655 1656
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;
1657
	int ret = -ENOTTY;
1658

1659 1660 1661
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1662 1663 1664
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1665

1666 1667
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1668
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1669 1670
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1671 1672 1673 1674 1675 1676 1677
	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;
1678
	}
L
Li Zefan 已提交
1679

1680
	kfree(vol);
L
Linda Knippers 已提交
1681
	return ret;
1682 1683
}

1684
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1685
{
1686 1687 1688
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

M
Miao Xie 已提交
1689
	trans = btrfs_attach_transaction_barrier(root);
1690 1691 1692 1693 1694 1695 1696
	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 已提交
1697 1698
}

1699
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1700
{
1701
	return 0;
Y
Yan 已提交
1702
}
1703

J
Josef Bacik 已提交
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
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) {
1717 1718
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
			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;
}

1737
static const struct super_operations btrfs_super_ops = {
1738
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1739
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1740
	.put_super	= btrfs_put_super,
1741
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1742
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1743
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1744
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1745 1746
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1747
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1748
	.remount_fs	= btrfs_remount,
1749 1750
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1751
};
1752 1753 1754 1755 1756

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1757
	.llseek = noop_llseek,
1758 1759 1760
};

static struct miscdevice btrfs_misc = {
1761
	.minor		= BTRFS_MINOR,
1762 1763 1764 1765
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1766 1767 1768
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1769 1770 1771 1772 1773
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1774
static void btrfs_interface_exit(void)
1775 1776
{
	if (misc_deregister(&btrfs_misc) < 0)
D
Daniel J Blueman 已提交
1777
		printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
1778 1779
}

1780 1781 1782 1783 1784 1785
static void btrfs_print_info(void)
{
	printk(KERN_INFO "Btrfs loaded"
#ifdef CONFIG_BTRFS_DEBUG
			", debug=on"
#endif
1786 1787 1788
#ifdef CONFIG_BTRFS_ASSERT
			", assert=on"
#endif
1789 1790 1791 1792 1793 1794
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
			", integrity-checker=on"
#endif
			"\n");
}

1795 1796
static int btrfs_run_sanity_tests(void)
{
1797 1798
	int ret;

1799
	ret = btrfs_init_test_fs();
1800 1801
	if (ret)
		return ret;
1802 1803 1804 1805 1806 1807 1808 1809

	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();
1810 1811 1812
	if (ret)
		goto out;
	ret = btrfs_test_inodes();
1813 1814 1815
out:
	btrfs_destroy_test_fs();
	return ret;
1816 1817
}

1818 1819
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1820
	int err;
1821 1822 1823 1824 1825

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

1826
	btrfs_init_compress();
1827

1828 1829 1830 1831
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1832
	err = extent_io_init();
1833 1834 1835
	if (err)
		goto free_cachep;

1836 1837 1838 1839
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1840
	err = ordered_data_init();
1841 1842
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1843

1844 1845 1846 1847
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1848
	err = btrfs_auto_defrag_init();
1849 1850 1851
	if (err)
		goto free_delayed_inode;

1852
	err = btrfs_delayed_ref_init();
1853 1854 1855
	if (err)
		goto free_auto_defrag;

1856 1857 1858 1859
	err = btrfs_prelim_ref_init();
	if (err)
		goto free_prelim_ref;

1860 1861 1862 1863
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1864 1865
	btrfs_init_lockdep();

1866
	btrfs_print_info();
1867 1868 1869 1870 1871 1872 1873 1874

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

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

1876 1877
	return 0;

1878 1879
unregister_ioctl:
	btrfs_interface_exit();
1880 1881
free_prelim_ref:
	btrfs_prelim_ref_exit();
1882 1883
free_delayed_ref:
	btrfs_delayed_ref_exit();
1884 1885
free_auto_defrag:
	btrfs_auto_defrag_exit();
1886 1887
free_delayed_inode:
	btrfs_delayed_inode_exit();
1888 1889
free_ordered_data:
	ordered_data_exit();
1890 1891
free_extent_map:
	extent_map_exit();
1892 1893
free_extent_io:
	extent_io_exit();
1894 1895
free_cachep:
	btrfs_destroy_cachep();
1896 1897
free_compress:
	btrfs_exit_compress();
1898 1899
	btrfs_exit_sysfs();
	return err;
1900 1901 1902 1903
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1904
	btrfs_destroy_cachep();
1905
	btrfs_delayed_ref_exit();
1906
	btrfs_auto_defrag_exit();
1907
	btrfs_delayed_inode_exit();
1908
	btrfs_prelim_ref_exit();
1909
	ordered_data_exit();
1910
	extent_map_exit();
1911
	extent_io_exit();
1912
	btrfs_interface_exit();
1913
	unregister_filesystem(&btrfs_fs_type);
1914
	btrfs_exit_sysfs();
1915
	btrfs_cleanup_fs_uuids();
1916
	btrfs_exit_compress();
1917 1918 1919 1920 1921 1922
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");