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

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

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

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

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

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

	return errstr;
}

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

/* btrfs handle error by forcing the filesystem readonly */
static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
{
	struct super_block *sb = fs_info->sb;

	if (sb->s_flags & MS_RDONLY)
		return;

112
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
liubo 已提交
113
		sb->s_flags |= MS_RDONLY;
114
		btrfs_info(fs_info, "forced readonly");
115 116 117 118 119 120 121 122 123 124
		/*
		 * Note that a running device replace operation is not
		 * canceled here although there is no way to update
		 * the progress. It would add the risk of a deadlock,
		 * therefore the canceling is ommited. The only penalty
		 * is that some I/O remains active until the procedure
		 * completes. The next time when the filesystem is
		 * mounted writeable again, the device replace
		 * operation continues.
		 */
L
liubo 已提交
125 126 127
	}
}

128
#ifdef CONFIG_PRINTK
L
liubo 已提交
129 130 131 132 133
/*
 * __btrfs_std_error decodes expected errors from the caller and
 * invokes the approciate error response.
 */
void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
J
Jeff Mahoney 已提交
134
		       unsigned int line, int errno, const char *fmt, ...)
L
liubo 已提交
135 136 137 138 139 140 141 142 143
{
	struct super_block *sb = fs_info->sb;
	const char *errstr;

	/*
	 * Special case: if the error is EROFS, and we're already
	 * under MS_RDONLY, then it is safe here.
	 */
	if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
J
Jeff Mahoney 已提交
144 145
  		return;

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

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

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

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

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

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

	va_start(args, fmt);

192 193 194 195 196 197 198
	kern_level = printk_get_level(fmt);
	if (kern_level) {
		size_t size = printk_skip_level(fmt) - fmt;
		memcpy(lvl, fmt,  size);
		lvl[size] = '\0';
		fmt += size;
		type = logtypes[kern_level - '0'];
J
Jeff Mahoney 已提交
199 200 201 202 203
	} else
		*lvl = '\0';

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

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

	va_end(args);
}

#else

void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
		       unsigned int line, int errno, const char *fmt, ...)
{
	struct super_block *sb = fs_info->sb;

	/*
	 * Special case: if the error is EROFS, and we're already
	 * under MS_RDONLY, then it is safe here.
	 */
	if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
		return;

	/* Don't go through full error handling during mount */
	if (sb->s_flags & MS_BORN) {
		save_error_info(fs_info);
		btrfs_handle_error(fs_info);
	}
L
liubo 已提交
229
}
230
#endif
L
liubo 已提交
231

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
/*
 * We only mark the transaction aborted and then set the file system read-only.
 * This will prevent new transactions from starting or trying to join this
 * one.
 *
 * This means that error recovery at the call site is limited to freeing
 * any local memory allocations and passing the error code up without
 * further cleanup. The transaction should complete as it normally would
 * in the call path but will return -EIO.
 *
 * We'll complete the cleanup in btrfs_end_transaction and
 * btrfs_commit_transaction.
 */
void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root, const char *function,
			       unsigned int line, int errno)
{
249 250 251 252 253
	/*
	 * Report first abort since mount
	 */
	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,
				&root->fs_info->fs_state)) {
254
		WARN(1, KERN_DEBUG "BTRFS: Transaction aborted (error %d)\n",
255 256
				errno);
	}
257 258 259 260
	trans->aborted = errno;
	/* Nothing used. The other threads that have joined this
	 * transaction may be able to continue. */
	if (!trans->blocks_used) {
261 262
		const char *errstr;

263
		errstr = btrfs_decode_error(errno);
264 265 266
		btrfs_warn(root->fs_info,
		           "%s:%d: Aborting unused transaction(%s).",
		           function, line, errstr);
L
liubo 已提交
267
		return;
268
	}
269
	ACCESS_ONCE(trans->transaction->aborted) = errno;
270 271 272
	/* Wake up anybody who may be waiting on this transaction */
	wake_up(&root->fs_info->transaction_wait);
	wake_up(&root->fs_info->transaction_blocked_wait);
273 274
	__btrfs_std_error(root->fs_info, function, line, errno, NULL);
}
J
Jeff Mahoney 已提交
275 276 277 278 279 280 281 282 283 284 285
/*
 * __btrfs_panic decodes unexpected, fatal errors from the caller,
 * issues an alert, and either panics or BUGs, depending on mount options.
 */
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
		   unsigned int line, int errno, const char *fmt, ...)
{
	char *s_id = "<unknown>";
	const char *errstr;
	struct va_format vaf = { .fmt = fmt };
	va_list args;
L
liubo 已提交
286

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

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

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

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

C
Chris Mason 已提交
304
static void btrfs_put_super(struct super_block *sb)
C
Chris Mason 已提交
305
{
306
	(void)close_ctree(btrfs_sb(sb)->tree_root);
A
Al Viro 已提交
307 308 309 310 311 312
	/* FIXME: need to fix VFS to return error? */
	/* AV: return it _where_?  ->put_super() can be triggered by any number
	 * of async events, up to and including delivery of SIGKILL to the
	 * last process that kept it busy.  Or segfault in the aforementioned
	 * process...  Whom would you report that to?
	 */
C
Chris Mason 已提交
313 314
}

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

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

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

399
	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
400 401 402
	if (cache_gen)
		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

403
	if (!options)
404
		goto out;
405

406 407 408 409 410 411 412 413
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

414
	orig = options;
415

416
	while ((p = strsep(&options, ",")) != NULL) {
417 418 419 420 421 422
		int token;
		if (!*p)
			continue;

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

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

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

/*
 * 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.
 */
746
static int btrfs_parse_early_options(const char *options, fmode_t flags,
747
		void *holder, char **subvol_name, u64 *subvol_objectid,
748
		struct btrfs_fs_devices **fs_devices)
749 750
{
	substring_t args[MAX_OPT_ARGS];
751
	char *device_name, *opts, *orig, *p;
752
	char *num = NULL;
753 754 755
	int error = 0;

	if (!options)
756
		return 0;
757 758 759 760 761 762 763 764

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
765
	orig = opts;
766 767 768 769 770 771 772 773 774

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
775
			kfree(*subvol_name);
776
			*subvol_name = match_strdup(&args[0]);
777 778 779 780
			if (!*subvol_name) {
				error = -ENOMEM;
				goto out;
			}
781
			break;
782
		case Opt_subvolid:
783 784 785 786
			num = match_strdup(&args[0]);
			if (num) {
				*subvol_objectid = memparse(num, NULL);
				kfree(num);
787
				/* we want the original fs_tree */
788
				if (!*subvol_objectid)
789 790
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
791 792 793
			} else {
				error = -EINVAL;
				goto out;
794
			}
795
			break;
796
		case Opt_subvolrootid:
797
			printk(KERN_WARNING
798 799
				"BTRFS: 'subvolrootid' mount option is deprecated and has "
				"no effect\n");
800
			break;
801
		case Opt_device:
802 803 804 805 806 807
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
808
					flags, holder, fs_devices);
809
			kfree(device_name);
810
			if (error)
811
				goto out;
812
			break;
813 814 815 816 817
		default:
			break;
		}
	}

818
out:
819
	kfree(orig);
820
	return error;
821 822
}

823 824 825
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
826 827
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
	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.
	 */
857
	dir_id = btrfs_super_root_dir(fs_info->super_copy);
858
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
859 860
	if (IS_ERR(di)) {
		btrfs_free_path(path);
861
		return ERR_CAST(di);
862
	}
863 864 865 866 867 868 869 870
	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;
871
		new_root = fs_info->fs_root;
872 873 874 875 876 877 878
		goto setup_root;
	}

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

find_root:
879
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
880
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
881
		return ERR_CAST(new_root);
882 883 884 885 886 887 888 889

	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);
890 891
	if (IS_ERR(inode))
		return ERR_CAST(inode);
892 893 894 895 896 897 898 899 900 901 902

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

903
	return d_obtain_alias(inode);
904 905
}

C
Chris Mason 已提交
906
static int btrfs_fill_super(struct super_block *sb,
907
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
908
			    void *data, int silent)
C
Chris Mason 已提交
909
{
C
Chris Mason 已提交
910
	struct inode *inode;
911
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
912
	struct btrfs_key key;
C
Chris Mason 已提交
913
	int err;
914

C
Chris Mason 已提交
915 916 917
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
918
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
919
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
920
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
921
	sb->s_time_gran = 1;
C
Chris Mason 已提交
922
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
923
	sb->s_flags |= MS_POSIXACL;
924
#endif
925
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
926 927
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
928
		printk(KERN_ERR "BTRFS: open_ctree failed\n");
A
Al Viro 已提交
929
		return err;
930 931
	}

932 933 934
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
935
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
936 937
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
938
		goto fail_close;
C
Chris Mason 已提交
939 940
	}

941 942
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
943 944
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
945
	}
946

C
Chris Mason 已提交
947
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
948
	cleancache_init_fs(sb);
949
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
950
	return 0;
C
Chris Mason 已提交
951 952

fail_close:
953
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
954
	return err;
C
Chris Mason 已提交
955 956
}

S
Sage Weil 已提交
957
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
958 959
{
	struct btrfs_trans_handle *trans;
960 961
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
962

963 964
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
965
	if (!wait) {
966
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
967 968
		return 0;
	}
969

970
	btrfs_wait_ordered_roots(fs_info, -1);
971

M
Miao Xie 已提交
972
	trans = btrfs_attach_transaction_barrier(root);
973
	if (IS_ERR(trans)) {
974 975
		/* no transaction, don't bother */
		if (PTR_ERR(trans) == -ENOENT)
976
			return 0;
977
		return PTR_ERR(trans);
978
	}
979
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
980 981
}

982
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
983
{
984 985
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
986
	char *compress_type;
E
Eric Paris 已提交
987 988 989 990 991 992 993 994 995 996

	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)
997
		seq_printf(seq, ",max_inline=%llu", info->max_inline);
E
Eric Paris 已提交
998
	if (info->alloc_start != 0)
999
		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
E
Eric Paris 已提交
1000 1001 1002
	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 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
	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 已提交
1013 1014
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
1015 1016 1017
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
1018
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
1019
	if (btrfs_test_opt(root, NOTREELOG))
1020
		seq_puts(seq, ",notreelog");
1021
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
1022
		seq_puts(seq, ",flushoncommit");
1023 1024
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
1025 1026
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
1027 1028
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
1029
	else
1030
		seq_puts(seq, ",nospace_cache");
1031 1032
	if (btrfs_test_opt(root, RESCAN_UUID_TREE))
		seq_puts(seq, ",rescan_uuid_tree");
T
Tsutomu Itoh 已提交
1033 1034 1035 1036
	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");
1037 1038 1039 1040 1041 1042
	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");
1043 1044
	if (btrfs_test_opt(root, SKIP_BALANCE))
		seq_puts(seq, ",skip_balance");
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
	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 已提交
1059 1060
	if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
		seq_puts(seq, ",fatal_errors=panic");
1061 1062
	if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
		seq_printf(seq, ",commit=%d", info->commit_interval);
E
Eric Paris 已提交
1063 1064 1065
	return 0;
}

1066
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
1067
{
1068 1069
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
1070

1071
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
1072 1073
}

1074 1075
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
1076 1077 1078 1079
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
1080 1081
}

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
/*
 * 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;
}

1092 1093 1094 1095 1096 1097 1098
/*
 * 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)
{
1099 1100
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
1101 1102

	/*
1103 1104
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
1105
	 *
1106 1107
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
1108 1109
	 */

1110
	src = strstr(args, "subvol=");
1111
	/* This shouldn't happen, but just in case.. */
1112 1113 1114 1115 1116
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
1117 1118 1119
		return NULL;

	/*
1120 1121
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
1122
	 */
1123 1124 1125 1126
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
1127 1128
	}

1129 1130
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1131 1132

	/*
1133 1134
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1135
	 */
1136 1137 1138
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1139

1140
	return buf;
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
}

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

A
Al Viro 已提交
1161 1162 1163 1164 1165
	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);
1166
		printk(KERN_ERR "BTRFS: '%s' is not a valid subvolume\n",
1167 1168 1169
				subvol_name);
	}

1170 1171
	return root;
}
1172

1173 1174 1175 1176 1177 1178
/*
 * 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 已提交
1179
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1180
		const char *device_name, void *data)
Y
Yan 已提交
1181 1182 1183 1184
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
1185
	struct btrfs_fs_devices *fs_devices = NULL;
1186
	struct btrfs_fs_info *fs_info = NULL;
1187
	fmode_t mode = FMODE_READ;
1188 1189
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
1190 1191
	int error = 0;

1192 1193 1194 1195
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1196
					  &subvol_name, &subvol_objectid,
1197
					  &fs_devices);
1198 1199
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1200
		return ERR_PTR(error);
1201
	}
1202

1203 1204 1205 1206 1207 1208
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1209
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1210
	if (error)
1211
		return ERR_PTR(error);
Y
Yan 已提交
1212

1213 1214 1215 1216 1217 1218 1219
	/*
	 * 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);
1220 1221 1222
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1223 1224
	fs_info->fs_devices = fs_devices;

1225 1226 1227 1228
	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;
1229 1230 1231 1232 1233 1234 1235 1236 1237
		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;
1238 1239 1240
		goto error_close_devices;
	}

1241
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1242 1243
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1244 1245 1246 1247
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1248 1249

	if (s->s_root) {
Y
Yan Zheng 已提交
1250
		btrfs_close_devices(fs_devices);
1251
		free_fs_info(fs_info);
1252 1253
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1254 1255 1256 1257
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1258
		btrfs_sb(s)->bdev_holder = fs_type;
1259 1260
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1261 1262
	}

1263 1264
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1265
		deactivate_locked_super(s);
Y
Yan 已提交
1266

A
Al Viro 已提交
1267
	return root;
Y
Yan 已提交
1268

Y
Yan Zheng 已提交
1269
error_close_devices:
1270
	btrfs_close_devices(fs_devices);
1271
error_fs_info:
1272
	free_fs_info(fs_info);
A
Al Viro 已提交
1273
	return ERR_PTR(error);
Y
Yan 已提交
1274
}
1275

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
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;

1291
	btrfs_info(fs_info, "resize thread pool %d -> %d",
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
	       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);
1307 1308
	btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
			      new_pool_size);
1309 1310
}

1311
static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
M
Miao Xie 已提交
1312 1313
{
	set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1314
}
M
Miao Xie 已提交
1315

1316 1317 1318
static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
				       unsigned long old_opts, int flags)
{
M
Miao Xie 已提交
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
	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 已提交
1346 1347
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1348 1349
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1350 1351 1352 1353 1354 1355 1356
	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 已提交
1357 1358
	int ret;

1359
	btrfs_remount_prepare(fs_info);
M
Miao Xie 已提交
1360

1361
	ret = btrfs_parse_options(root, data);
1362 1363 1364 1365
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1366

1367
	btrfs_remount_begin(fs_info, old_opts, *flags);
1368 1369 1370
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1371
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
M
Miao Xie 已提交
1372
		goto out;
Y
Yan Zheng 已提交
1373 1374

	if (*flags & MS_RDONLY) {
1375 1376 1377 1378
		/*
		 * this also happens on 'umount -rf' or on shutdown, when
		 * the filesystem is busy.
		 */
1379 1380 1381 1382 1383 1384

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

1387 1388
		btrfs_dev_replace_suspend_for_unmount(fs_info);
		btrfs_scrub_cancel(fs_info);
1389
		btrfs_pause_balance(fs_info);
1390

1391 1392 1393
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1394
	} else {
1395 1396
		if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
			btrfs_err(fs_info,
1397
				"Remounting read-write after error is not allowed");
1398 1399 1400
			ret = -EINVAL;
			goto restore;
		}
1401
		if (fs_info->fs_devices->rw_devices == 0) {
1402 1403
			ret = -EACCES;
			goto restore;
1404
		}
Y
Yan Zheng 已提交
1405

1406 1407 1408
		if (fs_info->fs_devices->missing_devices >
		     fs_info->num_tolerated_disk_barrier_failures &&
		    !(*flags & MS_RDONLY)) {
1409 1410
			btrfs_warn(fs_info,
				"too many missing devices, writeable remount is not allowed");
1411 1412 1413 1414
			ret = -EACCES;
			goto restore;
		}

1415
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1416 1417
			ret = -EINVAL;
			goto restore;
1418
		}
Y
Yan Zheng 已提交
1419

1420
		ret = btrfs_cleanup_fs_roots(fs_info);
1421 1422
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1423

1424 1425
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1426 1427
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1428

1429 1430 1431 1432
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

1433 1434
		ret = btrfs_resume_dev_replace_async(fs_info);
		if (ret) {
1435
			btrfs_warn(fs_info, "failed to resume dev_replace");
1436 1437
			goto restore;
		}
1438 1439

		if (!fs_info->uuid_root) {
1440
			btrfs_info(fs_info, "creating UUID tree");
1441 1442
			ret = btrfs_create_uuid_tree(fs_info);
			if (ret) {
1443
				btrfs_warn(fs_info, "failed to create the UUID tree %d", ret);
1444 1445 1446
				goto restore;
			}
		}
Y
Yan Zheng 已提交
1447 1448
		sb->s_flags &= ~MS_RDONLY;
	}
M
Miao Xie 已提交
1449 1450
out:
	btrfs_remount_cleanup(fs_info, old_opts);
Y
Yan Zheng 已提交
1451
	return 0;
1452 1453 1454 1455 1456 1457 1458 1459 1460

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 已提交
1461
	mutex_lock(&fs_info->chunk_mutex);
1462
	fs_info->alloc_start = old_alloc_start;
M
Miao Xie 已提交
1463
	mutex_unlock(&fs_info->chunk_mutex);
1464 1465
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1466
	fs_info->metadata_ratio = old_metadata_ratio;
M
Miao Xie 已提交
1467
	btrfs_remount_cleanup(fs_info, old_opts);
1468
	return ret;
Y
Yan Zheng 已提交
1469 1470
}

1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
/* 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);
}

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
/*
 * 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;
1512
	int min_stripes = 1, num_stripes = 1;
1513 1514 1515
	int i = 0, nr_devices;
	int ret;

1516
	nr_devices = fs_info->fs_devices->open_devices;
1517 1518
	BUG_ON(!nr_devices);

1519
	devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1520 1521 1522 1523 1524 1525
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1526
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1527
		min_stripes = 2;
1528 1529
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1530
		min_stripes = 2;
1531 1532
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1533
		min_stripes = 4;
1534 1535
		num_stripes = 4;
	}
1536 1537 1538 1539 1540 1541

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

1542
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
1543 1544
		if (!device->in_fs_metadata || !device->bdev ||
		    device->is_tgtdev_for_dev_replace)
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
			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) {
1605 1606 1607
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1608 1609 1610 1611
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1612
			avail_space += devices_info[i].max_avail * num_stripes;
1613
			alloc_size = devices_info[i].max_avail;
1614
			for (j = i + 1 - num_stripes; j <= i; j++)
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1626 1627
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1628 1629 1630
	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;
1631 1632
	struct btrfs_space_info *found;
	u64 total_used = 0;
1633
	u64 total_free_data = 0;
1634
	int bits = dentry->d_sb->s_blocksize_bits;
1635
	__be32 *fsid = (__be32 *)fs_info->fsid;
1636
	int ret;
C
Chris Mason 已提交
1637

1638
	/* holding chunk_muext to avoid allocating new chunks */
1639
	mutex_lock(&fs_info->chunk_mutex);
1640
	rcu_read_lock();
J
Josef Bacik 已提交
1641
	list_for_each_entry_rcu(found, head, list) {
1642 1643 1644 1645 1646 1647
		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);
		}

1648
		total_used += found->disk_used;
J
Josef Bacik 已提交
1649
	}
1650 1651
	rcu_read_unlock();

C
Chris Mason 已提交
1652
	buf->f_namelen = BTRFS_NAME_LEN;
1653
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1654
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1655 1656
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1657
	buf->f_bavail = total_free_data;
1658
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1659
	if (ret) {
1660
		mutex_unlock(&fs_info->chunk_mutex);
1661 1662 1663 1664
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1665
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1666

1667
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1668
	   because we want the fsid to come out the same whether mounted
1669 1670 1671
	   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]);
1672 1673 1674 1675
	/* 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 已提交
1676 1677
	return 0;
}
C
Chris Mason 已提交
1678

A
Al Viro 已提交
1679 1680
static void btrfs_kill_super(struct super_block *sb)
{
1681
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1682
	kill_anon_super(sb);
1683
	free_fs_info(fs_info);
A
Al Viro 已提交
1684 1685
}

1686 1687 1688
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1689
	.mount		= btrfs_mount,
A
Al Viro 已提交
1690
	.kill_sb	= btrfs_kill_super,
1691 1692
	.fs_flags	= FS_REQUIRES_DEV,
};
1693
MODULE_ALIAS_FS("btrfs");
1694

C
Chris Mason 已提交
1695 1696 1697
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1698 1699 1700 1701 1702
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;
1703
	int ret = -ENOTTY;
1704

1705 1706 1707
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1708 1709 1710
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1711

1712 1713
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1714
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1715 1716
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1717 1718 1719 1720 1721 1722 1723
	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;
1724
	}
L
Li Zefan 已提交
1725

1726
	kfree(vol);
L
Linda Knippers 已提交
1727
	return ret;
1728 1729
}

1730
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1731
{
1732 1733 1734
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = btrfs_sb(sb)->tree_root;

M
Miao Xie 已提交
1735
	trans = btrfs_attach_transaction_barrier(root);
1736 1737 1738 1739 1740 1741 1742
	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 已提交
1743 1744
}

1745
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1746
{
1747
	return 0;
Y
Yan 已提交
1748
}
1749

J
Josef Bacik 已提交
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
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) {
1763 1764
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
			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;
}

1783
static const struct super_operations btrfs_super_ops = {
1784
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1785
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1786
	.put_super	= btrfs_put_super,
1787
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1788
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1789
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1790
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1791 1792
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1793
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1794
	.remount_fs	= btrfs_remount,
1795 1796
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1797
};
1798 1799 1800 1801 1802

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1803
	.llseek = noop_llseek,
1804 1805 1806
};

static struct miscdevice btrfs_misc = {
1807
	.minor		= BTRFS_MINOR,
1808 1809 1810 1811
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1812 1813 1814
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1815 1816 1817 1818 1819
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1820
static void btrfs_interface_exit(void)
1821 1822
{
	if (misc_deregister(&btrfs_misc) < 0)
1823
		printk(KERN_INFO "BTRFS: misc_deregister failed for control device\n");
1824 1825
}

1826 1827 1828 1829 1830 1831
static void btrfs_print_info(void)
{
	printk(KERN_INFO "Btrfs loaded"
#ifdef CONFIG_BTRFS_DEBUG
			", debug=on"
#endif
1832 1833 1834
#ifdef CONFIG_BTRFS_ASSERT
			", assert=on"
#endif
1835 1836 1837 1838 1839 1840
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
			", integrity-checker=on"
#endif
			"\n");
}

1841 1842
static int btrfs_run_sanity_tests(void)
{
1843 1844
	int ret;

1845
	ret = btrfs_init_test_fs();
1846 1847
	if (ret)
		return ret;
1848 1849 1850 1851 1852 1853 1854 1855

	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();
1856 1857 1858
	if (ret)
		goto out;
	ret = btrfs_test_inodes();
1859 1860 1861
out:
	btrfs_destroy_test_fs();
	return ret;
1862 1863
}

1864 1865
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1866
	int err;
1867 1868 1869 1870 1871

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

1872
	btrfs_init_compress();
1873

1874 1875 1876 1877
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1878
	err = extent_io_init();
1879 1880 1881
	if (err)
		goto free_cachep;

1882 1883 1884 1885
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1886
	err = ordered_data_init();
1887 1888
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1889

1890 1891 1892 1893
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1894
	err = btrfs_auto_defrag_init();
1895 1896 1897
	if (err)
		goto free_delayed_inode;

1898
	err = btrfs_delayed_ref_init();
1899 1900 1901
	if (err)
		goto free_auto_defrag;

1902 1903 1904 1905
	err = btrfs_prelim_ref_init();
	if (err)
		goto free_prelim_ref;

1906 1907 1908 1909
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_ref;

1910 1911
	btrfs_init_lockdep();

1912
	btrfs_print_info();
1913 1914 1915 1916 1917 1918 1919 1920

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

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

1922 1923
	return 0;

1924 1925
unregister_ioctl:
	btrfs_interface_exit();
1926 1927
free_prelim_ref:
	btrfs_prelim_ref_exit();
1928 1929
free_delayed_ref:
	btrfs_delayed_ref_exit();
1930 1931
free_auto_defrag:
	btrfs_auto_defrag_exit();
1932 1933
free_delayed_inode:
	btrfs_delayed_inode_exit();
1934 1935
free_ordered_data:
	ordered_data_exit();
1936 1937
free_extent_map:
	extent_map_exit();
1938 1939
free_extent_io:
	extent_io_exit();
1940 1941
free_cachep:
	btrfs_destroy_cachep();
1942 1943
free_compress:
	btrfs_exit_compress();
1944 1945
	btrfs_exit_sysfs();
	return err;
1946 1947 1948 1949
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1950
	btrfs_destroy_cachep();
1951
	btrfs_delayed_ref_exit();
1952
	btrfs_auto_defrag_exit();
1953
	btrfs_delayed_inode_exit();
1954
	btrfs_prelim_ref_exit();
1955
	ordered_data_exit();
1956
	extent_map_exit();
1957
	extent_io_exit();
1958
	btrfs_interface_exit();
1959
	unregister_filesystem(&btrfs_fs_type);
1960
	btrfs_exit_sysfs();
1961
	btrfs_cleanup_fs_uuids();
1962
	btrfs_exit_compress();
1963 1964 1965 1966 1967 1968
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");