Btrfs: update space balancing code

This patch updates the space balancing code to utilize the new
backref format.  Before, btrfs-vol -b would break any COW links
on data blocks or metadata.  This was slow and caused the amount
of space used to explode if a large number of snapshots were present.

The new code can keeps the sharing of all data extents and
most of the tree blocks.

To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.

To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).

To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.

Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 13 insertions, 2 deletions

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 8c83cf464c83..444abe0796ae 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -477,6 +477,7 @@ static noinline int add_dirty_roots(struct btrfs_trans_handle *trans,
                         dirty = root->dirty_root;
 
                         btrfs_free_log(trans, root);
+                        btrfs_free_reloc_root(root);
 
                         if (root->commit_root == root->node) {
                                 WARN_ON(root->node->start !=
@@ -855,6 +856,11 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
          * with the tree-log code.
          */
         mutex_lock(&root->fs_info->tree_log_mutex);
+        /*
+         * keep tree reloc code from adding new reloc trees
+         */
+        mutex_lock(&root->fs_info->tree_reloc_mutex);
+
 
         ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix,
                               &dirty_fs_roots);
@@ -865,6 +871,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
          */
         btrfs_free_log_root_tree(trans, root->fs_info);
 
+        btrfs_free_reloc_mappings(root);
+
         ret = btrfs_commit_tree_roots(trans, root);
         BUG_ON(ret);
 
@@ -910,10 +918,13 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         mutex_unlock(&root->fs_info->tree_log_mutex);
 
         btrfs_finish_extent_commit(trans, root, pinned_copy);
-        mutex_lock(&root->fs_info->trans_mutex);
-
         kfree(pinned_copy);
 
+        btrfs_drop_dead_reloc_roots(root);
+        mutex_unlock(&root->fs_info->tree_reloc_mutex);
+
+        mutex_lock(&root->fs_info->trans_mutex);
+
         cur_trans->commit_done = 1;
         root->fs_info->last_trans_committed = cur_trans->transid;
         wake_up(&cur_trans->commit_wait);