super.c 45.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

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

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

66
static const char *btrfs_decode_error(int errno, char nbuf[16])
L
liubo 已提交
67 68 69 70 71 72 73 74 75 76 77 78 79
{
	char *errstr = NULL;

	switch (errno) {
	case -EIO:
		errstr = "IO failure";
		break;
	case -ENOMEM:
		errstr = "Out of memory";
		break;
	case -EROFS:
		errstr = "Readonly filesystem";
		break;
J
Jeff Mahoney 已提交
80 81 82
	case -EEXIST:
		errstr = "Object already exists";
		break;
L
liubo 已提交
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
	default:
		if (nbuf) {
			if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
				errstr = nbuf;
		}
		break;
	}

	return errstr;
}

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

static void save_error_info(struct btrfs_fs_info *fs_info)
{
	__save_error_info(fs_info);
}

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

116
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
liubo 已提交
117 118
		sb->s_flags |= MS_RDONLY;
		printk(KERN_INFO "btrfs is forced readonly\n");
119 120 121 122 123 124 125 126 127 128
		/*
		 * 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.
		 */
129
//		WARN_ON(1);
L
liubo 已提交
130 131 132
	}
}

133
#ifdef CONFIG_PRINTK
L
liubo 已提交
134 135 136 137 138
/*
 * __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 已提交
139
		       unsigned int line, int errno, const char *fmt, ...)
L
liubo 已提交
140 141 142 143 144 145 146 147 148 149
{
	struct super_block *sb = fs_info->sb;
	char nbuf[16];
	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 已提交
150 151
  		return;

152
  	errstr = btrfs_decode_error(errno, nbuf);
J
Jeff Mahoney 已提交
153
	if (fmt) {
154 155 156 157 158 159
		struct va_format vaf;
		va_list args;

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

		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s (%pV)\n",
			sb->s_id, function, line, errstr, &vaf);
163
		va_end(args);
J
Jeff Mahoney 已提交
164 165 166 167
	} else {
		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
			sb->s_id, function, line, errstr);
	}
L
liubo 已提交
168

J
Jeff Mahoney 已提交
169 170 171 172 173 174
	/* 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 已提交
175

176
static const char * const logtypes[] = {
J
Jeff Mahoney 已提交
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
	"emergency",
	"alert",
	"critical",
	"error",
	"warning",
	"notice",
	"info",
	"debug",
};

void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...)
{
	struct super_block *sb = fs_info->sb;
	char lvl[4];
	struct va_format vaf;
	va_list args;
	const char *type = logtypes[4];
194
	int kern_level;
J
Jeff Mahoney 已提交
195 196 197

	va_start(args, fmt);

198 199 200 201 202 203 204
	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 已提交
205 206 207 208 209
	} else
		*lvl = '\0';

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

J
Jeff Mahoney 已提交
211
	printk("%sBTRFS %s (device %s): %pV", lvl, type, sb->s_id, &vaf);
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

	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 已提交
235
}
236
#endif
L
liubo 已提交
237

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
/*
 * 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)
{
D
Daniel J Blueman 已提交
255
	WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted\n");
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 262
		char nbuf[16];
		const char *errstr;

263
		errstr = btrfs_decode_error(errno, nbuf);
264 265 266
		btrfs_printk(root->fs_info,
			     "%s:%d: Aborting unused transaction(%s).\n",
			     function, line, errstr);
L
liubo 已提交
267
		return;
268
	}
269
	ACCESS_ONCE(trans->transaction->aborted) = errno;
270 271
	__btrfs_std_error(root->fs_info, function, line, errno, NULL);
}
J
Jeff Mahoney 已提交
272 273 274 275 276 277 278 279 280 281 282 283
/*
 * __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 nbuf[16];
	char *s_id = "<unknown>";
	const char *errstr;
	struct va_format vaf = { .fmt = fmt };
	va_list args;
L
liubo 已提交
284

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

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

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

	printk(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (%s)\n",
	       s_id, function, line, &vaf, errstr);
	va_end(args);
	/* Caller calls BUG() */
L
liubo 已提交
300 301
}

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

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

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

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

383
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
384 385 386
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

387
	if (!options)
388
		goto out;
389

390 391 392 393 394 395 396 397
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

398
	orig = options;
399

400
	while ((p = strsep(&options, ",")) != NULL) {
401 402 403 404 405 406
		int token;
		if (!*p)
			continue;

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

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

/*
 * 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.
 */
651
static int btrfs_parse_early_options(const char *options, fmode_t flags,
652
		void *holder, char **subvol_name, u64 *subvol_objectid,
653
		u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
654 655
{
	substring_t args[MAX_OPT_ARGS];
656
	char *device_name, *opts, *orig, *p;
657
	int error = 0;
658
	int intarg;
659 660

	if (!options)
661
		return 0;
662 663 664 665 666 667 668 669

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
670
	orig = opts;
671 672 673 674 675 676 677 678 679

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
680
			kfree(*subvol_name);
681 682
			*subvol_name = match_strdup(&args[0]);
			break;
683 684
		case Opt_subvolid:
			intarg = 0;
685 686 687 688 689 690 691 692 693
			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;
			}
694
			break;
695 696 697 698 699 700 701 702 703 704 705 706
		case Opt_subvolrootid:
			intarg = 0;
			error = match_int(&args[0], &intarg);
			if (!error) {
				/* we want the original fs_tree */
				if (!intarg)
					*subvol_rootid =
						BTRFS_FS_TREE_OBJECTID;
				else
					*subvol_rootid = intarg;
			}
			break;
707
		case Opt_device:
708 709 710 711 712 713
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
714
					flags, holder, fs_devices);
715
			kfree(device_name);
716
			if (error)
717
				goto out;
718
			break;
719 720 721 722 723
		default:
			break;
		}
	}

724
out:
725
	kfree(orig);
726
	return error;
727 728
}

729 730 731
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
732 733
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
	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.
	 */
763
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
764
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
765 766
	if (IS_ERR(di)) {
		btrfs_free_path(path);
767
		return ERR_CAST(di);
768
	}
769 770 771 772 773 774 775 776
	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;
777
		new_root = fs_info->fs_root;
778 779 780 781 782 783 784
		goto setup_root;
	}

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

find_root:
785
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
786
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
787
		return ERR_CAST(new_root);
788 789 790 791 792 793 794 795 796 797 798

	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);
799 800
	if (IS_ERR(inode))
		return ERR_CAST(inode);
801 802 803 804 805 806 807 808 809 810 811

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

812
	return d_obtain_alias(inode);
813 814
}

C
Chris Mason 已提交
815
static int btrfs_fill_super(struct super_block *sb,
816
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
817
			    void *data, int silent)
C
Chris Mason 已提交
818
{
C
Chris Mason 已提交
819
	struct inode *inode;
820
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
821
	struct btrfs_key key;
C
Chris Mason 已提交
822
	int err;
823

C
Chris Mason 已提交
824 825 826
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
827
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
828
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
829
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
830
	sb->s_time_gran = 1;
C
Chris Mason 已提交
831
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
832
	sb->s_flags |= MS_POSIXACL;
833
#endif
834
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
835 836
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
C
Chris Mason 已提交
837
		printk("btrfs: open_ctree failed\n");
A
Al Viro 已提交
838
		return err;
839 840
	}

841 842 843
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
844
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
845 846
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
847
		goto fail_close;
C
Chris Mason 已提交
848 849
	}

850 851
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
852 853
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
854
	}
855

C
Chris Mason 已提交
856
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
857
	cleancache_init_fs(sb);
858
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
859
	return 0;
C
Chris Mason 已提交
860 861

fail_close:
862
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
863
	return err;
C
Chris Mason 已提交
864 865
}

S
Sage Weil 已提交
866
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
867 868
{
	struct btrfs_trans_handle *trans;
869 870
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
871

872 873
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
874
	if (!wait) {
875
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
876 877
		return 0;
	}
878

879
	btrfs_wait_ordered_extents(root, 0);
880

881
	trans = btrfs_attach_transaction(root);
882
	if (IS_ERR(trans)) {
883 884
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
885
			return 0;
886
		return PTR_ERR(trans);
887
	}
888
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
889 890
}

891
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
892
{
893 894
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
895
	char *compress_type;
E
Eric Paris 已提交
896 897 898 899 900 901 902 903 904 905

	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)
906 907
		seq_printf(seq, ",max_inline=%llu",
			   (unsigned long long)info->max_inline);
E
Eric Paris 已提交
908
	if (info->alloc_start != 0)
909 910
		seq_printf(seq, ",alloc_start=%llu",
			   (unsigned long long)info->alloc_start);
E
Eric Paris 已提交
911 912 913
	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 已提交
914 915 916 917 918 919 920 921 922 923
	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 已提交
924 925
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
926 927 928
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
929
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
930
	if (btrfs_test_opt(root, NOTREELOG))
931
		seq_puts(seq, ",notreelog");
932
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
933
		seq_puts(seq, ",flushoncommit");
934 935
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
936 937
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
938 939
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
940
	else
941
		seq_puts(seq, ",nospace_cache");
T
Tsutomu Itoh 已提交
942 943 944 945
	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");
946 947 948 949 950 951
	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");
952 953
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
J
Jeff Mahoney 已提交
954 955
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
E
Eric Paris 已提交
956 957 958
	return 0;
}

959
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
960
{
961 962
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
963

964
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
965 966
}

967 968
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
969 970 971 972
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
973 974
}

975 976 977 978 979 980 981 982 983 984
/*
 * 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;
}

985 986 987 988 989 990 991
/*
 * 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)
{
992 993
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
994 995

	/*
996 997
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
998
	 *
999 1000
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
1001 1002
	 */

1003
	src = strstr(args, "subvol=");
1004
	/* This shouldn't happen, but just in case.. */
1005 1006 1007 1008 1009
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
1010 1011 1012
		return NULL;

	/*
1013 1014
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1015
	 */
1016 1017 1018 1019
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1020 1021
	}

1022 1023
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1024 1025

	/*
1026 1027
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1028
	 */
1029 1030 1031
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1032

1033
	return buf;
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
}

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

A
Al Viro 已提交
1054 1055 1056 1057 1058
	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);
1059 1060 1061 1062
		printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
				subvol_name);
	}

1063 1064
	return root;
}
1065

1066 1067 1068 1069 1070 1071
/*
 * 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 已提交
1072
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1073
		const char *device_name, void *data)
Y
Yan 已提交
1074 1075 1076 1077
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1078
	struct btrfs_fs_devices *fs_devices = NULL;
1079
	struct btrfs_fs_info *fs_info = NULL;
1080
	fmode_t mode = FMODE_READ;
1081 1082
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
1083
	u64 subvol_rootid = 0;
Y
Yan 已提交
1084 1085
	int error = 0;

1086 1087 1088 1089
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1090
					  &subvol_name, &subvol_objectid,
1091
					  &subvol_rootid, &fs_devices);
1092 1093
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1094
		return ERR_PTR(error);
1095
	}
1096

1097 1098 1099 1100 1101 1102
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1103
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1104
	if (error)
1105
		return ERR_PTR(error);
Y
Yan 已提交
1106

1107 1108 1109 1110 1111 1112 1113
	/*
	 * 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);
1114 1115 1116
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1117 1118
	fs_info->fs_devices = fs_devices;

1119 1120 1121 1122
	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;
1123 1124 1125 1126 1127 1128 1129 1130 1131
		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;
1132 1133 1134
		goto error_close_devices;
	}

1135
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1136 1137
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1138 1139 1140 1141
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1142 1143

	if (s->s_root) {
Y
Yan Zheng 已提交
1144
		btrfs_close_devices(fs_devices);
1145
		free_fs_info(fs_info);
1146 1147
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1148 1149 1150 1151
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1152
		btrfs_sb(s)->bdev_holder = fs_type;
1153 1154
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1155 1156
	}

1157 1158
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1159
		deactivate_locked_super(s);
Y
Yan 已提交
1160

A
Al Viro 已提交
1161
	return root;
Y
Yan 已提交
1162

Y
Yan Zheng 已提交
1163
error_close_devices:
1164
	btrfs_close_devices(fs_devices);
1165
error_fs_info:
1166
	free_fs_info(fs_info);
A
Al Viro 已提交
1167
	return ERR_PTR(error);
Y
Yan 已提交
1168
}
1169

1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
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);
1201 1202
	btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
			      new_pool_size);
1203 1204
}

Y
Yan Zheng 已提交
1205 1206
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1207 1208
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1209 1210 1211 1212 1213 1214 1215
	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 已提交
1216 1217
	int ret;

1218
	ret = btrfs_parse_options(root, data);
1219 1220 1221 1222
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1223

1224 1225 1226
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1227 1228 1229 1230
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
		return 0;

	if (*flags & MS_RDONLY) {
1231 1232 1233 1234
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
Y
Yan Zheng 已提交
1235 1236
		sb->s_flags |= MS_RDONLY;

1237 1238 1239
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);

1240 1241 1242
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1243
	} else {
1244
		if (fs_info->fs_devices->rw_devices == 0) {
1245 1246
			ret = -EACCES;
			goto restore;
1247
		}
Y
Yan Zheng 已提交
1248

1249 1250 1251 1252 1253 1254 1255 1256 1257
		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;
		}

1258
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1259 1260
			ret = -EINVAL;
			goto restore;
1261
		}
Y
Yan Zheng 已提交
1262

1263
		ret = btrfs_cleanup_fs_roots(fs_info);
1264 1265
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1266

1267 1268
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1269 1270
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1271

1272 1273 1274 1275
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1276 1277 1278 1279 1280
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
			pr_warn("btrfs: failed to resume dev_replace\n");
			goto restore;
		}
Y
Yan Zheng 已提交
1281 1282 1283 1284
		sb->s_flags &= ~MS_RDONLY;
	}

	return 0;
1285 1286 1287 1288 1289 1290 1291 1292 1293

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 已提交
1294
	mutex_lock(&fs_info->chunk_mutex);
1295
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1296
	mutex_unlock(&fs_info->chunk_mutex);
1297 1298
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1299 1300
	fs_info->metadata_ratio = old_metadata_ratio;
	return ret;
Y
Yan Zheng 已提交
1301 1302
}

1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
/* 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);
}

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
/*
 * 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;
1344
	int min_stripes = 1, num_stripes = 1;
1345 1346 1347
	int i = 0, nr_devices;
	int ret;

1348
	nr_devices = fs_info->fs_devices->open_devices;
1349 1350 1351 1352 1353 1354 1355 1356 1357
	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);
1358
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1359
		min_stripes = 2;
1360 1361
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1362
		min_stripes = 2;
1363 1364
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1365
		min_stripes = 4;
1366 1367
		num_stripes = 4;
	}
1368 1369 1370 1371 1372 1373

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

1374
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1375 1376
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 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
			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) {
1437 1438 1439
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1440 1441 1442 1443
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1444
			avail_space += devices_info[i].max_avail * num_stripes;
1445
			alloc_size = devices_info[i].max_avail;
1446
			for (j = i + 1 - num_stripes; j <= i; j++)
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1458 1459
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1460 1461 1462
	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;
1463 1464
	struct btrfs_space_info *found;
	u64 total_used = 0;
1465
	u64 total_free_data = 0;
1466
	int bits = dentry->d_sb->s_blocksize_bits;
1467
	__be32 *fsid = (__be32 *)fs_info->fsid;
1468
	int ret;
C
Chris Mason 已提交
1469

1470
	/* holding chunk_muext to avoid allocating new chunks */
1471
	mutex_lock(&fs_info->chunk_mutex);
1472
	rcu_read_lock();
J
Josef Bacik 已提交
1473
	list_for_each_entry_rcu(found, head, list) {
1474 1475 1476 1477 1478 1479
		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);
		}

1480
		total_used += found->disk_used;
J
Josef Bacik 已提交
1481
	}
1482 1483
	rcu_read_unlock();

C
Chris Mason 已提交
1484
	buf->f_namelen = BTRFS_NAME_LEN;
1485
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1486
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1487 1488
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1489
	buf->f_bavail = total_free_data;
1490
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1491
	if (ret) {
1492
		mutex_unlock(&fs_info->chunk_mutex);
1493 1494 1495 1496
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1497
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1498

1499
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1500
	   because we want the fsid to come out the same whether mounted
1501 1502 1503
	   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]);
1504 1505 1506 1507
	/* 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 已提交
1508 1509
	return 0;
}
C
Chris Mason 已提交
1510

A
Al Viro 已提交
1511 1512
static void btrfs_kill_super(struct super_block *sb)
{
1513
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1514
	kill_anon_super(sb);
1515
	free_fs_info(fs_info);
A
Al Viro 已提交
1516 1517
}

1518 1519 1520
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1521
	.mount		= btrfs_mount,
A
Al Viro 已提交
1522
	.kill_sb	= btrfs_kill_super,
1523 1524
	.fs_flags	= FS_REQUIRES_DEV,
};
1525

C
Chris Mason 已提交
1526 1527 1528
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1529 1530 1531 1532 1533
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;
1534
	int ret = -ENOTTY;
1535

1536 1537 1538
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1539 1540 1541
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1542

1543 1544
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1545
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1546 1547
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1548 1549 1550 1551 1552 1553 1554
	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;
1555
	}
L
Li Zefan 已提交
1556

1557
	kfree(vol);
L
Linda Knippers 已提交
1558
	return ret;
1559 1560
}

1561
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1562
{
1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

	trans = btrfs_attach_transaction(root);
	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 已提交
1574 1575
}

1576
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1577
{
1578
	return 0;
Y
Yan 已提交
1579
}
1580

J
Josef Bacik 已提交
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
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) {
1594 1595
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
			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;
}

1614
static const struct super_operations btrfs_super_ops = {
1615
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1616
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1617
	.put_super	= btrfs_put_super,
1618
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1619
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1620
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1621
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1622 1623
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1624
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1625
	.remount_fs	= btrfs_remount,
1626 1627
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1628
};
1629 1630 1631 1632 1633

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1634
	.llseek = noop_llseek,
1635 1636 1637
};

static struct miscdevice btrfs_misc = {
1638
	.minor		= BTRFS_MINOR,
1639 1640 1641 1642
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1643 1644 1645
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1646 1647 1648 1649 1650
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1651
static void btrfs_interface_exit(void)
1652 1653
{
	if (misc_deregister(&btrfs_misc) < 0)
D
Daniel J Blueman 已提交
1654
		printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
1655 1656
}

1657 1658
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1659
	int err;
1660 1661 1662 1663 1664

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

1665
	btrfs_init_compress();
1666

1667 1668 1669 1670
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1671
	err = extent_io_init();
1672 1673 1674
	if (err)
		goto free_cachep;

1675 1676 1677 1678
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1679
	err = ordered_data_init();
1680 1681
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1682

1683 1684 1685 1686
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1687
	err = btrfs_auto_defrag_init();
1688 1689 1690
	if (err)
		goto free_delayed_inode;

1691
	err = btrfs_delayed_ref_init();
1692 1693 1694
	if (err)
		goto free_auto_defrag;

1695 1696 1697 1698
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1699 1700 1701
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
1702

1703 1704
	btrfs_init_lockdep();

1705
	printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1706 1707
	return 0;

1708 1709
unregister_ioctl:
	btrfs_interface_exit();
1710 1711
free_delayed_ref:
	btrfs_delayed_ref_exit();
1712 1713
free_auto_defrag:
	btrfs_auto_defrag_exit();
1714 1715
free_delayed_inode:
	btrfs_delayed_inode_exit();
1716 1717
free_ordered_data:
	ordered_data_exit();
1718 1719
free_extent_map:
	extent_map_exit();
1720 1721
free_extent_io:
	extent_io_exit();
1722 1723
free_cachep:
	btrfs_destroy_cachep();
1724 1725
free_compress:
	btrfs_exit_compress();
1726 1727
	btrfs_exit_sysfs();
	return err;
1728 1729 1730 1731
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1732
	btrfs_destroy_cachep();
1733
	btrfs_delayed_ref_exit();
1734
	btrfs_auto_defrag_exit();
1735
	btrfs_delayed_inode_exit();
1736
	ordered_data_exit();
1737
	extent_map_exit();
1738
	extent_io_exit();
1739
	btrfs_interface_exit();
1740
	unregister_filesystem(&btrfs_fs_type);
1741
	btrfs_exit_sysfs();
1742
	btrfs_cleanup_fs_uuids();
1743
	btrfs_exit_compress();
1744 1745 1746 1747 1748 1749
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");