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