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, 100 insertions, 47 deletions

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 34836036f01b..0b278b117cbe 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -875,7 +875,6 @@ static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans,
                                      struct btrfs_delayed_item *delayed_item)
 {
         struct extent_buffer *leaf;
-        struct btrfs_item *item;
         char *ptr;
         int ret;
 
@@ -886,7 +885,6 @@ static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans,
 
         leaf = path->nodes[0];
 
-        item = btrfs_item_nr(leaf, path->slots[0]);
         ptr = btrfs_item_ptr(leaf, path->slots[0], char);
 
         write_extent_buffer(leaf, delayed_item->data, (unsigned long)ptr,
@@ -1065,32 +1063,25 @@ static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node)
         }
 }
 
-static int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
-                                      struct btrfs_root *root,
-                                      struct btrfs_path *path,
-                                      struct btrfs_delayed_node *node)
+static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
+                                        struct btrfs_root *root,
+                                        struct btrfs_path *path,
+                                        struct btrfs_delayed_node *node)
 {
         struct btrfs_key key;
         struct btrfs_inode_item *inode_item;
         struct extent_buffer *leaf;
         int ret;
 
-        mutex_lock(&node->mutex);
-        if (!node->inode_dirty) {
-                mutex_unlock(&node->mutex);
-                return 0;
-        }
-
         key.objectid = node->inode_id;
         btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
         key.offset = 0;
+
         ret = btrfs_lookup_inode(trans, root, path, &key, 1);
         if (ret > 0) {
                 btrfs_release_path(path);
-                mutex_unlock(&node->mutex);
                 return -ENOENT;
         } else if (ret < 0) {
-                mutex_unlock(&node->mutex);
                 return ret;
         }
 
@@ -1105,11 +1096,47 @@ static int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
 
         btrfs_delayed_inode_release_metadata(root, node);
         btrfs_release_delayed_inode(node);
-        mutex_unlock(&node->mutex);
 
         return 0;
 }
 
+static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
+                                             struct btrfs_root *root,
+                                             struct btrfs_path *path,
+                                             struct btrfs_delayed_node *node)
+{
+        int ret;
+
+        mutex_lock(&node->mutex);
+        if (!node->inode_dirty) {
+                mutex_unlock(&node->mutex);
+                return 0;
+        }
+
+        ret = __btrfs_update_delayed_inode(trans, root, path, node);
+        mutex_unlock(&node->mutex);
+        return ret;
+}
+
+static inline int
+__btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
+                                   struct btrfs_path *path,
+                                   struct btrfs_delayed_node *node)
+{
+        int ret;
+
+        ret = btrfs_insert_delayed_items(trans, path, node->root, node);
+        if (ret)
+                return ret;
+
+        ret = btrfs_delete_delayed_items(trans, path, node->root, node);
+        if (ret)
+                return ret;
+
+        ret = btrfs_update_delayed_inode(trans, node->root, path, node);
+        return ret;
+}
+
 /*
  * Called when committing the transaction.
  * Returns 0 on success.
@@ -1119,7 +1146,6 @@ static int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
 static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans,
                                      struct btrfs_root *root, int nr)
 {
-        struct btrfs_root *curr_root = root;
         struct btrfs_delayed_root *delayed_root;
         struct btrfs_delayed_node *curr_node, *prev_node;
         struct btrfs_path *path;
@@ -1142,15 +1168,8 @@ static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans,
 
         curr_node = btrfs_first_delayed_node(delayed_root);
         while (curr_node && (!count || (count && nr--))) {
-                curr_root = curr_node->root;
-                ret = btrfs_insert_delayed_items(trans, path, curr_root,
-                                                 curr_node);
-                if (!ret)
-                        ret = btrfs_delete_delayed_items(trans, path,
-                                                curr_root, curr_node);
-                if (!ret)
-                        ret = btrfs_update_delayed_inode(trans, curr_root,
-                                                path, curr_node);
+                ret = __btrfs_commit_inode_delayed_items(trans, path,
+                                                         curr_node);
                 if (ret) {
                         btrfs_release_delayed_node(curr_node);
                         curr_node = NULL;
@@ -1183,51 +1202,93 @@ int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans,
         return __btrfs_run_delayed_items(trans, root, nr);
 }
 
-static int __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
-                                              struct btrfs_delayed_node *node)
+int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
+                                     struct inode *inode)
 {
+        struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
         struct btrfs_path *path;
         struct btrfs_block_rsv *block_rsv;
         int ret;
 
+        if (!delayed_node)
+                return 0;
+
+        mutex_lock(&delayed_node->mutex);
+        if (!delayed_node->count) {
+                mutex_unlock(&delayed_node->mutex);
+                btrfs_release_delayed_node(delayed_node);
+                return 0;
+        }
+        mutex_unlock(&delayed_node->mutex);
+
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
         path->leave_spinning = 1;
 
         block_rsv = trans->block_rsv;
-        trans->block_rsv = &node->root->fs_info->delayed_block_rsv;
+        trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv;
 
-        ret = btrfs_insert_delayed_items(trans, path, node->root, node);
-        if (!ret)
-                ret = btrfs_delete_delayed_items(trans, path, node->root, node);
-        if (!ret)
-                ret = btrfs_update_delayed_inode(trans, node->root, path, node);
-        btrfs_free_path(path);
+        ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
 
+        btrfs_release_delayed_node(delayed_node);
+        btrfs_free_path(path);
         trans->block_rsv = block_rsv;
+
         return ret;
 }
 
-int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
-                                     struct inode *inode)
+int btrfs_commit_inode_delayed_inode(struct inode *inode)
 {
+        struct btrfs_trans_handle *trans;
         struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
+        struct btrfs_path *path;
+        struct btrfs_block_rsv *block_rsv;
         int ret;
 
         if (!delayed_node)
                 return 0;
 
         mutex_lock(&delayed_node->mutex);
-        if (!delayed_node->count) {
+        if (!delayed_node->inode_dirty) {
                 mutex_unlock(&delayed_node->mutex);
                 btrfs_release_delayed_node(delayed_node);
                 return 0;
         }
         mutex_unlock(&delayed_node->mutex);
 
-        ret = __btrfs_commit_inode_delayed_items(trans, delayed_node);
+        trans = btrfs_join_transaction(delayed_node->root);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                goto out;
+        }
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = -ENOMEM;
+                goto trans_out;
+        }
+        path->leave_spinning = 1;
+
+        block_rsv = trans->block_rsv;
+        trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv;
+
+        mutex_lock(&delayed_node->mutex);
+        if (delayed_node->inode_dirty)
+                ret = __btrfs_update_delayed_inode(trans, delayed_node->root,
+                                                   path, delayed_node);
+        else
+                ret = 0;
+        mutex_unlock(&delayed_node->mutex);
+
+        btrfs_free_path(path);
+        trans->block_rsv = block_rsv;
+trans_out:
+        btrfs_end_transaction(trans, delayed_node->root);
+        btrfs_btree_balance_dirty(delayed_node->root);
+out:
         btrfs_release_delayed_node(delayed_node);
+
         return ret;
 }
 
@@ -1258,7 +1319,6 @@ static void btrfs_async_run_delayed_node_done(struct btrfs_work *work)
         struct btrfs_root *root;
         struct btrfs_block_rsv *block_rsv;
         int need_requeue = 0;
-        int ret;
 
         async_node = container_of(work, struct btrfs_async_delayed_node, work);
 
@@ -1277,14 +1337,7 @@ static void btrfs_async_run_delayed_node_done(struct btrfs_work *work)
         block_rsv = trans->block_rsv;
         trans->block_rsv = &root->fs_info->delayed_block_rsv;
 
-        ret = btrfs_insert_delayed_items(trans, path, root, delayed_node);
-        if (!ret)
-                ret = btrfs_delete_delayed_items(trans, path, root,
-                                                 delayed_node);
-
-        if (!ret)
-                btrfs_update_delayed_inode(trans, root, path, delayed_node);
-
+        __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
         /*
          * Maybe new delayed items have been inserted, so we need requeue
          * the work. Besides that, we must dequeue the empty delayed nodes