super.c 22.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>
C
Chris Mason 已提交
42
#include "compat.h"
43
#include "ctree.h"
C
Chris Mason 已提交
44
#include "disk-io.h"
45
#include "transaction.h"
C
Chris Mason 已提交
46
#include "btrfs_inode.h"
C
Chris Mason 已提交
47
#include "ioctl.h"
C
Chris Mason 已提交
48
#include "print-tree.h"
J
Josef Bacik 已提交
49
#include "xattr.h"
50
#include "volumes.h"
51
#include "version.h"
B
Balaji Rao 已提交
52
#include "export.h"
C
Chris Mason 已提交
53
#include "compression.h"
54

55
static const struct super_operations btrfs_super_ops;
C
Chris Mason 已提交
56

C
Chris Mason 已提交
57
static void btrfs_put_super(struct super_block *sb)
C
Chris Mason 已提交
58
{
C
Chris Mason 已提交
59
	struct btrfs_root *root = btrfs_sb(sb);
C
Chris Mason 已提交
60 61
	int ret;

C
Chris Mason 已提交
62 63
	ret = close_ctree(root);
	sb->s_fs_info = NULL;
64 65

	(void)ret; /* FIXME: need to fix VFS to return error? */
C
Chris Mason 已提交
66 67
}

68
enum {
69
	Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
70 71 72
	Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
	Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
	Opt_compress_force, Opt_notreelog, Opt_ratio, Opt_flushoncommit,
73
	Opt_discard, Opt_space_cache, Opt_clear_cache, Opt_err,
74 75 76
};

static match_table_t tokens = {
77
	{Opt_degraded, "degraded"},
78
	{Opt_subvol, "subvol=%s"},
79
	{Opt_subvolid, "subvolid=%d"},
80
	{Opt_device, "device=%s"},
81
	{Opt_nodatasum, "nodatasum"},
82
	{Opt_nodatacow, "nodatacow"},
83
	{Opt_nobarrier, "nobarrier"},
84
	{Opt_max_inline, "max_inline=%s"},
85
	{Opt_alloc_start, "alloc_start=%s"},
86
	{Opt_thread_pool, "thread_pool=%d"},
C
Chris Mason 已提交
87
	{Opt_compress, "compress"},
C
Chris Mason 已提交
88
	{Opt_compress_force, "compress-force"},
89
	{Opt_ssd, "ssd"},
90
	{Opt_ssd_spread, "ssd_spread"},
C
Chris Mason 已提交
91
	{Opt_nossd, "nossd"},
J
Josef Bacik 已提交
92
	{Opt_noacl, "noacl"},
S
Sage Weil 已提交
93
	{Opt_notreelog, "notreelog"},
94
	{Opt_flushoncommit, "flushoncommit"},
95
	{Opt_ratio, "metadata_ratio=%d"},
C
Christoph Hellwig 已提交
96
	{Opt_discard, "discard"},
97
	{Opt_space_cache, "space_cache"},
98
	{Opt_clear_cache, "clear_cache"},
J
Josef Bacik 已提交
99
	{Opt_err, NULL},
100 101
};

102 103 104 105 106
/*
 * Regular mount options parser.  Everything that is needed only when
 * reading in a new superblock is parsed here.
 */
int btrfs_parse_options(struct btrfs_root *root, char *options)
107
{
108
	struct btrfs_fs_info *info = root->fs_info;
109
	substring_t args[MAX_OPT_ARGS];
110
	char *p, *num, *orig;
111
	int intarg;
S
Sage Weil 已提交
112
	int ret = 0;
113

114
	if (!options)
115
		return 0;
116

117 118 119 120 121 122 123 124
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

125
	orig = options;
126

127
	while ((p = strsep(&options, ",")) != NULL) {
128 129 130 131 132 133
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
134
		case Opt_degraded:
135 136
			printk(KERN_INFO "btrfs: allowing degraded mounts\n");
			btrfs_set_opt(info->mount_opt, DEGRADED);
137
			break;
138
		case Opt_subvol:
139
		case Opt_subvolid:
140
		case Opt_device:
141
			/*
142
			 * These are parsed by btrfs_parse_early_options
143 144
			 * and can be happily ignored here.
			 */
145 146
			break;
		case Opt_nodatasum:
147
			printk(KERN_INFO "btrfs: setting nodatasum\n");
148
			btrfs_set_opt(info->mount_opt, NODATASUM);
149 150
			break;
		case Opt_nodatacow:
151 152 153
			printk(KERN_INFO "btrfs: setting nodatacow\n");
			btrfs_set_opt(info->mount_opt, NODATACOW);
			btrfs_set_opt(info->mount_opt, NODATASUM);
154
			break;
C
Chris Mason 已提交
155 156 157 158
		case Opt_compress:
			printk(KERN_INFO "btrfs: use compression\n");
			btrfs_set_opt(info->mount_opt, COMPRESS);
			break;
C
Chris Mason 已提交
159 160 161 162 163
		case Opt_compress_force:
			printk(KERN_INFO "btrfs: forcing compression\n");
			btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
			btrfs_set_opt(info->mount_opt, COMPRESS);
			break;
164
		case Opt_ssd:
165 166
			printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
			btrfs_set_opt(info->mount_opt, SSD);
167
			break;
168 169 170 171 172 173
		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 已提交
174
		case Opt_nossd:
175 176
			printk(KERN_INFO "btrfs: not using ssd allocation "
			       "scheme\n");
C
Chris Mason 已提交
177
			btrfs_set_opt(info->mount_opt, NOSSD);
C
Chris Mason 已提交
178
			btrfs_clear_opt(info->mount_opt, SSD);
179
			btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
C
Chris Mason 已提交
180
			break;
181
		case Opt_nobarrier:
182 183
			printk(KERN_INFO "btrfs: turning off barriers\n");
			btrfs_set_opt(info->mount_opt, NOBARRIER);
184
			break;
185 186 187 188 189 190 191 192 193
		case Opt_thread_pool:
			intarg = 0;
			match_int(&args[0], &intarg);
			if (intarg) {
				info->thread_pool_size = intarg;
				printk(KERN_INFO "btrfs: thread pool %d\n",
				       info->thread_pool_size);
			}
			break;
194
		case Opt_max_inline:
195 196
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
197
				info->max_inline = memparse(num, NULL);
198 199
				kfree(num);

C
Chris Mason 已提交
200 201 202 203 204
				if (info->max_inline) {
					info->max_inline = max_t(u64,
						info->max_inline,
						root->sectorsize);
				}
205
				printk(KERN_INFO "btrfs: max_inline at %llu\n",
206
					(unsigned long long)info->max_inline);
207 208
			}
			break;
209
		case Opt_alloc_start:
210 211
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
212
				info->alloc_start = memparse(num, NULL);
213 214 215
				kfree(num);
				printk(KERN_INFO
					"btrfs: allocations start at %llu\n",
216
					(unsigned long long)info->alloc_start);
217 218
			}
			break;
J
Josef Bacik 已提交
219 220 221
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
222 223 224 225
		case Opt_notreelog:
			printk(KERN_INFO "btrfs: disabling tree log\n");
			btrfs_set_opt(info->mount_opt, NOTREELOG);
			break;
226 227 228 229
		case Opt_flushoncommit:
			printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
			btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
			break;
230 231 232 233 234 235 236 237 238
		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 已提交
239 240 241
		case Opt_discard:
			btrfs_set_opt(info->mount_opt, DISCARD);
			break;
242 243 244
		case Opt_space_cache:
			printk(KERN_INFO "btrfs: enabling disk space caching\n");
			btrfs_set_opt(info->mount_opt, SPACE_CACHE);
245 246 247
		case Opt_clear_cache:
			printk(KERN_INFO "btrfs: force clearing of disk cache\n");
			btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
248
			break;
S
Sage Weil 已提交
249 250 251 252 253
		case Opt_err:
			printk(KERN_INFO "btrfs: unrecognized mount option "
			       "'%s'\n", p);
			ret = -EINVAL;
			goto out;
254
		default:
255
			break;
256 257
		}
	}
S
Sage Weil 已提交
258
out:
259
	kfree(orig);
S
Sage Weil 已提交
260
	return ret;
261 262 263 264 265 266 267 268
}

/*
 * 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.
 */
269
static int btrfs_parse_early_options(const char *options, fmode_t flags,
270
		void *holder, char **subvol_name, u64 *subvol_objectid,
271
		struct btrfs_fs_devices **fs_devices)
272 273 274 275
{
	substring_t args[MAX_OPT_ARGS];
	char *opts, *p;
	int error = 0;
276
	int intarg;
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

	if (!options)
		goto out;

	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	opts = kstrdup(options, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;

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

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
			*subvol_name = match_strdup(&args[0]);
			break;
299 300
		case Opt_subvolid:
			intarg = 0;
301 302 303 304 305 306 307 308 309
			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;
			}
310
			break;
311 312 313 314 315 316
		case Opt_device:
			error = btrfs_scan_one_device(match_strdup(&args[0]),
					flags, holder, fs_devices);
			if (error)
				goto out_free_opts;
			break;
317 318 319 320 321
		default:
			break;
		}
	}

322
 out_free_opts:
323 324 325 326
	kfree(opts);
 out:
	/*
	 * If no subvolume name is specified we use the default one.  Allocate
327
	 * a copy of the string "." here so that code later in the
328 329 330
	 * mount path doesn't care if it's the default volume or another one.
	 */
	if (!*subvol_name) {
331
		*subvol_name = kstrdup(".", GFP_KERNEL);
332 333 334 335
		if (!*subvol_name)
			return -ENOMEM;
	}
	return error;
336 337
}

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
static struct dentry *get_default_root(struct super_block *sb,
				       u64 subvol_objectid)
{
	struct btrfs_root *root = sb->s_fs_info;
	struct btrfs_root *new_root;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_key location;
	struct inode *inode;
	struct dentry *dentry;
	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.
	 */
	dir_id = btrfs_super_root_dir(&root->fs_info->super_copy);
	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
374 375
	if (IS_ERR(di))
		return ERR_CAST(di);
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
	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;
		new_root = root->fs_info->fs_root;
		goto setup_root;
	}

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

find_root:
	new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
	if (IS_ERR(new_root))
J
Julia Lawall 已提交
394
		return ERR_CAST(new_root);
395 396 397 398 399 400 401 402 403 404 405

	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);
406 407
	if (IS_ERR(inode))
		return ERR_CAST(inode);
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

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

	if (new) {
		const struct qstr name = { .name = "/", .len = 1 };

		/*
		 * New inode, we need to make the dentry a sibling of s_root so
		 * everything gets cleaned up properly on unmount.
		 */
		dentry = d_alloc(sb->s_root, &name);
		if (!dentry) {
			iput(inode);
			return ERR_PTR(-ENOMEM);
		}
		d_splice_alias(inode, dentry);
	} else {
		/*
		 * We found the inode in cache, just find a dentry for it and
		 * put the reference to the inode we just got.
		 */
		dentry = d_find_alias(inode);
		iput(inode);
	}

	return dentry;
}

C
Chris Mason 已提交
444
static int btrfs_fill_super(struct super_block *sb,
445
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
446
			    void *data, int silent)
C
Chris Mason 已提交
447
{
C
Chris Mason 已提交
448 449
	struct inode *inode;
	struct dentry *root_dentry;
C
Chris Mason 已提交
450
	struct btrfs_root *tree_root;
451
	struct btrfs_key key;
C
Chris Mason 已提交
452
	int err;
453

C
Chris Mason 已提交
454 455 456
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
B
Balaji Rao 已提交
457
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
458
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
459
	sb->s_time_gran = 1;
C
Chris Mason 已提交
460
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
461
	sb->s_flags |= MS_POSIXACL;
462
#endif
463

464
	tree_root = open_ctree(sb, fs_devices, (char *)data);
465

466
	if (IS_ERR(tree_root)) {
C
Chris Mason 已提交
467
		printk("btrfs: open_ctree failed\n");
468
		return PTR_ERR(tree_root);
469
	}
C
Chris Mason 已提交
470
	sb->s_fs_info = tree_root;
471

472 473 474
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
475
	inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
476 477
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
478
		goto fail_close;
C
Chris Mason 已提交
479 480
	}

C
Chris Mason 已提交
481 482 483 484 485
	root_dentry = d_alloc_root(inode);
	if (!root_dentry) {
		iput(inode);
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
486
	}
487

C
Chris Mason 已提交
488
	sb->s_root = root_dentry;
C
Chris Mason 已提交
489 490

	save_mount_options(sb, data);
C
Chris Mason 已提交
491
	return 0;
C
Chris Mason 已提交
492 493 494 495

fail_close:
	close_ctree(tree_root);
	return err;
C
Chris Mason 已提交
496 497
}

S
Sage Weil 已提交
498
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
499 500
{
	struct btrfs_trans_handle *trans;
501
	struct btrfs_root *root = btrfs_sb(sb);
C
Chris Mason 已提交
502
	int ret;
C
Chris Mason 已提交
503

C
Chris Mason 已提交
504 505 506 507
	if (!wait) {
		filemap_flush(root->fs_info->btree_inode->i_mapping);
		return 0;
	}
508

Y
Yan, Zheng 已提交
509 510
	btrfs_start_delalloc_inodes(root, 0);
	btrfs_wait_ordered_extents(root, 0, 0);
511

512
	trans = btrfs_start_transaction(root, 0);
C
Chris Mason 已提交
513
	ret = btrfs_commit_transaction(trans, root);
514
	return ret;
C
Chris Mason 已提交
515 516
}

E
Eric Paris 已提交
517 518 519 520 521 522 523 524 525 526 527 528 529 530
static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
{
	struct btrfs_root *root = btrfs_sb(vfs->mnt_sb);
	struct btrfs_fs_info *info = root->fs_info;

	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)
531 532
		seq_printf(seq, ",max_inline=%llu",
			   (unsigned long long)info->max_inline);
E
Eric Paris 已提交
533
	if (info->alloc_start != 0)
534 535
		seq_printf(seq, ",alloc_start=%llu",
			   (unsigned long long)info->alloc_start);
E
Eric Paris 已提交
536 537 538 539 540
	if (info->thread_pool_size !=  min_t(unsigned long,
					     num_online_cpus() + 2, 8))
		seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
	if (btrfs_test_opt(root, COMPRESS))
		seq_puts(seq, ",compress");
C
Chris Mason 已提交
541 542
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
543 544 545
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
546
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
547
	if (btrfs_test_opt(root, NOTREELOG))
548
		seq_puts(seq, ",notreelog");
549
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
550
		seq_puts(seq, ",flushoncommit");
551 552
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
553 554 555 556 557
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
	return 0;
}

558
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
559
{
560 561
	struct btrfs_fs_devices *test_fs_devices = data;
	struct btrfs_root *root = btrfs_sb(s);
Y
Yan 已提交
562

563
	return root->fs_info->fs_devices == test_fs_devices;
Y
Yan 已提交
564 565
}

566 567 568 569 570 571 572 573
/*
 * 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.
 */
static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
		const char *dev_name, void *data, struct vfsmount *mnt)
Y
Yan 已提交
574 575 576 577
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
578
	struct btrfs_fs_devices *fs_devices = NULL;
579
	fmode_t mode = FMODE_READ;
580 581
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
Y
Yan 已提交
582 583
	int error = 0;

584 585 586 587
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
588 589
					  &subvol_name, &subvol_objectid,
					  &fs_devices);
590
	if (error)
591
		return error;
592

593
	error = btrfs_scan_one_device(dev_name, mode, fs_type, &fs_devices);
594
	if (error)
595
		goto error_free_subvol_name;
Y
Yan 已提交
596

597
	error = btrfs_open_devices(fs_devices, mode, fs_type);
598
	if (error)
599
		goto error_free_subvol_name;
600

Y
Yan Zheng 已提交
601 602 603 604 605
	if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
		error = -EACCES;
		goto error_close_devices;
	}

606
	bdev = fs_devices->latest_bdev;
607
	s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
Y
Yan 已提交
608 609 610 611 612
	if (IS_ERR(s))
		goto error_s;

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
613
			deactivate_locked_super(s);
Y
Yan 已提交
614
			error = -EBUSY;
Y
Yan Zheng 已提交
615
			goto error_close_devices;
Y
Yan 已提交
616 617
		}

Y
Yan Zheng 已提交
618
		btrfs_close_devices(fs_devices);
Y
Yan 已提交
619 620 621 622 623
	} else {
		char b[BDEVNAME_SIZE];

		s->s_flags = flags;
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
624 625
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
626
		if (error) {
627
			deactivate_locked_super(s);
628
			goto error_free_subvol_name;
Y
Yan 已提交
629 630
		}

631
		btrfs_sb(s)->fs_info->bdev_holder = fs_type;
Y
Yan 已提交
632 633 634
		s->s_flags |= MS_ACTIVE;
	}

635 636 637 638
	root = get_default_root(s, subvol_objectid);
	if (IS_ERR(root)) {
		error = PTR_ERR(root);
		deactivate_locked_super(s);
639
		goto error_free_subvol_name;
640 641 642 643 644 645
	}
	/* if they gave us a subvolume name bind mount into that */
	if (strcmp(subvol_name, ".")) {
		struct dentry *new_root;
		mutex_lock(&root->d_inode->i_mutex);
		new_root = lookup_one_len(subvol_name, root,
C
Chris Mason 已提交
646
				      strlen(subvol_name));
647
		mutex_unlock(&root->d_inode->i_mutex);
C
Chris Mason 已提交
648

649
		if (IS_ERR(new_root)) {
650
			deactivate_locked_super(s);
651 652
			error = PTR_ERR(new_root);
			dput(root);
653
			goto error_free_subvol_name;
654
		}
655
		if (!new_root->d_inode) {
656
			dput(root);
657
			dput(new_root);
658
			deactivate_locked_super(s);
659
			error = -ENXIO;
660
			goto error_free_subvol_name;
661
		}
662 663
		dput(root);
		root = new_root;
Y
Yan 已提交
664 665 666 667
	}

	mnt->mnt_sb = s;
	mnt->mnt_root = root;
668 669

	kfree(subvol_name);
Y
Yan 已提交
670 671 672 673
	return 0;

error_s:
	error = PTR_ERR(s);
Y
Yan Zheng 已提交
674
error_close_devices:
675
	btrfs_close_devices(fs_devices);
676 677
error_free_subvol_name:
	kfree(subvol_name);
Y
Yan 已提交
678 679
	return error;
}
680

Y
Yan Zheng 已提交
681 682 683 684 685
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
	struct btrfs_root *root = btrfs_sb(sb);
	int ret;

686 687 688 689
	ret = btrfs_parse_options(root, data);
	if (ret)
		return -EINVAL;

Y
Yan Zheng 已提交
690 691 692 693 694 695 696 697 698
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
		return 0;

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

		ret =  btrfs_commit_super(root);
		WARN_ON(ret);
	} else {
Y
Yan Zheng 已提交
699 700 701
		if (root->fs_info->fs_devices->rw_devices == 0)
			return -EACCES;

Y
Yan Zheng 已提交
702 703 704
		if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
			return -EINVAL;

705
		ret = btrfs_cleanup_fs_roots(root->fs_info);
Y
Yan Zheng 已提交
706 707
		WARN_ON(ret);

708 709
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
Y
Yan Zheng 已提交
710 711 712 713 714 715 716 717
		WARN_ON(ret);

		sb->s_flags &= ~MS_RDONLY;
	}

	return 0;
}

C
Chris Mason 已提交
718 719 720
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct btrfs_root *root = btrfs_sb(dentry->d_sb);
721
	struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
722 723 724
	struct list_head *head = &root->fs_info->space_info;
	struct btrfs_space_info *found;
	u64 total_used = 0;
J
Josef Bacik 已提交
725
	u64 total_used_data = 0;
726
	int bits = dentry->d_sb->s_blocksize_bits;
727
	__be32 *fsid = (__be32 *)root->fs_info->fsid;
C
Chris Mason 已提交
728

729
	rcu_read_lock();
J
Josef Bacik 已提交
730 731 732 733 734 735
	list_for_each_entry_rcu(found, head, list) {
		if (found->flags & (BTRFS_BLOCK_GROUP_METADATA |
				    BTRFS_BLOCK_GROUP_SYSTEM))
			total_used_data += found->disk_total;
		else
			total_used_data += found->disk_used;
736
		total_used += found->disk_used;
J
Josef Bacik 已提交
737
	}
738 739
	rcu_read_unlock();

C
Chris Mason 已提交
740
	buf->f_namelen = BTRFS_NAME_LEN;
741
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
742
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
J
Josef Bacik 已提交
743
	buf->f_bavail = buf->f_blocks - (total_used_data >> bits);
C
Chris Mason 已提交
744 745
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
C
Chris Mason 已提交
746

747
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
748
	   because we want the fsid to come out the same whether mounted
749 750 751
	   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]);
752 753 754 755
	/* 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 已提交
756 757
	return 0;
}
C
Chris Mason 已提交
758

759 760 761 762
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
	.get_sb		= btrfs_get_sb,
763
	.kill_sb	= kill_anon_super,
764 765
	.fs_flags	= FS_REQUIRES_DEV,
};
766

C
Chris Mason 已提交
767 768 769
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
770 771 772 773 774
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;
775
	int ret = -ENOTTY;
776

777 778 779
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
780 781 782
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
783

784 785
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
786
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
787 788 789
					    &btrfs_fs_type, &fs_devices);
		break;
	}
L
Li Zefan 已提交
790

791
	kfree(vol);
L
Linda Knippers 已提交
792
	return ret;
793 794
}

795
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
796 797
{
	struct btrfs_root *root = btrfs_sb(sb);
798 799
	mutex_lock(&root->fs_info->transaction_kthread_mutex);
	mutex_lock(&root->fs_info->cleaner_mutex);
800
	return 0;
Y
Yan 已提交
801 802
}

803
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
804 805
{
	struct btrfs_root *root = btrfs_sb(sb);
806 807
	mutex_unlock(&root->fs_info->cleaner_mutex);
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);
808
	return 0;
Y
Yan 已提交
809
}
810

811
static const struct super_operations btrfs_super_ops = {
812
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
813
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
814
	.put_super	= btrfs_put_super,
815
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
816
	.show_options	= btrfs_show_options,
C
Chris Mason 已提交
817
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
818
	.dirty_inode	= btrfs_dirty_inode,
C
Chris Mason 已提交
819 820
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
821
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
822
	.remount_fs	= btrfs_remount,
823 824
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
825
};
826 827 828 829 830 831 832 833

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
};

static struct miscdevice btrfs_misc = {
834
	.minor		= BTRFS_MINOR,
835 836 837 838
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

839 840 841
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

842 843 844 845 846
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

847
static void btrfs_interface_exit(void)
848 849
{
	if (misc_deregister(&btrfs_misc) < 0)
C
Chris Mason 已提交
850
		printk(KERN_INFO "misc_deregister failed for control device");
851 852
}

853 854
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
855
	int err;
856 857 858 859 860

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

C
Chris Mason 已提交
861
	err = btrfs_init_cachep();
C
Chris Mason 已提交
862
	if (err)
863
		goto free_sysfs;
864 865

	err = extent_io_init();
866 867 868
	if (err)
		goto free_cachep;

869 870 871 872
	err = extent_map_init();
	if (err)
		goto free_extent_io;

873
	err = btrfs_interface_init();
874 875
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
876

877 878 879
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
880 881

	printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
882 883
	return 0;

884 885
unregister_ioctl:
	btrfs_interface_exit();
886 887
free_extent_map:
	extent_map_exit();
888 889
free_extent_io:
	extent_io_exit();
890 891
free_cachep:
	btrfs_destroy_cachep();
892
free_sysfs:
893 894
	btrfs_exit_sysfs();
	return err;
895 896 897 898
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
899
	btrfs_destroy_cachep();
900
	extent_map_exit();
901
	extent_io_exit();
902
	btrfs_interface_exit();
903
	unregister_filesystem(&btrfs_fs_type);
904
	btrfs_exit_sysfs();
905
	btrfs_cleanup_fs_uuids();
C
Chris Mason 已提交
906
	btrfs_zlib_exit();
907 908 909 910 911 912
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");