super.c 46.4 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>
C
Chris Mason 已提交
45
#include "compat.h"
46
#include "delayed-inode.h"
47
#include "ctree.h"
C
Chris Mason 已提交
48
#include "disk-io.h"
49
#include "transaction.h"
C
Chris Mason 已提交
50
#include "btrfs_inode.h"
C
Chris Mason 已提交
51
#include "print-tree.h"
J
Josef Bacik 已提交
52
#include "xattr.h"
53
#include "volumes.h"
54
#include "version.h"
B
Balaji Rao 已提交
55
#include "export.h"
C
Chris Mason 已提交
56
#include "compression.h"
J
Josef Bacik 已提交
57
#include "rcu-string.h"
58
#include "dev-replace.h"
59
#include "free-space-cache.h"
60

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;
L
liubo 已提交
84 85 86 87 88
	}

	return errstr;
}

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

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

106
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
liubo 已提交
107
		sb->s_flags |= MS_RDONLY;
108
		btrfs_info(fs_info, "forced readonly");
109 110 111 112 113 114 115 116 117 118
		/*
		 * 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 已提交
119 120 121
	}
}

122
#ifdef CONFIG_PRINTK
L
liubo 已提交
123 124 125 126 127
/*
 * __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 已提交
128
		       unsigned int line, int errno, const char *fmt, ...)
L
liubo 已提交
129 130 131 132 133 134 135 136 137
{
	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 已提交
138 139
  		return;

140
	errstr = btrfs_decode_error(errno);
J
Jeff Mahoney 已提交
141
	if (fmt) {
142 143 144 145 146 147
		struct va_format vaf;
		va_list args;

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

149 150
		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s (%pV)\n",
			sb->s_id, function, line, errno, errstr, &vaf);
151
		va_end(args);
J
Jeff Mahoney 已提交
152
	} else {
153 154
		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s\n",
			sb->s_id, function, line, errno, errstr);
J
Jeff Mahoney 已提交
155
	}
L
liubo 已提交
156

J
Jeff Mahoney 已提交
157 158 159 160 161 162
	/* 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 已提交
163

164
static const char * const logtypes[] = {
J
Jeff Mahoney 已提交
165 166 167 168 169 170 171 172 173 174
	"emergency",
	"alert",
	"critical",
	"error",
	"warning",
	"notice",
	"info",
	"debug",
};

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

	va_start(args, fmt);

186 187 188 189 190 191 192
	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 已提交
193 194 195 196 197
	} else
		*lvl = '\0';

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

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

	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 已提交
223
}
224
#endif
L
liubo 已提交
225

226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
/*
 * 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)
{
243 244 245 246 247 248 249 250
	/*
	 * 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);
	}
251 252 253 254
	trans->aborted = errno;
	/* Nothing used. The other threads that have joined this
	 * transaction may be able to continue. */
	if (!trans->blocks_used) {
255 256
		const char *errstr;

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

J
Jeff Mahoney 已提交
278 279
	if (fs_info)
		s_id = fs_info->sb->s_id;
L
liubo 已提交
280

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

284
	errstr = btrfs_decode_error(errno);
285
	if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
286 287
		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 已提交
288

289 290
	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 已提交
291 292
	va_end(args);
	/* Caller calls BUG() */
L
liubo 已提交
293 294
}

C
Chris Mason 已提交
295
static void btrfs_put_super(struct super_block *sb)
C
Chris Mason 已提交
296
{
297
	(void)close_ctree(btrfs_sb(sb)->tree_root);
A
Al Viro 已提交
298 299 300 301 302 303
	/* 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 已提交
304 305
}

306
enum {
307
	Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
308 309
	Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
	Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
310 311
	Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
	Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
312
	Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
313 314
	Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache,
	Opt_no_space_cache, Opt_recovery, Opt_skip_balance,
315
	Opt_check_integrity, Opt_check_integrity_including_extent_data,
J
Jeff Mahoney 已提交
316
	Opt_check_integrity_print_mask, Opt_fatal_errors,
317
	Opt_err,
318 319 320
};

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

360 361 362
/*
 * Regular mount options parser.  Everything that is needed only when
 * reading in a new superblock is parsed here.
363
 * XXX JDM: This needs to be cleaned up for remount.
364 365
 */
int btrfs_parse_options(struct btrfs_root *root, char *options)
366
{
367
	struct btrfs_fs_info *info = root->fs_info;
368
	substring_t args[MAX_OPT_ARGS];
369 370
	char *p, *num, *orig = NULL;
	u64 cache_gen;
371
	int intarg;
S
Sage Weil 已提交
372
	int ret = 0;
373 374
	char *compress_type;
	bool compress_force = false;
375

376
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
377 378 379
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

380
	if (!options)
381
		goto out;
382

383 384 385 386 387 388 389 390
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

391
	orig = options;
392

393
	while ((p = strsep(&options, ",")) != NULL) {
394 395 396 397 398 399
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
400
		case Opt_degraded:
401 402
			printk(KERN_INFO "btrfs: allowing degraded mounts\n");
			btrfs_set_opt(info->mount_opt, DEGRADED);
403
			break;
404
		case Opt_subvol:
405
		case Opt_subvolid:
406
		case Opt_subvolrootid:
407
		case Opt_device:
408
			/*
409
			 * These are parsed by btrfs_parse_early_options
410 411
			 * and can be happily ignored here.
			 */
412 413
			break;
		case Opt_nodatasum:
414
			printk(KERN_INFO "btrfs: setting nodatasum\n");
415
			btrfs_set_opt(info->mount_opt, NODATASUM);
416 417
			break;
		case Opt_nodatacow:
418 419 420 421 422 423 424 425 426
			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);
427 428
			btrfs_set_opt(info->mount_opt, NODATACOW);
			btrfs_set_opt(info->mount_opt, NODATASUM);
429
			break;
C
Chris Mason 已提交
430
		case Opt_compress_force:
431 432
		case Opt_compress_force_type:
			compress_force = true;
433
			/* Fallthrough */
434 435 436 437 438 439 440
		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;
441
				btrfs_set_opt(info->mount_opt, COMPRESS);
442 443
				btrfs_clear_opt(info->mount_opt, NODATACOW);
				btrfs_clear_opt(info->mount_opt, NODATASUM);
L
Li Zefan 已提交
444 445 446
			} else if (strcmp(args[0].from, "lzo") == 0) {
				compress_type = "lzo";
				info->compress_type = BTRFS_COMPRESS_LZO;
447
				btrfs_set_opt(info->mount_opt, COMPRESS);
448 449
				btrfs_clear_opt(info->mount_opt, NODATACOW);
				btrfs_clear_opt(info->mount_opt, NODATASUM);
450
				btrfs_set_fs_incompat(info, COMPRESS_LZO);
451 452 453 454 455 456
			} 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;
457 458 459 460 461 462 463 464 465 466 467 468
			} 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 已提交
469
			break;
470
		case Opt_ssd:
471 472
			printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
			btrfs_set_opt(info->mount_opt, SSD);
473
			break;
474 475 476 477 478 479
		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 已提交
480
		case Opt_nossd:
481 482
			printk(KERN_INFO "btrfs: not using ssd allocation "
			       "scheme\n");
C
Chris Mason 已提交
483
			btrfs_set_opt(info->mount_opt, NOSSD);
C
Chris Mason 已提交
484
			btrfs_clear_opt(info->mount_opt, SSD);
485
			btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
C
Chris Mason 已提交
486
			break;
487
		case Opt_nobarrier:
488 489
			printk(KERN_INFO "btrfs: turning off barriers\n");
			btrfs_set_opt(info->mount_opt, NOBARRIER);
490
			break;
491 492 493
		case Opt_thread_pool:
			intarg = 0;
			match_int(&args[0], &intarg);
494
			if (intarg)
495 496
				info->thread_pool_size = intarg;
			break;
497
		case Opt_max_inline:
498 499
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
500
				info->max_inline = memparse(num, NULL);
501 502
				kfree(num);

C
Chris Mason 已提交
503 504 505 506 507
				if (info->max_inline) {
					info->max_inline = max_t(u64,
						info->max_inline,
						root->sectorsize);
				}
508
				printk(KERN_INFO "btrfs: max_inline at %llu\n",
509
					(unsigned long long)info->max_inline);
510 511
			}
			break;
512
		case Opt_alloc_start:
513 514
			num = match_strdup(&args[0]);
			if (num) {
M
Miao Xie 已提交
515
				mutex_lock(&info->chunk_mutex);
A
Akinobu Mita 已提交
516
				info->alloc_start = memparse(num, NULL);
M
Miao Xie 已提交
517
				mutex_unlock(&info->chunk_mutex);
518 519 520
				kfree(num);
				printk(KERN_INFO
					"btrfs: allocations start at %llu\n",
521
					(unsigned long long)info->alloc_start);
522 523
			}
			break;
J
Josef Bacik 已提交
524 525 526
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
527 528 529 530
		case Opt_notreelog:
			printk(KERN_INFO "btrfs: disabling tree log\n");
			btrfs_set_opt(info->mount_opt, NOTREELOG);
			break;
531 532 533 534
		case Opt_flushoncommit:
			printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
			btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
			break;
535 536 537 538 539 540 541 542 543
		case Opt_ratio:
			intarg = 0;
			match_int(&args[0], &intarg);
			if (intarg) {
				info->metadata_ratio = intarg;
				printk(KERN_INFO "btrfs: metadata ratio %d\n",
				       info->metadata_ratio);
			}
			break;
C
Christoph Hellwig 已提交
544 545 546
		case Opt_discard:
			btrfs_set_opt(info->mount_opt, DISCARD);
			break;
547 548
		case Opt_space_cache:
			btrfs_set_opt(info->mount_opt, SPACE_CACHE);
549
			break;
550 551 552 553
		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 已提交
554 555 556 557
		case Opt_inode_cache:
			printk(KERN_INFO "btrfs: enabling inode map caching\n");
			btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
			break;
558 559 560
		case Opt_clear_cache:
			printk(KERN_INFO "btrfs: force clearing of disk cache\n");
			btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
561
			break;
562 563 564
		case Opt_user_subvol_rm_allowed:
			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
			break;
565 566 567
		case Opt_enospc_debug:
			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
C
Chris Mason 已提交
568
		case Opt_defrag:
D
Daniel J Blueman 已提交
569
			printk(KERN_INFO "btrfs: enabling auto defrag\n");
C
Chris Mason 已提交
570 571
			btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
			break;
C
Chris Mason 已提交
572
		case Opt_recovery:
D
Daniel J Blueman 已提交
573
			printk(KERN_INFO "btrfs: enabling auto recovery\n");
C
Chris Mason 已提交
574 575
			btrfs_set_opt(info->mount_opt, RECOVERY);
			break;
576 577 578
		case Opt_skip_balance:
			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
			break;
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
#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:
			intarg = 0;
			match_int(&args[0], &intarg);
			if (intarg) {
				info->check_integrity_print_mask = intarg;
				printk(KERN_INFO "btrfs:"
				       " check_integrity_print_mask 0x%x\n",
				       info->check_integrity_print_mask);
			}
			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 已提交
610 611 612 613 614 615 616 617 618 619 620 621
		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;
S
Sage Weil 已提交
622 623 624 625 626
		case Opt_err:
			printk(KERN_INFO "btrfs: unrecognized mount option "
			       "'%s'\n", p);
			ret = -EINVAL;
			goto out;
627
		default:
628
			break;
629 630
		}
	}
S
Sage Weil 已提交
631
out:
632 633
	if (!ret && btrfs_test_opt(root, SPACE_CACHE))
		printk(KERN_INFO "btrfs: disk space caching is enabled\n");
634
	kfree(orig);
S
Sage Weil 已提交
635
	return ret;
636 637 638 639 640 641 642 643
}

/*
 * 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.
 */
644
static int btrfs_parse_early_options(const char *options, fmode_t flags,
645
		void *holder, char **subvol_name, u64 *subvol_objectid,
646
		struct btrfs_fs_devices **fs_devices)
647 648
{
	substring_t args[MAX_OPT_ARGS];
649
	char *device_name, *opts, *orig, *p;
650
	int error = 0;
651
	int intarg;
652 653

	if (!options)
654
		return 0;
655 656 657 658 659 660 661 662

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
663
	orig = opts;
664 665 666 667 668 669 670 671 672

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
673
			kfree(*subvol_name);
674 675
			*subvol_name = match_strdup(&args[0]);
			break;
676 677
		case Opt_subvolid:
			intarg = 0;
678 679 680 681 682 683 684 685 686
			error = match_int(&args[0], &intarg);
			if (!error) {
				/* we want the original fs_tree */
				if (!intarg)
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
				else
					*subvol_objectid = intarg;
			}
687
			break;
688
		case Opt_subvolrootid:
689 690
			printk(KERN_WARNING
				"btrfs: 'subvolrootid' mount option is deprecated and has no effect\n");
691
			break;
692
		case Opt_device:
693 694 695 696 697 698
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
699
					flags, holder, fs_devices);
700
			kfree(device_name);
701
			if (error)
702
				goto out;
703
			break;
704 705 706 707 708
		default:
			break;
		}
	}

709
out:
710
	kfree(orig);
711
	return error;
712 713
}

714 715 716
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
717 718
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	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.
	 */
748
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
749
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
750 751
	if (IS_ERR(di)) {
		btrfs_free_path(path);
752
		return ERR_CAST(di);
753
	}
754 755 756 757 758 759 760 761
	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;
762
		new_root = fs_info->fs_root;
763 764 765 766 767 768 769
		goto setup_root;
	}

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

find_root:
770
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
771
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
772
		return ERR_CAST(new_root);
773 774 775 776 777 778 779 780 781 782 783

	if (btrfs_root_refs(&new_root->root_item) == 0)
		return ERR_PTR(-ENOENT);

	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);
784 785
	if (IS_ERR(inode))
		return ERR_CAST(inode);
786 787 788 789 790 791 792 793 794 795 796

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

797
	return d_obtain_alias(inode);
798 799
}

C
Chris Mason 已提交
800
static int btrfs_fill_super(struct super_block *sb,
801
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
802
			    void *data, int silent)
C
Chris Mason 已提交
803
{
C
Chris Mason 已提交
804
	struct inode *inode;
805
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
806
	struct btrfs_key key;
C
Chris Mason 已提交
807
	int err;
808

C
Chris Mason 已提交
809 810 811
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
812
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
813
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
814
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
815
	sb->s_time_gran = 1;
C
Chris Mason 已提交
816
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
817
	sb->s_flags |= MS_POSIXACL;
818
#endif
819
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
820 821
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
C
Chris Mason 已提交
822
		printk("btrfs: open_ctree failed\n");
A
Al Viro 已提交
823
		return err;
824 825
	}

826 827 828
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
829
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
830 831
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
832
		goto fail_close;
C
Chris Mason 已提交
833 834
	}

835 836
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
837 838
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
839
	}
840

C
Chris Mason 已提交
841
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
842
	cleancache_init_fs(sb);
843
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
844
	return 0;
C
Chris Mason 已提交
845 846

fail_close:
847
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
848
	return err;
C
Chris Mason 已提交
849 850
}

S
Sage Weil 已提交
851
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
852 853
{
	struct btrfs_trans_handle *trans;
854 855
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
856

857 858
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
859
	if (!wait) {
860
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
861 862
		return 0;
	}
863

864
	btrfs_wait_ordered_extents(root, 0);
865

M
Miao Xie 已提交
866
	trans = btrfs_attach_transaction_barrier(root);
867
	if (IS_ERR(trans)) {
868 869
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
870
			return 0;
871
		return PTR_ERR(trans);
872
	}
873
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
874 875
}

876
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
877
{
878 879
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
880
	char *compress_type;
E
Eric Paris 已提交
881 882 883 884 885 886 887 888 889 890

	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)
891 892
		seq_printf(seq, ",max_inline=%llu",
			   (unsigned long long)info->max_inline);
E
Eric Paris 已提交
893
	if (info->alloc_start != 0)
894 895
		seq_printf(seq, ",alloc_start=%llu",
			   (unsigned long long)info->alloc_start);
E
Eric Paris 已提交
896 897 898
	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 已提交
899 900 901 902 903 904 905 906 907 908
	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 已提交
909 910
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
911 912 913
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
914
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
915
	if (btrfs_test_opt(root, NOTREELOG))
916
		seq_puts(seq, ",notreelog");
917
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
918
		seq_puts(seq, ",flushoncommit");
919 920
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
921 922
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
923 924
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
925
	else
926
		seq_puts(seq, ",nospace_cache");
T
Tsutomu Itoh 已提交
927 928 929 930
	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");
931 932 933 934 935 936
	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");
937 938
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
J
Jeff Mahoney 已提交
939 940
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
E
Eric Paris 已提交
941 942 943
	return 0;
}

944
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
945
{
946 947
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
948

949
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
950 951
}

952 953
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
954 955 956 957
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
958 959
}

960 961 962 963 964 965 966 967 968 969
/*
 * 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;
}

970 971 972 973 974 975 976
/*
 * 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)
{
977 978
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
979 980

	/*
981 982
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
983
	 *
984 985
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
986 987
	 */

988
	src = strstr(args, "subvol=");
989
	/* This shouldn't happen, but just in case.. */
990 991 992 993 994
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
995 996 997
		return NULL;

	/*
998 999
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1000
	 */
1001 1002 1003 1004
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1005 1006
	}

1007 1008
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1009 1010

	/*
1011 1012
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1013
	 */
1014 1015 1016
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1017

1018
	return buf;
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
}

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

A
Al Viro 已提交
1039 1040 1041 1042 1043
	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);
1044 1045 1046 1047
		printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
				subvol_name);
	}

1048 1049
	return root;
}
1050

1051 1052 1053 1054 1055 1056
/*
 * 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 已提交
1057
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1058
		const char *device_name, void *data)
Y
Yan 已提交
1059 1060 1061 1062
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1063
	struct btrfs_fs_devices *fs_devices = NULL;
1064
	struct btrfs_fs_info *fs_info = NULL;
1065
	fmode_t mode = FMODE_READ;
1066 1067
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1068 1069
	int error = 0;

1070 1071 1072 1073
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1074
					  &subvol_name, &subvol_objectid,
1075
					  &fs_devices);
1076 1077
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1078
		return ERR_PTR(error);
1079
	}
1080

1081 1082 1083 1084 1085 1086
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1087
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1088
	if (error)
1089
		return ERR_PTR(error);
Y
Yan 已提交
1090

1091 1092 1093 1094 1095 1096 1097
	/*
	 * 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);
1098 1099 1100
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1101 1102
	fs_info->fs_devices = fs_devices;

1103 1104 1105 1106
	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;
1107 1108 1109 1110 1111 1112 1113 1114 1115
		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;
1116 1117 1118
		goto error_close_devices;
	}

1119
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1120 1121
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1122 1123 1124 1125
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1126 1127

	if (s->s_root) {
Y
Yan Zheng 已提交
1128
		btrfs_close_devices(fs_devices);
1129
		free_fs_info(fs_info);
1130 1131
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1132 1133 1134 1135
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1136
		btrfs_sb(s)->bdev_holder = fs_type;
1137 1138
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1139 1140
	}

1141 1142
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1143
		deactivate_locked_super(s);
Y
Yan 已提交
1144

A
Al Viro 已提交
1145
	return root;
Y
Yan 已提交
1146

Y
Yan Zheng 已提交
1147
error_close_devices:
1148
	btrfs_close_devices(fs_devices);
1149
error_fs_info:
1150
	free_fs_info(fs_info);
A
Al Viro 已提交
1151
	return ERR_PTR(error);
Y
Yan 已提交
1152
}
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
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);
1185 1186
	btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
			      new_pool_size);
1187 1188
}

M
Miao Xie 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info,
					 unsigned long old_opts, int flags)
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);

	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 已提交
1221 1222
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1223 1224
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1225 1226 1227 1228 1229 1230 1231
	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 已提交
1232 1233
	int ret;

M
Miao Xie 已提交
1234 1235
	btrfs_remount_prepare(fs_info, old_opts, *flags);

1236
	ret = btrfs_parse_options(root, data);
1237 1238 1239 1240
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1241

1242 1243 1244
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1245
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1246
		goto out;
Y
Yan Zheng 已提交
1247 1248

	if (*flags & MS_RDONLY) {
1249 1250 1251 1252
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
Y
Yan Zheng 已提交
1253 1254
		sb->s_flags |= MS_RDONLY;

1255 1256 1257
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);

1258 1259 1260
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1261
	} else {
1262
		if (fs_info->fs_devices->rw_devices == 0) {
1263 1264
			ret = -EACCES;
			goto restore;
1265
		}
Y
Yan Zheng 已提交
1266

1267 1268 1269 1270 1271 1272 1273 1274 1275
		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;
		}

1276
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1277 1278
			ret = -EINVAL;
			goto restore;
1279
		}
Y
Yan Zheng 已提交
1280

1281
		ret = btrfs_cleanup_fs_roots(fs_info);
1282 1283
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1284

1285 1286
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1287 1288
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1289

1290 1291 1292 1293
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1294 1295 1296 1297 1298
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
			pr_warn("btrfs: failed to resume dev_replace\n");
			goto restore;
		}
Y
Yan Zheng 已提交
1299 1300
		sb->s_flags &= ~MS_RDONLY;
	}
M
Miao Xie 已提交
1301 1302
out:
	btrfs_remount_cleanup(fs_info, old_opts);
Y
Yan Zheng 已提交
1303
	return 0;
1304 1305 1306 1307 1308 1309 1310 1311 1312

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 已提交
1313
	mutex_lock(&fs_info->chunk_mutex);
1314
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1315
	mutex_unlock(&fs_info->chunk_mutex);
1316 1317
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1318
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1319
	btrfs_remount_cleanup(fs_info, old_opts);
1320
	return ret;
Y
Yan Zheng 已提交
1321 1322
}

1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
/* 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);
}

1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
/*
 * 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;
1364
	int min_stripes = 1, num_stripes = 1;
1365 1366 1367
	int i = 0, nr_devices;
	int ret;

1368
	nr_devices = fs_info->fs_devices->open_devices;
1369 1370 1371 1372 1373 1374 1375 1376 1377
	BUG_ON(!nr_devices);

	devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1378
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1379
		min_stripes = 2;
1380 1381
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1382
		min_stripes = 2;
1383 1384
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1385
		min_stripes = 4;
1386 1387
		num_stripes = 4;
	}
1388 1389 1390 1391 1392 1393

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

1394
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1395 1396
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 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 1451 1452 1453 1454 1455 1456
			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) {
1457 1458 1459
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1460 1461 1462 1463
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1464
			avail_space += devices_info[i].max_avail * num_stripes;
1465
			alloc_size = devices_info[i].max_avail;
1466
			for (j = i + 1 - num_stripes; j <= i; j++)
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1478 1479
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1480 1481 1482
	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;
1483 1484
	struct btrfs_space_info *found;
	u64 total_used = 0;
1485
	u64 total_free_data = 0;
1486
	int bits = dentry->d_sb->s_blocksize_bits;
1487
	__be32 *fsid = (__be32 *)fs_info->fsid;
1488
	int ret;
C
Chris Mason 已提交
1489

1490
	/* holding chunk_muext to avoid allocating new chunks */
1491
	mutex_lock(&fs_info->chunk_mutex);
1492
	rcu_read_lock();
J
Josef Bacik 已提交
1493
	list_for_each_entry_rcu(found, head, list) {
1494 1495 1496 1497 1498 1499
		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);
		}

1500
		total_used += found->disk_used;
J
Josef Bacik 已提交
1501
	}
1502 1503
	rcu_read_unlock();

C
Chris Mason 已提交
1504
	buf->f_namelen = BTRFS_NAME_LEN;
1505
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1506
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1507 1508
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1509
	buf->f_bavail = total_free_data;
1510
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1511
	if (ret) {
1512
		mutex_unlock(&fs_info->chunk_mutex);
1513 1514 1515 1516
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1517
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1518

1519
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1520
	   because we want the fsid to come out the same whether mounted
1521 1522 1523
	   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]);
1524 1525 1526 1527
	/* 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 已提交
1528 1529
	return 0;
}
C
Chris Mason 已提交
1530

A
Al Viro 已提交
1531 1532
static void btrfs_kill_super(struct super_block *sb)
{
1533
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1534
	kill_anon_super(sb);
1535
	free_fs_info(fs_info);
A
Al Viro 已提交
1536 1537
}

1538 1539 1540
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1541
	.mount		= btrfs_mount,
A
Al Viro 已提交
1542
	.kill_sb	= btrfs_kill_super,
1543 1544
	.fs_flags	= FS_REQUIRES_DEV,
};
1545
MODULE_ALIAS_FS("btrfs");
1546

C
Chris Mason 已提交
1547 1548 1549
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1550 1551 1552 1553 1554
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;
1555
	int ret = -ENOTTY;
1556

1557 1558 1559
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1560 1561 1562
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1563

1564 1565
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1566
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1567 1568
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1569 1570 1571 1572 1573 1574 1575
	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;
1576
	}
L
Li Zefan 已提交
1577

1578
	kfree(vol);
L
Linda Knippers 已提交
1579
	return ret;
1580 1581
}

1582
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1583
{
1584 1585 1586
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

M
Miao Xie 已提交
1587
	trans = btrfs_attach_transaction_barrier(root);
1588 1589 1590 1591 1592 1593 1594
	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 已提交
1595 1596
}

1597
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1598
{
1599
	return 0;
Y
Yan 已提交
1600
}
1601

J
Josef Bacik 已提交
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
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) {
1615 1616
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
			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;
}

1635
static const struct super_operations btrfs_super_ops = {
1636
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1637
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1638
	.put_super	= btrfs_put_super,
1639
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1640
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1641
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1642
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1643 1644
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1645
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1646
	.remount_fs	= btrfs_remount,
1647 1648
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1649
};
1650 1651 1652 1653 1654

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1655
	.llseek = noop_llseek,
1656 1657 1658
};

static struct miscdevice btrfs_misc = {
1659
	.minor		= BTRFS_MINOR,
1660 1661 1662 1663
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1664 1665 1666
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1667 1668 1669 1670 1671
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1672
static void btrfs_interface_exit(void)
1673 1674
{
	if (misc_deregister(&btrfs_misc) < 0)
D
Daniel J Blueman 已提交
1675
		printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
1676 1677
}

1678 1679
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1680
	int err;
1681 1682 1683 1684 1685

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

1686
	btrfs_init_compress();
1687

1688 1689 1690 1691
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1692
	err = extent_io_init();
1693 1694 1695
	if (err)
		goto free_cachep;

1696 1697 1698 1699
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1700
	err = ordered_data_init();
1701 1702
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1703

1704 1705 1706 1707
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1708
	err = btrfs_auto_defrag_init();
1709 1710 1711
	if (err)
		goto free_delayed_inode;

1712
	err = btrfs_delayed_ref_init();
1713 1714 1715
	if (err)
		goto free_auto_defrag;

1716 1717 1718 1719
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1720 1721 1722
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
1723

1724 1725
	btrfs_init_lockdep();

1726 1727 1728 1729
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	btrfs_test_free_space_cache();
#endif

1730
	printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1731 1732
	return 0;

1733 1734
unregister_ioctl:
	btrfs_interface_exit();
1735 1736
free_delayed_ref:
	btrfs_delayed_ref_exit();
1737 1738
free_auto_defrag:
	btrfs_auto_defrag_exit();
1739 1740
free_delayed_inode:
	btrfs_delayed_inode_exit();
1741 1742
free_ordered_data:
	ordered_data_exit();
1743 1744
free_extent_map:
	extent_map_exit();
1745 1746
free_extent_io:
	extent_io_exit();
1747 1748
free_cachep:
	btrfs_destroy_cachep();
1749 1750
free_compress:
	btrfs_exit_compress();
1751 1752
	btrfs_exit_sysfs();
	return err;
1753 1754 1755 1756
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1757
	btrfs_destroy_cachep();
1758
	btrfs_delayed_ref_exit();
1759
	btrfs_auto_defrag_exit();
1760
	btrfs_delayed_inode_exit();
1761
	ordered_data_exit();
1762
	extent_map_exit();
1763
	extent_io_exit();
1764
	btrfs_interface_exit();
1765
	unregister_filesystem(&btrfs_fs_type);
1766
	btrfs_exit_sysfs();
1767
	btrfs_cleanup_fs_uuids();
1768
	btrfs_exit_compress();
1769 1770 1771 1772 1773 1774
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");