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 0x9123682E
  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->disk_super;
 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->location.flags = 0;
 125         bi->root = tree_root;
 126
 127         btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
 128
 129         if (!inode) {
 130                 err = -ENOMEM;
 131                 goto fail_close;
 132         }
 133         if (inode->i_state & I_NEW) {
 134                 btrfs_read_locked_inode(inode);
 135                 unlock_new_inode(inode);
 136         }
 137
 138         root_dentry = d_alloc_root(inode);
 139         if (!root_dentry) {
 140                 iput(inode);
 141                 err = -ENOMEM;
 142                 goto fail_close;
 143         }
 144
 145         /* this does the super kobj at the same time */
 146         err = btrfs_sysfs_add_super(tree_root->fs_info);
 147         if (err)
 148                 goto fail_close;
 149
 150         sb->s_root = root_dentry;
 151         btrfs_transaction_queue_work(tree_root, HZ * 30);
 152         return 0;
 153
 154 fail_close:
 155         close_ctree(tree_root);
 156         return err;
 157 }
 158
 159 static int btrfs_sync_fs(struct super_block *sb, int wait)
 160 {
 161         struct btrfs_trans_handle *trans;
 162         struct btrfs_root *root;
 163         int ret;
 164         root = btrfs_sb(sb);
 165
 166         sb->s_dirt = 0;
 167         if (!wait) {
 168                 filemap_flush(root->fs_info->btree_inode->i_mapping);
 169                 return 0;
 170         }
 171         btrfs_clean_old_snapshots(root);
 172         mutex_lock(&root->fs_info->fs_mutex);
 173         btrfs_defrag_dirty_roots(root->fs_info);
 174         trans = btrfs_start_transaction(root, 1);
 175         ret = btrfs_commit_transaction(trans, root);
 176         sb->s_dirt = 0;
 177         mutex_unlock(&root->fs_info->fs_mutex);
 178         return ret;
 179 }
 180
 181 static void btrfs_write_super(struct super_block *sb)
 182 {
 183         sb->s_dirt = 0;
 184 }
 185
 186 /*
 187  * This is almost a copy of get_sb_bdev in fs/super.c.
 188  * We need the local copy to allow direct mounting of
 189  * subvolumes, but this could be easily integrated back
 190  * into the generic version.  --hch
 191  */
 192
 193 /* start copy & paste */
 194 static int set_bdev_super(struct super_block *s, void *data)
 195 {
 196         s->s_bdev = data;
 197         s->s_dev = s->s_bdev->bd_dev;
 198         return 0;
 199 }
 200
 201 static int test_bdev_super(struct super_block *s, void *data)
 202 {
 203         return (void *)s->s_bdev == data;
 204 }
 205
 206 int btrfs_get_sb_bdev(struct file_system_type *fs_type,
 207         int flags, const char *dev_name, void *data,
 208         int (*fill_super)(struct super_block *, void *, int),
 209         struct vfsmount *mnt, const char *subvol)
 210 {
 211         struct block_device *bdev = NULL;
 212         struct super_block *s;
 213         struct dentry *root;
 214         int error = 0;
 215
 216         bdev = open_bdev_excl(dev_name, flags, fs_type);
 217         if (IS_ERR(bdev))
 218                 return PTR_ERR(bdev);
 219
 220         /*
 221          * once the super is inserted into the list by sget, s_umount
 222          * will protect the lockfs code from trying to start a snapshot
 223          * while we are mounting
 224          */
 225         down(&bdev->bd_mount_sem);
 226         s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
 227         up(&bdev->bd_mount_sem);
 228         if (IS_ERR(s))
 229                 goto error_s;
 230
 231         if (s->s_root) {
 232                 if ((flags ^ s->s_flags) & MS_RDONLY) {
 233                         up_write(&s->s_umount);
 234                         deactivate_super(s);
 235                         error = -EBUSY;
 236                         goto error_bdev;
 237                 }
 238
 239                 close_bdev_excl(bdev);
 240         } else {
 241                 char b[BDEVNAME_SIZE];
 242
 243                 s->s_flags = flags;
 244                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
 245                 sb_set_blocksize(s, block_size(bdev));
 246                 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 247                 if (error) {
 248                         up_write(&s->s_umount);
 249                         deactivate_super(s);
 250                         goto error;
 251                 }
 252
 253                 s->s_flags |= MS_ACTIVE;
 254         }
 255
 256         if (subvol) {
 257                 root = lookup_one_len(subvol, s->s_root, strlen(subvol));
 258                 if (IS_ERR(root)) {
 259                         up_write(&s->s_umount);
 260                         deactivate_super(s);
 261                         error = PTR_ERR(root);
 262                         goto error;
 263                 }
 264                 if (!root->d_inode) {
 265                         dput(root);
 266                         up_write(&s->s_umount);
 267                         deactivate_super(s);
 268                         error = -ENXIO;
 269                         goto error;
 270                 }
 271         } else {
 272                 root = dget(s->s_root);
 273         }
 274
 275         mnt->mnt_sb = s;
 276         mnt->mnt_root = root;
 277         return 0;
 278
 279 error_s:
 280         error = PTR_ERR(s);
 281 error_bdev:
 282         close_bdev_excl(bdev);
 283 error:
 284         return error;
 285 }
 286 /* end copy & paste */
 287
 288 static int btrfs_get_sb(struct file_system_type *fs_type,
 289         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 290 {
 291         int ret;
 292         char *subvol_name = NULL;
 293
 294         parse_options((char *)data, NULL, &subvol_name);
 295         ret = btrfs_get_sb_bdev(fs_type, flags, dev_name, data,
 296                         btrfs_fill_super, mnt,
 297                         subvol_name ? subvol_name : "default");
 298         return ret;
 299 }
 300
 301 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 302 {
 303         struct btrfs_root *root = btrfs_sb(dentry->d_sb);
 304         struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
 305
 306         buf->f_namelen = BTRFS_NAME_LEN;
 307         buf->f_blocks = btrfs_super_total_blocks(disk_super);
 308         buf->f_bfree = buf->f_blocks - btrfs_super_blocks_used(disk_super);
 309         buf->f_bavail = buf->f_bfree;
 310         buf->f_bsize = dentry->d_sb->s_blocksize;
 311         buf->f_type = BTRFS_SUPER_MAGIC;
 312         return 0;
 313 }
 314
 315 static struct file_system_type btrfs_fs_type = {
 316         .owner          = THIS_MODULE,
 317         .name           = "btrfs",
 318         .get_sb         = btrfs_get_sb,
 319         .kill_sb        = kill_block_super,
 320         .fs_flags       = FS_REQUIRES_DEV,
 321 };
 322
 323 static struct super_operations btrfs_super_ops = {
 324         .delete_inode   = btrfs_delete_inode,
 325         .put_super      = btrfs_put_super,
 326         .read_inode     = btrfs_read_locked_inode,
 327         .write_super    = btrfs_write_super,
 328         .sync_fs        = btrfs_sync_fs,
 329         .write_inode    = btrfs_write_inode,
 330         .dirty_inode    = btrfs_dirty_inode,
 331         .alloc_inode    = btrfs_alloc_inode,
 332         .destroy_inode  = btrfs_destroy_inode,
 333         .statfs         = btrfs_statfs,
 334 };
 335
 336 static int __init init_btrfs_fs(void)
 337 {
 338         int err;
 339
 340         err = btrfs_init_sysfs();
 341         if (err)
 342                 return err;
 343
 344         btrfs_init_transaction_sys();
 345         err = btrfs_init_cachep();
 346         if (err)
 347                 return err;
 348         extent_map_init();
 349         return register_filesystem(&btrfs_fs_type);
 350 }
 351
 352 static void __exit exit_btrfs_fs(void)
 353 {
 354         btrfs_exit_transaction_sys();
 355         btrfs_destroy_cachep();
 356         extent_map_exit();
 357         unregister_filesystem(&btrfs_fs_type);
 358         btrfs_exit_sysfs();
 359 }
 360
 361 module_init(init_btrfs_fs)
 362 module_exit(exit_btrfs_fs)
 363
 364 MODULE_LICENSE("GPL");