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

57 58 59
#define CREATE_TRACE_POINTS
#include <trace/events/btrfs.h>

60
static const struct super_operations btrfs_super_ops;
C
Chris Mason 已提交
61

L
liubo 已提交
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 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 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
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;
	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;
}

/* NOTE:
 *	We move write_super stuff at umount in order to avoid deadlock
 *	for umount hold all lock.
 */
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");
	}
}

/*
 * __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,
		     unsigned int line, int errno)
{
	struct super_block *sb = fs_info->sb;
	char nbuf[16];
	const char *errstr;

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

	errstr = btrfs_decode_error(fs_info, errno, nbuf);
	printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
		sb->s_id, function, line, errstr);
	save_error_info(fs_info);

	btrfs_handle_error(fs_info);
}

C
Chris Mason 已提交
146
static void btrfs_put_super(struct super_block *sb)
C
Chris Mason 已提交
147
{
C
Chris Mason 已提交
148
	struct btrfs_root *root = btrfs_sb(sb);
C
Chris Mason 已提交
149 150
	int ret;

C
Chris Mason 已提交
151 152
	ret = close_ctree(root);
	sb->s_fs_info = NULL;
153 154

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

157
enum {
158
	Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
159 160
	Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
	Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
161 162
	Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
	Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
163
	Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
C
Chris Mason 已提交
164 165
	Opt_enospc_debug, Opt_subvolrootid, Opt_defrag,
	Opt_inode_cache, Opt_err,
166 167 168
};

static match_table_t tokens = {
169
	{Opt_degraded, "degraded"},
170
	{Opt_subvol, "subvol=%s"},
171
	{Opt_subvolid, "subvolid=%d"},
172
	{Opt_device, "device=%s"},
173
	{Opt_nodatasum, "nodatasum"},
174
	{Opt_nodatacow, "nodatacow"},
175
	{Opt_nobarrier, "nobarrier"},
176
	{Opt_max_inline, "max_inline=%s"},
177
	{Opt_alloc_start, "alloc_start=%s"},
178
	{Opt_thread_pool, "thread_pool=%d"},
C
Chris Mason 已提交
179
	{Opt_compress, "compress"},
180
	{Opt_compress_type, "compress=%s"},
C
Chris Mason 已提交
181
	{Opt_compress_force, "compress-force"},
182
	{Opt_compress_force_type, "compress-force=%s"},
183
	{Opt_ssd, "ssd"},
184
	{Opt_ssd_spread, "ssd_spread"},
C
Chris Mason 已提交
185
	{Opt_nossd, "nossd"},
J
Josef Bacik 已提交
186
	{Opt_noacl, "noacl"},
S
Sage Weil 已提交
187
	{Opt_notreelog, "notreelog"},
188
	{Opt_flushoncommit, "flushoncommit"},
189
	{Opt_ratio, "metadata_ratio=%d"},
C
Christoph Hellwig 已提交
190
	{Opt_discard, "discard"},
191
	{Opt_space_cache, "space_cache"},
192
	{Opt_clear_cache, "clear_cache"},
193
	{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
194
	{Opt_enospc_debug, "enospc_debug"},
195
	{Opt_subvolrootid, "subvolrootid=%d"},
C
Chris Mason 已提交
196
	{Opt_defrag, "autodefrag"},
C
Chris Mason 已提交
197
	{Opt_inode_cache, "inode_cache"},
J
Josef Bacik 已提交
198
	{Opt_err, NULL},
199 200
};

201 202 203 204 205
/*
 * 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)
206
{
207
	struct btrfs_fs_info *info = root->fs_info;
208
	substring_t args[MAX_OPT_ARGS];
209
	char *p, *num, *orig;
210
	int intarg;
S
Sage Weil 已提交
211
	int ret = 0;
212 213
	char *compress_type;
	bool compress_force = false;
214

215
	if (!options)
216
		return 0;
217

218 219 220 221 222 223 224 225
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

226
	orig = options;
227

228
	while ((p = strsep(&options, ",")) != NULL) {
229 230 231 232 233 234
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
235
		case Opt_degraded:
236 237
			printk(KERN_INFO "btrfs: allowing degraded mounts\n");
			btrfs_set_opt(info->mount_opt, DEGRADED);
238
			break;
239
		case Opt_subvol:
240
		case Opt_subvolid:
241
		case Opt_subvolrootid:
242
		case Opt_device:
243
			/*
244
			 * These are parsed by btrfs_parse_early_options
245 246
			 * and can be happily ignored here.
			 */
247 248
			break;
		case Opt_nodatasum:
249
			printk(KERN_INFO "btrfs: setting nodatasum\n");
250
			btrfs_set_opt(info->mount_opt, NODATASUM);
251 252
			break;
		case Opt_nodatacow:
253 254 255
			printk(KERN_INFO "btrfs: setting nodatacow\n");
			btrfs_set_opt(info->mount_opt, NODATACOW);
			btrfs_set_opt(info->mount_opt, NODATASUM);
256
			break;
C
Chris Mason 已提交
257
		case Opt_compress_force:
258 259 260 261 262 263 264 265 266
		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;
L
Li Zefan 已提交
267 268 269
			} else if (strcmp(args[0].from, "lzo") == 0) {
				compress_type = "lzo";
				info->compress_type = BTRFS_COMPRESS_LZO;
270 271 272 273 274
			} else {
				ret = -EINVAL;
				goto out;
			}

C
Chris Mason 已提交
275
			btrfs_set_opt(info->mount_opt, COMPRESS);
276 277 278 279 280 281 282
			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 已提交
283
			break;
284
		case Opt_ssd:
285 286
			printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
			btrfs_set_opt(info->mount_opt, SSD);
287
			break;
288 289 290 291 292 293
		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 已提交
294
		case Opt_nossd:
295 296
			printk(KERN_INFO "btrfs: not using ssd allocation "
			       "scheme\n");
C
Chris Mason 已提交
297
			btrfs_set_opt(info->mount_opt, NOSSD);
C
Chris Mason 已提交
298
			btrfs_clear_opt(info->mount_opt, SSD);
299
			btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
C
Chris Mason 已提交
300
			break;
301
		case Opt_nobarrier:
302 303
			printk(KERN_INFO "btrfs: turning off barriers\n");
			btrfs_set_opt(info->mount_opt, NOBARRIER);
304
			break;
305 306 307 308 309 310 311 312 313
		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;
314
		case Opt_max_inline:
315 316
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
317
				info->max_inline = memparse(num, NULL);
318 319
				kfree(num);

C
Chris Mason 已提交
320 321 322 323 324
				if (info->max_inline) {
					info->max_inline = max_t(u64,
						info->max_inline,
						root->sectorsize);
				}
325
				printk(KERN_INFO "btrfs: max_inline at %llu\n",
326
					(unsigned long long)info->max_inline);
327 328
			}
			break;
329
		case Opt_alloc_start:
330 331
			num = match_strdup(&args[0]);
			if (num) {
A
Akinobu Mita 已提交
332
				info->alloc_start = memparse(num, NULL);
333 334 335
				kfree(num);
				printk(KERN_INFO
					"btrfs: allocations start at %llu\n",
336
					(unsigned long long)info->alloc_start);
337 338
			}
			break;
J
Josef Bacik 已提交
339 340 341
		case Opt_noacl:
			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
			break;
S
Sage Weil 已提交
342 343 344 345
		case Opt_notreelog:
			printk(KERN_INFO "btrfs: disabling tree log\n");
			btrfs_set_opt(info->mount_opt, NOTREELOG);
			break;
346 347 348 349
		case Opt_flushoncommit:
			printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
			btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
			break;
350 351 352 353 354 355 356 357 358
		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 已提交
359 360 361
		case Opt_discard:
			btrfs_set_opt(info->mount_opt, DISCARD);
			break;
362 363 364
		case Opt_space_cache:
			printk(KERN_INFO "btrfs: enabling disk space caching\n");
			btrfs_set_opt(info->mount_opt, SPACE_CACHE);
365
			break;
C
Chris Mason 已提交
366 367 368 369
		case Opt_inode_cache:
			printk(KERN_INFO "btrfs: enabling inode map caching\n");
			btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
			break;
370 371 372
		case Opt_clear_cache:
			printk(KERN_INFO "btrfs: force clearing of disk cache\n");
			btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
373
			break;
374 375 376
		case Opt_user_subvol_rm_allowed:
			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
			break;
377 378 379
		case Opt_enospc_debug:
			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
			break;
C
Chris Mason 已提交
380 381 382 383
		case Opt_defrag:
			printk(KERN_INFO "btrfs: enabling auto defrag");
			btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
			break;
S
Sage Weil 已提交
384 385 386 387 388
		case Opt_err:
			printk(KERN_INFO "btrfs: unrecognized mount option "
			       "'%s'\n", p);
			ret = -EINVAL;
			goto out;
389
		default:
390
			break;
391 392
		}
	}
S
Sage Weil 已提交
393
out:
394
	kfree(orig);
S
Sage Weil 已提交
395
	return ret;
396 397 398 399 400 401 402 403
}

/*
 * 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.
 */
404
static int btrfs_parse_early_options(const char *options, fmode_t flags,
405
		void *holder, char **subvol_name, u64 *subvol_objectid,
406
		u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
407 408
{
	substring_t args[MAX_OPT_ARGS];
409
	char *opts, *orig, *p;
410
	int error = 0;
411
	int intarg;
412 413 414 415 416 417 418 419 420 421 422

	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;
423
	orig = opts;
424 425 426 427 428 429 430 431 432 433 434

	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;
435 436
		case Opt_subvolid:
			intarg = 0;
437 438 439 440 441 442 443 444 445
			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;
			}
446
			break;
447 448 449 450 451 452 453 454 455 456 457 458
		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;
459 460 461 462 463 464
		case Opt_device:
			error = btrfs_scan_one_device(match_strdup(&args[0]),
					flags, holder, fs_devices);
			if (error)
				goto out_free_opts;
			break;
465 466 467 468 469
		default:
			break;
		}
	}

470
 out_free_opts:
471
	kfree(orig);
472 473 474
 out:
	/*
	 * If no subvolume name is specified we use the default one.  Allocate
475
	 * a copy of the string "." here so that code later in the
476 477 478
	 * mount path doesn't care if it's the default volume or another one.
	 */
	if (!*subvol_name) {
479
		*subvol_name = kstrdup(".", GFP_KERNEL);
480 481 482 483
		if (!*subvol_name)
			return -ENOMEM;
	}
	return error;
484 485
}

486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
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);
522 523
	if (IS_ERR(di)) {
		btrfs_free_path(path);
524
		return ERR_CAST(di);
525
	}
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
	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 已提交
544
		return ERR_CAST(new_root);
545 546 547 548 549 550 551 552 553 554 555

	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);
556 557
	if (IS_ERR(inode))
		return ERR_CAST(inode);
558 559 560 561 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 593

	/*
	 * 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 已提交
594
static int btrfs_fill_super(struct super_block *sb,
595
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
596
			    void *data, int silent)
C
Chris Mason 已提交
597
{
C
Chris Mason 已提交
598 599
	struct inode *inode;
	struct dentry *root_dentry;
C
Chris Mason 已提交
600
	struct btrfs_root *tree_root;
601
	struct btrfs_key key;
C
Chris Mason 已提交
602
	int err;
603

C
Chris Mason 已提交
604 605 606
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
607
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
608
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
609
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
610
	sb->s_time_gran = 1;
C
Chris Mason 已提交
611
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
612
	sb->s_flags |= MS_POSIXACL;
613
#endif
614

615
	tree_root = open_ctree(sb, fs_devices, (char *)data);
616

617
	if (IS_ERR(tree_root)) {
C
Chris Mason 已提交
618
		printk("btrfs: open_ctree failed\n");
619
		return PTR_ERR(tree_root);
620
	}
C
Chris Mason 已提交
621
	sb->s_fs_info = tree_root;
622

623 624 625
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
626
	inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
627 628
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
629
		goto fail_close;
C
Chris Mason 已提交
630 631
	}

C
Chris Mason 已提交
632 633 634 635 636
	root_dentry = d_alloc_root(inode);
	if (!root_dentry) {
		iput(inode);
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
637
	}
638

C
Chris Mason 已提交
639
	sb->s_root = root_dentry;
C
Chris Mason 已提交
640 641

	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
642
	cleancache_init_fs(sb);
C
Chris Mason 已提交
643
	return 0;
C
Chris Mason 已提交
644 645 646 647

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

S
Sage Weil 已提交
650
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
651 652
{
	struct btrfs_trans_handle *trans;
653
	struct btrfs_root *root = btrfs_sb(sb);
C
Chris Mason 已提交
654
	int ret;
C
Chris Mason 已提交
655

656 657
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
658 659 660 661
	if (!wait) {
		filemap_flush(root->fs_info->btree_inode->i_mapping);
		return 0;
	}
662

Y
Yan, Zheng 已提交
663 664
	btrfs_start_delalloc_inodes(root, 0);
	btrfs_wait_ordered_extents(root, 0, 0);
665

666
	trans = btrfs_start_transaction(root, 0);
667 668
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
669
	ret = btrfs_commit_transaction(trans, root);
670
	return ret;
C
Chris Mason 已提交
671 672
}

E
Eric Paris 已提交
673 674 675 676
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;
T
Tsutomu Itoh 已提交
677
	char *compress_type;
E
Eric Paris 已提交
678 679 680 681 682 683 684 685 686 687

	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)
688 689
		seq_printf(seq, ",max_inline=%llu",
			   (unsigned long long)info->max_inline);
E
Eric Paris 已提交
690
	if (info->alloc_start != 0)
691 692
		seq_printf(seq, ",alloc_start=%llu",
			   (unsigned long long)info->alloc_start);
E
Eric Paris 已提交
693 694 695
	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 已提交
696 697 698 699 700 701 702 703 704 705
	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 已提交
706 707
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
708 709 710
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
711
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
712
	if (btrfs_test_opt(root, NOTREELOG))
713
		seq_puts(seq, ",notreelog");
714
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
715
		seq_puts(seq, ",flushoncommit");
716 717
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
718 719
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
720 721 722 723 724 725
	if (btrfs_test_opt(root, SPACE_CACHE))
		seq_puts(seq, ",space_cache");
	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");
726 727 728 729 730 731
	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");
E
Eric Paris 已提交
732 733 734
	return 0;
}

735
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
736
{
737
	struct btrfs_root *test_root = data;
738
	struct btrfs_root *root = btrfs_sb(s);
Y
Yan 已提交
739

740 741 742 743 744 745
	/*
	 * If this super block is going away, return false as it
	 * can't match as an existing super block.
	 */
	if (!atomic_read(&s->s_active))
		return 0;
746
	return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
Y
Yan 已提交
747 748
}

749 750 751 752 753
static int btrfs_set_super(struct super_block *s, void *data)
{
	s->s_fs_info = data;

	return set_anon_super(s, data);
Y
Yan 已提交
754 755
}

756

757 758 759 760 761 762
/*
 * 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 已提交
763
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
764
		const char *device_name, void *data)
Y
Yan 已提交
765 766 767 768
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
769
	struct btrfs_fs_devices *fs_devices = NULL;
770 771
	struct btrfs_root *tree_root = NULL;
	struct btrfs_fs_info *fs_info = NULL;
772
	fmode_t mode = FMODE_READ;
773 774
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
775
	u64 subvol_rootid = 0;
Y
Yan 已提交
776 777
	int error = 0;

778 779 780 781
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
782
					  &subvol_name, &subvol_objectid,
783
					  &subvol_rootid, &fs_devices);
784
	if (error)
A
Al Viro 已提交
785
		return ERR_PTR(error);
786

787
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
788
	if (error)
789
		goto error_free_subvol_name;
Y
Yan 已提交
790

791
	error = btrfs_open_devices(fs_devices, mode, fs_type);
792
	if (error)
793
		goto error_free_subvol_name;
794

Y
Yan Zheng 已提交
795 796 797 798 799
	if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
		error = -EACCES;
		goto error_close_devices;
	}

800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
	/*
	 * 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);
	tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
	if (!fs_info || !tree_root) {
		error = -ENOMEM;
		goto error_close_devices;
	}
	fs_info->tree_root = tree_root;
	fs_info->fs_devices = fs_devices;
	tree_root->fs_info = fs_info;

816
	bdev = fs_devices->latest_bdev;
817
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
Y
Yan 已提交
818 819 820 821 822
	if (IS_ERR(s))
		goto error_s;

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
823
			deactivate_locked_super(s);
Y
Yan 已提交
824
			error = -EBUSY;
Y
Yan Zheng 已提交
825
			goto error_close_devices;
Y
Yan 已提交
826 827
		}

Y
Yan Zheng 已提交
828
		btrfs_close_devices(fs_devices);
829 830
		kfree(fs_info);
		kfree(tree_root);
Y
Yan 已提交
831 832 833
	} else {
		char b[BDEVNAME_SIZE];

A
Al Viro 已提交
834
		s->s_flags = flags | MS_NOSEC;
Y
Yan 已提交
835
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
836 837
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
838
		if (error) {
839
			deactivate_locked_super(s);
840
			goto error_free_subvol_name;
Y
Yan 已提交
841 842
		}

843
		btrfs_sb(s)->fs_info->bdev_holder = fs_type;
Y
Yan 已提交
844 845 846
		s->s_flags |= MS_ACTIVE;
	}

847 848 849
	/* if they gave us a subvolume name bind mount into that */
	if (strcmp(subvol_name, ".")) {
		struct dentry *new_root;
850 851 852 853 854 855 856 857

		root = get_default_root(s, subvol_rootid);
		if (IS_ERR(root)) {
			error = PTR_ERR(root);
			deactivate_locked_super(s);
			goto error_free_subvol_name;
		}

858 859
		mutex_lock(&root->d_inode->i_mutex);
		new_root = lookup_one_len(subvol_name, root,
C
Chris Mason 已提交
860
				      strlen(subvol_name));
861
		mutex_unlock(&root->d_inode->i_mutex);
C
Chris Mason 已提交
862

863
		if (IS_ERR(new_root)) {
864
			dput(root);
865
			deactivate_locked_super(s);
866
			error = PTR_ERR(new_root);
867
			goto error_free_subvol_name;
868
		}
869
		if (!new_root->d_inode) {
870
			dput(root);
871
			dput(new_root);
872
			deactivate_locked_super(s);
873
			error = -ENXIO;
874
			goto error_free_subvol_name;
875
		}
876 877
		dput(root);
		root = new_root;
878 879 880 881 882 883 884
	} else {
		root = get_default_root(s, subvol_objectid);
		if (IS_ERR(root)) {
			error = PTR_ERR(root);
			deactivate_locked_super(s);
			goto error_free_subvol_name;
		}
Y
Yan 已提交
885 886
	}

887
	kfree(subvol_name);
A
Al Viro 已提交
888
	return root;
Y
Yan 已提交
889 890 891

error_s:
	error = PTR_ERR(s);
Y
Yan Zheng 已提交
892
error_close_devices:
893
	btrfs_close_devices(fs_devices);
894 895
	kfree(fs_info);
	kfree(tree_root);
896 897
error_free_subvol_name:
	kfree(subvol_name);
A
Al Viro 已提交
898
	return ERR_PTR(error);
Y
Yan 已提交
899
}
900

Y
Yan Zheng 已提交
901 902 903 904 905
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
	struct btrfs_root *root = btrfs_sb(sb);
	int ret;

906 907 908 909
	ret = btrfs_parse_options(root, data);
	if (ret)
		return -EINVAL;

Y
Yan Zheng 已提交
910 911 912 913 914 915 916 917 918
	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 已提交
919 920 921
		if (root->fs_info->fs_devices->rw_devices == 0)
			return -EACCES;

Y
Yan Zheng 已提交
922 923 924
		if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
			return -EINVAL;

925
		ret = btrfs_cleanup_fs_roots(root->fs_info);
Y
Yan Zheng 已提交
926 927
		WARN_ON(ret);

928 929
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
Y
Yan Zheng 已提交
930 931 932 933 934 935 936 937
		WARN_ON(ret);

		sb->s_flags &= ~MS_RDONLY;
	}

	return 0;
}

938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
/* 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);
}

964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
/*
 * 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;
	int min_stripes = 1;
	int i = 0, nr_devices;
	int ret;

	nr_devices = fs_info->fs_devices->rw_devices;
	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);
	if (type & BTRFS_BLOCK_GROUP_RAID0)
		min_stripes = 2;
	else if (type & BTRFS_BLOCK_GROUP_RAID1)
		min_stripes = 2;
	else if (type & BTRFS_BLOCK_GROUP_RAID10)
		min_stripes = 4;

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

	list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
		if (!device->in_fs_metadata)
			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) {
		if (devices_info[i].max_avail >= min_stripe_size) {
			int j;
			u64 alloc_size;

			avail_space += devices_info[i].max_avail * min_stripes;
			alloc_size = devices_info[i].max_avail;
			for (j = i + 1 - min_stripes; j <= i; j++)
				devices_info[j].max_avail -= alloc_size;
		}
		i--;
		nr_devices--;
	}

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

C
Chris Mason 已提交
1085 1086 1087
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct btrfs_root *root = btrfs_sb(dentry->d_sb);
1088
	struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
1089 1090 1091
	struct list_head *head = &root->fs_info->space_info;
	struct btrfs_space_info *found;
	u64 total_used = 0;
1092
	u64 total_free_data = 0;
1093
	int bits = dentry->d_sb->s_blocksize_bits;
1094
	__be32 *fsid = (__be32 *)root->fs_info->fsid;
1095
	int ret;
C
Chris Mason 已提交
1096

1097 1098
	/* holding chunk_muext to avoid allocating new chunks */
	mutex_lock(&root->fs_info->chunk_mutex);
1099
	rcu_read_lock();
J
Josef Bacik 已提交
1100
	list_for_each_entry_rcu(found, head, list) {
1101 1102 1103 1104 1105 1106
		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);
		}

1107
		total_used += found->disk_used;
J
Josef Bacik 已提交
1108
	}
1109 1110
	rcu_read_unlock();

C
Chris Mason 已提交
1111
	buf->f_namelen = BTRFS_NAME_LEN;
1112
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1113
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1114 1115
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1116 1117 1118 1119 1120 1121 1122 1123 1124
	buf->f_bavail = total_free_data;
	ret = btrfs_calc_avail_data_space(root, &total_free_data);
	if (ret) {
		mutex_unlock(&root->fs_info->chunk_mutex);
		return ret;
	}
	buf->f_bavail += total_free_data;
	buf->f_bavail = buf->f_bavail >> bits;
	mutex_unlock(&root->fs_info->chunk_mutex);
C
Chris Mason 已提交
1125

1126
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1127
	   because we want the fsid to come out the same whether mounted
1128 1129 1130
	   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]);
1131 1132 1133 1134
	/* 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 已提交
1135 1136
	return 0;
}
C
Chris Mason 已提交
1137

1138 1139 1140
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1141
	.mount		= btrfs_mount,
1142
	.kill_sb	= kill_anon_super,
1143 1144
	.fs_flags	= FS_REQUIRES_DEV,
};
1145

C
Chris Mason 已提交
1146 1147 1148
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1149 1150 1151 1152 1153
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;
1154
	int ret = -ENOTTY;
1155

1156 1157 1158
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1159 1160 1161
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1162

1163 1164
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1165
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1166 1167 1168
					    &btrfs_fs_type, &fs_devices);
		break;
	}
L
Li Zefan 已提交
1169

1170
	kfree(vol);
L
Linda Knippers 已提交
1171
	return ret;
1172 1173
}

1174
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1175 1176
{
	struct btrfs_root *root = btrfs_sb(sb);
1177 1178
	mutex_lock(&root->fs_info->transaction_kthread_mutex);
	mutex_lock(&root->fs_info->cleaner_mutex);
1179
	return 0;
Y
Yan 已提交
1180 1181
}

1182
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1183 1184
{
	struct btrfs_root *root = btrfs_sb(sb);
1185 1186
	mutex_unlock(&root->fs_info->cleaner_mutex);
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1187
	return 0;
Y
Yan 已提交
1188
}
1189

1190
static const struct super_operations btrfs_super_ops = {
1191
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1192
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1193
	.put_super	= btrfs_put_super,
1194
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1195
	.show_options	= btrfs_show_options,
C
Chris Mason 已提交
1196
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1197
	.dirty_inode	= btrfs_dirty_inode,
C
Chris Mason 已提交
1198 1199
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1200
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1201
	.remount_fs	= btrfs_remount,
1202 1203
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1204
};
1205 1206 1207 1208 1209

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1210
	.llseek = noop_llseek,
1211 1212 1213
};

static struct miscdevice btrfs_misc = {
1214
	.minor		= BTRFS_MINOR,
1215 1216 1217 1218
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1219 1220 1221
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1222 1223 1224 1225 1226
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1227
static void btrfs_interface_exit(void)
1228 1229
{
	if (misc_deregister(&btrfs_misc) < 0)
C
Chris Mason 已提交
1230
		printk(KERN_INFO "misc_deregister failed for control device");
1231 1232
}

1233 1234
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1235
	int err;
1236 1237 1238 1239 1240

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

1241
	err = btrfs_init_compress();
C
Chris Mason 已提交
1242
	if (err)
1243
		goto free_sysfs;
1244

1245 1246 1247 1248
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1249
	err = extent_io_init();
1250 1251 1252
	if (err)
		goto free_cachep;

1253 1254 1255 1256
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1257
	err = btrfs_delayed_inode_init();
1258 1259
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1260

1261 1262 1263 1264
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_inode;

1265 1266 1267
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
1268 1269

	printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1270 1271
	return 0;

1272 1273
unregister_ioctl:
	btrfs_interface_exit();
1274 1275
free_delayed_inode:
	btrfs_delayed_inode_exit();
1276 1277
free_extent_map:
	extent_map_exit();
1278 1279
free_extent_io:
	extent_io_exit();
1280 1281
free_cachep:
	btrfs_destroy_cachep();
1282 1283
free_compress:
	btrfs_exit_compress();
1284
free_sysfs:
1285 1286
	btrfs_exit_sysfs();
	return err;
1287 1288 1289 1290
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1291
	btrfs_destroy_cachep();
1292
	btrfs_delayed_inode_exit();
1293
	extent_map_exit();
1294
	extent_io_exit();
1295
	btrfs_interface_exit();
1296
	unregister_filesystem(&btrfs_fs_type);
1297
	btrfs_exit_sysfs();
1298
	btrfs_cleanup_fs_uuids();
1299
	btrfs_exit_compress();
1300 1301 1302 1303 1304 1305
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");