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

Y
Yan 已提交
19
#include <linux/blkdev.h>
20
#include <linux/module.h>
C
Chris Mason 已提交
21
#include <linux/buffer_head.h>
22 23 24 25 26
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
E
Eric Paris 已提交
27
#include <linux/seq_file.h>
28 29
#include <linux/string.h>
#include <linux/backing-dev.h>
Y
Yan 已提交
30
#include <linux/mount.h>
C
Chris Mason 已提交
31
#include <linux/mpage.h>
C
Chris Mason 已提交
32 33
#include <linux/swap.h>
#include <linux/writeback.h>
C
Chris Mason 已提交
34
#include <linux/statfs.h>
C
Chris Mason 已提交
35
#include <linux/compat.h>
36
#include <linux/parser.h>
37
#include <linux/ctype.h>
38
#include <linux/namei.h>
39
#include <linux/miscdevice.h>
40
#include <linux/magic.h>
41
#include <linux/slab.h>
D
Dan Magenheimer 已提交
42
#include <linux/cleancache.h>
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
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;
	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);
521 522
	if (IS_ERR(di)) {
		btrfs_free_path(path);
523
		return ERR_CAST(di);
524
	}
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
	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 已提交
543
		return ERR_CAST(new_root);
544 545 546 547 548 549 550 551 552 553 554

	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);
555 556
	if (IS_ERR(inode))
		return ERR_CAST(inode);
557 558 559 560 561 562 563 564 565 566 567

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

568
	return d_obtain_alias(inode);
569 570
}

C
Chris Mason 已提交
571
static int btrfs_fill_super(struct super_block *sb,
572
			    struct btrfs_fs_devices *fs_devices,
C
Chris Mason 已提交
573
			    void *data, int silent)
C
Chris Mason 已提交
574
{
C
Chris Mason 已提交
575 576
	struct inode *inode;
	struct dentry *root_dentry;
C
Chris Mason 已提交
577
	struct btrfs_root *tree_root;
578
	struct btrfs_key key;
C
Chris Mason 已提交
579
	int err;
580

C
Chris Mason 已提交
581 582 583
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
A
Al Viro 已提交
584
	sb->s_d_op = &btrfs_dentry_operations;
B
Balaji Rao 已提交
585
	sb->s_export_op = &btrfs_export_ops;
J
Josef Bacik 已提交
586
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
587
	sb->s_time_gran = 1;
C
Chris Mason 已提交
588
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
J
Josef Bacik 已提交
589
	sb->s_flags |= MS_POSIXACL;
590
#endif
591

592
	tree_root = open_ctree(sb, fs_devices, (char *)data);
593

594
	if (IS_ERR(tree_root)) {
C
Chris Mason 已提交
595
		printk("btrfs: open_ctree failed\n");
596
		return PTR_ERR(tree_root);
597
	}
C
Chris Mason 已提交
598
	sb->s_fs_info = tree_root;
599

600 601 602
	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
603
	inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
604 605
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
606
		goto fail_close;
C
Chris Mason 已提交
607 608
	}

C
Chris Mason 已提交
609 610 611 612 613
	root_dentry = d_alloc_root(inode);
	if (!root_dentry) {
		iput(inode);
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
614
	}
615

C
Chris Mason 已提交
616
	sb->s_root = root_dentry;
C
Chris Mason 已提交
617 618

	save_mount_options(sb, data);
D
Dan Magenheimer 已提交
619
	cleancache_init_fs(sb);
C
Chris Mason 已提交
620
	return 0;
C
Chris Mason 已提交
621 622 623 624

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

S
Sage Weil 已提交
627
int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
628 629
{
	struct btrfs_trans_handle *trans;
630
	struct btrfs_root *root = btrfs_sb(sb);
C
Chris Mason 已提交
631
	int ret;
C
Chris Mason 已提交
632

633 634
	trace_btrfs_sync_fs(wait);

C
Chris Mason 已提交
635 636 637 638
	if (!wait) {
		filemap_flush(root->fs_info->btree_inode->i_mapping);
		return 0;
	}
639

Y
Yan, Zheng 已提交
640 641
	btrfs_start_delalloc_inodes(root, 0);
	btrfs_wait_ordered_extents(root, 0, 0);
642

643
	trans = btrfs_start_transaction(root, 0);
644 645
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
646
	ret = btrfs_commit_transaction(trans, root);
647
	return ret;
C
Chris Mason 已提交
648 649
}

E
Eric Paris 已提交
650 651 652 653
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 已提交
654
	char *compress_type;
E
Eric Paris 已提交
655 656 657 658 659 660 661 662 663 664

	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)
665 666
		seq_printf(seq, ",max_inline=%llu",
			   (unsigned long long)info->max_inline);
E
Eric Paris 已提交
667
	if (info->alloc_start != 0)
668 669
		seq_printf(seq, ",alloc_start=%llu",
			   (unsigned long long)info->alloc_start);
E
Eric Paris 已提交
670 671 672
	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 已提交
673 674 675 676 677 678 679 680 681 682
	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 已提交
683 684
	if (btrfs_test_opt(root, NOSSD))
		seq_puts(seq, ",nossd");
685 686 687
	if (btrfs_test_opt(root, SSD_SPREAD))
		seq_puts(seq, ",ssd_spread");
	else if (btrfs_test_opt(root, SSD))
E
Eric Paris 已提交
688
		seq_puts(seq, ",ssd");
S
Sage Weil 已提交
689
	if (btrfs_test_opt(root, NOTREELOG))
690
		seq_puts(seq, ",notreelog");
691
	if (btrfs_test_opt(root, FLUSHONCOMMIT))
692
		seq_puts(seq, ",flushoncommit");
693 694
	if (btrfs_test_opt(root, DISCARD))
		seq_puts(seq, ",discard");
E
Eric Paris 已提交
695 696
	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
		seq_puts(seq, ",noacl");
T
Tsutomu Itoh 已提交
697 698 699 700 701 702
	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");
703 704 705 706 707 708
	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 已提交
709 710 711
	return 0;
}

712
static int btrfs_test_super(struct super_block *s, void *data)
Y
Yan 已提交
713
{
714
	struct btrfs_root *test_root = data;
715
	struct btrfs_root *root = btrfs_sb(s);
Y
Yan 已提交
716

717 718 719 720 721 722
	/*
	 * 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;
723
	return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
Y
Yan 已提交
724 725
}

726 727 728 729 730
static int btrfs_set_super(struct super_block *s, void *data)
{
	s->s_fs_info = data;

	return set_anon_super(s, data);
Y
Yan 已提交
731 732
}

733

734 735 736 737 738 739
/*
 * 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 已提交
740
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
741
		const char *device_name, void *data)
Y
Yan 已提交
742 743 744 745
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
746
	struct btrfs_fs_devices *fs_devices = NULL;
747 748
	struct btrfs_root *tree_root = NULL;
	struct btrfs_fs_info *fs_info = NULL;
749
	fmode_t mode = FMODE_READ;
750 751
	char *subvol_name = NULL;
	u64 subvol_objectid = 0;
752
	u64 subvol_rootid = 0;
Y
Yan 已提交
753 754
	int error = 0;

755 756 757 758
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	error = btrfs_parse_early_options(data, mode, fs_type,
759
					  &subvol_name, &subvol_objectid,
760
					  &subvol_rootid, &fs_devices);
761
	if (error)
A
Al Viro 已提交
762
		return ERR_PTR(error);
763

764
	error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
765
	if (error)
766
		goto error_free_subvol_name;
Y
Yan 已提交
767

768
	error = btrfs_open_devices(fs_devices, mode, fs_type);
769
	if (error)
770
		goto error_free_subvol_name;
771

Y
Yan Zheng 已提交
772 773 774 775 776
	if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
		error = -EACCES;
		goto error_close_devices;
	}

777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
	/*
	 * 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;

793
	bdev = fs_devices->latest_bdev;
794
	s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
Y
Yan 已提交
795 796 797 798 799
	if (IS_ERR(s))
		goto error_s;

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
800
			deactivate_locked_super(s);
Y
Yan 已提交
801
			error = -EBUSY;
Y
Yan Zheng 已提交
802
			goto error_close_devices;
Y
Yan 已提交
803 804
		}

Y
Yan Zheng 已提交
805
		btrfs_close_devices(fs_devices);
806 807
		kfree(fs_info);
		kfree(tree_root);
Y
Yan 已提交
808 809 810
	} else {
		char b[BDEVNAME_SIZE];

A
Al Viro 已提交
811
		s->s_flags = flags | MS_NOSEC;
Y
Yan 已提交
812
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
813 814
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
815
		if (error) {
816
			deactivate_locked_super(s);
817
			goto error_free_subvol_name;
Y
Yan 已提交
818 819
		}

820
		btrfs_sb(s)->fs_info->bdev_holder = fs_type;
Y
Yan 已提交
821 822 823
		s->s_flags |= MS_ACTIVE;
	}

824 825 826
	/* if they gave us a subvolume name bind mount into that */
	if (strcmp(subvol_name, ".")) {
		struct dentry *new_root;
827 828 829 830 831 832 833 834

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

835 836
		mutex_lock(&root->d_inode->i_mutex);
		new_root = lookup_one_len(subvol_name, root,
C
Chris Mason 已提交
837
				      strlen(subvol_name));
838
		mutex_unlock(&root->d_inode->i_mutex);
C
Chris Mason 已提交
839

840
		if (IS_ERR(new_root)) {
841
			dput(root);
842
			deactivate_locked_super(s);
843
			error = PTR_ERR(new_root);
844
			goto error_free_subvol_name;
845
		}
846
		if (!new_root->d_inode) {
847
			dput(root);
848
			dput(new_root);
849
			deactivate_locked_super(s);
850
			error = -ENXIO;
851
			goto error_free_subvol_name;
852
		}
853 854
		dput(root);
		root = new_root;
855 856 857 858 859 860 861
	} 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 已提交
862 863
	}

864
	kfree(subvol_name);
A
Al Viro 已提交
865
	return root;
Y
Yan 已提交
866 867 868

error_s:
	error = PTR_ERR(s);
Y
Yan Zheng 已提交
869
error_close_devices:
870
	btrfs_close_devices(fs_devices);
871 872
	kfree(fs_info);
	kfree(tree_root);
873 874
error_free_subvol_name:
	kfree(subvol_name);
A
Al Viro 已提交
875
	return ERR_PTR(error);
Y
Yan 已提交
876
}
877

Y
Yan Zheng 已提交
878 879 880 881 882
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{
	struct btrfs_root *root = btrfs_sb(sb);
	int ret;

883 884 885 886
	ret = btrfs_parse_options(root, data);
	if (ret)
		return -EINVAL;

Y
Yan Zheng 已提交
887 888 889 890 891 892 893 894 895
	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 已提交
896 897 898
		if (root->fs_info->fs_devices->rw_devices == 0)
			return -EACCES;

Y
Yan Zheng 已提交
899 900 901
		if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
			return -EINVAL;

902
		ret = btrfs_cleanup_fs_roots(root->fs_info);
Y
Yan Zheng 已提交
903 904
		WARN_ON(ret);

905 906
		/* recover relocation */
		ret = btrfs_recover_relocation(root);
Y
Yan Zheng 已提交
907 908 909 910 911 912 913 914
		WARN_ON(ret);

		sb->s_flags &= ~MS_RDONLY;
	}

	return 0;
}

915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
/* 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);
}

941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 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
/*
 * 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 已提交
1062 1063 1064
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct btrfs_root *root = btrfs_sb(dentry->d_sb);
1065
	struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
1066 1067 1068
	struct list_head *head = &root->fs_info->space_info;
	struct btrfs_space_info *found;
	u64 total_used = 0;
1069
	u64 total_free_data = 0;
1070
	int bits = dentry->d_sb->s_blocksize_bits;
1071
	__be32 *fsid = (__be32 *)root->fs_info->fsid;
1072
	int ret;
C
Chris Mason 已提交
1073

1074 1075
	/* holding chunk_muext to avoid allocating new chunks */
	mutex_lock(&root->fs_info->chunk_mutex);
1076
	rcu_read_lock();
J
Josef Bacik 已提交
1077
	list_for_each_entry_rcu(found, head, list) {
1078 1079 1080 1081 1082 1083
		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);
		}

1084
		total_used += found->disk_used;
J
Josef Bacik 已提交
1085
	}
1086 1087
	rcu_read_unlock();

C
Chris Mason 已提交
1088
	buf->f_namelen = BTRFS_NAME_LEN;
1089
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1090
	buf->f_bfree = buf->f_blocks - (total_used >> bits);
C
Chris Mason 已提交
1091 1092
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
1093 1094 1095 1096 1097 1098 1099 1100 1101
	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 已提交
1102

1103
	/* We treat it as constant endianness (it doesn't matter _which_)
C
Chris Mason 已提交
1104
	   because we want the fsid to come out the same whether mounted
1105 1106 1107
	   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]);
1108 1109 1110 1111
	/* 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 已提交
1112 1113
	return 0;
}
C
Chris Mason 已提交
1114

1115 1116 1117
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
A
Al Viro 已提交
1118
	.mount		= btrfs_mount,
1119
	.kill_sb	= kill_anon_super,
1120 1121
	.fs_flags	= FS_REQUIRES_DEV,
};
1122

C
Chris Mason 已提交
1123 1124 1125
/*
 * used by btrfsctl to scan devices when no FS is mounted
 */
1126 1127 1128 1129 1130
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;
1131
	int ret = -ENOTTY;
1132

1133 1134 1135
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

L
Li Zefan 已提交
1136 1137 1138
	vol = memdup_user((void __user *)arg, sizeof(*vol));
	if (IS_ERR(vol))
		return PTR_ERR(vol);
1139

1140 1141
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
1142
		ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1143 1144 1145
					    &btrfs_fs_type, &fs_devices);
		break;
	}
L
Li Zefan 已提交
1146

1147
	kfree(vol);
L
Linda Knippers 已提交
1148
	return ret;
1149 1150
}

1151
static int btrfs_freeze(struct super_block *sb)
Y
Yan 已提交
1152 1153
{
	struct btrfs_root *root = btrfs_sb(sb);
1154 1155
	mutex_lock(&root->fs_info->transaction_kthread_mutex);
	mutex_lock(&root->fs_info->cleaner_mutex);
1156
	return 0;
Y
Yan 已提交
1157 1158
}

1159
static int btrfs_unfreeze(struct super_block *sb)
Y
Yan 已提交
1160 1161
{
	struct btrfs_root *root = btrfs_sb(sb);
1162 1163
	mutex_unlock(&root->fs_info->cleaner_mutex);
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1164
	return 0;
Y
Yan 已提交
1165
}
1166

1167
static const struct super_operations btrfs_super_ops = {
1168
	.drop_inode	= btrfs_drop_inode,
A
Al Viro 已提交
1169
	.evict_inode	= btrfs_evict_inode,
C
Chris Mason 已提交
1170
	.put_super	= btrfs_put_super,
1171
	.sync_fs	= btrfs_sync_fs,
E
Eric Paris 已提交
1172
	.show_options	= btrfs_show_options,
C
Chris Mason 已提交
1173
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
1174
	.dirty_inode	= btrfs_dirty_inode,
C
Chris Mason 已提交
1175 1176
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
1177
	.statfs		= btrfs_statfs,
Y
Yan Zheng 已提交
1178
	.remount_fs	= btrfs_remount,
1179 1180
	.freeze_fs	= btrfs_freeze,
	.unfreeze_fs	= btrfs_unfreeze,
C
Chris Mason 已提交
1181
};
1182 1183 1184 1185 1186

static const struct file_operations btrfs_ctl_fops = {
	.unlocked_ioctl	 = btrfs_control_ioctl,
	.compat_ioctl = btrfs_control_ioctl,
	.owner	 = THIS_MODULE,
1187
	.llseek = noop_llseek,
1188 1189 1190
};

static struct miscdevice btrfs_misc = {
1191
	.minor		= BTRFS_MINOR,
1192 1193 1194 1195
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

1196 1197 1198
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
MODULE_ALIAS("devname:btrfs-control");

1199 1200 1201 1202 1203
static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

1204
static void btrfs_interface_exit(void)
1205 1206
{
	if (misc_deregister(&btrfs_misc) < 0)
C
Chris Mason 已提交
1207
		printk(KERN_INFO "misc_deregister failed for control device");
1208 1209
}

1210 1211
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
1212
	int err;
1213 1214 1215 1216 1217

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

1218
	err = btrfs_init_compress();
C
Chris Mason 已提交
1219
	if (err)
1220
		goto free_sysfs;
1221

1222 1223 1224 1225
	err = btrfs_init_cachep();
	if (err)
		goto free_compress;

1226
	err = extent_io_init();
1227 1228 1229
	if (err)
		goto free_cachep;

1230 1231 1232 1233
	err = extent_map_init();
	if (err)
		goto free_extent_io;

1234
	err = btrfs_delayed_inode_init();
1235 1236
	if (err)
		goto free_extent_map;
C
Chris Mason 已提交
1237

1238 1239 1240 1241
	err = btrfs_interface_init();
	if (err)
		goto free_delayed_inode;

1242 1243 1244
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
1245 1246

	printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1247 1248
	return 0;

1249 1250
unregister_ioctl:
	btrfs_interface_exit();
1251 1252
free_delayed_inode:
	btrfs_delayed_inode_exit();
1253 1254
free_extent_map:
	extent_map_exit();
1255 1256
free_extent_io:
	extent_io_exit();
1257 1258
free_cachep:
	btrfs_destroy_cachep();
1259 1260
free_compress:
	btrfs_exit_compress();
1261
free_sysfs:
1262 1263
	btrfs_exit_sysfs();
	return err;
1264 1265 1266 1267
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
1268
	btrfs_destroy_cachep();
1269
	btrfs_delayed_inode_exit();
1270
	extent_map_exit();
1271
	extent_io_exit();
1272
	btrfs_interface_exit();
1273
	unregister_filesystem(&btrfs_fs_type);
1274
	btrfs_exit_sysfs();
1275
	btrfs_cleanup_fs_uuids();
1276
	btrfs_exit_compress();
1277 1278 1279 1280 1281 1282
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");