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 <linux/ctype.h>
  38 #include <linux/namei.h>
  39 #include "ctree.h"
  40 #include "disk-io.h"
  41 #include "transaction.h"
  42 #include "btrfs_inode.h"
  43 #include "ioctl.h"
  44 #include "print-tree.h"
  45 #include "xattr.h"
  46
  47 #define BTRFS_SUPER_MAGIC 0x9123683E
  48
  49 static struct super_operations btrfs_super_ops;
  50
  51 static void btrfs_put_super (struct super_block * sb)
  52 {
  53         struct btrfs_root *root = btrfs_sb(sb);
  54         struct btrfs_fs_info *fs = root->fs_info;
  55         int ret;
  56
  57         ret = close_ctree(root);
  58         if (ret) {
  59                 printk("close ctree returns %d\n", ret);
  60         }
  61         btrfs_sysfs_del_super(fs);
  62         sb->s_fs_info = NULL;
  63 }
  64
  65 enum {
  66         Opt_subvol, Opt_nodatasum, Opt_nodatacow, Opt_max_extent,
  67         Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd, Opt_err,
  68 };
  69
  70 static match_table_t tokens = {
  71         {Opt_subvol, "subvol=%s"},
  72         {Opt_nodatasum, "nodatasum"},
  73         {Opt_nodatacow, "nodatacow"},
  74         {Opt_nobarrier, "nobarrier"},
  75         {Opt_max_extent, "max_extent=%s"},
  76         {Opt_max_inline, "max_inline=%s"},
  77         {Opt_alloc_start, "alloc_start=%s"},
  78         {Opt_ssd, "ssd"},
  79         {Opt_err, NULL}
  80 };
  81
  82 u64 btrfs_parse_size(char *str)
  83 {
  84         u64 res;
  85         int mult = 1;
  86         char *end;
  87         char last;
  88
  89         res = simple_strtoul(str, &end, 10);
  90
  91         last = end[0];
  92         if (isalpha(last)) {
  93                 last = tolower(last);
  94                 switch (last) {
  95                 case 'g':
  96                         mult *= 1024;
  97                 case 'm':
  98                         mult *= 1024;
  99                 case 'k':
 100                         mult *= 1024;
 101                 }
 102                 res = res * mult;
 103         }
 104         return res;
 105 }
 106
 107 static int parse_options (char * options,
 108                           struct btrfs_root *root,
 109                           char **subvol_name)
 110 {
 111         char * p;
 112         struct btrfs_fs_info *info = NULL;
 113         substring_t args[MAX_OPT_ARGS];
 114
 115         if (!options)
 116                 return 1;
 117
 118         /*
 119          * strsep changes the string, duplicate it because parse_options
 120          * gets called twice
 121          */
 122         options = kstrdup(options, GFP_NOFS);
 123         if (!options)
 124                 return -ENOMEM;
 125
 126         if (root)
 127                 info = root->fs_info;
 128
 129         while ((p = strsep (&options, ",")) != NULL) {
 130                 int token;
 131                 if (!*p)
 132                         continue;
 133
 134                 token = match_token(p, tokens, args);
 135                 switch (token) {
 136                 case Opt_subvol:
 137                         if (subvol_name) {
 138                                 *subvol_name = match_strdup(&args[0]);
 139                         }
 140                         break;
 141                 case Opt_nodatasum:
 142                         if (info) {
 143                                 printk("btrfs: setting nodatacsum\n");
 144                                 btrfs_set_opt(info->mount_opt, NODATASUM);
 145                         }
 146                         break;
 147                 case Opt_nodatacow:
 148                         if (info) {
 149                                 printk("btrfs: setting nodatacow\n");
 150                                 btrfs_set_opt(info->mount_opt, NODATACOW);
 151                                 btrfs_set_opt(info->mount_opt, NODATASUM);
 152                         }
 153                         break;
 154                 case Opt_ssd:
 155                         if (info) {
 156                                 printk("btrfs: use ssd allocation scheme\n");
 157                                 btrfs_set_opt(info->mount_opt, SSD);
 158                         }
 159                         break;
 160                 case Opt_nobarrier:
 161                         if (info) {
 162                                 printk("btrfs: turning off barriers\n");
 163                                 btrfs_set_opt(info->mount_opt, NOBARRIER);
 164                         }
 165                         break;
 166                 case Opt_max_extent:
 167                         if (info) {
 168                                 char *num = match_strdup(&args[0]);
 169                                 if (num) {
 170                                         info->max_extent =
 171                                                 btrfs_parse_size(num);
 172                                         kfree(num);
 173
 174                                         info->max_extent = max_t(u64,
 175                                                          info->max_extent,
 176                                                          root->sectorsize);
 177                                         printk("btrfs: max_extent at %Lu\n",
 178                                                info->max_extent);
 179                                 }
 180                         }
 181                         break;
 182                 case Opt_max_inline:
 183                         if (info) {
 184                                 char *num = match_strdup(&args[0]);
 185                                 if (num) {
 186                                         info->max_inline =
 187                                                 btrfs_parse_size(num);
 188                                         kfree(num);
 189
 190                                         info->max_inline = max_t(u64,
 191                                                          info->max_inline,
 192                                                          root->sectorsize);
 193                                         printk("btrfs: max_inline at %Lu\n",
 194                                                info->max_inline);
 195                                 }
 196                         }
 197                         break;
 198                 case Opt_alloc_start:
 199                         if (info) {
 200                                 char *num = match_strdup(&args[0]);
 201                                 if (num) {
 202                                         info->alloc_start =
 203                                                 btrfs_parse_size(num);
 204                                         kfree(num);
 205                                         printk("btrfs: allocations start at "
 206                                                "%Lu\n", info->alloc_start);
 207                                 }
 208                         }
 209                         break;
 210                 default:
 211                         break;
 212                 }
 213         }
 214         kfree(options);
 215         return 1;
 216 }
 217
 218 static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
 219 {
 220         struct inode * inode;
 221         struct dentry * root_dentry;
 222         struct btrfs_super_block *disk_super;
 223         struct btrfs_root *tree_root;
 224         struct btrfs_inode *bi;
 225         int err;
 226
 227         sb->s_maxbytes = MAX_LFS_FILESIZE;
 228         sb->s_magic = BTRFS_SUPER_MAGIC;
 229         sb->s_op = &btrfs_super_ops;
 230         sb->s_xattr = btrfs_xattr_handlers;
 231         sb->s_time_gran = 1;
 232
 233         tree_root = open_ctree(sb);
 234
 235         if (!tree_root || IS_ERR(tree_root)) {
 236                 printk("btrfs: open_ctree failed\n");
 237                 return -EIO;
 238         }
 239         sb->s_fs_info = tree_root;
 240         disk_super = &tree_root->fs_info->super_copy;
 241         inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
 242                                   tree_root);
 243         bi = BTRFS_I(inode);
 244         bi->location.objectid = inode->i_ino;
 245         bi->location.offset = 0;
 246         bi->root = tree_root;
 247
 248         btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
 249
 250         if (!inode) {
 251                 err = -ENOMEM;
 252                 goto fail_close;
 253         }
 254         if (inode->i_state & I_NEW) {
 255                 btrfs_read_locked_inode(inode);
 256                 unlock_new_inode(inode);
 257         }
 258
 259         root_dentry = d_alloc_root(inode);
 260         if (!root_dentry) {
 261                 iput(inode);
 262                 err = -ENOMEM;
 263                 goto fail_close;
 264         }
 265
 266         parse_options((char *)data, tree_root, NULL);
 267
 268         /* this does the super kobj at the same time */
 269         err = btrfs_sysfs_add_super(tree_root->fs_info);
 270         if (err)
 271                 goto fail_close;
 272
 273         sb->s_root = root_dentry;
 274         btrfs_transaction_queue_work(tree_root, HZ * 30);
 275         return 0;
 276
 277 fail_close:
 278         close_ctree(tree_root);
 279         return err;
 280 }
 281
 282 static int btrfs_sync_fs(struct super_block *sb, int wait)
 283 {
 284         struct btrfs_trans_handle *trans;
 285         struct btrfs_root *root;
 286         int ret;
 287         root = btrfs_sb(sb);
 288
 289         sb->s_dirt = 0;
 290         if (!wait) {
 291                 filemap_flush(root->fs_info->btree_inode->i_mapping);
 292                 return 0;
 293         }
 294         btrfs_clean_old_snapshots(root);
 295         mutex_lock(&root->fs_info->fs_mutex);
 296         btrfs_defrag_dirty_roots(root->fs_info);
 297         trans = btrfs_start_transaction(root, 1);
 298         ret = btrfs_commit_transaction(trans, root);
 299         sb->s_dirt = 0;
 300         mutex_unlock(&root->fs_info->fs_mutex);
 301         return ret;
 302 }
 303
 304 static void btrfs_write_super(struct super_block *sb)
 305 {
 306         sb->s_dirt = 0;
 307 }
 308
 309 /*
 310  * This is almost a copy of get_sb_bdev in fs/super.c.
 311  * We need the local copy to allow direct mounting of
 312  * subvolumes, but this could be easily integrated back
 313  * into the generic version.  --hch
 314  */
 315
 316 /* start copy & paste */
 317 static int set_bdev_super(struct super_block *s, void *data)
 318 {
 319         s->s_bdev = data;
 320         s->s_dev = s->s_bdev->bd_dev;
 321         return 0;
 322 }
 323
 324 static int test_bdev_super(struct super_block *s, void *data)
 325 {
 326         return (void *)s->s_bdev == data;
 327 }
 328
 329 int btrfs_get_sb_bdev(struct file_system_type *fs_type,
 330         int flags, const char *dev_name, void *data,
 331         int (*fill_super)(struct super_block *, void *, int),
 332         struct vfsmount *mnt, const char *subvol)
 333 {
 334         struct block_device *bdev = NULL;
 335         struct super_block *s;
 336         struct dentry *root;
 337         int error = 0;
 338
 339         bdev = open_bdev_excl(dev_name, flags, fs_type);
 340         if (IS_ERR(bdev))
 341                 return PTR_ERR(bdev);
 342
 343         /*
 344          * once the super is inserted into the list by sget, s_umount
 345          * will protect the lockfs code from trying to start a snapshot
 346          * while we are mounting
 347          */
 348         down(&bdev->bd_mount_sem);
 349         s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
 350         up(&bdev->bd_mount_sem);
 351         if (IS_ERR(s))
 352                 goto error_s;
 353
 354         if (s->s_root) {
 355                 if ((flags ^ s->s_flags) & MS_RDONLY) {
 356                         up_write(&s->s_umount);
 357                         deactivate_super(s);
 358                         error = -EBUSY;
 359                         goto error_bdev;
 360                 }
 361
 362                 close_bdev_excl(bdev);
 363         } else {
 364                 char b[BDEVNAME_SIZE];
 365
 366                 s->s_flags = flags;
 367                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
 368                 sb_set_blocksize(s, block_size(bdev));
 369                 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 370                 if (error) {
 371                         up_write(&s->s_umount);
 372                         deactivate_super(s);
 373                         goto error;
 374                 }
 375
 376                 s->s_flags |= MS_ACTIVE;
 377         }
 378
 379         if (subvol) {
 380                 root = lookup_one_len(subvol, s->s_root, strlen(subvol));
 381                 if (IS_ERR(root)) {
 382                         up_write(&s->s_umount);
 383                         deactivate_super(s);
 384                         error = PTR_ERR(root);
 385                         goto error;
 386                 }
 387                 if (!root->d_inode) {
 388                         dput(root);
 389                         up_write(&s->s_umount);
 390                         deactivate_super(s);
 391                         error = -ENXIO;
 392                         goto error;
 393                 }
 394         } else {
 395                 root = dget(s->s_root);
 396         }
 397
 398         mnt->mnt_sb = s;
 399         mnt->mnt_root = root;
 400         return 0;
 401
 402 error_s:
 403         error = PTR_ERR(s);
 404 error_bdev:
 405         close_bdev_excl(bdev);
 406 error:
 407         return error;
 408 }
 409 /* end copy & paste */
 410
 411 static int btrfs_get_sb(struct file_system_type *fs_type,
 412         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 413 {
 414         int ret;
 415         char *subvol_name = NULL;
 416
 417         parse_options((char *)data, NULL, &subvol_name);
 418         ret = btrfs_get_sb_bdev(fs_type, flags, dev_name, data,
 419                         btrfs_fill_super, mnt,
 420                         subvol_name ? subvol_name : "default");
 421         if (subvol_name)
 422                 kfree(subvol_name);
 423         return ret;
 424 }
 425
 426 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 427 {
 428         struct btrfs_root *root = btrfs_sb(dentry->d_sb);
 429         struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
 430         int bits = dentry->d_sb->s_blocksize_bits;
 431
 432         buf->f_namelen = BTRFS_NAME_LEN;
 433         buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
 434         buf->f_bfree = buf->f_blocks -
 435                 (btrfs_super_bytes_used(disk_super) >> bits);
 436         buf->f_bavail = buf->f_bfree;
 437         buf->f_bsize = dentry->d_sb->s_blocksize;
 438         buf->f_type = BTRFS_SUPER_MAGIC;
 439         return 0;
 440 }
 441
 442 static struct file_system_type btrfs_fs_type = {
 443         .owner          = THIS_MODULE,
 444         .name           = "btrfs",
 445         .get_sb         = btrfs_get_sb,
 446         .kill_sb        = kill_block_super,
 447         .fs_flags       = FS_REQUIRES_DEV,
 448 };
 449 static void btrfs_write_super_lockfs(struct super_block *sb)
 450 {
 451         struct btrfs_root *root = btrfs_sb(sb);
 452         btrfs_transaction_flush_work(root);
 453 }
 454
 455 static void btrfs_unlockfs(struct super_block *sb)
 456 {
 457         struct btrfs_root *root = btrfs_sb(sb);
 458         btrfs_transaction_queue_work(root, HZ * 30);
 459 }
 460
 461 static struct super_operations btrfs_super_ops = {
 462         .delete_inode   = btrfs_delete_inode,
 463         .put_inode      = btrfs_put_inode,
 464         .put_super      = btrfs_put_super,
 465         .read_inode     = btrfs_read_locked_inode,
 466         .write_super    = btrfs_write_super,
 467         .sync_fs        = btrfs_sync_fs,
 468         .write_inode    = btrfs_write_inode,
 469         .dirty_inode    = btrfs_dirty_inode,
 470         .alloc_inode    = btrfs_alloc_inode,
 471         .destroy_inode  = btrfs_destroy_inode,
 472         .statfs         = btrfs_statfs,
 473         .write_super_lockfs = btrfs_write_super_lockfs,
 474         .unlockfs       = btrfs_unlockfs,
 475 };
 476 static int __init init_btrfs_fs(void)
 477 {
 478         int err;
 479
 480         err = btrfs_init_sysfs();
 481         if (err)
 482                 return err;
 483
 484         btrfs_init_transaction_sys();
 485         err = btrfs_init_cachep();
 486         if (err)
 487                 goto free_transaction_sys;
 488
 489         err = extent_io_init();
 490         if (err)
 491                 goto free_cachep;
 492
 493         err = extent_map_init();
 494         if (err)
 495                 goto free_extent_io;
 496
 497         err = register_filesystem(&btrfs_fs_type);
 498         if (err)
 499                 goto free_extent_map;
 500         return 0;
 501
 502 free_extent_map:
 503         extent_map_exit();
 504 free_extent_io:
 505         extent_io_exit();
 506 free_cachep:
 507         btrfs_destroy_cachep();
 508 free_transaction_sys:
 509         btrfs_exit_transaction_sys();
 510         btrfs_exit_sysfs();
 511         return err;
 512 }
 513
 514 static void __exit exit_btrfs_fs(void)
 515 {
 516         btrfs_exit_transaction_sys();
 517         btrfs_destroy_cachep();
 518         extent_map_exit();
 519         extent_io_exit();
 520         unregister_filesystem(&btrfs_fs_type);
 521         btrfs_exit_sysfs();
 522 }
 523
 524 module_init(init_btrfs_fs)
 525 module_exit(exit_btrfs_fs)
 526
 527 MODULE_LICENSE("GPL");