Btrfs: Split the extent_map code into two parts

[mirror_ubuntu-artful-kernel.git] / fs / btrfs / super.c

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index b7323914bf5a144fc098d63764eb3db9190268f2..f8a1016600b182ae31814dba3852fb35885ab69c 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -35,6 +35,7 @@
 #include <linux/compat.h>
 #include <linux/parser.h>
 #include <linux/ctype.h>
+#include <linux/namei.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
@@ -62,20 +63,24 @@ static void btrfs_put_super (struct super_block * sb)
 }
 
 enum {
-       Opt_subvol, Opt_nodatasum, Opt_nodatacow, Opt_max_extent, Opt_err,
+       Opt_subvol, Opt_nodatasum, Opt_nodatacow, Opt_max_extent,
+       Opt_alloc_start, Opt_nobarrier, Opt_ssd, Opt_err,
 };
 
 static match_table_t tokens = {
        {Opt_subvol, "subvol=%s"},
        {Opt_nodatasum, "nodatasum"},
        {Opt_nodatacow, "nodatacow"},
+       {Opt_nobarrier, "nobarrier"},
        {Opt_max_extent, "max_extent=%s"},
+       {Opt_alloc_start, "alloc_start=%s"},
+       {Opt_ssd, "ssd"},
        {Opt_err, NULL}
 };
 
-static unsigned long parse_size(char *str)
+u64 btrfs_parse_size(char *str)
 {
-       unsigned long res;
+       u64 res;
        int mult = 1;
        char *end;
        char last;
@@ -145,11 +150,24 @@ static int parse_options (char * options,
                                btrfs_set_opt(info->mount_opt, NODATASUM);
                        }
                        break;
+               case Opt_ssd:
+                       if (info) {
+                               printk("btrfs: use ssd allocation scheme\n");
+                               btrfs_set_opt(info->mount_opt, SSD);
+                       }
+                       break;
+               case Opt_nobarrier:
+                       if (info) {
+                               printk("btrfs: turning off barriers\n");
+                               btrfs_set_opt(info->mount_opt, NOBARRIER);
+                       }
+                       break;
                case Opt_max_extent:
                        if (info) {
                                char *num = match_strdup(&args[0]);
                                if (num) {
-                                       info->max_extent = parse_size(num);
+                                       info->max_extent =
+                                               btrfs_parse_size(num);
                                        kfree(num);
 
                                        info->max_extent = max_t(u64,
@@ -160,6 +178,18 @@ static int parse_options (char * options,
                                }
                        }
                        break;
+               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;
                default:
                        break;
                }
@@ -399,9 +429,21 @@ static struct file_system_type btrfs_fs_type = {
        .kill_sb        = kill_block_super,
        .fs_flags       = FS_REQUIRES_DEV,
 };
+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);
+}
 
 static struct super_operations btrfs_super_ops = {
        .delete_inode   = btrfs_delete_inode,
+       .put_inode      = btrfs_put_inode,
        .put_super      = btrfs_put_super,
        .read_inode     = btrfs_read_locked_inode,
        .write_super    = btrfs_write_super,
@@ -411,8 +453,9 @@ static struct super_operations btrfs_super_ops = {
        .alloc_inode    = btrfs_alloc_inode,
        .destroy_inode  = btrfs_destroy_inode,
        .statfs         = btrfs_statfs,
+       .write_super_lockfs = btrfs_write_super_lockfs,
+       .unlockfs       = btrfs_unlockfs,
 };
-
 static int __init init_btrfs_fs(void)
 {
        int err;
@@ -425,10 +468,15 @@ static int __init init_btrfs_fs(void)
        err = btrfs_init_cachep();
        if (err)
                goto free_transaction_sys;
-       err = extent_map_init();
+
+       err = extent_io_init();
        if (err)
                goto free_cachep;
 
+       err = extent_map_init();
+       if (err)
+               goto free_extent_io;
+
        err = register_filesystem(&btrfs_fs_type);
        if (err)
                goto free_extent_map;
@@ -436,6 +484,8 @@ static int __init init_btrfs_fs(void)
 
 free_extent_map:
        extent_map_exit();
+free_extent_io:
+       extent_io_exit();
 free_cachep:
        btrfs_destroy_cachep();
 free_transaction_sys:
@@ -449,6 +499,7 @@ static void __exit exit_btrfs_fs(void)
        btrfs_exit_transaction_sys();
        btrfs_destroy_cachep();
        extent_map_exit();
+       extent_io_exit();
        unregister_filesystem(&btrfs_fs_type);
        btrfs_exit_sysfs();
 }