2 * Copyright (C) 2007 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include <linux/blkdev.h>
20 #include <linux/module.h>
21 #include <linux/buffer_head.h>
23 #include <linux/pagemap.h>
24 #include <linux/highmem.h>
25 #include <linux/time.h>
26 #include <linux/init.h>
27 #include <linux/string.h>
28 #include <linux/smp_lock.h>
29 #include <linux/backing-dev.h>
30 #include <linux/mount.h>
31 #include <linux/mpage.h>
32 #include <linux/swap.h>
33 #include <linux/writeback.h>
34 #include <linux/statfs.h>
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>
42 #include "transaction.h"
43 #include "btrfs_inode.h"
45 #include "print-tree.h"
49 #define BTRFS_SUPER_MAGIC 0x9123683E
51 static struct super_operations btrfs_super_ops;
53 static void btrfs_put_super (struct super_block * sb)
55 struct btrfs_root *root = btrfs_sb(sb);
56 struct btrfs_fs_info *fs = root->fs_info;
59 ret = close_ctree(root);
61 printk("close ctree returns %d\n", ret);
63 btrfs_sysfs_del_super(fs);
68 Opt_degraded, Opt_subvol, Opt_device, Opt_nodatasum, Opt_nodatacow,
69 Opt_max_extent, Opt_max_inline, Opt_alloc_start, Opt_nobarrier,
73 static match_table_t tokens = {
74 {Opt_degraded, "degraded"},
75 {Opt_subvol, "subvol=%s"},
76 {Opt_device, "device=%s"},
77 {Opt_nodatasum, "nodatasum"},
78 {Opt_nodatacow, "nodatacow"},
79 {Opt_nobarrier, "nobarrier"},
80 {Opt_max_extent, "max_extent=%s"},
81 {Opt_max_inline, "max_inline=%s"},
82 {Opt_alloc_start, "alloc_start=%s"},
87 u64 btrfs_parse_size(char *str)
94 res = simple_strtoul(str, &end, 10);
113 * Regular mount options parser. Everything that is needed only when
114 * reading in a new superblock is parsed here.
116 int btrfs_parse_options(struct btrfs_root *root, char *options)
118 struct btrfs_fs_info *info = root->fs_info;
119 substring_t args[MAX_OPT_ARGS];
126 * strsep changes the string, duplicate it because parse_options
129 options = kstrdup(options, GFP_NOFS);
134 while ((p = strsep(&options, ",")) != NULL) {
139 token = match_token(p, tokens, args);
142 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
143 btrfs_set_opt(info->mount_opt, DEGRADED);
148 * These are parsed by btrfs_parse_early_options
149 * and can be happily ignored here.
153 printk(KERN_INFO "btrfs: setting nodatacsum\n");
154 btrfs_set_opt(info->mount_opt, NODATASUM);
157 printk(KERN_INFO "btrfs: setting nodatacow\n");
158 btrfs_set_opt(info->mount_opt, NODATACOW);
159 btrfs_set_opt(info->mount_opt, NODATASUM);
162 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
163 btrfs_set_opt(info->mount_opt, SSD);
166 printk(KERN_INFO "btrfs: turning off barriers\n");
167 btrfs_set_opt(info->mount_opt, NOBARRIER);
170 num = match_strdup(&args[0]);
172 info->max_extent = btrfs_parse_size(num);
175 info->max_extent = max_t(u64,
176 info->max_extent, root->sectorsize);
177 printk(KERN_INFO "btrfs: max_extent at %llu\n",
182 num = match_strdup(&args[0]);
184 info->max_inline = btrfs_parse_size(num);
187 if (info->max_inline) {
188 info->max_inline = max_t(u64,
192 printk(KERN_INFO "btrfs: max_inline at %llu\n",
196 case Opt_alloc_start:
197 num = match_strdup(&args[0]);
199 info->alloc_start = btrfs_parse_size(num);
202 "btrfs: allocations start at %llu\n",
215 * Parse mount options that are required early in the mount process.
217 * All other options will be parsed on much later in the mount process and
218 * only when we need to allocate a new super block.
220 static int btrfs_parse_early_options(const char *options, int flags,
221 void *holder, char **subvol_name,
222 struct btrfs_fs_devices **fs_devices)
224 substring_t args[MAX_OPT_ARGS];
232 * strsep changes the string, duplicate it because parse_options
235 opts = kstrdup(options, GFP_KERNEL);
239 while ((p = strsep(&opts, ",")) != NULL) {
244 token = match_token(p, tokens, args);
247 *subvol_name = match_strdup(&args[0]);
250 error = btrfs_scan_one_device(match_strdup(&args[0]),
251 flags, holder, fs_devices);
264 * If no subvolume name is specified we use the default one. Allocate
265 * a copy of the string "default" here so that code later in the
266 * mount path doesn't care if it's the default volume or another one.
269 *subvol_name = kstrdup("default", GFP_KERNEL);
276 static int btrfs_fill_super(struct super_block * sb,
277 struct btrfs_fs_devices *fs_devices,
278 void * data, int silent)
280 struct inode * inode;
281 struct dentry * root_dentry;
282 struct btrfs_super_block *disk_super;
283 struct btrfs_root *tree_root;
284 struct btrfs_inode *bi;
287 sb->s_maxbytes = MAX_LFS_FILESIZE;
288 sb->s_magic = BTRFS_SUPER_MAGIC;
289 sb->s_op = &btrfs_super_ops;
290 sb->s_xattr = btrfs_xattr_handlers;
293 tree_root = open_ctree(sb, fs_devices, (char *)data);
295 if (IS_ERR(tree_root)) {
296 printk("btrfs: open_ctree failed\n");
297 return PTR_ERR(tree_root);
299 sb->s_fs_info = tree_root;
300 disk_super = &tree_root->fs_info->super_copy;
301 inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
304 bi->location.objectid = inode->i_ino;
305 bi->location.offset = 0;
306 bi->root = tree_root;
308 btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
314 if (inode->i_state & I_NEW) {
315 btrfs_read_locked_inode(inode);
316 unlock_new_inode(inode);
319 root_dentry = d_alloc_root(inode);
326 /* this does the super kobj at the same time */
327 err = btrfs_sysfs_add_super(tree_root->fs_info);
331 sb->s_root = root_dentry;
332 btrfs_transaction_queue_work(tree_root, HZ * 30);
334 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
335 save_mount_options(sb, data);
341 close_ctree(tree_root);
345 int btrfs_sync_fs(struct super_block *sb, int wait)
347 struct btrfs_trans_handle *trans;
348 struct btrfs_root *root;
354 filemap_flush(root->fs_info->btree_inode->i_mapping);
357 btrfs_clean_old_snapshots(root);
358 mutex_lock(&root->fs_info->fs_mutex);
359 btrfs_defrag_dirty_roots(root->fs_info);
360 trans = btrfs_start_transaction(root, 1);
361 ret = btrfs_commit_transaction(trans, root);
363 mutex_unlock(&root->fs_info->fs_mutex);
367 static void btrfs_write_super(struct super_block *sb)
372 static int btrfs_test_super(struct super_block *s, void *data)
374 struct btrfs_fs_devices *test_fs_devices = data;
375 struct btrfs_root *root = btrfs_sb(s);
377 return root->fs_info->fs_devices == test_fs_devices;
381 * Find a superblock for the given device / mount point.
383 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
384 * for multiple device setup. Make sure to keep it in sync.
386 static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
387 const char *dev_name, void *data, struct vfsmount *mnt)
389 char *subvol_name = NULL;
390 struct block_device *bdev = NULL;
391 struct super_block *s;
393 struct btrfs_fs_devices *fs_devices = NULL;
396 error = btrfs_parse_early_options(data, flags, fs_type,
397 &subvol_name, &fs_devices);
401 error = btrfs_scan_one_device(dev_name, flags, fs_type, &fs_devices);
403 goto error_free_subvol_name;
405 error = btrfs_open_devices(fs_devices, flags, fs_type);
407 goto error_free_subvol_name;
409 bdev = fs_devices->latest_bdev;
410 btrfs_lock_volumes();
411 s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
412 btrfs_unlock_volumes();
417 if ((flags ^ s->s_flags) & MS_RDONLY) {
418 up_write(&s->s_umount);
425 char b[BDEVNAME_SIZE];
428 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
429 error = btrfs_fill_super(s, fs_devices, data,
430 flags & MS_SILENT ? 1 : 0);
432 up_write(&s->s_umount);
437 btrfs_sb(s)->fs_info->bdev_holder = fs_type;
438 s->s_flags |= MS_ACTIVE;
441 root = lookup_one_len(subvol_name, s->s_root, strlen(subvol_name));
443 up_write(&s->s_umount);
445 error = PTR_ERR(root);
448 if (!root->d_inode) {
450 up_write(&s->s_umount);
457 mnt->mnt_root = root;
465 btrfs_close_devices(fs_devices);
466 error_free_subvol_name:
472 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
474 struct btrfs_root *root = btrfs_sb(dentry->d_sb);
475 struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
476 int bits = dentry->d_sb->s_blocksize_bits;
478 buf->f_namelen = BTRFS_NAME_LEN;
479 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
480 buf->f_bfree = buf->f_blocks -
481 (btrfs_super_bytes_used(disk_super) >> bits);
482 buf->f_bavail = buf->f_bfree;
483 buf->f_bsize = dentry->d_sb->s_blocksize;
484 buf->f_type = BTRFS_SUPER_MAGIC;
488 static struct file_system_type btrfs_fs_type = {
489 .owner = THIS_MODULE,
491 .get_sb = btrfs_get_sb,
492 .kill_sb = kill_anon_super,
493 .fs_flags = FS_REQUIRES_DEV,
496 static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
499 struct btrfs_ioctl_vol_args *vol;
500 struct btrfs_fs_devices *fs_devices;
504 vol = kmalloc(sizeof(*vol), GFP_KERNEL);
505 if (copy_from_user(vol, (void __user *)arg, sizeof(*vol))) {
509 len = strnlen(vol->name, BTRFS_PATH_NAME_MAX);
511 case BTRFS_IOC_SCAN_DEV:
512 ret = btrfs_scan_one_device(vol->name, MS_RDONLY,
513 &btrfs_fs_type, &fs_devices);
521 static void btrfs_write_super_lockfs(struct super_block *sb)
523 struct btrfs_root *root = btrfs_sb(sb);
524 btrfs_transaction_flush_work(root);
527 static void btrfs_unlockfs(struct super_block *sb)
529 struct btrfs_root *root = btrfs_sb(sb);
530 btrfs_transaction_queue_work(root, HZ * 30);
533 static struct super_operations btrfs_super_ops = {
534 .delete_inode = btrfs_delete_inode,
535 .put_super = btrfs_put_super,
536 .write_super = btrfs_write_super,
537 .sync_fs = btrfs_sync_fs,
538 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
539 .read_inode = btrfs_read_locked_inode,
541 .show_options = generic_show_options,
543 .write_inode = btrfs_write_inode,
544 .dirty_inode = btrfs_dirty_inode,
545 .alloc_inode = btrfs_alloc_inode,
546 .destroy_inode = btrfs_destroy_inode,
547 .statfs = btrfs_statfs,
548 .write_super_lockfs = btrfs_write_super_lockfs,
549 .unlockfs = btrfs_unlockfs,
552 static const struct file_operations btrfs_ctl_fops = {
553 .unlocked_ioctl = btrfs_control_ioctl,
554 .compat_ioctl = btrfs_control_ioctl,
555 .owner = THIS_MODULE,
558 static struct miscdevice btrfs_misc = {
559 .minor = MISC_DYNAMIC_MINOR,
560 .name = "btrfs-control",
561 .fops = &btrfs_ctl_fops
564 static int btrfs_interface_init(void)
566 return misc_register(&btrfs_misc);
569 void btrfs_interface_exit(void)
571 if (misc_deregister(&btrfs_misc) < 0)
572 printk("misc_deregister failed for control device");
575 static int __init init_btrfs_fs(void)
579 err = btrfs_init_sysfs();
583 btrfs_init_transaction_sys();
584 err = btrfs_init_cachep();
586 goto free_transaction_sys;
588 err = extent_io_init();
592 err = extent_map_init();
596 err = btrfs_interface_init();
598 goto free_extent_map;
599 err = register_filesystem(&btrfs_fs_type);
601 goto unregister_ioctl;
605 btrfs_interface_exit();
611 btrfs_destroy_cachep();
612 free_transaction_sys:
613 btrfs_exit_transaction_sys();
618 static void __exit exit_btrfs_fs(void)
620 btrfs_exit_transaction_sys();
621 btrfs_destroy_cachep();
624 btrfs_interface_exit();
625 unregister_filesystem(&btrfs_fs_type);
627 btrfs_cleanup_fs_uuids();
630 module_init(init_btrfs_fs)
631 module_exit(exit_btrfs_fs)
633 MODULE_LICENSE("GPL");