btrfs: move the block_rsv code out of extent-tree.c
cover btrfs: move the block_rsv code out of extent-tree.c
This patchset depends on the space_info migration patchset. This is the next logical chunk of things to move out of extent-tree.c With these sets of patches we're down below 10k loc in extent-tree.c. This chunk was much easier to move as we had exported a lot of these functions already. There is 1 code change patch in here and that's to cleanup the logic in __btrfs_block_rsv_release so it could be used more globally by everybody. The rest is just exporting and migrating code around. Again I specifically didn't clean anything else up, I'm just trying to re-organize everything. The diffstat of the series is as follows
fs/btrfs/Makefile | 3 +- fs/btrfs/block-rsv.c | 429 ++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/block-rsv.h | 104 ++++++++++++ fs/btrfs/ctree.h | 70 +------- fs/btrfs/extent-tree.c | 452 ++----------------------------------------------- 5 files changed, 549 insertions(+), 509 deletions(-)
Thanks,
Josef
PATCH 1/8 btrfs: move btrfs_block_rsv definitions into it's own header
Prep work for separating out all of the block_rsv related code into its own file.
--- fs/btrfs/block-rsv.h | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/ctree.h | 70 +------------------------------------------ fs/btrfs/extent-tree.c | 1 + 3 files changed, 83 insertions(+), 69 deletions(-) create mode 100644 fs/btrfs/block-rsv.h
fs/btrfs/block-rsv.h new file +81 -0
@@ -0,0 +1,81 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2019 Facebook. All rights reserved. +*/ + +#ifndef BTRFS_BLOCK_RSV_H +#define BTRFS_BLOCK_RSV_H + + +enum btrfs_reserve_flush_enum ; + +/* +* Types of block reserves +*/ +enum { +BTRFS_BLOCK_RSV_GLOBAL , +BTRFS_BLOCK_RSV_DELALLOC , +BTRFS_BLOCK_RSV_TRANS , +BTRFS_BLOCK_RSV_CHUNK , +BTRFS_BLOCK_RSV_DELOPS , +BTRFS_BLOCK_RSV_DELREFS , +BTRFS_BLOCK_RSV_EMPTY , +BTRFS_BLOCK_RSV_TEMP , +}; + +struct btrfs_block_rsv { +u64 size; +u64 reserved; +struct btrfs_space_info *space_info; +spinlock_t lock; +unsigned short full; +unsigned short type; +unsigned short failfast; + +/* +* Qgroup equivalent for @size @reserved +* +* Unlike normal @size/@reserved for inode rsv, qgroup doesn't care +* about things like csum size nor how many tree blocks it will need to +* reserve. +* +* Qgroup cares more about net change of the extent usage. +* +* So for one newly inserted file extent, in worst case it will cause +* leaf split and level increase, nodesize for each file extent is +* already too much. +* +* In short, qgroup_size/reserved is the upper limit of possible needed +* qgroup metadata reservation. +*/ +u64 qgroup_rsv_size; +u64 qgroup_rsv_reserved; +}; + +void btrfs_init_block_rsv (struct btrfs_block_rsv *rsv,unsigned short type); +struct btrfs_block_rsv *btrfs_alloc_block_rsv (struct btrfs_fs_info *fs_info, +unsigned short type); +void btrfs_init_metadata_block_rsv (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *rsv, +unsigned short type); +void btrfs_free_block_rsv (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *rsv); +int btrfs_block_rsv_add (struct btrfs_root *root, +struct btrfs_block_rsv *block_rsv,u64 num_bytes, +enum btrfs_reserve_flush_enum flush); +int btrfs_block_rsv_check (struct btrfs_block_rsv *block_rsv,int min_factor); +int btrfs_block_rsv_refill (struct btrfs_root *root, +struct btrfs_block_rsv *block_rsv,u64 min_reserved, +enum btrfs_reserve_flush_enum flush); +int btrfs_block_rsv_migrate (struct btrfs_block_rsv *src_rsv, +struct btrfs_block_rsv *dst_rsv,u64 num_bytes, +bool update_size); +int btrfs_block_rsv_use_bytes (struct btrfs_block_rsv *block_rsv, +u64 num_bytes); +int btrfs_cond_migrate_bytes (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *dest,u64 num_bytes, +int min_factor); +void btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *block_rsv, +u64 num_bytes); +#endif /* BTRFS_BLOCK_RSV_H */
fs/btrfs/ctree.h +1 -69
88 lines not on this page · raw message
fs/btrfs/extent-tree.c +1 -0
@@ -29,6 +29,7 @@#include "qgroup.h" #include "ref-verify.h" #include "space-info.h" +#include "block-rsv.h" #undef SCRAMBLE_DELAYED_REFS
Signature · 1 line
2.14.3
PATCH 2/8 btrfs: export btrfs_block_rsv_add_bytes
In reply to Josef BacikThis is used in a few places, we need to make sure it's exported so we can move it around.
--- fs/btrfs/block-rsv.h | 2 ++ fs/btrfs/extent-tree.c | 18 +++++++++--------- 2 files changed, 11 insertions(+), 9 deletions(-)
fs/btrfs/block-rsv.h +2 -0
@@ -78,4 +78,6 @@ int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,void btrfs_block_rsv_release (struct btrfs_fs_info *fs_info,struct btrfs_block_rsv *block_rsv,u64 num_bytes); +void btrfs_block_rsv_add_bytes (struct btrfs_block_rsv *block_rsv, +u64 num_bytes,bool update_size);#endif /* BTRFS_BLOCK_RSV_H */
fs/btrfs/extent-tree.c +9 -9
@@ -4385,8 +4385,8 @@ int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,return ret; } -static void block_rsv_add_bytes (struct btrfs_block_rsv *block_rsv, -u64 num_bytes,bool update_size) +void btrfs_block_rsv_add_bytes (struct btrfs_block_rsv *block_rsv, +u64 num_bytes,bool update_size) {spin_lock (&block_rsv->lock); block_rsv->reserved += num_bytes;
@@ -4418,7 +4418,7 @@ int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info, global_rsv->full =0 ;spin_unlock (&global_rsv->lock); -block_rsv_add_bytes (dest, num_bytes, true); +btrfs_block_rsv_add_bytes (dest, num_bytes, true);return 0 ; }
@@ -4501,7 +4501,7 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info, num_bytes, flush);if (ret)return ret; -block_rsv_add_bytes (block_rsv, num_bytes,0 ); +btrfs_block_rsv_add_bytes (block_rsv, num_bytes,0 );trace_btrfs_space_reservation (fs_info,"delayed_refs_rsv" ,0 , num_bytes,1 );return 0 ;
@@ -4573,7 +4573,7 @@ int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,if (ret)return ret; -block_rsv_add_bytes (dst, num_bytes, update_size); +btrfs_block_rsv_add_bytes (dst, num_bytes, update_size);return 0 ; }
@@ -4626,7 +4626,7 @@ int btrfs_block_rsv_add(struct btrfs_root *root, ret =btrfs_reserve_metadata_bytes (root, block_rsv, num_bytes, flush);if (!ret) -block_rsv_add_bytes (block_rsv, num_bytes, true); +btrfs_block_rsv_add_bytes (block_rsv, num_bytes, true);return ret; }
@@ -4671,7 +4671,7 @@ int btrfs_block_rsv_refill(struct btrfs_root *root, ret =btrfs_reserve_metadata_bytes (root, block_rsv, num_bytes, flush);if (!ret) { -block_rsv_add_bytes (block_rsv, num_bytes, false); +btrfs_block_rsv_add_bytes (block_rsv, num_bytes, false);return 0 ; }
@@ -5062,7 +5062,7 @@ int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)spin_unlock (&inode->lock);/* Now we can safely add our space to our block rsv */ -block_rsv_add_bytes (block_rsv, meta_reserve, false); +btrfs_block_rsv_add_bytes (block_rsv, meta_reserve, false);trace_btrfs_space_reservation (root->fs_info,"delalloc" ,btrfs_ino (inode), meta_reserve,1 );
@@ -7439,7 +7439,7 @@ use_block_rsv(struct btrfs_trans_handle *trans,static void unuse_block_rsv (struct btrfs_fs_info *fs_info,struct btrfs_block_rsv *block_rsv,u32 blocksize) { -block_rsv_add_bytes (block_rsv, blocksize, false); +btrfs_block_rsv_add_bytes (block_rsv, blocksize, false);block_rsv_release_bytes (fs_info, block_rsv,NULL ,0 ,NULL ); }
Signature · 1 line
2.14.3
PATCH 3/8 btrfs: export __btrfs_block_rsv_release
In reply to Josef BacikThe delalloc reserve stuff calls this directly because it cares about the qgroup accounting stuff, so export it so we can move it around. Fix btrfs_block_rsv_release() to just be a static inline since it just calls __btrfs_block_rsv_release() with NULL for the qgroup stuff.
--- fs/btrfs/block-rsv.h | 13 ++++++++++--- fs/btrfs/extent-tree.c | 13 +++---------- 2 files changed, 13 insertions(+), 13 deletions(-)
fs/btrfs/block-rsv.h +10 -3
@@ -75,9 +75,16 @@ int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,int btrfs_cond_migrate_bytes (struct btrfs_fs_info *fs_info,struct btrfs_block_rsv *dest,u64 num_bytes,int min_factor); -void btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, -struct btrfs_block_rsv *block_rsv, -u64 num_bytes);void btrfs_block_rsv_add_bytes (struct btrfs_block_rsv *block_rsv,u64 num_bytes,bool update_size); +u64 __btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *block_rsv, +u64 num_bytes,u64 *qgroup_to_release); + +static inline void btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *block_rsv, +u64 num_bytes) +{ +__btrfs_block_rsv_release (fs_info, block_rsv, num_bytes,NULL ); +}#endif /* BTRFS_BLOCK_RSV_H */
fs/btrfs/extent-tree.c +3 -10
@@ -4678,9 +4678,9 @@ int btrfs_block_rsv_refill(struct btrfs_root *root,return ret; } -static u64 __btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, -struct btrfs_block_rsv *block_rsv, -u64 num_bytes,u64 *qgroup_to_release) +u64 __btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *block_rsv, +u64 num_bytes,u64 *qgroup_to_release) {struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
@@ -4696,13 +4696,6 @@ static u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, qgroup_to_release); } -void btrfs_block_rsv_release (struct btrfs_fs_info *fs_info, -struct btrfs_block_rsv *block_rsv, -u64 num_bytes) -{ -__btrfs_block_rsv_release (fs_info, block_rsv, num_bytes,NULL ); -} -/** * btrfs_inode_rsv_release - release any excessive reservation. * @inode - the inode we need to release from.
Signature · 1 line
2.14.3
PATCH 4/8 btrfs: cleanup the target logic in __btrfs_block_rsv_release
In reply to Josef BacikThis works for all callers already, but if we wanted to use the helper for the global_block_rsv it would end up trying to refill itself. Fix the logic to be able to be used no matter which block rsv is passed in to this helper.
--- fs/btrfs/extent-tree.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-)
fs/btrfs/extent-tree.c +11 -3
@@ -4684,12 +4684,20 @@ u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, {struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_block_rsv *target = delayed_rsv; +struct btrfs_block_rsv *target =NULL ; -if (target->full || target == block_rsv) +/* +* If we are the delayed_rsv then push to the global rsv, otherwise dump +* into the delayed rsv if it is not full. +*/ +if (block_rsv == delayed_rsv) { target = global_rsv; + }else if (block_rsv != global_rsv) { +if (!delayed_rsv->full) + target = delayed_rsv; + } -if (block_rsv->space_info != target->space_info) +if (target && block_rsv->space_info != target->space_info) target =NULL ; return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
Signature · 1 line
2.14.3
Re: [PATCH 4/8] btrfs: cleanup the target logic in __btrfs_block_rsv_release
Quoted 22 lines · Josef Bacik
This works for all callers already, but if we wanted to use the helper for the
global_block_rsvit would end up trying to refill itself. Fix the logic to be able to be used no matter which block rsv is passed in to this helper.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/extent-tree.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-)fs/btrfs/extent-tree.c +1
-2@@ -4684,12 +4684,20 @@ u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, {struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_block_rsv *target = delayed_rsv; +struct btrfs_block_rsv *target =NULL ; -if (target->full || target == block_rsv)
fs/btrfs/extent-tree.c u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, · line 4698
Quoted 10 lines
fs/btrfs/extent-tree.c +9
-0+/* +* If we are the delayed_rsv then push to the global rsv, otherwise dump +* into the delayed rsv if it is not full. +*/ +if (block_rsv == delayed_rsv) { target = global_rsv; + }else if (block_rsv != global_rsv) { +if (!delayed_rsv->full) + target = delayed_rsv; + }
nit:
} else if (block_rsv != global_rsv && !delayed_rs->full) {
doesn't surpass the 80 character limit and IMO makes it a bit more readable but it's minor.
Otherwise looks good.
Quoted 7 lines
fs/btrfs/extent-tree.c +1
-1-if (block_rsv->space_info != target->space_info) +if (target && block_rsv->space_info != target->space_info) target =NULL ; return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
Re: [PATCH 4/8] btrfs: cleanup the target logic in __btrfs_block_rsv_release
Quoted 38 lines · Nikolay Borisov
Quoted 22 lines · Josef Bacik
This works for all callers already, but if we wanted to use the helper for the
global_block_rsvit would end up trying to refill itself. Fix the logic to be able to be used no matter which block rsv is passed in to this helper.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/extent-tree.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-)fs/btrfs/extent-tree.c +1
-2@@ -4684,12 +4684,20 @@ u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, {struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_block_rsv *target = delayed_rsv; +struct btrfs_block_rsv *target =NULL ; -if (target->full || target == block_rsv)fs/btrfs/extent-tree.c u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, · line 4698
Quoted 10 lines
fs/btrfs/extent-tree.c +9
-0+/* +* If we are the delayed_rsv then push to the global rsv, otherwise dump +* into the delayed rsv if it is not full. +*/ +if (block_rsv == delayed_rsv) { target = global_rsv; + }else if (block_rsv != global_rsv) { +if (!delayed_rsv->full) + target = delayed_rsv; + }nit:
Quoted 4 lines
} else if (
block_rsv!=global_rsv&& !delayed_rs->full) {doesn't surpass the 80 character limit and IMO makes it a bit more readable but it's minor.
Agreed, updated.
PATCH 5/8 btrfs: stop using block_rsv_release_bytes everywhere
In reply to Josef Bacikblock_rsv_release_bytes() is the internal to the block_rsv code, and shouldn't be called directly by anything else. Switch all users to the exported helpers.
--- fs/btrfs/extent-tree.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
fs/btrfs/extent-tree.c +6 -8
@@ -4750,12 +4750,11 @@ static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free)void btrfs_delayed_refs_rsv_release (struct btrfs_fs_info *fs_info,int nr) {struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;u64 num_bytes =btrfs_calc_trans_metadata_size (fs_info, nr);u64 released =0 ; - released =block_rsv_release_bytes (fs_info, block_rsv, global_rsv, - num_bytes,NULL ); + released =__btrfs_block_rsv_release (fs_info, block_rsv, num_bytes, +NULL );if (released)trace_btrfs_space_reservation (fs_info,"delayed_refs_rsv" ,0 , released,0 );
@@ -4840,8 +4839,7 @@ static void init_global_block_rsv(struct btrfs_fs_info *fs_info)static void release_global_block_rsv (struct btrfs_fs_info *fs_info) { -block_rsv_release_bytes (fs_info, &fs_info->global_block_rsv,NULL , - (u64)-1 ,NULL ); +btrfs_block_rsv_release (fs_info, &fs_info->global_block_rsv, (u64)-1 );WARN_ON (fs_info->trans_block_rsv.size >0 );WARN_ON (fs_info->trans_block_rsv.reserved >0 );WARN_ON (fs_info->chunk_block_rsv.size >0 );
@@ -4890,8 +4888,8 @@ void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans)WARN_ON_ONCE (!list_empty (&trans->new_bgs)); -block_rsv_release_bytes (fs_info, &fs_info->chunk_block_rsv,NULL , - trans->chunk_bytes_reserved,NULL ); +btrfs_block_rsv_release (fs_info, &fs_info->chunk_block_rsv, + trans->chunk_bytes_reserved); trans->chunk_bytes_reserved =0 ; }
@@ -7441,7 +7439,7 @@ static void unuse_block_rsv(struct btrfs_fs_info *fs_info, struct btrfs_block_rsv *block_rsv, u32 blocksize) {btrfs_block_rsv_add_bytes (block_rsv ,blocksize ,false ); -block_rsv_release_bytes (fs_info, block_rsv,NULL ,0 ,NULL ); +btrfs_block_rsv_release (fs_info, block_rsv,0 ); }/*
Signature · 1 line
2.14.3
Re: [PATCH 5/8] btrfs: stop using block_rsv_release_bytes everywhere
Quoted 15 lines · Josef Bacik
block_rsv_release_bytes()is the internal to theblock_rsvcode, and shouldn't be called directly by anything else. Switch all users to the exported helpers.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/extent-tree.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)fs/btrfs/extent-tree.c +0
-0@@ -4750,12 +4750,11 @@ static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free)void btrfs_delayed_refs_rsv_release (struct btrfs_fs_info *fs_info,int nr)
fs/btrfs/extent-tree.c static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free) · line 4757
Quoted 10 lines
fs/btrfs/extent-tree.c +2
-3{struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;u64 num_bytes =btrfs_calc_trans_metadata_size (fs_info, nr);u64 released =0 ; - released =block_rsv_release_bytes (fs_info, block_rsv, global_rsv, - num_bytes,NULL ); + released =__btrfs_block_rsv_release (fs_info, block_rsv, num_bytes, +NULL );
You should use btrfs_block_rsv_release when qgroup_to_release is NULL.
<snip>
Re: [PATCH 5/8] btrfs: stop using block_rsv_release_bytes everywhere
Quoted 24 lines · Nikolay Borisov
Quoted 21 lines · Josef Bacik
block_rsv_release_bytes()is the internal to theblock_rsvcode, and shouldn't be called directly by anything else. Switch all users to the exported helpers.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/extent-tree.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)fs/btrfs/extent-tree.c +0
-1@@ -4750,12 +4750,11 @@ static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free)void btrfs_delayed_refs_rsv_release (struct btrfs_fs_info *fs_info,int nr) {struct btrfs_block_rsv *block_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;u64 num_bytes =btrfs_calc_trans_metadata_size (fs_info, nr);u64 released =0 ;
Quoted 7 lines
fs/btrfs/extent-tree.c static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free) · line 4757
Quoted 4 lines
fs/btrfs/extent-tree.c +2
-2- released =block_rsv_release_bytes (fs_info, block_rsv, global_rsv, - num_bytes,NULL ); + released =__btrfs_block_rsv_release (fs_info, block_rsv, num_bytes, +NULL );You should use
btrfs_block_rsv_releasewhenqgroup_to_releaseis NULL.
btrfs_block_rsv_release() is a void, __btrfs_block_rsv_release returns how much was free'd. This could be cleaned up later, but I'm purposefully trying to not change code and just move things around. Thanks,
Josef
PATCH 6/8 btrfs: migrate the block-rsv code to block-rsv.c
In reply to Josef BacikThis moves everything out of extent-tree.c to block-rsv.c.
--- fs/btrfs/Makefile | 3 +- fs/btrfs/block-rsv.c | 257 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/extent-tree.c | 249 ----------------------------------------------- 3 files changed, 259 insertions(+), 250 deletions(-) create mode 100644 fs/btrfs/block-rsv.c
fs/btrfs/Makefile +2 -1
@@ -10,7 +10,8 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ export.o tree-log.o free-space-cache.o zlib.o lzo.o zstd.o \ compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \ reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \ - uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o + uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \ + block-rsv.o btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
fs/btrfs/block-rsv.c new file +257 -0
257 lines not on this page · raw message
fs/btrfs/extent-tree.c +0 -249
261 lines not on this page · raw message
Signature · 1 line
2.14.3
PATCH 7/8 btrfs: migrate the global_block_rsv helpers to block-rsv.c
In reply to Josef BacikThese helpers belong in block-rsv.c
--- fs/btrfs/block-rsv.c | 90 +++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/block-rsv.h | 3 ++ fs/btrfs/extent-tree.c | 99 +++----------------------------------------------- 3 files changed, 98 insertions(+), 94 deletions(-)
fs/btrfs/block-rsv.c +90 -0
@@ -255,3 +255,93 @@ int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,btrfs_block_rsv_add_bytes (dest, num_bytes, true);return 0 ; } + +void btrfs_update_global_block_rsv (struct btrfs_fs_info *fs_info) +{ +struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; +struct btrfs_space_info *sinfo = block_rsv->space_info; +u64 num_bytes; + +/* +* The global block rsv is based on the size of the extent tree, the +* checksum tree and the root tree. If the fs is empty we want to set +* it to a minimal amount for safety. +*/ + num_bytes =btrfs_root_used (&fs_info->extent_root->root_item) + +btrfs_root_used (&fs_info->csum_root->root_item) + +btrfs_root_used (&fs_info->tree_root->root_item); + num_bytes =max_t (u64, num_bytes,SZ_16M ); + +spin_lock (&sinfo->lock); +spin_lock (&block_rsv->lock); + + block_rsv->size =min_t (u64, num_bytes,SZ_512M ); + +if (block_rsv->reserved < block_rsv->size) { + num_bytes =btrfs_space_info_used (sinfo, true); +if (sinfo->total_bytes > num_bytes) { + num_bytes = sinfo->total_bytes - num_bytes; + num_bytes =min (num_bytes, + block_rsv->size - block_rsv->reserved); + block_rsv->reserved += num_bytes; +btrfs_space_info_update_bytes_may_use (fs_info, sinfo, + num_bytes); +trace_btrfs_space_reservation (fs_info,"space_info" , + sinfo->flags, num_bytes, +1 ); + } + }else if (block_rsv->reserved > block_rsv->size) { + num_bytes = block_rsv->reserved - block_rsv->size; +btrfs_space_info_update_bytes_may_use (fs_info, sinfo, + -num_bytes); +trace_btrfs_space_reservation (fs_info,"space_info" , + sinfo->flags, num_bytes,0 ); + block_rsv->reserved = block_rsv->size; + } + +if (block_rsv->reserved == block_rsv->size) + block_rsv->full =1 ; +else + block_rsv->full =0 ; + +spin_unlock (&block_rsv->lock); +spin_unlock (&sinfo->lock); +} + +void btrfs_init_global_block_rsv (struct btrfs_fs_info *fs_info) +{ +struct btrfs_space_info *space_info; + + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_SYSTEM ); + fs_info->chunk_block_rsv.space_info = space_info; + + space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); + fs_info->global_block_rsv.space_info = space_info; + fs_info->trans_block_rsv.space_info = space_info; + fs_info->empty_block_rsv.space_info = space_info; + fs_info->delayed_block_rsv.space_info = space_info; + fs_info->delayed_refs_rsv.space_info = space_info; + + fs_info->extent_root->block_rsv = &fs_info->delayed_refs_rsv; + fs_info->csum_root->block_rsv = &fs_info->delayed_refs_rsv; + fs_info->dev_root->block_rsv = &fs_info->global_block_rsv; + fs_info->tree_root->block_rsv = &fs_info->global_block_rsv; +if (fs_info->quota_root) + fs_info->quota_root->block_rsv = &fs_info->global_block_rsv; + fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv; + +btrfs_update_global_block_rsv (fs_info); +} + +void btrfs_release_global_block_rsv (struct btrfs_fs_info *fs_info) +{ +btrfs_block_rsv_release (fs_info, &fs_info->global_block_rsv, (u64)-1 ); +WARN_ON (fs_info->trans_block_rsv.size >0 ); +WARN_ON (fs_info->trans_block_rsv.reserved >0 ); +WARN_ON (fs_info->chunk_block_rsv.size >0 ); +WARN_ON (fs_info->chunk_block_rsv.reserved >0 ); +WARN_ON (fs_info->delayed_block_rsv.size >0 ); +WARN_ON (fs_info->delayed_block_rsv.reserved >0 ); +WARN_ON (fs_info->delayed_refs_rsv.reserved >0 ); +WARN_ON (fs_info->delayed_refs_rsv.size >0 ); +}
fs/btrfs/block-rsv.h +3 -0
@@ -80,6 +80,9 @@ void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,u64 __btrfs_block_rsv_release (struct btrfs_fs_info *fs_info,struct btrfs_block_rsv *block_rsv,u64 num_bytes,u64 *qgroup_to_release); +void btrfs_update_global_block_rsv (struct btrfs_fs_info *fs_info); +void btrfs_init_global_block_rsv (struct btrfs_fs_info *fs_info); +void btrfs_release_global_block_rsv (struct btrfs_fs_info *fs_info); static inline void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, struct btrfs_block_rsv *block_rsv,
fs/btrfs/extent-tree.c +5 -94
135 lines not on this page · raw message
Signature · 1 line
2.14.3
PATCH 8/8 btrfs: export and migrate use_block_rsv/unuse_block_rsv
In reply to Josef BacikMove these into block_rsv.c/h respectively, and export them for use by alloc_tree_block.
--- fs/btrfs/block-rsv.c | 82 ++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/block-rsv.h | 13 ++++++- fs/btrfs/extent-tree.c | 92 ++------------------------------------------------ 3 files changed, 96 insertions(+), 91 deletions(-)
fs/btrfs/block-rsv.c +82 -0
@@ -6,6 +6,7 @@#include "block-rsv.h" #include "space-info.h" #include "math.h" +#include "transaction.h" static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info, struct btrfs_block_rsv *block_rsv,
@@ -345,3 +346,84 @@ void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)WARN_ON (fs_info->delayed_refs_rsv.reserved >0 );WARN_ON (fs_info->delayed_refs_rsv.size >0 ); } + +static struct btrfs_block_rsv *get_block_rsv ( +const struct btrfs_trans_handle *trans, +const struct btrfs_root *root) +{ +struct btrfs_fs_info *fs_info = root->fs_info; +struct btrfs_block_rsv *block_rsv =NULL ; + +if (test_bit (BTRFS_ROOT_REF_COWS , &root->state) || + (root == fs_info->csum_root && trans->adding_csums) || + (root == fs_info->uuid_root)) + block_rsv = trans->block_rsv; + +if (!block_rsv) + block_rsv = root->block_rsv; + +if (!block_rsv) + block_rsv = &fs_info->empty_block_rsv; + +return block_rsv; +} + +struct btrfs_block_rsv *btrfs_use_block_rsv (struct btrfs_trans_handle *trans, +struct btrfs_root *root, +u32 blocksize) +{ +struct btrfs_fs_info *fs_info = root->fs_info; +struct btrfs_block_rsv *block_rsv; +struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; +int ret; +bool global_updated = false; + + block_rsv =get_block_rsv (trans, root); + +if (unlikely (block_rsv->size ==0 )) + goto try_reserve; +again: + ret =btrfs_block_rsv_use_bytes (block_rsv, blocksize); +if (!ret) +return block_rsv; + +if (block_rsv->failfast) +return ERR_PTR (ret); + +if (block_rsv->type ==BTRFS_BLOCK_RSV_GLOBAL && !global_updated) { + global_updated = true; +btrfs_update_global_block_rsv (fs_info); + goto again; + } + +/* +* The global reserve still exists to save us from ourselves, so don't +* warn_on if we are short on our delayed refs reserve. +*/ +if (block_rsv->type !=BTRFS_BLOCK_RSV_DELREFS && +btrfs_test_opt (fs_info,ENOSPC_DEBUG )) { + static DEFINE_RATELIMIT_STATE(_rs, + DEFAULT_RATELIMIT_INTERVAL * 10, + /*DEFAULT_RATELIMIT_BURST*/ 1); +if (__ratelimit (&_rs)) +WARN (1 ,KERN_DEBUG +"BTRFS: block rsv returned %d\n" , ret); + } +try_reserve: + ret =btrfs_reserve_metadata_bytes (root, block_rsv, blocksize, +BTRFS_RESERVE_NO_FLUSH ); +if (!ret) +return block_rsv; +/* +* If we couldn't reserve metadata bytes try and use some from +* the global reserve if its space type is the same as the global +* reservation. +*/ +if (block_rsv->type !=BTRFS_BLOCK_RSV_GLOBAL && + block_rsv->space_info == global_rsv->space_info) { + ret =btrfs_block_rsv_use_bytes (global_rsv, blocksize); +if (!ret) +return global_rsv; + } +return ERR_PTR (ret); +}
fs/btrfs/block-rsv.h +12 -1
@@ -6,7 +6,7 @@#ifndef BTRFS_BLOCK_RSV_H #define BTRFS_BLOCK_RSV_H - +struct btrfs_trans_handle ;enum btrfs_reserve_flush_enum ;/*
@@ -83,6 +83,9 @@ u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,void btrfs_update_global_block_rsv (struct btrfs_fs_info *fs_info);void btrfs_init_global_block_rsv (struct btrfs_fs_info *fs_info);void btrfs_release_global_block_rsv (struct btrfs_fs_info *fs_info); +struct btrfs_block_rsv *btrfs_use_block_rsv (struct btrfs_trans_handle *trans, +struct btrfs_root *root, +u32 blocksize); static inline void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, struct btrfs_block_rsv *block_rsv,
@@ -90,4 +93,12 @@ static inline void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, {__btrfs_block_rsv_release (fs_info, block_rsv, num_bytes,NULL ); } + +static inline void btrfs_unuse_block_rsv (struct btrfs_fs_info *fs_info, +struct btrfs_block_rsv *block_rsv, +u32 blocksize) +{ +btrfs_block_rsv_add_bytes (block_rsv, blocksize, false); +btrfs_block_rsv_release (fs_info, block_rsv,0 ); +}#endif /* BTRFS_BLOCK_RSV_H */
fs/btrfs/extent-tree.c +2 -90
116 lines not on this page · raw message
Signature · 1 line
2.14.3
Quoted 9 lines · Josef Bacik
This patchset depends on the
space_infomigration patchset. This is the next logical chunk of things to move out ofextent-tree.cWith these sets of patches we're down below 10k loc inextent-tree.c. This chunk was much easier to move as we had exported a lot of these functions already. There is 1 code change patch in here and that's to cleanup the logic in__btrfs_block_rsv_releaseso it could be used more globally by everybody. The rest is just exporting and migrating code around. Again I specifically didn't clean anything else up, I'm just trying to re-organize everything. The diffstat of the series is as follows
Quoted 6 lines
fs/btrfs/Makefile | 3 +- fs/btrfs/block-rsv.c | 429 ++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/block-rsv.h | 104 ++++++++++++ fs/btrfs/ctree.h | 70 +------- fs/btrfs/extent-tree.c | 452 ++----------------------------------------------- 5 files changed, 549 insertions(+), 509 deletions(-)
Added to misc-next, thanks.