Btrfs: remove empty block groups automatically

One problem that has plagued us is that a user will use up all of his space with
data, remove a bunch of that data, and then try to create a bunch of small files
and run out of space.  This happens because all the chunks were allocated for
data since the metadata requirements were so low.  But now there's a bunch of
empty data block groups and not enough metadata space to do anything.  This
patch solves this problem by automatically deleting empty block groups.  If we
notice the used count go down to 0 when deleting or on mount notice that a block
group has a used count of 0 then we will queue it to be deleted.

When the cleaner thread runs we will double check to make sure the block group
is still empty and then we will delete it.  This patch has the side effect of no
longer having a bunch of BUG_ON()'s in the chunk delete code, which will be
helpful for both this and relocate.  Thanks,

Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>

1 files changed, 76 insertions, 39 deletions

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 63e632746d8a..f27c0f7c387e 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2568,58 +2568,49 @@ static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
         return ret;
 }
 
-static int btrfs_relocate_chunk(struct btrfs_root *root,
-                         u64 chunk_tree, u64 chunk_objectid,
-                         u64 chunk_offset)
+int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root, u64 chunk_offset)
 {
         struct extent_map_tree *em_tree;
-        struct btrfs_root *extent_root;
-        struct btrfs_trans_handle *trans;
-        struct btrfs_device *device;
         struct extent_map *em;
+        struct btrfs_root *extent_root = root->fs_info->extent_root;
         struct map_lookup *map;
         u64 dev_extent_len = 0;
-        int ret;
-        int i;
+        u64 chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
+        u64 chunk_tree = root->fs_info->chunk_root->objectid;
+        int i, ret = 0;
 
+        /* Just in case */
         root = root->fs_info->chunk_root;
-        extent_root = root->fs_info->extent_root;
         em_tree = &root->fs_info->mapping_tree.map_tree;
 
-        ret = btrfs_can_relocate(extent_root, chunk_offset);
-        if (ret)
-                return -ENOSPC;
-
-        /* step one, relocate all the extents inside this chunk */
-        ret = btrfs_relocate_block_group(extent_root, chunk_offset);
-        if (ret)
-                return ret;
-
-        trans = btrfs_start_transaction(root, 0);
-        if (IS_ERR(trans)) {
-                ret = PTR_ERR(trans);
-                btrfs_std_error(root->fs_info, ret);
-                return ret;
-        }
-
-        /*
-         * step two, delete the device extents and the
-         * chunk tree entries
-         */
         read_lock(&em_tree->lock);
         em = lookup_extent_mapping(em_tree, chunk_offset, 1);
         read_unlock(&em_tree->lock);
 
-        BUG_ON(!em || em->start > chunk_offset ||
-               em->start + em->len < chunk_offset);
+        if (!em || em->start > chunk_offset ||
+            em->start + em->len < chunk_offset) {
+                /*
+                 * This is a logic error, but we don't want to just rely on the
+                 * user having built with ASSERT enabled, so if ASSERT doens't
+                 * do anything we still error out.
+                 */
+                ASSERT(0);
+                if (em)
+                        free_extent_map(em);
+                return -EINVAL;
+        }
         map = (struct map_lookup *)em->bdev;
 
         for (i = 0; i < map->num_stripes; i++) {
-                device = map->stripes[i].dev;
+                struct btrfs_device *device = map->stripes[i].dev;
                 ret = btrfs_free_dev_extent(trans, device,
                                             map->stripes[i].physical,
                                             &dev_extent_len);
-                BUG_ON(ret);
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
 
                 if (device->bytes_used > 0) {
                         lock_chunks(root);
@@ -2634,23 +2625,34 @@ static int btrfs_relocate_chunk(struct btrfs_root *root,
 
                 if (map->stripes[i].dev) {
                         ret = btrfs_update_device(trans, map->stripes[i].dev);
-                        BUG_ON(ret);
+                        if (ret) {
+                                btrfs_abort_transaction(trans, root, ret);
+                                goto out;
+                        }
                 }
         }
         ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid,
                                chunk_offset);
-
-        BUG_ON(ret);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         trace_btrfs_chunk_free(root, map, chunk_offset, em->len);
 
         if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
                 ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
-                BUG_ON(ret);
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
         }
 
         ret = btrfs_remove_block_group(trans, extent_root, chunk_offset);
-        BUG_ON(ret);
+        if (ret) {
+                btrfs_abort_transaction(trans, extent_root, ret);
+                goto out;
+        }
 
         write_lock(&em_tree->lock);
         remove_extent_mapping(em_tree, em);
@@ -2658,11 +2660,46 @@ static int btrfs_relocate_chunk(struct btrfs_root *root,
 
         /* once for the tree */
         free_extent_map(em);
+out:
         /* once for us */
         free_extent_map(em);
+        return ret;
+}
+
+static int btrfs_relocate_chunk(struct btrfs_root *root,
+                         u64 chunk_tree, u64 chunk_objectid,
+                         u64 chunk_offset)
+{
+        struct btrfs_root *extent_root;
+        struct btrfs_trans_handle *trans;
+        int ret;
+
+        root = root->fs_info->chunk_root;
+        extent_root = root->fs_info->extent_root;
+
+        ret = btrfs_can_relocate(extent_root, chunk_offset);
+        if (ret)
+                return -ENOSPC;
+
+        /* step one, relocate all the extents inside this chunk */
+        ret = btrfs_relocate_block_group(extent_root, chunk_offset);
+        if (ret)
+                return ret;
 
+        trans = btrfs_start_transaction(root, 0);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                btrfs_std_error(root->fs_info, ret);
+                return ret;
+        }
+
+        /*
+         * step two, delete the device extents and the
+         * chunk tree entries
+         */
+        ret = btrfs_remove_chunk(trans, root, chunk_offset);
         btrfs_end_transaction(trans, root);
-        return 0;
+        return ret;
 }
 
 static int btrfs_relocate_sys_chunks(struct btrfs_root *root)