[PATCH] Btrfs: dynamically remove unused block groups

[PATCH] Btrfs: dynamically remove unused block groups

[Josef Bacik]

Btrfs only allocates chunks as we need them, however we do not delete chunks as
we stop using them.  This patch adds this capability.  Whenever we clear the
last bit of used space in a block group we try and mark it read only, and then
when the last pinned space is finally removed we queue up the deletion work.
I've tested this with xfstests and my enospc tests.  When filling up the disk
I see that we've allocated the entire disk of chunks, and then when I do rm *
there is a bunch of space freed up.  Thanks,

Signed-off-by: Josef Bacik <josef@redhat.com>
---
 fs/btrfs/ctree.h       |    3 +
 fs/btrfs/extent-tree.c |  148 ++++++++++++++++++++++++++++++++++++++++++-----
 fs/btrfs/volumes.c     |   52 +++++++++++------
 fs/btrfs/volumes.h     |    4 +
 4 files changed, 174 insertions(+), 33 deletions(-)

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 8db9234..50ec64b 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -839,6 +839,9 @@ struct btrfs_block_group_cache {
 	 * Today it will only have one thing on it, but that may change
 	 */
 	struct list_head cluster_list;
+
+	/* Worker for deleting the block group if its empty */
+	struct btrfs_work work;
 };
 
 struct reloc_control;
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 43aa62a..87aae66 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -64,6 +64,11 @@ static int find_next_key(struct btrfs_path *path, int level,
 			 struct btrfs_key *key);
 static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
 			    int dump_block_groups);
+static int btrfs_set_block_group_ro_trans(struct btrfs_trans_handle *trans,
+					  struct btrfs_root *root,
+					  struct btrfs_block_group_cache
+					  *cache);
+static int set_block_group_ro_lock(struct btrfs_block_group_cache *cache);
 
 static noinline int
 block_group_cache_done(struct btrfs_block_group_cache *cache)
@@ -4052,6 +4057,7 @@ static int update_block_group(struct btrfs_trans_handle *trans,
 	u64 old_val;
 	u64 byte_in_group;
 	int factor;
+	int empty = 0;
 
 	/* block accounting for super block */
 	spin_lock(&info->delalloc_lock);
@@ -4064,6 +4070,7 @@ static int update_block_group(struct btrfs_trans_handle *trans,
 	spin_unlock(&info->delalloc_lock);
 
 	while (total) {
+		empty = 0;
 		cache = btrfs_lookup_block_group(info, bytenr);
 		if (!cache)
 			return -1;
@@ -4096,6 +4103,12 @@ static int update_block_group(struct btrfs_trans_handle *trans,
 		old_val = btrfs_block_group_used(&cache->item);
 		num_bytes = min(total, cache->key.offset - byte_in_group);
 		if (alloc) {
+			/*
+			 * We raced with setting the block group read only, we
+			 * need to change it back to rw
+			 */
+			if (cache->ro)
+				empty = -1;
 			old_val += num_bytes;
 			btrfs_set_block_group_used(&cache->item, old_val);
 			cache->reserved -= num_bytes;
@@ -4106,6 +4119,8 @@ static int update_block_group(struct btrfs_trans_handle *trans,
 			spin_unlock(&cache->space_info->lock);
 		} else {
 			old_val -= num_bytes;
+			if (old_val == 0)
+				empty = 1;
 			btrfs_set_block_group_used(&cache->item, old_val);
 			cache->pinned += num_bytes;
 			cache->space_info->bytes_pinned += num_bytes;
@@ -4118,6 +4133,29 @@ static int update_block_group(struct btrfs_trans_handle *trans,
 					 bytenr, bytenr + num_bytes - 1,
 					 GFP_NOFS | __GFP_NOFAIL);
 		}
+		/*
+		 * So we need to deal with 2 cases here
+		 *
+		 * 1) empty == 1, which means the block group is empty and
+		 * needs to be marked ro so we can remove it later
+		 *
+		 * -or-
+		 *
+		 * 2) empty == -1, which means the block group was previously
+		 * empty and marked read only, but not before somebody tried to
+		 * make an allocation, so go ahead and mark it rw.
+		 */
+		switch (empty) {
+		case -1:
+			btrfs_set_block_group_rw(root, cache);
+			break;
+		case 1:
+			btrfs_set_block_group_ro_trans(trans, root, cache);
+			break;
+		default:
+			break;
+		}
+
 		btrfs_put_block_group(cache);
 		total -= num_bytes;
 		bytenr += num_bytes;
@@ -4288,6 +4326,17 @@ static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
 			cache->reserved_pinned -= len;
 			cache->space_info->bytes_reserved += len;
 		}
+
+		if (btrfs_block_group_used(&cache->item) == 0 &&
+		    cache->pinned == 0) {
+			int ret = 0;
+
+			if (!cache->ro)
+				ret = set_block_group_ro_lock(cache);
+			if (!ret)
+				btrfs_queue_worker(&fs_info->generic_worker,
+						   &cache->work);
+		}
 		spin_unlock(&cache->lock);
 		spin_unlock(&cache->space_info->lock);
 	}
@@ -7905,7 +7954,7 @@ static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
 	return flags;
 }
 
-static int set_block_group_ro(struct btrfs_block_group_cache *cache)
+static int set_block_group_ro_lock(struct btrfs_block_group_cache *cache)
 {
 	struct btrfs_space_info *sinfo = cache->space_info;
 	u64 num_bytes;
@@ -7914,8 +7963,6 @@ static int set_block_group_ro(struct btrfs_block_group_cache *cache)
 	if (cache->ro)
 		return 0;
 
-	spin_lock(&sinfo->lock);
-	spin_lock(&cache->lock);
 	num_bytes = cache->key.offset - cache->reserved - cache->pinned -
 		    cache->bytes_super - btrfs_block_group_used(&cache->item);
 
@@ -7928,37 +7975,67 @@ static int set_block_group_ro(struct btrfs_block_group_cache *cache)
 		cache->ro = 1;
 		ret = 0;
 	}
+
+	return ret;
+}
+
+static int set_block_group_ro(struct btrfs_block_group_cache *cache)
+{
+	struct btrfs_space_info *sinfo = cache->space_info;
+	int ret;
+
+	spin_lock(&sinfo->lock);
+	spin_lock(&cache->lock);
+	ret = set_block_group_ro_lock(cache);
 	spin_unlock(&cache->lock);
 	spin_unlock(&sinfo->lock);
+
 	return ret;
 }
 
-int btrfs_set_block_group_ro(struct btrfs_root *root,
-			     struct btrfs_block_group_cache *cache)
-
+static int btrfs_set_block_group_ro_trans(struct btrfs_trans_handle *trans,
+					  struct btrfs_root *root,
+					  struct btrfs_block_group_cache
+					  *cache)
 {
-	struct btrfs_trans_handle *trans;
 	u64 alloc_flags;
 	int ret;
+	bool alloc = true;
 
-	BUG_ON(cache->ro);
+	/*
+	 * If we're trying to set the block group as read only in a transaction
+	 * commit then avoid doing the chunk alloc to make lockdep happy.
+	 */
+	if (trans->transaction->in_commit)
+		alloc = false;
 
-	trans = btrfs_join_transaction(root, 1);
-	BUG_ON(IS_ERR(trans));
+	if (cache->ro)
+		return 0;
 
 	alloc_flags = update_block_group_flags(root, cache->flags);
-	if (alloc_flags != cache->flags)
+	if (alloc && alloc_flags != cache->flags)
 		do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, 1);
 
 	ret = set_block_group_ro(cache);
-	if (!ret)
-		goto out;
+	if (!ret || !alloc)
+		return ret;
 	alloc_flags = get_alloc_profile(root, cache->space_info->flags);
 	ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, 1);
 	if (ret < 0)
-		goto out;
-	ret = set_block_group_ro(cache);
-out:
+		return ret;
+	return set_block_group_ro(cache);
+}
+
+int btrfs_set_block_group_ro(struct btrfs_root *root,
+			     struct btrfs_block_group_cache *cache)
+{
+	struct btrfs_trans_handle *trans;
+	int ret;
+
+	trans = btrfs_join_transaction(root, 0);
+	if (IS_ERR(trans))
+		return PTR_ERR(trans);
+	ret = btrfs_set_block_group_ro_trans(trans, root, cache);
 	btrfs_end_transaction(trans, root);
 	return ret;
 }
@@ -8206,6 +8283,43 @@ static void __link_block_group(struct btrfs_space_info *space_info,
 	up_write(&space_info->groups_sem);
 }
 
+static void block_group_delete_fn(struct btrfs_work *work)
+{
+	struct btrfs_block_group_cache *cache;
+	struct btrfs_fs_info *info;
+	struct btrfs_trans_handle *trans;
+	struct btrfs_root *root;
+	u64 chunk_tree;
+	u64 chunk_objectid;
+	int ret;
+
+	/*
+	 * If anything fails in here, just mark the block group as rw and
+	 * return.
+	 */
+	cache = container_of(work, struct btrfs_block_group_cache, work);
+	info = cache->fs_info;
+	root = info->extent_root;
+	chunk_tree = info->chunk_root->root_key.objectid;
+	chunk_objectid = btrfs_block_group_chunk_objectid(&cache->item);
+
+	if (!cache->ro) {
+		WARN_ON_ONCE(1);
+		return;
+	}
+
+	trans = btrfs_start_transaction(info->extent_root, 0);
+	if (IS_ERR(trans)) {
+		btrfs_set_block_group_rw(root, cache);
+		return;
+	}
+	ret = btrfs_remove_chunk(trans, root, chunk_tree, chunk_objectid,
+				 cache->key.objectid);
+	if (ret)
+		btrfs_set_block_group_rw(root, cache);
+	btrfs_end_transaction(trans, root);
+}
+
 int btrfs_read_block_groups(struct btrfs_root *root)
 {
 	struct btrfs_path *path;
@@ -8257,6 +8371,7 @@ int btrfs_read_block_groups(struct btrfs_root *root)
 		cache->fs_info = info;
 		INIT_LIST_HEAD(&cache->list);
 		INIT_LIST_HEAD(&cache->cluster_list);
+		cache->work.func = block_group_delete_fn;
 
 		if (need_clear)
 			cache->disk_cache_state = BTRFS_DC_CLEAR;
@@ -8379,6 +8494,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
 	spin_lock_init(&cache->tree_lock);
 	INIT_LIST_HEAD(&cache->list);
 	INIT_LIST_HEAD(&cache->cluster_list);
+	cache->work.func = block_group_delete_fn;
 
 	btrfs_set_block_group_used(&cache->item, bytes_used);
 	btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index cc04dc1..49c055b 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1726,13 +1726,13 @@ 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_tree, u64 chunk_objectid,
+		       u64 chunk_offset)
 {
 	struct extent_map_tree *em_tree;
 	struct btrfs_root *extent_root;
-	struct btrfs_trans_handle *trans;
 	struct extent_map *em;
 	struct map_lookup *map;
 	int ret;
@@ -1742,18 +1742,6 @@ static int btrfs_relocate_chunk(struct btrfs_root *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);
-	BUG_ON(!trans);
-
 	lock_chunks(root);
 
 	/*
@@ -1804,10 +1792,40 @@ static int btrfs_relocate_chunk(struct btrfs_root *root,
 	free_extent_map(em);
 
 	unlock_chunks(root);
-	btrfs_end_transaction(trans, root);
 	return 0;
 }
 
+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);
+	BUG_ON(!trans);
+
+	ret = btrfs_remove_chunk(trans, root, chunk_tree, chunk_objectid,
+				 chunk_offset);
+
+	btrfs_end_transaction(trans, root);
+
+	return ret;
+}
+
 static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
 {
 	struct btrfs_root *chunk_root = root->fs_info->chunk_root;
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 2b638b6..4917cc0 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -183,4 +183,8 @@ int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
 int find_free_dev_extent(struct btrfs_trans_handle *trans,
 			 struct btrfs_device *device, u64 num_bytes,
 			 u64 *start, u64 *max_avail);
+int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
+		       struct btrfs_root *root,
+		       u64 chunk_tree, u64 chunk_objectid,
+		       u64 chunk_offset);
 #endif
-- 
1.6.6.1

Re: [PATCH] Btrfs: dynamically remove unused block groups

[Josh Berry]
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Re: [PATCH] Btrfs: dynamically remove unused block groups

[Josef Bacik]

On Tue, Nov 30, 2010 at 09:37:17AM -0800, Josh Berry wrote:
> On Tue, Nov 30, 2010 at 08:46, Josef Bacik <josef@redhat.com> wrote:
> > Btrfs only allocates chunks as we need them, however we do not dele=
te chunks as
> > we stop using them. =A0This patch adds this capability. =A0Whenever=
 we clear the
> > last bit of used space in a block group we try and mark it read onl=
y, and then
> > when the last pinned space is finally removed we queue up the delet=
ion work.
> > I've tested this with xfstests and my enospc tests. =A0When filling=
 up the disk
> > I see that we've allocated the entire disk of chunks, and then when=
 I do rm *
> > there is a bunch of space freed up. =A0Thanks,
>=20
> Stupid user question:
>=20
> I have a btrfs filesystem on a 2.6.36 kernel that used to have ~800GB
> of data on it.  Then I deleted ~500GB of it (moved it elsewhere), but
> my space usage as reported by df and the btrfs tool didn't decrease
> appreciably.  Might this be why?
>=20

So without this patch, with a full fs I do this

[root@test1244 ~]# ./btrfs-progs-unstable/btrfs fi df /mnt/btrfs-test/
Data: total=3D980.25MB, used=3D909.91MB
System, DUP: total=3D16.00MB, used=3D4.00KB
System: total=3D4.00MB, used=3D0.00
Metadata, DUP: total=3D511.88MB, used=3D190.42MB
Metadata: total=3D8.00MB, used=3D0.00

If I removed everything from the fs, you'd still see Data total=3D980.2=
5MB, but
used should be close to 0 (this is assuming no snapshots and such).  Wi=
th this
patch if I rm -rf /mnt/btrfs/* I get this

[root@test1244 ~]# ./btrfs-progs-unstable/btrfs fi df /mnt/btrfs-test/
Data: total=3D204.75MB, used=3D192.00KB
System, DUP: total=3D16.00MB, used=3D4.00KB
System: total=3D4.00MB, used=3D0.00
Metadata, DUP: total=3D307.12MB, used=3D24.00KB
Metadata: total=3D8.00MB, used=3D0.00

So that free'd up ~700mb in data space and ~200mb in metadata space tha=
t can be
allocated to either data/metadata based on your usage patterns.  I hope=
 that
helps explain it.  Thanks,

Josef
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" =
in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH] Btrfs: dynamically remove unused block groups

[Josh Berry]

On Tue, Nov 30, 2010 at 11:01, Josef Bacik <josef@redhat.com> wrote:
> On Tue, Nov 30, 2010 at 09:37:17AM -0800, Josh Berry wrote:
>> On Tue, Nov 30, 2010 at 08:46, Josef Bacik <josef@redhat.com> wrote:
>> > Btrfs only allocates chunks as we need them, however we do not del=
ete chunks as
>> > we stop using them. =C2=A0This patch adds this capability. =C2=A0W=
henever we clear the
>> > last bit of used space in a block group we try and mark it read on=
ly, and then
>> > when the last pinned space is finally removed we queue up the dele=
tion work.
>> > I've tested this with xfstests and my enospc tests. =C2=A0When fil=
ling up the disk
>> > I see that we've allocated the entire disk of chunks, and then whe=
n I do rm *
>> > there is a bunch of space freed up. =C2=A0Thanks,
>>
>> Stupid user question:
>>
>> I have a btrfs filesystem on a 2.6.36 kernel that used to have ~800G=
B
>> of data on it. =C2=A0Then I deleted ~500GB of it (moved it elsewhere=
), but
>> my space usage as reported by df and the btrfs tool didn't decrease
>> appreciably. =C2=A0Might this be why?
>>
>
> So without this patch, with a full fs I do this
>
> [root@test1244 ~]# ./btrfs-progs-unstable/btrfs fi df /mnt/btrfs-test=
/
> Data: total=3D980.25MB, used=3D909.91MB
> System, DUP: total=3D16.00MB, used=3D4.00KB
> System: total=3D4.00MB, used=3D0.00
> Metadata, DUP: total=3D511.88MB, used=3D190.42MB
> Metadata: total=3D8.00MB, used=3D0.00
>
> If I removed everything from the fs, you'd still see Data total=3D980=
=2E25MB, but
> used should be close to 0 (this is assuming no snapshots and such). =C2=
=A0With this
> patch if I rm -rf /mnt/btrfs/* I get this
>
> [root@test1244 ~]# ./btrfs-progs-unstable/btrfs fi df /mnt/btrfs-test=
/
> Data: total=3D204.75MB, used=3D192.00KB
> System, DUP: total=3D16.00MB, used=3D4.00KB
> System: total=3D4.00MB, used=3D0.00
> Metadata, DUP: total=3D307.12MB, used=3D24.00KB
> Metadata: total=3D8.00MB, used=3D0.00
>
> So that free'd up ~700mb in data space and ~200mb in metadata space t=
hat can be
> allocated to either data/metadata based on your usage patterns. =C2=A0=
I hope that
> helps explain it.

That makes sense, thanks.

I was still seeing very high data-used, but it turns out there was an
old snapshot I didn't know I had, so the problem was really
stupid-user error. :)

-- Josh
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" =
in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH] Btrfs: dynamically remove unused block groups

[Josef Bacik]

On Tue, Nov 30, 2010 at 11:31:17AM -0800, Josh Berry wrote:
> On Tue, Nov 30, 2010 at 11:01, Josef Bacik <josef@redhat.com> wrote:
> > On Tue, Nov 30, 2010 at 09:37:17AM -0800, Josh Berry wrote:
> >> On Tue, Nov 30, 2010 at 08:46, Josef Bacik <josef@redhat.com> wrot=
e:
> >> > Btrfs only allocates chunks as we need them, however we do not d=
elete chunks as
> >> > we stop using them. =A0This patch adds this capability. =A0Whene=
ver we clear the
> >> > last bit of used space in a block group we try and mark it read =
only, and then
> >> > when the last pinned space is finally removed we queue up the de=
letion work.
> >> > I've tested this with xfstests and my enospc tests. =A0When fill=
ing up the disk
> >> > I see that we've allocated the entire disk of chunks, and then w=
hen I do rm *
> >> > there is a bunch of space freed up. =A0Thanks,
> >>
> >> Stupid user question:
> >>
> >> I have a btrfs filesystem on a 2.6.36 kernel that used to have ~80=
0GB
> >> of data on it. =A0Then I deleted ~500GB of it (moved it elsewhere)=
, but
> >> my space usage as reported by df and the btrfs tool didn't decreas=
e
> >> appreciably. =A0Might this be why?
> >>
> >
> > So without this patch, with a full fs I do this
> >
> > [root@test1244 ~]# ./btrfs-progs-unstable/btrfs fi df /mnt/btrfs-te=
st/
> > Data: total=3D980.25MB, used=3D909.91MB
> > System, DUP: total=3D16.00MB, used=3D4.00KB
> > System: total=3D4.00MB, used=3D0.00
> > Metadata, DUP: total=3D511.88MB, used=3D190.42MB
> > Metadata: total=3D8.00MB, used=3D0.00
> >
> > If I removed everything from the fs, you'd still see Data total=3D9=
80.25MB, but
> > used should be close to 0 (this is assuming no snapshots and such).=
 =A0With this
> > patch if I rm -rf /mnt/btrfs/* I get this
> >
> > [root@test1244 ~]# ./btrfs-progs-unstable/btrfs fi df /mnt/btrfs-te=
st/
> > Data: total=3D204.75MB, used=3D192.00KB
> > System, DUP: total=3D16.00MB, used=3D4.00KB
> > System: total=3D4.00MB, used=3D0.00
> > Metadata, DUP: total=3D307.12MB, used=3D24.00KB
> > Metadata: total=3D8.00MB, used=3D0.00
> >
> > So that free'd up ~700mb in data space and ~200mb in metadata space=
 that can be
> > allocated to either data/metadata based on your usage patterns. =A0=
I hope that
> > helps explain it.
>=20
> That makes sense, thanks.
>=20
> I was still seeing very high data-used, but it turns out there was an
> old snapshot I didn't know I had, so the problem was really
> stupid-user error. :)
>=20

Yeah 2 things to keep in mind, 1 if you have snapshots you are likely t=
o not see
data free'd up the way you expect it.  The other thing is that because
everything is COW we can't allocate the newly free'd space until the tr=
ansaction
commits, so you may have to wait ~30 seconds or run sync to force the
transaction to commit before you see your space actually free'd up.  Th=
anks,

Josef
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" =
in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH] Btrfs: dynamically remove unused block groups

[Anthony Roberts]

 Hello,

 What happens in the event the filesystem has mostly been cleared out, 
 but there's a few things left? For example, several of the chunks might 
 be at very low usage, but not zero. Would the user be able to defragment 
 the filesystem to cause these chunks to be consolidated?

 Regards,

 -Anthony

> Yeah 2 things to keep in mind, 1 if you have snapshots you are likely
> to not see
> data free'd up the way you expect it.  The other thing is that 
> because
> everything is COW we can't allocate the newly free'd space until the
> transaction
> commits, so you may have to wait ~30 seconds or run sync to force the
> transaction to commit before you see your space actually free'd up.  
> Thanks,
>
> Josef
> --
> To unsubscribe from this list: send the line "unsubscribe 
> linux-btrfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH] Btrfs: dynamically remove unused block groups

[Josef Bacik]

On Tue, Nov 30, 2010 at 09:53:41PM -0700, Anthony Roberts wrote:
> Hello,
>
> What happens in the event the filesystem has mostly been cleared out,  
> but there's a few things left? For example, several of the chunks might  
> be at very low usage, but not zero. Would the user be able to defragment  
> the filesystem to cause these chunks to be consolidated?
>

Yeah thats what balance is for.  Thanks,

Josef