super.c 13.2 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 27 28 29
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/smp_lock.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 "ctree.h"
C
Chris Mason 已提交
41
#include "disk-io.h"
42
#include "transaction.h"
C
Chris Mason 已提交
43
#include "btrfs_inode.h"
C
Chris Mason 已提交
44
#include "ioctl.h"
C
Chris Mason 已提交
45
#include "print-tree.h"
J
Josef Bacik 已提交
46
#include "xattr.h"
47
#include "volumes.h"
48

49
#define BTRFS_SUPER_MAGIC 0x9123683E
C
Chris Mason 已提交
50

C
Chris Mason 已提交
51
static struct super_operations btrfs_super_ops;
C
Chris Mason 已提交
52

C
Chris Mason 已提交
53
static void btrfs_put_super (struct super_block * sb)
C
Chris Mason 已提交
54
{
C
Chris Mason 已提交
55
	struct btrfs_root *root = btrfs_sb(sb);
56
	struct btrfs_fs_info *fs = root->fs_info;
C
Chris Mason 已提交
57 58
	int ret;

C
Chris Mason 已提交
59 60 61
	ret = close_ctree(root);
	if (ret) {
		printk("close ctree returns %d\n", ret);
C
Chris Mason 已提交
62
	}
63
	btrfs_sysfs_del_super(fs);
C
Chris Mason 已提交
64
	sb->s_fs_info = NULL;
C
Chris Mason 已提交
65 66
}

67
enum {
68
	Opt_subvol, Opt_nodatasum, Opt_nodatacow, Opt_max_extent,
69
	Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd, Opt_err,
70 71 72 73
};

static match_table_t tokens = {
	{Opt_subvol, "subvol=%s"},
74
	{Opt_nodatasum, "nodatasum"},
75
	{Opt_nodatacow, "nodatacow"},
76
	{Opt_nobarrier, "nobarrier"},
77
	{Opt_max_extent, "max_extent=%s"},
78
	{Opt_max_inline, "max_inline=%s"},
79
	{Opt_alloc_start, "alloc_start=%s"},
80
	{Opt_ssd, "ssd"},
81 82 83
	{Opt_err, NULL}
};

84
u64 btrfs_parse_size(char *str)
85
{
86
	u64 res;
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
	int mult = 1;
	char *end;
	char last;

	res = simple_strtoul(str, &end, 10);

	last = end[0];
	if (isalpha(last)) {
		last = tolower(last);
		switch (last) {
		case 'g':
			mult *= 1024;
		case 'm':
			mult *= 1024;
		case 'k':
			mult *= 1024;
		}
		res = res * mult;
	}
	return res;
}

109 110 111 112 113
static int parse_options (char * options,
			  struct btrfs_root *root,
			  char **subvol_name)
{
	char * p;
114
	struct btrfs_fs_info *info = NULL;
115
	substring_t args[MAX_OPT_ARGS];
116

117 118 119
	if (!options)
		return 1;

120 121 122 123 124 125 126 127 128 129 130
	/*
	 * strsep changes the string, duplicate it because parse_options
	 * gets called twice
	 */
	options = kstrdup(options, GFP_NOFS);
	if (!options)
		return -ENOMEM;

	if (root)
		info = root->fs_info;

131 132 133 134 135 136 137 138
	while ((p = strsep (&options, ",")) != NULL) {
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_subvol:
139
			if (subvol_name) {
140
				*subvol_name = match_strdup(&args[0]);
141
			}
142 143
			break;
		case Opt_nodatasum:
144 145
			if (info) {
				printk("btrfs: setting nodatacsum\n");
146
				btrfs_set_opt(info->mount_opt, NODATASUM);
147 148 149 150 151 152 153 154
			}
			break;
		case Opt_nodatacow:
			if (info) {
				printk("btrfs: setting nodatacow\n");
				btrfs_set_opt(info->mount_opt, NODATACOW);
				btrfs_set_opt(info->mount_opt, NODATASUM);
			}
155
			break;
156 157 158 159 160 161
		case Opt_ssd:
			if (info) {
				printk("btrfs: use ssd allocation scheme\n");
				btrfs_set_opt(info->mount_opt, SSD);
			}
			break;
162 163 164 165 166 167
		case Opt_nobarrier:
			if (info) {
				printk("btrfs: turning off barriers\n");
				btrfs_set_opt(info->mount_opt, NOBARRIER);
			}
			break;
168 169 170 171
		case Opt_max_extent:
			if (info) {
				char *num = match_strdup(&args[0]);
				if (num) {
172 173
					info->max_extent =
						btrfs_parse_size(num);
174 175 176 177 178 179 180 181 182 183
					kfree(num);

					info->max_extent = max_t(u64,
							 info->max_extent,
							 root->sectorsize);
					printk("btrfs: max_extent at %Lu\n",
					       info->max_extent);
				}
			}
			break;
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
		case Opt_max_inline:
			if (info) {
				char *num = match_strdup(&args[0]);
				if (num) {
					info->max_inline =
						btrfs_parse_size(num);
					kfree(num);

					info->max_inline = max_t(u64,
							 info->max_inline,
							 root->sectorsize);
					printk("btrfs: max_inline at %Lu\n",
					       info->max_inline);
				}
			}
			break;
200 201 202 203 204 205 206 207 208 209 210 211
		case Opt_alloc_start:
			if (info) {
				char *num = match_strdup(&args[0]);
				if (num) {
					info->alloc_start =
						btrfs_parse_size(num);
					kfree(num);
					printk("btrfs: allocations start at "
					       "%Lu\n", info->alloc_start);
				}
			}
			break;
212
		default:
213
			break;
214 215
		}
	}
216
	kfree(options);
217 218 219
	return 1;
}

220 221 222
static int btrfs_fill_super(struct super_block * sb,
			    struct btrfs_fs_devices *fs_devices,
			    void * data, int silent)
C
Chris Mason 已提交
223
{
C
Chris Mason 已提交
224 225 226 227 228 229
	struct inode * inode;
	struct dentry * root_dentry;
	struct btrfs_super_block *disk_super;
	struct btrfs_root *tree_root;
	struct btrfs_inode *bi;
	int err;
230

C
Chris Mason 已提交
231 232 233
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_magic = BTRFS_SUPER_MAGIC;
	sb->s_op = &btrfs_super_ops;
J
Josef Bacik 已提交
234
	sb->s_xattr = btrfs_xattr_handlers;
C
Chris Mason 已提交
235
	sb->s_time_gran = 1;
236

237
	tree_root = open_ctree(sb, fs_devices);
238

C
Chris Mason 已提交
239 240 241
	if (!tree_root || IS_ERR(tree_root)) {
		printk("btrfs: open_ctree failed\n");
		return -EIO;
242
	}
C
Chris Mason 已提交
243
	sb->s_fs_info = tree_root;
244
	disk_super = &tree_root->fs_info->super_copy;
C
Chris Mason 已提交
245 246 247 248 249 250
	inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
				  tree_root);
	bi = BTRFS_I(inode);
	bi->location.objectid = inode->i_ino;
	bi->location.offset = 0;
	bi->root = tree_root;
251

C
Chris Mason 已提交
252
	btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
253

C
Chris Mason 已提交
254
	if (!inode) {
255
		err = -ENOMEM;
C
Chris Mason 已提交
256
		goto fail_close;
C
Chris Mason 已提交
257
	}
C
Chris Mason 已提交
258 259 260
	if (inode->i_state & I_NEW) {
		btrfs_read_locked_inode(inode);
		unlock_new_inode(inode);
C
Chris Mason 已提交
261 262
	}

C
Chris Mason 已提交
263 264 265 266 267
	root_dentry = d_alloc_root(inode);
	if (!root_dentry) {
		iput(inode);
		err = -ENOMEM;
		goto fail_close;
C
Chris Mason 已提交
268
	}
269

270 271
	parse_options((char *)data, tree_root, NULL);

272 273 274 275 276
	/* this does the super kobj at the same time */
	err = btrfs_sysfs_add_super(tree_root->fs_info);
	if (err)
		goto fail_close;

C
Chris Mason 已提交
277 278
	sb->s_root = root_dentry;
	btrfs_transaction_queue_work(tree_root, HZ * 30);
C
Chris Mason 已提交
279 280 281 282 283

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
	save_mount_options(sb, data);
#endif

C
Chris Mason 已提交
284
	return 0;
C
Chris Mason 已提交
285 286 287 288

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

C
Chris Mason 已提交
291
static int btrfs_sync_fs(struct super_block *sb, int wait)
C
Chris Mason 已提交
292 293
{
	struct btrfs_trans_handle *trans;
C
Chris Mason 已提交
294
	struct btrfs_root *root;
C
Chris Mason 已提交
295
	int ret;
C
Chris Mason 已提交
296
	root = btrfs_sb(sb);
C
Chris Mason 已提交
297

C
Chris Mason 已提交
298 299 300 301 302
	sb->s_dirt = 0;
	if (!wait) {
		filemap_flush(root->fs_info->btree_inode->i_mapping);
		return 0;
	}
303
	btrfs_clean_old_snapshots(root);
C
Chris Mason 已提交
304
	mutex_lock(&root->fs_info->fs_mutex);
305
	btrfs_defrag_dirty_roots(root->fs_info);
C
Chris Mason 已提交
306 307
	trans = btrfs_start_transaction(root, 1);
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
308
	sb->s_dirt = 0;
C
Chris Mason 已提交
309
	mutex_unlock(&root->fs_info->fs_mutex);
310
	return ret;
C
Chris Mason 已提交
311 312
}

C
Chris Mason 已提交
313
static void btrfs_write_super(struct super_block *sb)
C
Chris Mason 已提交
314
{
C
Chris Mason 已提交
315
	sb->s_dirt = 0;
C
Chris Mason 已提交
316 317
}

Y
Yan 已提交
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
/*
 * This is almost a copy of get_sb_bdev in fs/super.c.
 * We need the local copy to allow direct mounting of
 * subvolumes, but this could be easily integrated back
 * into the generic version.  --hch
 */

/* start copy & paste */
static int set_bdev_super(struct super_block *s, void *data)
{
	s->s_bdev = data;
	s->s_dev = s->s_bdev->bd_dev;
	return 0;
}

static int test_bdev_super(struct super_block *s, void *data)
{
	return (void *)s->s_bdev == data;
}

int btrfs_get_sb_bdev(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data,
	struct vfsmount *mnt, const char *subvol)
{
	struct block_device *bdev = NULL;
	struct super_block *s;
	struct dentry *root;
345
	struct btrfs_fs_devices *fs_devices = NULL;
Y
Yan 已提交
346 347
	int error = 0;

348 349 350
	error = btrfs_scan_one_device(dev_name, flags, fs_type, &fs_devices);
	if (error)
		return error;
Y
Yan 已提交
351

352 353 354 355 356
	error = btrfs_open_devices(fs_devices, flags, fs_type);
	if (error)
		return error;

	bdev = fs_devices->lowest_bdev;
Y
Yan 已提交
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
	/*
	 * once the super is inserted into the list by sget, s_umount
	 * will protect the lockfs code from trying to start a snapshot
	 * while we are mounting
	 */
	down(&bdev->bd_mount_sem);
	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
	up(&bdev->bd_mount_sem);
	if (IS_ERR(s))
		goto error_s;

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
			up_write(&s->s_umount);
			deactivate_super(s);
			error = -EBUSY;
			goto error_bdev;
		}

		close_bdev_excl(bdev);
	} else {
		char b[BDEVNAME_SIZE];

		s->s_flags = flags;
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
		sb_set_blocksize(s, block_size(bdev));
383 384
		error = btrfs_fill_super(s, fs_devices, data,
					 flags & MS_SILENT ? 1 : 0);
Y
Yan 已提交
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
		if (error) {
			up_write(&s->s_umount);
			deactivate_super(s);
			goto error;
		}

		s->s_flags |= MS_ACTIVE;
	}

	if (subvol) {
		root = lookup_one_len(subvol, s->s_root, strlen(subvol));
		if (IS_ERR(root)) {
			up_write(&s->s_umount);
			deactivate_super(s);
			error = PTR_ERR(root);
			goto error;
		}
		if (!root->d_inode) {
			dput(root);
			up_write(&s->s_umount);
			deactivate_super(s);
			error = -ENXIO;
			goto error;
		}
	} else {
		root = dget(s->s_root);
	}

	mnt->mnt_sb = s;
	mnt->mnt_root = root;
	return 0;

error_s:
	error = PTR_ERR(s);
error_bdev:
420
	btrfs_close_devices(fs_devices);
Y
Yan 已提交
421 422 423 424 425
error:
	return error;
}
/* end copy & paste */

426
static int btrfs_get_sb(struct file_system_type *fs_type,
427
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
428
{
Y
Yan 已提交
429
	int ret;
430
	char *subvol_name = NULL;
Y
Yan 已提交
431

432
	parse_options((char *)data, NULL, &subvol_name);
433
	ret = btrfs_get_sb_bdev(fs_type, flags, dev_name, data, mnt,
Y
Yan 已提交
434
			subvol_name ? subvol_name : "default");
435 436
	if (subvol_name)
		kfree(subvol_name);
Y
Yan 已提交
437
	return ret;
438 439
}

C
Chris Mason 已提交
440 441 442
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct btrfs_root *root = btrfs_sb(dentry->d_sb);
443
	struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
444
	int bits = dentry->d_sb->s_blocksize_bits;
C
Chris Mason 已提交
445 446

	buf->f_namelen = BTRFS_NAME_LEN;
447 448 449
	buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
	buf->f_bfree = buf->f_blocks -
		(btrfs_super_bytes_used(disk_super) >> bits);
C
Chris Mason 已提交
450 451 452 453 454
	buf->f_bavail = buf->f_bfree;
	buf->f_bsize = dentry->d_sb->s_blocksize;
	buf->f_type = BTRFS_SUPER_MAGIC;
	return 0;
}
C
Chris Mason 已提交
455

456 457 458 459 460 461 462
static struct file_system_type btrfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "btrfs",
	.get_sb		= btrfs_get_sb,
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
463

464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
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;
	int ret;
	int len;

	vol = kmalloc(sizeof(*vol), GFP_KERNEL);
	if (copy_from_user(vol, (void __user *)arg, sizeof(*vol))) {
		ret = -EFAULT;
		goto out;
	}
	len = strnlen(vol->name, BTRFS_PATH_NAME_MAX);
	switch (cmd) {
	case BTRFS_IOC_SCAN_DEV:
		ret = btrfs_scan_one_device(vol->name, MS_RDONLY,
					    &btrfs_fs_type, &fs_devices);
		break;
	}
out:
	kfree(vol);
	return 0;
}

Y
Yan 已提交
489 490 491 492 493 494 495 496 497 498 499
static void btrfs_write_super_lockfs(struct super_block *sb)
{
	struct btrfs_root *root = btrfs_sb(sb);
	btrfs_transaction_flush_work(root);
}

static void btrfs_unlockfs(struct super_block *sb)
{
	struct btrfs_root *root = btrfs_sb(sb);
	btrfs_transaction_queue_work(root, HZ * 30);
}
500

C
Chris Mason 已提交
501
static struct super_operations btrfs_super_ops = {
C
Chris Mason 已提交
502
	.delete_inode	= btrfs_delete_inode,
503
	.put_inode	= btrfs_put_inode,
C
Chris Mason 已提交
504
	.put_super	= btrfs_put_super,
505 506
	.write_super	= btrfs_write_super,
	.sync_fs	= btrfs_sync_fs,
C
Chris Mason 已提交
507 508 509 510 511
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
	.read_inode     = btrfs_read_locked_inode,
#else
	.show_options	= generic_show_options,
#endif
C
Chris Mason 已提交
512
	.write_inode	= btrfs_write_inode,
C
Chris Mason 已提交
513
	.dirty_inode	= btrfs_dirty_inode,
C
Chris Mason 已提交
514 515
	.alloc_inode	= btrfs_alloc_inode,
	.destroy_inode	= btrfs_destroy_inode,
C
Chris Mason 已提交
516
	.statfs		= btrfs_statfs,
Y
Yan 已提交
517 518
	.write_super_lockfs = btrfs_write_super_lockfs,
	.unlockfs	= btrfs_unlockfs,
C
Chris Mason 已提交
519
};
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543

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 = {
	.minor		= MISC_DYNAMIC_MINOR,
	.name		= "btrfs-control",
	.fops		= &btrfs_ctl_fops
};

static int btrfs_interface_init(void)
{
	return misc_register(&btrfs_misc);
}

void btrfs_interface_exit(void)
{
	if (misc_deregister(&btrfs_misc) < 0)
		printk("misc_deregister failed for control device");
}

544 545
static int __init init_btrfs_fs(void)
{
C
Chris Mason 已提交
546
	int err;
547 548 549 550 551

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

C
Chris Mason 已提交
552
	btrfs_init_transaction_sys();
C
Chris Mason 已提交
553
	err = btrfs_init_cachep();
C
Chris Mason 已提交
554
	if (err)
555
		goto free_transaction_sys;
556 557

	err = extent_io_init();
558 559 560
	if (err)
		goto free_cachep;

561 562 563 564
	err = extent_map_init();
	if (err)
		goto free_extent_io;

565
	err = btrfs_interface_init();
566 567
	if (err)
		goto free_extent_map;
568 569 570
	err = register_filesystem(&btrfs_fs_type);
	if (err)
		goto unregister_ioctl;
571 572
	return 0;

573 574
unregister_ioctl:
	btrfs_interface_exit();
575 576
free_extent_map:
	extent_map_exit();
577 578
free_extent_io:
	extent_io_exit();
579 580 581 582 583 584
free_cachep:
	btrfs_destroy_cachep();
free_transaction_sys:
	btrfs_exit_transaction_sys();
	btrfs_exit_sysfs();
	return err;
585 586 587 588
}

static void __exit exit_btrfs_fs(void)
{
C
Chris Mason 已提交
589
	btrfs_exit_transaction_sys();
C
Chris Mason 已提交
590
	btrfs_destroy_cachep();
591
	extent_map_exit();
592
	extent_io_exit();
593
	btrfs_interface_exit();
594
	unregister_filesystem(&btrfs_fs_type);
595
	btrfs_exit_sysfs();
596
	btrfs_cleanup_fs_uuids();
597 598 599 600 601 602
}

module_init(init_btrfs_fs)
module_exit(exit_btrfs_fs)

MODULE_LICENSE("GPL");