super.c 52.0 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

Y
Yan 已提交
19
#include <linux/blkdev.h>
20
#include <linux/module.h>
C
Chris Mason 已提交
21
#include <linux/buffer_head.h>
22 23 24 25 26
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
E
Eric Paris 已提交
27
#include <linux/seq_file.h>
28 29
#include <linux/string.h>
#include <linux/backing-dev.h>
Y
Yan 已提交
30
#include <linux/mount.h>
C
Chris Mason 已提交
31
#include <linux/mpage.h>
C
Chris Mason 已提交
32 33
#include <linux/swap.h>
#include <linux/writeback.h>
C
Chris Mason 已提交
34
#include <linux/statfs.h>
C
Chris Mason 已提交
35
#include <linux/compat.h>
36
#include <linux/parser.h>
37
#include <linux/ctype.h>
38
#include <linux/namei.h>
39
#include <linux/miscdevice.h>
40
#include <linux/magic.h>
41
#include <linux/slab.h>
D
Dan Magenheimer 已提交
42
#include <linux/cleancache.h>
43
#include <linux/ratelimit.h>
44
#include <linux/btrfs.h>
45
#include "delayed-inode.h"
46
#include "ctree.h"
C
Chris Mason 已提交
47
#include "disk-io.h"
48
#include "transaction.h"
C
Chris Mason 已提交
49
#include "btrfs_inode.h"
C
Chris Mason 已提交
50
#include "print-tree.h"
51
#include "hash.h"
52
#include "props.h"
J
Josef Bacik 已提交
53
#include "xattr.h"
54
#include "volumes.h"
B
Balaji Rao 已提交
55
#include "export.h"
C
Chris Mason 已提交
56
#include "compression.h"
J
Josef Bacik 已提交
57
#include "rcu-string.h"
58
#include "dev-replace.h"
59
#include "free-space-cache.h"
60
#include "backref.h"
61
#include "tests/btrfs-tests.h"
62

63 64 65
#define CREATE_TRACE_POINTS
#include <trace/events/btrfs.h>

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

69 70
static int btrfs_remount(struct super_block *sb, int *flags, char *data);

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

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

	return errstr;
}

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

/* 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
		sb->s_flags |= MS_RDONLY;
118
		btrfs_info(fs_info, "forced readonly");
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.
		 */
L
liubo 已提交
129 130 131
	}
}

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

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

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

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

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

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

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

	va_start(args, fmt);

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

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

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

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

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

267
		errstr = btrfs_decode_error(errno);
268 269 270
		btrfs_warn(root->fs_info,
		           "%s:%d: Aborting unused transaction(%s).",
		           function, line, errstr);
L
liubo 已提交
271
		return;
272
	}
273
	ACCESS_ONCE(trans->transaction->aborted) = errno;
274 275 276
	/* Wake up anybody who may be waiting on this transaction */
	wake_up(&root->fs_info->transaction_wait);
	wake_up(&root->fs_info->transaction_blocked_wait);
277 278
	__btrfs_std_error(root->fs_info, function, line, errno, NULL);
}
J
Jeff Mahoney 已提交
279 280 281 282 283 284 285 286 287 288 289
/*
 * __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 已提交
290

J
Jeff Mahoney 已提交
291 292
	if (fs_info)
		s_id = fs_info->sb->s_id;
L
liubo 已提交
293

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

297
	errstr = btrfs_decode_error(errno);
298
	if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
299 300
		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 已提交
301

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

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

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

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

388 389 390
/*
 * Regular mount options parser.  Everything that is needed only when
 * reading in a new superblock is parsed here.
391
 * XXX JDM: This needs to be cleaned up for remount.
392 393
 */
int btrfs_parse_options(struct btrfs_root *root, char *options)
394
{
395
	struct btrfs_fs_info *info = root->fs_info;
396
	substring_t args[MAX_OPT_ARGS];
397 398
	char *p, *num, *orig = NULL;
	u64 cache_gen;
399
	int intarg;
S
Sage Weil 已提交
400
	int ret = 0;
401 402
	char *compress_type;
	bool compress_force = false;
403
	bool compress = false;
404

405
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
406 407 408
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

409
	if (!options)
410
		goto out;
411

412 413 414 415 416 417 418 419
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

420
	orig = options;
421

422
	while ((p = strsep(&options, ",")) != NULL) {
423 424 425 426 427 428
		int token;
		if (!*p)
			continue;

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

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

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

/*
 * 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.
 */
759
static int btrfs_parse_early_options(const char *options, fmode_t flags,
760
		void *holder, char **subvol_name, u64 *subvol_objectid,
761
		struct btrfs_fs_devices **fs_devices)
762 763
{
	substring_t args[MAX_OPT_ARGS];
764
	char *device_name, *opts, *orig, *p;
765
	char *num = NULL;
766 767 768
	int error = 0;

	if (!options)
769
		return 0;
770 771 772 773 774 775 776 777

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
778
	orig = opts;
779 780 781 782 783 784 785 786 787

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

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

831
out:
832
	kfree(orig);
833
	return error;
834 835
}

836 837 838
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
839 840
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
841 842 843 844 845
	struct btrfs_root *new_root;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_key location;
	struct inode *inode;
846
	struct dentry *dentry;
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
	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.
	 */
871
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
872
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
873 874
	if (IS_ERR(di)) {
		btrfs_free_path(path);
875
		return ERR_CAST(di);
876
	}
877 878 879 880 881 882 883 884
	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;
885
		new_root = fs_info->fs_root;
886 887 888 889 890 891 892
		goto setup_root;
	}

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

find_root:
893
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
894
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
895
		return ERR_CAST(new_root);
896 897 898 899 900 901 902 903

	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);
904 905
	if (IS_ERR(inode))
		return ERR_CAST(inode);
906 907 908 909 910 911 912 913 914 915 916

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

917 918 919 920 921 922 923
	dentry = d_obtain_alias(inode);
	if (!IS_ERR(dentry)) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags &= ~DCACHE_DISCONNECTED;
		spin_unlock(&dentry->d_lock);
	}
	return dentry;
924 925
}

C
Chris Mason 已提交
926
static int btrfs_fill_super(struct super_block *sb,
927
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
928
			    void *data, int silent)
C
Chris Mason 已提交
929
{
C
Chris Mason 已提交
930
	struct inode *inode;
931
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
932
	struct btrfs_key key;
C
Chris Mason 已提交
933
	int err;
934

C
Chris Mason 已提交
935 936 937
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
938
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
939
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
940
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
941
	sb->s_time_gran = 1;
C
Chris Mason 已提交
942
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
943
	sb->s_flags |= MS_POSIXACL;
944
#endif
945
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
946 947
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
948
		printk(KERN_ERR "BTRFS: open_ctree failed\n");
A
Al Viro 已提交
949
		return err;
950 951
	}

952 953 954
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
955
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
956 957
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
958
		goto fail_close;
C
Chris Mason 已提交
959 960
	}

961 962
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
963 964
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
965
	}
966

C
Chris Mason 已提交
967
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
968
	cleancache_init_fs(sb);
969
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
970
	return 0;
C
Chris Mason 已提交
971 972

fail_close:
973
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
974
	return err;
C
Chris Mason 已提交
975 976
}

S
Sage Weil 已提交
977
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
978 979
{
	struct btrfs_trans_handle *trans;
980 981
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
982

983 984
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
985
	if (!wait) {
986
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
987 988
		return 0;
	}
989

990
	btrfs_wait_ordered_roots(fs_info, -1);
991

M
Miao Xie 已提交
992
	trans = btrfs_attach_transaction_barrier(root);
993
	if (IS_ERR(trans)) {
994 995
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
996
			return 0;
997
		return PTR_ERR(trans);
998
	}
999
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
1000 1001
}

1002
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
1003
{
1004 1005
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
1006
	char *compress_type;
E
Eric Paris 已提交
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016

	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)
1017
		seq_printf(seq, ",max_inline=%llu", info->max_inline);
E
Eric Paris 已提交
1018
	if (info->alloc_start != 0)
1019
		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
E
Eric Paris 已提交
1020 1021 1022
	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 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
	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 已提交
1033 1034
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
1035 1036 1037
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
1038
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
1039
	if (btrfs_test_opt(root, NOTREELOG))
1040
		seq_puts(seq, ",notreelog");
1041
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
1042
		seq_puts(seq, ",flushoncommit");
1043 1044
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
1045 1046
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
1047 1048
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
1049
	else
1050
		seq_puts(seq, ",nospace_cache");
1051 1052
	if (btrfs_test_opt(root, RESCAN_UUID_TREE))
		seq_puts(seq, ",rescan_uuid_tree");
T
Tsutomu Itoh 已提交
1053 1054 1055 1056
	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");
1057 1058 1059 1060 1061 1062
	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");
1063 1064
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
	if (btrfs_test_opt(root, RECOVERY))
		seq_puts(seq, ",recovery");
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
		seq_puts(seq, ",check_int_data");
	else if (btrfs_test_opt(root, CHECK_INTEGRITY))
		seq_puts(seq, ",check_int");
	if (info->check_integrity_print_mask)
		seq_printf(seq, ",check_int_print_mask=%d",
				info->check_integrity_print_mask);
#endif
	if (info->metadata_ratio)
		seq_printf(seq, ",metadata_ratio=%d",
				info->metadata_ratio);
J
Jeff Mahoney 已提交
1079 1080
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
1081 1082
	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
		seq_printf(seq, ",commit=%d", info->commit_interval);
E
Eric Paris 已提交
1083 1084 1085
	return 0;
}

1086
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
1087
{
1088 1089
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
1090

1091
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
1092 1093
}

1094 1095
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
1096 1097 1098 1099
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
1100 1101
}

1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
/*
 * 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;
}

1112 1113 1114 1115 1116 1117 1118
/*
 * 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)
{
1119 1120
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
1121 1122

	/*
1123 1124
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
1125
	 *
1126 1127
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
1128 1129
	 */

1130
	src = strstr(args, "subvol=");
1131
	/* This shouldn't happen, but just in case.. */
1132 1133 1134 1135 1136
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
1137 1138 1139
		return NULL;

	/*
1140 1141
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1142
	 */
1143 1144 1145 1146
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1147 1148
	}

1149 1150
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1151 1152

	/*
1153 1154
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1155
	 */
1156 1157 1158
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1159

1160
	return buf;
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
}

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);
1175 1176 1177 1178 1179 1180 1181 1182 1183

	if (PTR_RET(mnt) == -EBUSY) {
		if (flags & MS_RDONLY) {
			mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY, device_name,
					     newargs);
		} else {
			int r;
			mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY, device_name,
					     newargs);
1184 1185
			if (IS_ERR(mnt)) {
				kfree(newargs);
1186
				return ERR_CAST(mnt);
1187
			}
1188 1189 1190 1191

			r = btrfs_remount(mnt->mnt_sb, &flags, NULL);
			if (r < 0) {
				/* FIXME: release vfsmount mnt ??*/
1192
				kfree(newargs);
1193 1194 1195 1196 1197
				return ERR_PTR(r);
			}
		}
	}

1198 1199
	kfree(newargs);

1200 1201 1202
	if (IS_ERR(mnt))
		return ERR_CAST(mnt);

A
Al Viro 已提交
1203
	root = mount_subtree(mnt, subvol_name);
1204

A
Al Viro 已提交
1205 1206 1207 1208 1209
	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);
1210
		printk(KERN_ERR "BTRFS: '%s' is not a valid subvolume\n",
1211 1212 1213
				subvol_name);
	}

1214 1215
	return root;
}
1216

1217 1218 1219 1220 1221 1222
/*
 * 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 已提交
1223
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1224
		const char *device_name, void *data)
Y
Yan 已提交
1225 1226 1227 1228
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1229
	struct btrfs_fs_devices *fs_devices = NULL;
1230
	struct btrfs_fs_info *fs_info = NULL;
1231
	fmode_t mode = FMODE_READ;
1232 1233
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1234 1235
	int error = 0;

1236 1237 1238 1239
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1240
					  &subvol_name, &subvol_objectid,
1241
					  &fs_devices);
1242 1243
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1244
		return ERR_PTR(error);
1245
	}
1246

1247 1248 1249 1250 1251 1252
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1253
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1254
	if (error)
1255
		return ERR_PTR(error);
Y
Yan 已提交
1256

1257 1258 1259 1260 1261 1262 1263
	/*
	 * 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);
1264 1265 1266
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1267 1268
	fs_info->fs_devices = fs_devices;

1269 1270 1271 1272
	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;
1273 1274 1275 1276 1277 1278 1279 1280 1281
		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;
1282 1283 1284
		goto error_close_devices;
	}

1285
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1286 1287
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1288 1289 1290 1291
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1292 1293

	if (s->s_root) {
Y
Yan Zheng 已提交
1294
		btrfs_close_devices(fs_devices);
1295
		free_fs_info(fs_info);
1296 1297
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1298 1299 1300 1301
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1302
		btrfs_sb(s)->bdev_holder = fs_type;
1303 1304
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1305 1306
	}

1307 1308
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1309
		deactivate_locked_super(s);
Y
Yan 已提交
1310

A
Al Viro 已提交
1311
	return root;
Y
Yan 已提交
1312

Y
Yan Zheng 已提交
1313
error_close_devices:
1314
	btrfs_close_devices(fs_devices);
1315
error_fs_info:
1316
	free_fs_info(fs_info);
A
Al Viro 已提交
1317
	return ERR_PTR(error);
Y
Yan 已提交
1318
}
1319

1320 1321 1322 1323 1324 1325 1326 1327
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;

1328
	btrfs_info(fs_info, "resize thread pool %d -> %d",
1329 1330
	       old_pool_size, new_pool_size);

1331
	btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
1332
	btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
1333
	btrfs_workqueue_set_max(fs_info->submit_workers, new_pool_size);
1334
	btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);
1335 1336 1337 1338 1339 1340
	btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_meta_write_workers,
				new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);
	btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);
1341
	btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);
1342
	btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size);
1343 1344
	btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers,
				new_pool_size);
1345 1346
}

1347
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
M
Miao Xie 已提交
1348 1349
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1350
}
M
Miao Xie 已提交
1351

1352 1353 1354
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
				       unsigned long old_opts, int flags)
{
M
Miao Xie 已提交
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	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 已提交
1382 1383
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1384 1385
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1386 1387 1388 1389 1390 1391 1392
	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 已提交
1393 1394
	int ret;

1395
	sync_filesystem(sb);
1396
	btrfs_remount_prepare(fs_info);
M
Miao Xie 已提交
1397

1398
	ret = btrfs_parse_options(root, data);
1399 1400 1401 1402
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1403

1404
	btrfs_remount_begin(fs_info, old_opts, *flags);
1405 1406 1407
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1408
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1409
		goto out;
Y
Yan Zheng 已提交
1410 1411

	if (*flags & MS_RDONLY) {
1412 1413 1414 1415
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
1416
		cancel_work_sync(&fs_info->async_reclaim_work);
1417 1418 1419 1420 1421 1422

		/* wait for the uuid_scan task to finish */
		down(&fs_info->uuid_tree_rescan_sem);
		/* avoid complains from lockdep et al. */
		up(&fs_info->uuid_tree_rescan_sem);

Y
Yan Zheng 已提交
1423 1424
		sb->s_flags |= MS_RDONLY;

1425 1426
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);
1427
		btrfs_pause_balance(fs_info);
1428

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

1444 1445 1446
		if (fs_info->fs_devices->missing_devices >
		     fs_info->num_tolerated_disk_barrier_failures &&
		    !(*flags & MS_RDONLY)) {
1447 1448
			btrfs_warn(fs_info,
				"too many missing devices, writeable remount is not allowed");
1449 1450 1451 1452
			ret = -EACCES;
			goto restore;
		}

1453
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1454 1455
			ret = -EINVAL;
			goto restore;
1456
		}
Y
Yan Zheng 已提交
1457

1458
		ret = btrfs_cleanup_fs_roots(fs_info);
1459 1460
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1461

1462 1463
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1464 1465
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1466

1467 1468 1469 1470
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1471 1472
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
1473
			btrfs_warn(fs_info, "failed to resume dev_replace");
1474 1475
			goto restore;
		}
1476 1477

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

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 已提交
1500
	mutex_lock(&fs_info->chunk_mutex);
1501
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1502
	mutex_unlock(&fs_info->chunk_mutex);
1503 1504
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1505
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1506
	btrfs_remount_cleanup(fs_info, old_opts);
1507
	return ret;
Y
Yan Zheng 已提交
1508 1509
}

1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
/* 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);
}

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
/*
 * 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;
1551
	int min_stripes = 1, num_stripes = 1;
1552 1553 1554
	int i = 0, nr_devices;
	int ret;

1555
	nr_devices = fs_info->fs_devices->open_devices;
1556 1557
	BUG_ON(!nr_devices);

1558
	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1559 1560 1561 1562 1563 1564
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1565
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1566
		min_stripes = 2;
1567 1568
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1569
		min_stripes = 2;
1570 1571
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1572
		min_stripes = 4;
1573 1574
		num_stripes = 4;
	}
1575 1576 1577 1578 1579 1580

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

1581
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1582 1583
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
			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) {
1644 1645 1646
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1647 1648 1649 1650
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1651
			avail_space += devices_info[i].max_avail * num_stripes;
1652
			alloc_size = devices_info[i].max_avail;
1653
			for (j = i + 1 - num_stripes; j <= i; j++)
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1665 1666
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1667 1668 1669
	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;
1670 1671
	struct btrfs_space_info *found;
	u64 total_used = 0;
1672
	u64 total_free_data = 0;
1673
	int bits = dentry->d_sb->s_blocksize_bits;
1674
	__be32 *fsid = (__be32 *)fs_info->fsid;
1675
	int ret;
C
Chris Mason 已提交
1676

1677
	/* holding chunk_muext to avoid allocating new chunks */
1678
	mutex_lock(&fs_info->chunk_mutex);
1679
	rcu_read_lock();
J
Josef Bacik 已提交
1680
	list_for_each_entry_rcu(found, head, list) {
1681 1682 1683 1684 1685 1686
		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);
		}

1687
		total_used += found->disk_used;
J
Josef Bacik 已提交
1688
	}
1689 1690
	rcu_read_unlock();

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

1706
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1707
	   because we want the fsid to come out the same whether mounted
1708 1709 1710
	   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]);
1711 1712 1713 1714
	/* 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 已提交
1715 1716
	return 0;
}
C
Chris Mason 已提交
1717

A
Al Viro 已提交
1718 1719
static void btrfs_kill_super(struct super_block *sb)
{
1720
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1721
	kill_anon_super(sb);
1722
	free_fs_info(fs_info);
A
Al Viro 已提交
1723 1724
}

1725 1726 1727
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1728
	.mount		= btrfs_mount,
A
Al Viro 已提交
1729
	.kill_sb	= btrfs_kill_super,
1730 1731
	.fs_flags	= FS_REQUIRES_DEV,
};
1732
MODULE_ALIAS_FS("btrfs");
1733

C
Chris Mason 已提交
1734 1735 1736
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1737 1738 1739 1740 1741
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;
1742
	int ret = -ENOTTY;
1743

1744 1745 1746
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1747 1748 1749
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1750

1751 1752
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1753
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1754 1755
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1756 1757 1758 1759 1760 1761 1762
	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;
1763
	}
L
Li Zefan 已提交
1764

1765
	kfree(vol);
L
Linda Knippers 已提交
1766
	return ret;
1767 1768
}

1769
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1770
{
1771 1772 1773
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

M
Miao Xie 已提交
1774
	trans = btrfs_attach_transaction_barrier(root);
1775 1776 1777 1778 1779 1780 1781
	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 已提交
1782 1783
}

1784
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1785
{
1786
	return 0;
Y
Yan 已提交
1787
}
1788

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

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

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1842
	.llseek = noop_llseek,
1843 1844 1845
};

static struct miscdevice btrfs_misc = {
1846
	.minor		= BTRFS_MINOR,
1847 1848 1849 1850
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1851 1852 1853
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1854 1855 1856 1857 1858
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1859
static void btrfs_interface_exit(void)
1860 1861
{
	if (misc_deregister(&btrfs_misc) < 0)
1862
		printk(KERN_INFO "BTRFS: misc_deregister failed for control device\n");
1863 1864
}

1865 1866 1867 1868 1869 1870
static void btrfs_print_info(void)
{
	printk(KERN_INFO "Btrfs loaded"
#ifdef CONFIG_BTRFS_DEBUG
			", debug=on"
#endif
1871 1872 1873
#ifdef CONFIG_BTRFS_ASSERT
			", assert=on"
#endif
1874 1875 1876 1877 1878 1879
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
			", integrity-checker=on"
#endif
			"\n");
}

1880 1881
static int btrfs_run_sanity_tests(void)
{
1882 1883
	int ret;

1884
	ret = btrfs_init_test_fs();
1885 1886
	if (ret)
		return ret;
1887 1888 1889 1890 1891 1892 1893 1894

	ret = btrfs_test_free_space_cache();
	if (ret)
		goto out;
	ret = btrfs_test_extent_buffer_operations();
	if (ret)
		goto out;
	ret = btrfs_test_extent_io();
1895 1896 1897
	if (ret)
		goto out;
	ret = btrfs_test_inodes();
1898 1899 1900
	if (ret)
		goto out;
	ret = btrfs_test_qgroups();
1901 1902 1903
out:
	btrfs_destroy_test_fs();
	return ret;
1904 1905
}

1906 1907
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1908
	int err;
1909

1910 1911 1912 1913
	err = btrfs_hash_init();
	if (err)
		return err;

1914 1915
	btrfs_props_init();

1916 1917
	err = btrfs_init_sysfs();
	if (err)
1918
		goto free_hash;
1919

1920
	btrfs_init_compress();
1921

1922 1923 1924 1925
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1926
	err = extent_io_init();
1927 1928 1929
	if (err)
		goto free_cachep;

1930 1931 1932 1933
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1934
	err = ordered_data_init();
1935 1936
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1937

1938 1939 1940 1941
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1942
	err = btrfs_auto_defrag_init();
1943 1944 1945
	if (err)
		goto free_delayed_inode;

1946
	err = btrfs_delayed_ref_init();
1947 1948 1949
	if (err)
		goto free_auto_defrag;

1950 1951 1952 1953
	err = btrfs_prelim_ref_init();
	if (err)
		goto free_prelim_ref;

1954 1955 1956 1957
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1958 1959
	btrfs_init_lockdep();

1960
	btrfs_print_info();
1961 1962 1963 1964 1965 1966 1967 1968

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

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

1970 1971
	return 0;

1972 1973
unregister_ioctl:
	btrfs_interface_exit();
1974 1975
free_prelim_ref:
	btrfs_prelim_ref_exit();
1976 1977
free_delayed_ref:
	btrfs_delayed_ref_exit();
1978 1979
free_auto_defrag:
	btrfs_auto_defrag_exit();
1980 1981
free_delayed_inode:
	btrfs_delayed_inode_exit();
1982 1983
free_ordered_data:
	ordered_data_exit();
1984 1985
free_extent_map:
	extent_map_exit();
1986 1987
free_extent_io:
	extent_io_exit();
1988 1989
free_cachep:
	btrfs_destroy_cachep();
1990 1991
free_compress:
	btrfs_exit_compress();
1992
	btrfs_exit_sysfs();
1993 1994
free_hash:
	btrfs_hash_exit();
1995
	return err;
1996 1997 1998 1999
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
2000
	btrfs_destroy_cachep();
2001
	btrfs_delayed_ref_exit();
2002
	btrfs_auto_defrag_exit();
2003
	btrfs_delayed_inode_exit();
2004
	btrfs_prelim_ref_exit();
2005
	ordered_data_exit();
2006
	extent_map_exit();
2007
	extent_io_exit();
2008
	btrfs_interface_exit();
2009
	unregister_filesystem(&btrfs_fs_type);
2010
	btrfs_exit_sysfs();
2011
	btrfs_cleanup_fs_uuids();
2012
	btrfs_exit_compress();
2013
	btrfs_hash_exit();
2014 2015
}

2016
late_initcall(init_btrfs_fs);
2017 2018 2019
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");