Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs

Pull btrfs update from Chris Mason:
 "The biggest feature in the pull is the new (and still experimental)
  raid56 code that David Woodhouse started long ago.  I'm still working
  on the parity logging setup that will avoid inconsistent parity after
  a crash, so this is only for testing right now.  But, I'd really like
  to get it out to a broader audience to hammer out any performance
  issues or other problems.

  scrub does not yet correct errors on raid5/6 either.

  Josef has another pass at fsync performance.  The big change here is
  to combine waiting for metadata with waiting for data, which is a big
  latency win.  It is also step one toward using atomics from the
  hardware during a commit.

  Mark Fasheh has a new way to use btrfs send/receive to send only the
  metadata changes.  SUSE is using this to make snapper more efficient
  at finding changes between snapshosts.

  Snapshot-aware defrag is also included.

  Otherwise we have a large number of fixes and cleanups.  Eric Sandeen
  wins the award for removing the most lines, and I'm hoping we steal
  this idea from XFS over and over again."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (118 commits)
  btrfs: fixup/remove module.h usage as required
  Btrfs: delete inline extents when we find them during logging
  btrfs: try harder to allocate raid56 stripe cache
  Btrfs: cleanup to make the function btrfs_delalloc_reserve_metadata more logic
  Btrfs: don't call btrfs_qgroup_free if just btrfs_qgroup_reserve fails
  Btrfs: remove reduplicate check about root in the function btrfs_clean_quota_tree
  Btrfs: return ENOMEM rather than use BUG_ON when btrfs_alloc_path fails
  Btrfs: fix missing deleted items in btrfs_clean_quota_tree
  btrfs: use only inline_pages from extent buffer
  Btrfs: fix wrong reserved space when deleting a snapshot/subvolume
  Btrfs: fix wrong reserved space in qgroup during snap/subv creation
  Btrfs: remove unnecessary dget_parent/dput when creating the pending snapshot
  btrfs: remove a printk from scan_one_device
  Btrfs: fix NULL pointer after aborting a transaction
  Btrfs: fix memory leak of log roots
  Btrfs: copy everything if we've created an inline extent
  btrfs: cleanup for open-coded alignment
  Btrfs: do not change inode flags in rename
  Btrfs: use reserved space for creating a snapshot
  clear chunk_alloc flag on retryable failure
  ...

1 files changed, 163 insertions, 48 deletions

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index c3f09f71bedd..c83086fdda05 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -42,12 +42,12 @@
 #include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/uuid.h>
+#include <linux/btrfs.h>
 #include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
 #include "btrfs_inode.h"
-#include "ioctl.h"
 #include "print-tree.h"
 #include "volumes.h"
 #include "locking.h"
@@ -363,46 +363,52 @@ static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
         return 0;
 }
 
-static noinline int create_subvol(struct btrfs_root *root,
+static noinline int create_subvol(struct inode *dir,
                                   struct dentry *dentry,
                                   char *name, int namelen,
                                   u64 *async_transid,
-                                  struct btrfs_qgroup_inherit **inherit)
+                                  struct btrfs_qgroup_inherit *inherit)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_key key;
         struct btrfs_root_item root_item;
         struct btrfs_inode_item *inode_item;
         struct extent_buffer *leaf;
+        struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_root *new_root;
-        struct dentry *parent = dentry->d_parent;
-        struct inode *dir;
+        struct btrfs_block_rsv block_rsv;
         struct timespec cur_time = CURRENT_TIME;
         int ret;
         int err;
         u64 objectid;
         u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
         u64 index = 0;
+        u64 qgroup_reserved;
         uuid_le new_uuid;
 
         ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid);
         if (ret)
                 return ret;
 
-        dir = parent->d_inode;
-
+        btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
         /*
-         * 1 - inode item
-         * 2 - refs
-         * 1 - root item
-         * 2 - dir items
+         * The same as the snapshot creation, please see the comment
+         * of create_snapshot().
          */
-        trans = btrfs_start_transaction(root, 6);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
+        ret = btrfs_subvolume_reserve_metadata(root, &block_rsv,
+                                               7, &qgroup_reserved);
+        if (ret)
+                return ret;
+
+        trans = btrfs_start_transaction(root, 0);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                goto out;
+        }
+        trans->block_rsv = &block_rsv;
+        trans->bytes_reserved = block_rsv.size;
 
-        ret = btrfs_qgroup_inherit(trans, root->fs_info, 0, objectid,
-                                   inherit ? *inherit : NULL);
+        ret = btrfs_qgroup_inherit(trans, root->fs_info, 0, objectid, inherit);
         if (ret)
                 goto fail;
 
@@ -516,6 +522,8 @@ static noinline int create_subvol(struct btrfs_root *root,
         BUG_ON(ret);
 
 fail:
+        trans->block_rsv = NULL;
+        trans->bytes_reserved = 0;
         if (async_transid) {
                 *async_transid = trans->transid;
                 err = btrfs_commit_transaction_async(trans, root, 1);
@@ -527,13 +535,15 @@ fail:
 
         if (!ret)
                 d_instantiate(dentry, btrfs_lookup_dentry(dir, dentry));
-
+out:
+        btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
         return ret;
 }
 
-static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
-                           char *name, int namelen, u64 *async_transid,
-                           bool readonly, struct btrfs_qgroup_inherit **inherit)
+static int create_snapshot(struct btrfs_root *root, struct inode *dir,
+                           struct dentry *dentry, char *name, int namelen,
+                           u64 *async_transid, bool readonly,
+                           struct btrfs_qgroup_inherit *inherit)
 {
         struct inode *inode;
         struct btrfs_pending_snapshot *pending_snapshot;
@@ -549,23 +559,31 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
 
         btrfs_init_block_rsv(&pending_snapshot->block_rsv,
                              BTRFS_BLOCK_RSV_TEMP);
+        /*
+         * 1 - parent dir inode
+         * 2 - dir entries
+         * 1 - root item
+         * 2 - root ref/backref
+         * 1 - root of snapshot
+         */
+        ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
+                                        &pending_snapshot->block_rsv, 7,
+                                        &pending_snapshot->qgroup_reserved);
+        if (ret)
+                goto out;
+
         pending_snapshot->dentry = dentry;
         pending_snapshot->root = root;
         pending_snapshot->readonly = readonly;
-        if (inherit) {
-                pending_snapshot->inherit = *inherit;
-                *inherit = NULL;        /* take responsibility to free it */
-        }
+        pending_snapshot->dir = dir;
+        pending_snapshot->inherit = inherit;
 
-        trans = btrfs_start_transaction(root->fs_info->extent_root, 6);
+        trans = btrfs_start_transaction(root, 0);
         if (IS_ERR(trans)) {
                 ret = PTR_ERR(trans);
                 goto fail;
         }
 
-        ret = btrfs_snap_reserve_metadata(trans, pending_snapshot);
-        BUG_ON(ret);
-
         spin_lock(&root->fs_info->trans_lock);
         list_add(&pending_snapshot->list,
                  &trans->transaction->pending_snapshots);
@@ -602,6 +620,10 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
         d_instantiate(dentry, inode);
         ret = 0;
 fail:
+        btrfs_subvolume_release_metadata(BTRFS_I(dir)->root,
+                                         &pending_snapshot->block_rsv,
+                                         pending_snapshot->qgroup_reserved);
+out:
         kfree(pending_snapshot);
         return ret;
 }
@@ -695,7 +717,7 @@ static noinline int btrfs_mksubvol(struct path *parent,
                                    char *name, int namelen,
                                    struct btrfs_root *snap_src,
                                    u64 *async_transid, bool readonly,
-                                   struct btrfs_qgroup_inherit **inherit)
+                                   struct btrfs_qgroup_inherit *inherit)
 {
         struct inode *dir  = parent->dentry->d_inode;
         struct dentry *dentry;
@@ -732,11 +754,11 @@ static noinline int btrfs_mksubvol(struct path *parent,
                 goto out_up_read;
 
         if (snap_src) {
-                error = create_snapshot(snap_src, dentry, name, namelen,
+                error = create_snapshot(snap_src, dir, dentry, name, namelen,
                                         async_transid, readonly, inherit);
         } else {
-                error = create_subvol(BTRFS_I(dir)->root, dentry,
-                                      name, namelen, async_transid, inherit);
+                error = create_subvol(dir, dentry, name, namelen,
+                                      async_transid, inherit);
         }
         if (!error)
                 fsnotify_mkdir(dir, dentry);
@@ -818,7 +840,7 @@ static int find_new_extents(struct btrfs_root *root,
 
         while(1) {
                 ret = btrfs_search_forward(root, &min_key, &max_key,
-                                           path, 0, newer_than);
+                                           path, newer_than);
                 if (ret != 0)
                         goto none;
                 if (min_key.objectid != ino)
@@ -1206,6 +1228,12 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                 if (!(inode->i_sb->s_flags & MS_ACTIVE))
                         break;
 
+                if (btrfs_defrag_cancelled(root->fs_info)) {
+                        printk(KERN_DEBUG "btrfs: defrag_file cancelled\n");
+                        ret = -EAGAIN;
+                        break;
+                }
+
                 if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
                                          extent_thresh, &last_len, &skip,
                                          &defrag_end, range->flags &
@@ -1329,9 +1357,6 @@ static noinline int btrfs_ioctl_resize(struct file *file,
         int ret = 0;
         int mod = 0;
 
-        if (root->fs_info->sb->s_flags & MS_RDONLY)
-                return -EROFS;
-
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
@@ -1363,6 +1388,10 @@ static noinline int btrfs_ioctl_resize(struct file *file,
                 *devstr = '\0';
                 devstr = vol_args->name;
                 devid = simple_strtoull(devstr, &end, 10);
+                if (!devid) {
+                        ret = -EINVAL;
+                        goto out_free;
+                }
                 printk(KERN_INFO "btrfs: resizing devid %llu\n",
                        (unsigned long long)devid);
         }
@@ -1371,7 +1400,7 @@ static noinline int btrfs_ioctl_resize(struct file *file,
         if (!device) {
                 printk(KERN_INFO "btrfs: resizer unable to find device %llu\n",
                        (unsigned long long)devid);
-                ret = -EINVAL;
+                ret = -ENODEV;
                 goto out_free;
         }
 
@@ -1379,7 +1408,7 @@ static noinline int btrfs_ioctl_resize(struct file *file,
                 printk(KERN_INFO "btrfs: resizer unable to apply on "
                        "readonly device %llu\n",
                        (unsigned long long)devid);
-                ret = -EINVAL;
+                ret = -EPERM;
                 goto out_free;
         }
 
@@ -1401,7 +1430,7 @@ static noinline int btrfs_ioctl_resize(struct file *file,
         }
 
         if (device->is_tgtdev_for_dev_replace) {
-                ret = -EINVAL;
+                ret = -EPERM;
                 goto out_free;
         }
 
@@ -1457,7 +1486,7 @@ out:
 static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
                                 char *name, unsigned long fd, int subvol,
                                 u64 *transid, bool readonly,
-                                struct btrfs_qgroup_inherit **inherit)
+                                struct btrfs_qgroup_inherit *inherit)
 {
         int namelen;
         int ret = 0;
@@ -1566,7 +1595,7 @@ static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
 
         ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
                                               vol_args->fd, subvol, ptr,
-                                              readonly, &inherit);
+                                              readonly, inherit);
 
         if (ret == 0 && ptr &&
             copy_to_user(arg +
@@ -1863,7 +1892,7 @@ static noinline int search_ioctl(struct inode *inode,
         path->keep_locks = 1;
 
         while(1) {
-                ret = btrfs_search_forward(root, &key, &max_key, path, 0,
+                ret = btrfs_search_forward(root, &key, &max_key, path,
                                            sk->min_transid);
                 if (ret != 0) {
                         if (ret > 0)
@@ -2035,6 +2064,8 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
         struct btrfs_root *dest = NULL;
         struct btrfs_ioctl_vol_args *vol_args;
         struct btrfs_trans_handle *trans;
+        struct btrfs_block_rsv block_rsv;
+        u64 qgroup_reserved;
         int namelen;
         int ret;
         int err = 0;
@@ -2124,12 +2155,23 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
         if (err)
                 goto out_up_write;
 
+        btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
+        /*
+         * One for dir inode, two for dir entries, two for root
+         * ref/backref.
+         */
+        err = btrfs_subvolume_reserve_metadata(root, &block_rsv,
+                                               5, &qgroup_reserved);
+        if (err)
+                goto out_up_write;
+
         trans = btrfs_start_transaction(root, 0);
         if (IS_ERR(trans)) {
                 err = PTR_ERR(trans);
-                goto out_up_write;
+                goto out_release;
         }
-        trans->block_rsv = &root->fs_info->global_block_rsv;
+        trans->block_rsv = &block_rsv;
+        trans->bytes_reserved = block_rsv.size;
 
         ret = btrfs_unlink_subvol(trans, root, dir,
                                 dest->root_key.objectid,
@@ -2159,10 +2201,14 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                 }
         }
 out_end_trans:
+        trans->block_rsv = NULL;
+        trans->bytes_reserved = 0;
         ret = btrfs_end_transaction(trans, root);
         if (ret && !err)
                 err = ret;
         inode->i_flags |= S_DEAD;
+out_release:
+        btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
 out_up_write:
         up_write(&root->fs_info->subvol_sem);
 out_unlock:
@@ -2171,6 +2217,12 @@ out_unlock:
                 shrink_dcache_sb(root->fs_info->sb);
                 btrfs_invalidate_inodes(dest);
                 d_delete(dentry);
+
+                /* the last ref */
+                if (dest->cache_inode) {
+                        iput(dest->cache_inode);
+                        dest->cache_inode = NULL;
+                }
         }
 out_dput:
         dput(dentry);
@@ -2211,10 +2263,10 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
                         ret = -EPERM;
                         goto out;
                 }
-                ret = btrfs_defrag_root(root, 0);
+                ret = btrfs_defrag_root(root);
                 if (ret)
                         goto out;
-                ret = btrfs_defrag_root(root->fs_info->extent_root, 0);
+                ret = btrfs_defrag_root(root->fs_info->extent_root);
                 break;
         case S_IFREG:
                 if (!(file->f_mode & FMODE_WRITE)) {
@@ -3111,7 +3163,7 @@ static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
         u64 transid;
         int ret;
 
-        trans = btrfs_attach_transaction(root);
+        trans = btrfs_attach_transaction_barrier(root);
         if (IS_ERR(trans)) {
                 if (PTR_ERR(trans) != -ENOENT)
                         return PTR_ERR(trans);
@@ -3289,7 +3341,7 @@ static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
         struct inode_fs_paths *ipath = NULL;
         struct btrfs_path *path;
 
-        if (!capable(CAP_SYS_ADMIN))
+        if (!capable(CAP_DAC_READ_SEARCH))
                 return -EPERM;
 
         path = btrfs_alloc_path();
@@ -3914,6 +3966,65 @@ out:
         return ret;
 }
 
+static int btrfs_ioctl_get_fslabel(struct file *file, void __user *arg)
+{
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        const char *label = root->fs_info->super_copy->label;
+        size_t len = strnlen(label, BTRFS_LABEL_SIZE);
+        int ret;
+
+        if (len == BTRFS_LABEL_SIZE) {
+                pr_warn("btrfs: label is too long, return the first %zu bytes\n",
+                        --len);
+        }
+
+        mutex_lock(&root->fs_info->volume_mutex);
+        ret = copy_to_user(arg, label, len);
+        mutex_unlock(&root->fs_info->volume_mutex);
+
+        return ret ? -EFAULT : 0;
+}
+
+static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
+{
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_super_block *super_block = root->fs_info->super_copy;
+        struct btrfs_trans_handle *trans;
+        char label[BTRFS_LABEL_SIZE];
+        int ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        if (copy_from_user(label, arg, sizeof(label)))
+                return -EFAULT;
+
+        if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) {
+                pr_err("btrfs: unable to set label with more than %d bytes\n",
+                       BTRFS_LABEL_SIZE - 1);
+                return -EINVAL;
+        }
+
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
+
+        mutex_lock(&root->fs_info->volume_mutex);
+        trans = btrfs_start_transaction(root, 0);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                goto out_unlock;
+        }
+
+        strcpy(super_block->label, label);
+        ret = btrfs_end_transaction(trans, root);
+
+out_unlock:
+        mutex_unlock(&root->fs_info->volume_mutex);
+        mnt_drop_write_file(file);
+        return ret;
+}
+
 long btrfs_ioctl(struct file *file, unsigned int
                 cmd, unsigned long arg)
 {
@@ -4014,6 +4125,10 @@ long btrfs_ioctl(struct file *file, unsigned int
                 return btrfs_ioctl_qgroup_limit(file, argp);
         case BTRFS_IOC_DEV_REPLACE:
                 return btrfs_ioctl_dev_replace(root, argp);
+        case BTRFS_IOC_GET_FSLABEL:
+                return btrfs_ioctl_get_fslabel(file, argp);
+        case BTRFS_IOC_SET_FSLABEL:
+                return btrfs_ioctl_set_fslabel(file, argp);
         }
 
         return -ENOTTY;