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