super.c 43.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>
C
Chris Mason 已提交
44
#include "compat.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 "ioctl.h"
C
Chris Mason 已提交
51
#include "print-tree.h"
J
Josef Bacik 已提交
52
#include "xattr.h"
53
#include "volumes.h"
54
#include "version.h"
B
Balaji Rao 已提交
55
#include "export.h"
C
Chris Mason 已提交
56
#include "compression.h"
J
Josef Bacik 已提交
57
#include "rcu-string.h"
58

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

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

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

	switch (errno) {
	case -EIO:
		errstr = "IO failure";
		break;
	case -ENOMEM:
		errstr = "Out of memory";
		break;
	case -EROFS:
		errstr = "Readonly filesystem";
		break;
J
Jeff Mahoney 已提交
80 81 82
	case -EEXIST:
		errstr = "Object already exists";
		break;
L
liubo 已提交
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
	default:
		if (nbuf) {
			if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
				errstr = nbuf;
		}
		break;
	}

	return errstr;
}

static void __save_error_info(struct btrfs_fs_info *fs_info)
{
	/*
	 * today we only save the error info into ram.  Long term we'll
	 * also send it down to the disk
	 */
	fs_info->fs_state = BTRFS_SUPER_FLAG_ERROR;
}

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

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

	if (sb->s_flags & MS_RDONLY)
		return;

	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
		sb->s_flags |= MS_RDONLY;
		printk(KERN_INFO "btrfs is forced readonly\n");
119 120
		__btrfs_scrub_cancel(fs_info);
//		WARN_ON(1);
L
liubo 已提交
121 122 123
	}
}

124
#ifdef CONFIG_PRINTK
L
liubo 已提交
125 126 127 128 129
/*
 * __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 已提交
130
		       unsigned int line, int errno, const char *fmt, ...)
L
liubo 已提交
131 132 133 134
{
	struct super_block *sb = fs_info->sb;
	char nbuf[16];
	const char *errstr;
J
Jeff Mahoney 已提交
135 136
	va_list args;
	va_start(args, fmt);
L
liubo 已提交
137 138 139 140 141 142

	/*
	 * 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 已提交
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
  		return;

  	errstr = btrfs_decode_error(fs_info, errno, nbuf);
	if (fmt) {
		struct va_format vaf = {
			.fmt = fmt,
			.va = &args,
		};

		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s (%pV)\n",
			sb->s_id, function, line, errstr, &vaf);
	} else {
		printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
			sb->s_id, function, line, errstr);
	}
L
liubo 已提交
158

J
Jeff Mahoney 已提交
159 160 161 162 163 164 165
	/* 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);
	}
	va_end(args);
}
L
liubo 已提交
166

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

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

	va_start(args, fmt);

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

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

J
Jeff Mahoney 已提交
202
	printk("%sBTRFS %s (device %s): %pV", lvl, type, sb->s_id, &vaf);
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225

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

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

		errstr = btrfs_decode_error(root->fs_info, errno, nbuf);
		btrfs_printk(root->fs_info,
			     "%s:%d: Aborting unused transaction(%s).\n",
			     function, line, errstr);
L
liubo 已提交
258
		return;
259 260 261 262
	}
	trans->transaction->aborted = errno;
	__btrfs_std_error(root->fs_info, function, line, errno, NULL);
}
J
Jeff Mahoney 已提交
263 264 265 266 267 268 269 270 271 272 273 274
/*
 * __btrfs_panic decodes unexpected, fatal errors from the caller,
 * issues an alert, and either panics or BUGs, depending on mount options.
 */
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
		   unsigned int line, int errno, const char *fmt, ...)
{
	char nbuf[16];
	char *s_id = "<unknown>";
	const char *errstr;
	struct va_format vaf = { .fmt = fmt };
	va_list args;
L
liubo 已提交
275

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

J
Jeff Mahoney 已提交
279 280 281 282 283 284 285 286 287 288 289 290
	va_start(args, fmt);
	vaf.va = &args;

	errstr = btrfs_decode_error(fs_info, errno, nbuf);
	if (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR)
		panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (%s)\n",
			s_id, function, line, &vaf, errstr);

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

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

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

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

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

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

378
	if (!options)
379
		goto out;
380

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

389
	orig = options;
390

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

		token = match_token(p, tokens, args);
		switch (token) {
398
		case Opt_degraded:
399 400
			printk(KERN_INFO "btrfs: allowing degraded mounts\n");
			btrfs_set_opt(info->mount_opt, DEGRADED);
401
			break;
402
		case Opt_subvol:
403
		case Opt_subvolid:
404
		case Opt_subvolrootid:
405
		case Opt_device:
406
			/*
407
			 * These are parsed by btrfs_parse_early_options
408 409
			 * and can be happily ignored here.
			 */
410 411
			break;
		case Opt_nodatasum:
412
			printk(KERN_INFO "btrfs: setting nodatasum\n");
413
			btrfs_set_opt(info->mount_opt, NODATASUM);
414 415
			break;
		case Opt_nodatacow:
416 417 418
			printk(KERN_INFO "btrfs: setting nodatacow\n");
			btrfs_set_opt(info->mount_opt, NODATACOW);
			btrfs_set_opt(info->mount_opt, NODATASUM);
419
			break;
C
Chris Mason 已提交
420
		case Opt_compress_force:
421 422 423 424 425 426 427 428 429
		case Opt_compress_force_type:
			compress_force = true;
		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;
430
				btrfs_set_opt(info->mount_opt, COMPRESS);
L
Li Zefan 已提交
431 432 433
			} else if (strcmp(args[0].from, "lzo") == 0) {
				compress_type = "lzo";
				info->compress_type = BTRFS_COMPRESS_LZO;
434
				btrfs_set_opt(info->mount_opt, COMPRESS);
435
				btrfs_set_fs_incompat(info, COMPRESS_LZO);
436 437 438 439 440 441
			} else if (strncmp(args[0].from, "no", 2) == 0) {
				compress_type = "no";
				info->compress_type = BTRFS_COMPRESS_NONE;
				btrfs_clear_opt(info->mount_opt, COMPRESS);
				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
				compress_force = false;
442 443 444 445 446 447 448 449 450 451 452 453
			} else {
				ret = -EINVAL;
				goto out;
			}

			if (compress_force) {
				btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
				pr_info("btrfs: force %s compression\n",
					compress_type);
			} else
				pr_info("btrfs: use %s compression\n",
					compress_type);
C
Chris Mason 已提交
454
			break;
455
		case Opt_ssd:
456 457
			printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
			btrfs_set_opt(info->mount_opt, SSD);
458
			break;
459 460 461 462 463 464
		case Opt_ssd_spread:
			printk(KERN_INFO "btrfs: use spread ssd "
			       "allocation scheme\n");
			btrfs_set_opt(info->mount_opt, SSD);
			btrfs_set_opt(info->mount_opt, SSD_SPREAD);
			break;
C
Chris Mason 已提交
465
		case Opt_nossd:
466 467
			printk(KERN_INFO "btrfs: not using ssd allocation "
			       "scheme\n");
C
Chris Mason 已提交
468
			btrfs_set_opt(info->mount_opt, NOSSD);
C
Chris Mason 已提交
469
			btrfs_clear_opt(info->mount_opt, SSD);
470
			btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
C
Chris Mason 已提交
471
			break;
472
		case Opt_nobarrier:
473 474
			printk(KERN_INFO "btrfs: turning off barriers\n");
			btrfs_set_opt(info->mount_opt, NOBARRIER);
475
			break;
476 477 478
		case Opt_thread_pool:
			intarg = 0;
			match_int(&args[0], &intarg);
479
			if (intarg)
480 481
				info->thread_pool_size = intarg;
			break;
482
		case Opt_max_inline:
483 484
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
485
				info->max_inline = memparse(num, NULL);
486 487
				kfree(num);

C
Chris Mason 已提交
488 489 490 491 492
				if (info->max_inline) {
					info->max_inline = max_t(u64,
						info->max_inline,
						root->sectorsize);
				}
493
				printk(KERN_INFO "btrfs: max_inline at %llu\n",
494
					(unsigned long long)info->max_inline);
495 496
			}
			break;
497
		case Opt_alloc_start:
498 499
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
500
				info->alloc_start = memparse(num, NULL);
501 502 503
				kfree(num);
				printk(KERN_INFO
					"btrfs: allocations start at %llu\n",
504
					(unsigned long long)info->alloc_start);
505 506
			}
			break;
J
Josef Bacik 已提交
507 508 509
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
510 511 512 513
		case Opt_notreelog:
			printk(KERN_INFO "btrfs: disabling tree log\n");
			btrfs_set_opt(info->mount_opt, NOTREELOG);
			break;
514 515 516 517
		case Opt_flushoncommit:
			printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
			btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
			break;
518 519 520 521 522 523 524 525 526
		case Opt_ratio:
			intarg = 0;
			match_int(&args[0], &intarg);
			if (intarg) {
				info->metadata_ratio = intarg;
				printk(KERN_INFO "btrfs: metadata ratio %d\n",
				       info->metadata_ratio);
			}
			break;
C
Christoph Hellwig 已提交
527 528 529
		case Opt_discard:
			btrfs_set_opt(info->mount_opt, DISCARD);
			break;
530 531
		case Opt_space_cache:
			btrfs_set_opt(info->mount_opt, SPACE_CACHE);
532
			break;
533 534 535 536
		case Opt_no_space_cache:
			printk(KERN_INFO "btrfs: disabling disk space caching\n");
			btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
			break;
C
Chris Mason 已提交
537 538 539 540
		case Opt_inode_cache:
			printk(KERN_INFO "btrfs: enabling inode map caching\n");
			btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
			break;
541 542 543
		case Opt_clear_cache:
			printk(KERN_INFO "btrfs: force clearing of disk cache\n");
			btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
544
			break;
545 546 547
		case Opt_user_subvol_rm_allowed:
			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
			break;
548 549 550
		case Opt_enospc_debug:
			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
C
Chris Mason 已提交
551 552 553 554
		case Opt_defrag:
			printk(KERN_INFO "btrfs: enabling auto defrag");
			btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
			break;
C
Chris Mason 已提交
555 556 557 558
		case Opt_recovery:
			printk(KERN_INFO "btrfs: enabling auto recovery");
			btrfs_set_opt(info->mount_opt, RECOVERY);
			break;
559 560 561
		case Opt_skip_balance:
			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
			break;
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
		case Opt_check_integrity_including_extent_data:
			printk(KERN_INFO "btrfs: enabling check integrity"
			       " including extent data\n");
			btrfs_set_opt(info->mount_opt,
				      CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity:
			printk(KERN_INFO "btrfs: enabling check integrity\n");
			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
			break;
		case Opt_check_integrity_print_mask:
			intarg = 0;
			match_int(&args[0], &intarg);
			if (intarg) {
				info->check_integrity_print_mask = intarg;
				printk(KERN_INFO "btrfs:"
				       " check_integrity_print_mask 0x%x\n",
				       info->check_integrity_print_mask);
			}
			break;
#else
		case Opt_check_integrity_including_extent_data:
		case Opt_check_integrity:
		case Opt_check_integrity_print_mask:
			printk(KERN_ERR "btrfs: support for check_integrity*"
			       " not compiled in!\n");
			ret = -EINVAL;
			goto out;
#endif
J
Jeff Mahoney 已提交
593 594 595 596 597 598 599 600 601 602 603 604
		case Opt_fatal_errors:
			if (strcmp(args[0].from, "panic") == 0)
				btrfs_set_opt(info->mount_opt,
					      PANIC_ON_FATAL_ERROR);
			else if (strcmp(args[0].from, "bug") == 0)
				btrfs_clear_opt(info->mount_opt,
					      PANIC_ON_FATAL_ERROR);
			else {
				ret = -EINVAL;
				goto out;
			}
			break;
S
Sage Weil 已提交
605 606 607 608 609
		case Opt_err:
			printk(KERN_INFO "btrfs: unrecognized mount option "
			       "'%s'\n", p);
			ret = -EINVAL;
			goto out;
610
		default:
611
			break;
612 613
		}
	}
S
Sage Weil 已提交
614
out:
615 616
	if (!ret && btrfs_test_opt(root, SPACE_CACHE))
		printk(KERN_INFO "btrfs: disk space caching is enabled\n");
617
	kfree(orig);
S
Sage Weil 已提交
618
	return ret;
619 620 621 622 623 624 625 626
}

/*
 * 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.
 */
627
static int btrfs_parse_early_options(const char *options, fmode_t flags,
628
		void *holder, char **subvol_name, u64 *subvol_objectid,
629
		u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
630 631
{
	substring_t args[MAX_OPT_ARGS];
632
	char *device_name, *opts, *orig, *p;
633
	int error = 0;
634
	int intarg;
635 636

	if (!options)
637
		return 0;
638 639 640 641 642 643 644 645

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;
646
	orig = opts;
647 648 649 650 651 652 653 654 655

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
656
			kfree(*subvol_name);
657 658
			*subvol_name = match_strdup(&args[0]);
			break;
659 660
		case Opt_subvolid:
			intarg = 0;
661 662 663 664 665 666 667 668 669
			error = match_int(&args[0], &intarg);
			if (!error) {
				/* we want the original fs_tree */
				if (!intarg)
					*subvol_objectid =
						BTRFS_FS_TREE_OBJECTID;
				else
					*subvol_objectid = intarg;
			}
670
			break;
671 672 673 674 675 676 677 678 679 680 681 682
		case Opt_subvolrootid:
			intarg = 0;
			error = match_int(&args[0], &intarg);
			if (!error) {
				/* we want the original fs_tree */
				if (!intarg)
					*subvol_rootid =
						BTRFS_FS_TREE_OBJECTID;
				else
					*subvol_rootid = intarg;
			}
			break;
683
		case Opt_device:
684 685 686 687 688 689
			device_name = match_strdup(&args[0]);
			if (!device_name) {
				error = -ENOMEM;
				goto out;
			}
			error = btrfs_scan_one_device(device_name,
690
					flags, holder, fs_devices);
691
			kfree(device_name);
692
			if (error)
693
				goto out;
694
			break;
695 696 697 698 699
		default:
			break;
		}
	}

700
out:
701
	kfree(orig);
702
	return error;
703 704
}

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

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

find_root:
761
	new_root = btrfs_read_fs_root_no_name(fs_info, &location);
762
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
763
		return ERR_CAST(new_root);
764 765 766 767 768 769 770 771 772 773 774

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

	dir_id = btrfs_root_dirid(&new_root->root_item);
setup_root:
	location.objectid = dir_id;
	location.type = BTRFS_INODE_ITEM_KEY;
	location.offset = 0;

	inode = btrfs_iget(sb, &location, new_root, &new);
775 776
	if (IS_ERR(inode))
		return ERR_CAST(inode);
777 778 779 780 781 782 783 784 785 786 787

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

788
	return d_obtain_alias(inode);
789 790
}

C
Chris Mason 已提交
791
static int btrfs_fill_super(struct super_block *sb,
792
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
793
			    void *data, int silent)
C
Chris Mason 已提交
794
{
C
Chris Mason 已提交
795
	struct inode *inode;
796
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
797
	struct btrfs_key key;
C
Chris Mason 已提交
798
	int err;
799

C
Chris Mason 已提交
800 801 802
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
803
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
804
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
805
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
806
	sb->s_time_gran = 1;
C
Chris Mason 已提交
807
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
808
	sb->s_flags |= MS_POSIXACL;
809
#endif
810
	sb->s_flags |= MS_I_VERSION;
A
Al Viro 已提交
811 812
	err = open_ctree(sb, fs_devices, (char *)data);
	if (err) {
C
Chris Mason 已提交
813
		printk("btrfs: open_ctree failed\n");
A
Al Viro 已提交
814
		return err;
815 816
	}

817 818 819
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
820
	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
821 822
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
823
		goto fail_close;
C
Chris Mason 已提交
824 825
	}

826 827
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
C
Chris Mason 已提交
828 829
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
830
	}
831

C
Chris Mason 已提交
832
	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
833
	cleancache_init_fs(sb);
834
	sb->s_flags |= MS_ACTIVE;
C
Chris Mason 已提交
835
	return 0;
C
Chris Mason 已提交
836 837

fail_close:
838
	close_ctree(fs_info->tree_root);
C
Chris Mason 已提交
839
	return err;
C
Chris Mason 已提交
840 841
}

S
Sage Weil 已提交
842
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
843 844
{
	struct btrfs_trans_handle *trans;
845 846
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
C
Chris Mason 已提交
847

848 849
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
850
	if (!wait) {
851
		filemap_flush(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
852 853
		return 0;
	}
854

Y
Yan, Zheng 已提交
855
	btrfs_wait_ordered_extents(root, 0, 0);
856

857 858 859 860 861 862 863 864
	spin_lock(&fs_info->trans_lock);
	if (!fs_info->running_transaction) {
		spin_unlock(&fs_info->trans_lock);
		return 0;
	}
	spin_unlock(&fs_info->trans_lock);

	trans = btrfs_join_transaction(root);
865 866
	if (IS_ERR(trans))
		return PTR_ERR(trans);
867
	return btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
868 869
}

870
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
E
Eric Paris 已提交
871
{
872 873
	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
	struct btrfs_root *root = info->tree_root;
T
Tsutomu Itoh 已提交
874
	char *compress_type;
E
Eric Paris 已提交
875 876 877 878 879 880 881 882 883 884

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

938
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
939
{
940 941
	struct btrfs_fs_info *p = data;
	struct btrfs_fs_info *fs_info = btrfs_sb(s);
Y
Yan 已提交
942

943
	return fs_info->fs_devices == p->fs_devices;
Y
Yan 已提交
944 945
}

946 947
static int btrfs_set_super(struct super_block *s, void *data)
{
A
Al Viro 已提交
948 949 950 951
	int err = set_anon_super(s, data);
	if (!err)
		s->s_fs_info = data;
	return err;
Y
Yan 已提交
952 953
}

954 955 956 957 958 959 960 961 962 963
/*
 * 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;
}

964 965 966 967 968 969 970
/*
 * 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)
{
971 972
	unsigned len = strlen(args) + 2 + 1;
	char *src, *dst, *buf;
973 974

	/*
975 976
	 * We need the same args as before, but with this substitution:
	 * s!subvol=[^,]+!subvolid=0!
977
	 *
978 979
	 * Since the replacement string is up to 2 bytes longer than the
	 * original, allocate strlen(args) + 2 + 1 bytes.
980 981
	 */

982
	src = strstr(args, "subvol=");
983
	/* This shouldn't happen, but just in case.. */
984 985 986 987 988
	if (!src)
		return NULL;

	buf = dst = kmalloc(len, GFP_NOFS);
	if (!buf)
989 990 991
		return NULL;

	/*
992 993
	 * If the subvol= arg is not at the start of the string,
	 * copy whatever precedes it into buf.
994
	 */
995 996 997 998
	if (src != args) {
		*src++ = '\0';
		strcpy(buf, args);
		dst += strlen(args);
999 1000
	}

1001 1002
	strcpy(dst, "subvolid=0");
	dst += strlen("subvolid=0");
1003 1004

	/*
1005 1006
	 * If there is a "," after the original subvol=... string,
	 * copy that suffix into our buffer.  Otherwise, we're done.
1007
	 */
1008 1009 1010
	src = strchr(src, ',');
	if (src)
		strcpy(dst, src);
1011

1012
	return buf;
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
}

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

A
Al Viro 已提交
1033 1034 1035 1036 1037
	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);
1038 1039 1040 1041
		printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
				subvol_name);
	}

1042 1043
	return root;
}
1044

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

1065 1066 1067 1068
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
1069
					  &subvol_name, &subvol_objectid,
1070
					  &subvol_rootid, &fs_devices);
1071 1072
	if (error) {
		kfree(subvol_name);
A
Al Viro 已提交
1073
		return ERR_PTR(error);
1074
	}
1075

1076 1077 1078 1079 1080 1081
	if (subvol_name) {
		root = mount_subvol(subvol_name, flags, device_name, data);
		kfree(subvol_name);
		return root;
	}

1082
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1083
	if (error)
1084
		return ERR_PTR(error);
Y
Yan 已提交
1085

1086 1087 1088 1089 1090 1091 1092
	/*
	 * 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);
1093 1094 1095
	if (!fs_info)
		return ERR_PTR(-ENOMEM);

1096 1097
	fs_info->fs_devices = fs_devices;

1098 1099 1100 1101
	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;
1102 1103 1104 1105 1106 1107 1108 1109 1110
		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;
1111 1112 1113
		goto error_close_devices;
	}

1114
	bdev = fs_devices->latest_bdev;
D
David Howells 已提交
1115 1116
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
		 fs_info);
1117 1118 1119 1120
	if (IS_ERR(s)) {
		error = PTR_ERR(s);
		goto error_close_devices;
	}
Y
Yan 已提交
1121 1122

	if (s->s_root) {
Y
Yan Zheng 已提交
1123
		btrfs_close_devices(fs_devices);
1124
		free_fs_info(fs_info);
1125 1126
		if ((flags ^ s->s_flags) & MS_RDONLY)
			error = -EBUSY;
Y
Yan 已提交
1127 1128 1129 1130
	} else {
		char b[BDEVNAME_SIZE];

		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1131
		btrfs_sb(s)->bdev_holder = fs_type;
1132 1133
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
1134 1135
	}

1136 1137
	root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
	if (IS_ERR(root))
1138
		deactivate_locked_super(s);
Y
Yan 已提交
1139

A
Al Viro 已提交
1140
	return root;
Y
Yan 已提交
1141

Y
Yan Zheng 已提交
1142
error_close_devices:
1143
	btrfs_close_devices(fs_devices);
1144
error_fs_info:
1145
	free_fs_info(fs_info);
A
Al Viro 已提交
1146
	return ERR_PTR(error);
Y
Yan 已提交
1147
}
1148

1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
static void btrfs_set_max_workers(struct btrfs_workers *workers, int new_limit)
{
	spin_lock_irq(&workers->lock);
	workers->max_workers = new_limit;
	spin_unlock_irq(&workers->lock);
}

static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
				     int new_pool_size, int old_pool_size)
{
	if (new_pool_size == old_pool_size)
		return;

	fs_info->thread_pool_size = new_pool_size;

	printk(KERN_INFO "btrfs: resize thread pool %d -> %d\n",
	       old_pool_size, new_pool_size);

	btrfs_set_max_workers(&fs_info->generic_worker, new_pool_size);
	btrfs_set_max_workers(&fs_info->workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->delalloc_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->submit_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->caching_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->fixup_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_meta_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_meta_write_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_write_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->endio_freespace_worker, new_pool_size);
	btrfs_set_max_workers(&fs_info->delayed_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->readahead_workers, new_pool_size);
	btrfs_set_max_workers(&fs_info->scrub_workers, new_pool_size);
}

Y
Yan Zheng 已提交
1183 1184
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
1185 1186
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *root = fs_info->tree_root;
1187 1188 1189 1190 1191 1192 1193
	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 已提交
1194 1195
	int ret;

1196
	ret = btrfs_parse_options(root, data);
1197 1198 1199 1200
	if (ret) {
		ret = -EINVAL;
		goto restore;
	}
1201

1202 1203 1204
	btrfs_resize_thread_pool(fs_info,
		fs_info->thread_pool_size, old_thread_pool_size);

Y
Yan Zheng 已提交
1205 1206 1207 1208 1209 1210
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
		return 0;

	if (*flags & MS_RDONLY) {
		sb->s_flags |= MS_RDONLY;

1211 1212 1213
		ret = btrfs_commit_super(root);
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1214
	} else {
1215
		if (fs_info->fs_devices->rw_devices == 0) {
1216 1217
			ret = -EACCES;
			goto restore;
1218
		}
Y
Yan Zheng 已提交
1219

1220
		if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1221 1222
			ret = -EINVAL;
			goto restore;
1223
		}
Y
Yan Zheng 已提交
1224

1225
		ret = btrfs_cleanup_fs_roots(fs_info);
1226 1227
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1228

1229 1230
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
1231 1232
		if (ret)
			goto restore;
Y
Yan Zheng 已提交
1233

1234 1235 1236 1237
		ret = btrfs_resume_balance_async(fs_info);
		if (ret)
			goto restore;

Y
Yan Zheng 已提交
1238 1239 1240 1241
		sb->s_flags &= ~MS_RDONLY;
	}

	return 0;
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251

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;
	fs_info->alloc_start = old_alloc_start;
1252 1253
	btrfs_resize_thread_pool(fs_info,
		old_thread_pool_size, fs_info->thread_pool_size);
1254 1255
	fs_info->metadata_ratio = old_metadata_ratio;
	return ret;
Y
Yan Zheng 已提交
1256 1257
}

1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
/* 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);
}

1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
/*
 * 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;
1299
	int min_stripes = 1, num_stripes = 1;
1300 1301 1302
	int i = 0, nr_devices;
	int ret;

1303
	nr_devices = fs_info->fs_devices->open_devices;
1304 1305 1306 1307 1308 1309 1310 1311 1312
	BUG_ON(!nr_devices);

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

	/* calc min stripe number for data space alloction */
	type = btrfs_get_alloc_profile(root, 1);
1313
	if (type & BTRFS_BLOCK_GROUP_RAID0) {
1314
		min_stripes = 2;
1315 1316
		num_stripes = nr_devices;
	} else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1317
		min_stripes = 2;
1318 1319
		num_stripes = 2;
	} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1320
		min_stripes = 4;
1321 1322
		num_stripes = 4;
	}
1323 1324 1325 1326 1327 1328

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

1329 1330
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
		if (!device->in_fs_metadata || !device->bdev)
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 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 1382 1383 1384 1385 1386 1387 1388 1389 1390
			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) {
1391 1392 1393
		if (num_stripes > nr_devices)
			num_stripes = nr_devices;

1394 1395 1396 1397
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

1398
			avail_space += devices_info[i].max_avail * num_stripes;
1399
			alloc_size = devices_info[i].max_avail;
1400
			for (j = i + 1 - num_stripes; j <= i; j++)
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1412 1413
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
1414 1415 1416
	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;
1417 1418
	struct btrfs_space_info *found;
	u64 total_used = 0;
1419
	u64 total_free_data = 0;
1420
	int bits = dentry->d_sb->s_blocksize_bits;
1421
	__be32 *fsid = (__be32 *)fs_info->fsid;
1422
	int ret;
C
Chris Mason 已提交
1423

1424
	/* holding chunk_muext to avoid allocating new chunks */
1425
	mutex_lock(&fs_info->chunk_mutex);
1426
	rcu_read_lock();
J
Josef Bacik 已提交
1427
	list_for_each_entry_rcu(found, head, list) {
1428 1429 1430 1431 1432 1433
		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);
		}

1434
		total_used += found->disk_used;
J
Josef Bacik 已提交
1435
	}
1436 1437
	rcu_read_unlock();

C
Chris Mason 已提交
1438
	buf->f_namelen = BTRFS_NAME_LEN;
1439
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1440
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1441 1442
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1443
	buf->f_bavail = total_free_data;
1444
	ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1445
	if (ret) {
1446
		mutex_unlock(&fs_info->chunk_mutex);
1447 1448 1449 1450
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
1451
	mutex_unlock(&fs_info->chunk_mutex);
C
Chris Mason 已提交
1452

1453
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1454
	   because we want the fsid to come out the same whether mounted
1455 1456 1457
	   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]);
1458 1459 1460 1461
	/* 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 已提交
1462 1463
	return 0;
}
C
Chris Mason 已提交
1464

A
Al Viro 已提交
1465 1466
static void btrfs_kill_super(struct super_block *sb)
{
1467
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
A
Al Viro 已提交
1468
	kill_anon_super(sb);
1469
	free_fs_info(fs_info);
A
Al Viro 已提交
1470 1471
}

1472 1473 1474
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1475
	.mount		= btrfs_mount,
A
Al Viro 已提交
1476
	.kill_sb	= btrfs_kill_super,
1477 1478
	.fs_flags	= FS_REQUIRES_DEV,
};
1479

C
Chris Mason 已提交
1480 1481 1482
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1483 1484 1485 1486 1487
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;
1488
	int ret = -ENOTTY;
1489

1490 1491 1492
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1493 1494 1495
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1496

1497 1498
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1499
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1500 1501
					    &btrfs_fs_type, &fs_devices);
		break;
J
Josef Bacik 已提交
1502 1503 1504 1505 1506 1507 1508
	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;
1509
	}
L
Li Zefan 已提交
1510

1511
	kfree(vol);
L
Linda Knippers 已提交
1512
	return ret;
1513 1514
}

1515
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1516
{
1517 1518 1519
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	mutex_lock(&fs_info->transaction_kthread_mutex);
	mutex_lock(&fs_info->cleaner_mutex);
1520
	return 0;
Y
Yan 已提交
1521 1522
}

1523
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1524
{
1525 1526 1527
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	mutex_unlock(&fs_info->cleaner_mutex);
	mutex_unlock(&fs_info->transaction_kthread_mutex);
1528
	return 0;
Y
Yan 已提交
1529
}
1530

J
Josef Bacik 已提交
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
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) {
1544 1545
			if (dev->missing)
				continue;
J
Josef Bacik 已提交
1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
			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;
}

1564
static const struct super_operations btrfs_super_ops = {
1565
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1566
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1567
	.put_super	= btrfs_put_super,
1568
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1569
	.show_options	= btrfs_show_options,
J
Josef Bacik 已提交
1570
	.show_devname	= btrfs_show_devname,
C
Chris Mason 已提交
1571
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1572 1573
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1574
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1575
	.remount_fs	= btrfs_remount,
1576 1577
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1578
};
1579 1580 1581 1582 1583

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1584
	.llseek = noop_llseek,
1585 1586 1587
};

static struct miscdevice btrfs_misc = {
1588
	.minor		= BTRFS_MINOR,
1589 1590 1591 1592
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1593 1594 1595
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1596 1597 1598 1599 1600
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1601
static void btrfs_interface_exit(void)
1602 1603
{
	if (misc_deregister(&btrfs_misc) < 0)
C
Chris Mason 已提交
1604
		printk(KERN_INFO "misc_deregister failed for control device");
1605 1606
}

1607 1608
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1609
	int err;
1610 1611 1612 1613 1614

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

1615
	btrfs_init_compress();
1616

1617 1618 1619 1620
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1621
	err = extent_io_init();
1622 1623 1624
	if (err)
		goto free_cachep;

1625 1626 1627 1628
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1629
	err = ordered_data_init();
1630 1631
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1632

1633 1634 1635 1636
	err = btrfs_delayed_inode_init();
	if (err)
		goto free_ordered_data;

1637 1638 1639 1640
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_inode;

1641 1642 1643
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
1644

1645 1646
	btrfs_init_lockdep();

1647
	printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1648 1649
	return 0;

1650 1651
unregister_ioctl:
	btrfs_interface_exit();
1652 1653
free_delayed_inode:
	btrfs_delayed_inode_exit();
1654 1655
free_ordered_data:
	ordered_data_exit();
1656 1657
free_extent_map:
	extent_map_exit();
1658 1659
free_extent_io:
	extent_io_exit();
1660 1661
free_cachep:
	btrfs_destroy_cachep();
1662 1663
free_compress:
	btrfs_exit_compress();
1664 1665
	btrfs_exit_sysfs();
	return err;
1666 1667 1668 1669
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1670
	btrfs_destroy_cachep();
1671
	btrfs_delayed_inode_exit();
1672
	ordered_data_exit();
1673
	extent_map_exit();
1674
	extent_io_exit();
1675
	btrfs_interface_exit();
1676
	unregister_filesystem(&btrfs_fs_type);
1677
	btrfs_exit_sysfs();
1678
	btrfs_cleanup_fs_uuids();
1679
	btrfs_exit_compress();
1680 1681 1682 1683 1684 1685
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");