fs/btrfs/super.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   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.
   7  *
   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.
  12  *
  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.
  17  */
  18
  19 #include <linux/blkdev.h>
  20 #include <linux/module.h>
  21 #include <linux/buffer_head.h>
  22 #include <linux/fs.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 "ctree.h"
  38 #include "disk-io.h"
  39 #include "transaction.h"
  40 #include "btrfs_inode.h"
  41 #include "ioctl.h"
  42 #include "print-tree.h"
  43
  44 #define BTRFS_SUPER_MAGIC 0x9123683E
  45
  46 static struct super_operations btrfs_super_ops;
  47
  48 static void btrfs_put_super (struct super_block * sb)
  49 {
  50         struct btrfs_root *root = btrfs_sb(sb);
  51         struct btrfs_fs_info *fs = root->fs_info;
  52         int ret;
  53
  54         ret = close_ctree(root);
  55         if (ret) {
  56                 printk("close ctree returns %d\n", ret);
  57         }
  58         btrfs_sysfs_del_super(fs);
  59         sb->s_fs_info = NULL;
  60 }
  61
  62 enum {
  63         Opt_subvol, Opt_err,
  64 };
  65
  66 static match_table_t tokens = {
  67         {Opt_subvol, "subvol=%s"},
  68         {Opt_err, NULL}
  69 };
  70
  71 static int parse_options (char * options,
  72                           struct btrfs_root *root,
  73                           char **subvol_name)
  74 {
  75         char * p;
  76         substring_t args[MAX_OPT_ARGS];
  77         if (!options)
  78                 return 1;
  79
  80         while ((p = strsep (&options, ",")) != NULL) {
  81                 int token;
  82                 if (!*p)
  83                         continue;
  84
  85                 token = match_token(p, tokens, args);
  86                 switch (token) {
  87                 case Opt_subvol:
  88                         *subvol_name = match_strdup(&args[0]);
  89                         break;
  90                 default:
  91                         return 0;
  92                 }
  93         }
  94         return 1;
  95 }
  96
  97 static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
  98 {
  99         struct inode * inode;
 100         struct dentry * root_dentry;
 101         struct btrfs_super_block *disk_super;
 102         struct btrfs_root *tree_root;
 103         struct btrfs_inode *bi;
 104         int err;
 105
 106         sb->s_maxbytes = MAX_LFS_FILESIZE;
 107         sb->s_magic = BTRFS_SUPER_MAGIC;
 108         sb->s_op = &btrfs_super_ops;
 109         sb->s_time_gran = 1;
 110
 111         tree_root = open_ctree(sb);
 112
 113         if (!tree_root || IS_ERR(tree_root)) {
 114                 printk("btrfs: open_ctree failed\n");
 115                 return -EIO;
 116         }
 117         sb->s_fs_info = tree_root;
 118         disk_super = &tree_root->fs_info->super_copy;
 119         inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
 120                                   tree_root);
 121         bi = BTRFS_I(inode);
 122         bi->location.objectid = inode->i_ino;
 123         bi->location.offset = 0;
 124         bi->root = tree_root;
 125
 126         btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
 127
 128         if (!inode) {
 129                 err = -ENOMEM;
 130                 goto fail_close;
 131         }
 132         if (inode->i_state & I_NEW) {
 133                 btrfs_read_locked_inode(inode);
 134                 unlock_new_inode(inode);
 135         }
 136
 137         root_dentry = d_alloc_root(inode);
 138         if (!root_dentry) {
 139                 iput(inode);
 140                 err = -ENOMEM;
 141                 goto fail_close;
 142         }
 143
 144         /* this does the super kobj at the same time */
 145         err = btrfs_sysfs_add_super(tree_root->fs_info);
 146         if (err)
 147                 goto fail_close;
 148
 149         sb->s_root = root_dentry;
 150         btrfs_transaction_queue_work(tree_root, HZ * 30);
 151         return 0;
 152
 153 fail_close:
 154         close_ctree(tree_root);
 155         return err;
 156 }
 157
 158 static int btrfs_sync_fs(struct super_block *sb, int wait)
 159 {
 160         struct btrfs_trans_handle *trans;
 161         struct btrfs_root *root;
 162         int ret;
 163         root = btrfs_sb(sb);
 164
 165         sb->s_dirt = 0;
 166         if (!wait) {
 167                 filemap_flush(root->fs_info->btree_inode->i_mapping);
 168                 return 0;
 169         }
 170         btrfs_clean_old_snapshots(root);
 171         mutex_lock(&root->fs_info->fs_mutex);
 172         btrfs_defrag_dirty_roots(root->fs_info);
 173         trans = btrfs_start_transaction(root, 1);
 174         ret = btrfs_commit_transaction(trans, root);
 175         sb->s_dirt = 0;
 176         mutex_unlock(&root->fs_info->fs_mutex);
 177         return ret;
 178 }
 179
 180 static void btrfs_write_super(struct super_block *sb)
 181 {
 182         sb->s_dirt = 0;
 183 }
 184
 185 /*
 186  * This is almost a copy of get_sb_bdev in fs/super.c.
 187  * We need the local copy to allow direct mounting of
 188  * subvolumes, but this could be easily integrated back
 189  * into the generic version.  --hch
 190  */
 191
 192 /* start copy & paste */
 193 static int set_bdev_super(struct super_block *s, void *data)
 194 {
 195         s->s_bdev = data;
 196         s->s_dev = s->s_bdev->bd_dev;
 197         return 0;
 198 }
 199
 200 static int test_bdev_super(struct super_block *s, void *data)
 201 {
 202         return (void *)s->s_bdev == data;
 203 }
 204
 205 int btrfs_get_sb_bdev(struct file_system_type *fs_type,
 206         int flags, const char *dev_name, void *data,
 207         int (*fill_super)(struct super_block *, void *, int),
 208         struct vfsmount *mnt, const char *subvol)
 209 {
 210         struct block_device *bdev = NULL;
 211         struct super_block *s;
 212         struct dentry *root;
 213         int error = 0;
 214
 215         bdev = open_bdev_excl(dev_name, flags, fs_type);
 216         if (IS_ERR(bdev))
 217                 return PTR_ERR(bdev);
 218
 219         /*
 220          * once the super is inserted into the list by sget, s_umount
 221          * will protect the lockfs code from trying to start a snapshot
 222          * while we are mounting
 223          */
 224         down(&bdev->bd_mount_sem);
 225         s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
 226         up(&bdev->bd_mount_sem);
 227         if (IS_ERR(s))
 228                 goto error_s;
 229
 230         if (s->s_root) {
 231                 if ((flags ^ s->s_flags) & MS_RDONLY) {
 232                         up_write(&s->s_umount);
 233                         deactivate_super(s);
 234                         error = -EBUSY;
 235                         goto error_bdev;
 236                 }
 237
 238                 close_bdev_excl(bdev);
 239         } else {
 240                 char b[BDEVNAME_SIZE];
 241
 242                 s->s_flags = flags;
 243                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
 244                 sb_set_blocksize(s, block_size(bdev));
 245                 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 246                 if (error) {
 247                         up_write(&s->s_umount);
 248                         deactivate_super(s);
 249                         goto error;
 250                 }
 251
 252                 s->s_flags |= MS_ACTIVE;
 253         }
 254
 255         if (subvol) {
 256                 root = lookup_one_len(subvol, s->s_root, strlen(subvol));
 257                 if (IS_ERR(root)) {
 258                         up_write(&s->s_umount);
 259                         deactivate_super(s);
 260                         error = PTR_ERR(root);
 261                         goto error;
 262                 }
 263                 if (!root->d_inode) {
 264                         dput(root);
 265                         up_write(&s->s_umount);
 266                         deactivate_super(s);
 267                         error = -ENXIO;
 268                         goto error;
 269                 }
 270         } else {
 271                 root = dget(s->s_root);
 272         }
 273
 274         mnt->mnt_sb = s;
 275         mnt->mnt_root = root;
 276         return 0;
 277
 278 error_s:
 279         error = PTR_ERR(s);
 280 error_bdev:
 281         close_bdev_excl(bdev);
 282 error:
 283         return error;
 284 }
 285 /* end copy & paste */
 286
 287 static int btrfs_get_sb(struct file_system_type *fs_type,
 288         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 289 {
 290         int ret;
 291         char *subvol_name = NULL;
 292
 293         parse_options((char *)data, NULL, &subvol_name);
 294         ret = btrfs_get_sb_bdev(fs_type, flags, dev_name, data,
 295                         btrfs_fill_super, mnt,
 296                         subvol_name ? subvol_name : "default");
 297         return ret;
 298 }
 299
 300 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 301 {
 302         struct btrfs_root *root = btrfs_sb(dentry->d_sb);
 303         struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
 304         int bits = dentry->d_sb->s_blocksize_bits;
 305
 306         buf->f_namelen = BTRFS_NAME_LEN;
 307         buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
 308         buf->f_bfree = buf->f_blocks -
 309                 (btrfs_super_bytes_used(disk_super) >> bits);
 310         buf->f_bavail = buf->f_bfree;
 311         buf->f_bsize = dentry->d_sb->s_blocksize;
 312         buf->f_type = BTRFS_SUPER_MAGIC;
 313         return 0;
 314 }
 315
 316 static struct file_system_type btrfs_fs_type = {
 317         .owner          = THIS_MODULE,
 318         .name           = "btrfs",
 319         .get_sb         = btrfs_get_sb,
 320         .kill_sb        = kill_block_super,
 321         .fs_flags       = FS_REQUIRES_DEV,
 322 };
 323
 324 static struct super_operations btrfs_super_ops = {
 325         .delete_inode   = btrfs_delete_inode,
 326         .put_super      = btrfs_put_super,
 327         .read_inode     = btrfs_read_locked_inode,
 328         .write_super    = btrfs_write_super,
 329         .sync_fs        = btrfs_sync_fs,
 330         .write_inode    = btrfs_write_inode,
 331         .dirty_inode    = btrfs_dirty_inode,
 332         .alloc_inode    = btrfs_alloc_inode,
 333         .destroy_inode  = btrfs_destroy_inode,
 334         .statfs         = btrfs_statfs,
 335 };
 336
 337 static int __init init_btrfs_fs(void)
 338 {
 339         int err;
 340
 341         err = btrfs_init_sysfs();
 342         if (err)
 343                 return err;
 344
 345         btrfs_init_transaction_sys();
 346         err = btrfs_init_cachep();
 347         if (err)
 348                 return err;
 349         extent_map_init();
 350         return register_filesystem(&btrfs_fs_type);
 351 }
 352
 353 static void __exit exit_btrfs_fs(void)
 354 {
 355         btrfs_exit_transaction_sys();
 356         btrfs_destroy_cachep();
 357         extent_map_exit();
 358         unregister_filesystem(&btrfs_fs_type);
 359         btrfs_exit_sysfs();
 360 }
 361
 362 module_init(init_btrfs_fs)
 363 module_exit(exit_btrfs_fs)
 364
 365 MODULE_LICENSE("GPL");