xfs: set aside allocation btree blocks from block reservation
v4 cover xfs: set aside allocation btree blocks from block reservation
Hi all,
Here's v4 of the proposed allocbt block set aside fix. The patches have been swizzled around a bit based on previous feedback to try and avoid confusion over what bits are perag res related and not. This hopefully facilitates analysis when it comes time to evaluate potential changes to remove the current perag res mount time AG header scan behavior on which this currently depends. Otherwise the actual code changes from v3 are fairly light and documented in the changelog below. Thoughts, reviews, flames appreciated.
Brian
v4:
- Fix up perag res logic to not skip pagf init on partial res failure.
- Split up set aside patch into separate counter mechanism and set aside policy patches.
- Drop unnecessary ->m_has_agresv flag as pagf's are always initialized on filesystems with active reservations.
v3: https://lore.kernel.org/linux-xfs/[email protected]/
- Use a mount flag for easy detection of active perag reservation.
- Filter rmapbt blocks from allocbt block accounting.
v2: https://lore.kernel.org/linux-xfs/[email protected]/
- Use an atomic counter instead of a percpu counter.
v1: https://lore.kernel.org/linux-xfs/[email protected]/
Brian Foster (3):
xfs: unconditionally read all AGFs on mounts with perag reservation
xfs: introduce in-core global counter of allocbt blocks
xfs: set aside allocation btree blocks from block reservation
fs/xfs/libxfs/xfs_ag_resv.c | 34 ++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.c | 15 ++++++++++++++- fs/xfs/xfs_mount.h | 6 ++++++ 5 files changed, 57 insertions(+), 12 deletions(-)
Signature · 1 line
2.26.3
PATCH v4 1/3 xfs: unconditionally read all AGFs on mounts with perag reservation
perag reservation is enabled at mount time on a per AG basis. The upcoming change to set aside allocbt blocks from block reservation requires a populated allocbt counter as soon as possible after mount to be fully effective against large perag reservations. Therefore as a preparation step, initialize the pagf on all mounts where at least one reservation is active. Note that this already occurs to some degree on most default format filesystems as reservation requirement calculations already depend on the AGF or AGI, depending on the reservation type.
--- fs/xfs/libxfs/xfs_ag_resv.c | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_ag_resv.c +23 -11
@@ -253,7 +253,8 @@ xfs_ag_resv_init(xfs_agnumber_t agno = pag->pag_agno;xfs_extlen_t ask;xfs_extlen_t used; -int error =0 ; +int error =0 , error2; +bool has_resv = false;/* Create the metadata reservation. */ if (pag->pag_meta_resv.ar_asked ==0 ) {
@@ -291,6 +292,8 @@ xfs_ag_resv_init(if (error) goto out; } +if (ask) + has_resv = true; }/* Create the RMAPBT metadata reservation */
@@ -304,19 +307,28 @@ xfs_ag_resv_init( error =__xfs_ag_resv_init (pag,XFS_AG_RESV_RMAPBT , ask, used);if (error) goto out; +if (ask) + has_resv = true; } -#ifdef DEBUG -/* need to read in the AGF for the ASSERT below to work */ - error =xfs_alloc_pagf_init (pag->pag_mount, tp, pag->pag_agno,0 ); -if (error) -return error; - -ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + -xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= - pag->pagf_freeblks + pag->pagf_flcount); -#endif out: +/* +* Initialize the pagf if we have at least one active reservation on the +* AG. This may have occurred already via reservation calculation, but +* fall back to an explicit init to ensure the in-core allocbt usage +* counters are initialized as soon as possible. This is important +* because filesystems with large perag reservations are susceptible to +* free space reservation problems that the allocbt counter is used to +* address. +*/ +if (has_resv) { + error2 =xfs_alloc_pagf_init (mp, tp, pag->pag_agno,0 ); +if (error2) +return error2; +ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + +xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= + pag->pagf_freeblks + pag->pagf_flcount); + }return error; }
Signature · 1 line
2.26.3
Re: [PATCH v4 1/3] xfs: unconditionally read all AGFs on mounts with perag reservation
Quoted 10 lines · Brian Foster
perag reservation is enabled at mount time on a per AG basis. The upcoming change to set aside allocbt blocks from block reservation requires a populated allocbt counter as soon as possible after mount to be fully effective against large perag reservations. Therefore as a preparation step, initialize the pagf on all mounts where at least one reservation is active. Note that this already occurs to some degree on most default format filesystems as reservation requirement calculations already depend on the AGF or AGI, depending on the reservation type.
The changes look good to me.
Quoted 66 lines
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_ag_resv.c | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-)fs/xfs/libxfs/xfs_ag_resv.c +23
-11@@ -253,7 +253,8 @@ xfs_ag_resv_init(xfs_agnumber_t agno = pag->pag_agno;xfs_extlen_t ask;xfs_extlen_t used; -int error =0 ; +int error =0 , error2; +bool has_resv = false;/* Create the metadata reservation. */ if (pag->pag_meta_resv.ar_asked ==0 ) {@@ -291,6 +292,8 @@ xfs_ag_resv_init(if (error) goto out; } +if (ask) + has_resv = true; }/* Create the RMAPBT metadata reservation */ @@ -304,19 +307,28 @@ xfs_ag_resv_init( error =__xfs_ag_resv_init (pag,XFS_AG_RESV_RMAPBT , ask, used);if (error) goto out; +if (ask) + has_resv = true; } -#ifdef DEBUG -/* need to read in the AGF for the ASSERT below to work */ - error =xfs_alloc_pagf_init (pag->pag_mount, tp, pag->pag_agno,0 ); -if (error) -return error; - -ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + -xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= - pag->pagf_freeblks + pag->pagf_flcount); -#endif out: +/* +* Initialize the pagf if we have at least one active reservation on the +* AG. This may have occurred already via reservation calculation, but +* fall back to an explicit init to ensure the in-core allocbt usage +* counters are initialized as soon as possible. This is important +* because filesystems with large perag reservations are susceptible to +* free space reservation problems that the allocbt counter is used to +* address. +*/ +if (has_resv) { + error2 =xfs_alloc_pagf_init (mp, tp, pag->pag_agno,0 ); +if (error2) +return error2; +ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + +xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= + pag->pagf_freeblks + pag->pagf_flcount); + }return error; }
Signature · 1 line
chandan
Re: [PATCH v4 1/3] xfs: unconditionally read all AGFs on mounts with perag reservation
In reply to Brian FosterQuoted 11 lines · Brian Foster
perag reservation is enabled at mount time on a per AG basis. The upcoming change to set aside allocbt blocks from block reservation requires a populated allocbt counter as soon as possible after mount to be fully effective against large perag reservations. Therefore as a preparation step, initialize the pagf on all mounts where at least one reservation is active. Note that this already occurs to some degree on most default format filesystems as reservation requirement calculations already depend on the AGF or AGI, depending on the reservation type.
Signed-off-by Brian Foster <[email protected]>
Looks ok to me
Quoted 67 lines
--- fs/xfs/libxfs/xfs_ag_resv.c | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-)fs/xfs/libxfs/xfs_ag_resv.c +23
-11@@ -253,7 +253,8 @@ xfs_ag_resv_init(xfs_agnumber_t agno = pag->pag_agno;xfs_extlen_t ask;xfs_extlen_t used; -int error =0 ; +int error =0 , error2; +bool has_resv = false;/* Create the metadata reservation. */ if (pag->pag_meta_resv.ar_asked ==0 ) {@@ -291,6 +292,8 @@ xfs_ag_resv_init(if (error) goto out; } +if (ask) + has_resv = true; }/* Create the RMAPBT metadata reservation */ @@ -304,19 +307,28 @@ xfs_ag_resv_init( error =__xfs_ag_resv_init (pag,XFS_AG_RESV_RMAPBT , ask, used);if (error) goto out; +if (ask) + has_resv = true; } -#ifdef DEBUG -/* need to read in the AGF for the ASSERT below to work */ - error =xfs_alloc_pagf_init (pag->pag_mount, tp, pag->pag_agno,0 ); -if (error) -return error; - -ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + -xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= - pag->pagf_freeblks + pag->pagf_flcount); -#endif out: +/* +* Initialize the pagf if we have at least one active reservation on the +* AG. This may have occurred already via reservation calculation, but +* fall back to an explicit init to ensure the in-core allocbt usage +* counters are initialized as soon as possible. This is important +* because filesystems with large perag reservations are susceptible to +* free space reservation problems that the allocbt counter is used to +* address. +*/ +if (has_resv) { + error2 =xfs_alloc_pagf_init (mp, tp, pag->pag_agno,0 ); +if (error2) +return error2; +ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + +xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= + pag->pagf_freeblks + pag->pagf_flcount); + }return error; }
Re: [PATCH v4 1/3] xfs: unconditionally read all AGFs on mounts with perag reservation
In reply to Brian FosterQuoted 11 lines · Brian Foster
perag reservation is enabled at mount time on a per AG basis. The upcoming change to set aside allocbt blocks from block reservation requires a populated allocbt counter as soon as possible after mount to be fully effective against large perag reservations. Therefore as a preparation step, initialize the pagf on all mounts where at least one reservation is active. Note that this already occurs to some degree on most default format filesystems as reservation requirement calculations already depend on the AGF or AGI, depending on the reservation type.
Signed-off-by Brian Foster <[email protected]>
Looks good to me too,
--D
Quoted 69 lines
--- fs/xfs/libxfs/xfs_ag_resv.c | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-)fs/xfs/libxfs/xfs_ag_resv.c +23
-11@@ -253,7 +253,8 @@ xfs_ag_resv_init(xfs_agnumber_t agno = pag->pag_agno;xfs_extlen_t ask;xfs_extlen_t used; -int error =0 ; +int error =0 , error2; +bool has_resv = false;/* Create the metadata reservation. */ if (pag->pag_meta_resv.ar_asked ==0 ) {@@ -291,6 +292,8 @@ xfs_ag_resv_init(if (error) goto out; } +if (ask) + has_resv = true; }/* Create the RMAPBT metadata reservation */ @@ -304,19 +307,28 @@ xfs_ag_resv_init( error =__xfs_ag_resv_init (pag,XFS_AG_RESV_RMAPBT , ask, used);if (error) goto out; +if (ask) + has_resv = true; } -#ifdef DEBUG -/* need to read in the AGF for the ASSERT below to work */ - error =xfs_alloc_pagf_init (pag->pag_mount, tp, pag->pag_agno,0 ); -if (error) -return error; - -ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + -xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= - pag->pagf_freeblks + pag->pagf_flcount); -#endif out: +/* +* Initialize the pagf if we have at least one active reservation on the +* AG. This may have occurred already via reservation calculation, but +* fall back to an explicit init to ensure the in-core allocbt usage +* counters are initialized as soon as possible. This is important +* because filesystems with large perag reservations are susceptible to +* free space reservation problems that the allocbt counter is used to +* address. +*/ +if (has_resv) { + error2 =xfs_alloc_pagf_init (mp, tp, pag->pag_agno,0 ); +if (error2) +return error2; +ASSERT (xfs_perag_resv (pag,XFS_AG_RESV_METADATA )->ar_reserved + +xfs_perag_resv (pag,XFS_AG_RESV_RMAPBT )->ar_reserved <= + pag->pagf_freeblks + pag->pagf_flcount); + }return error; }Signature · 1 line
2.26.3
PATCH v4 2/3 xfs: introduce in-core global counter of allocbt blocks
In reply to Brian FosterIntroduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)
fs/xfs/libxfs/xfs_alloc.c +12 -0
@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);
@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) { + allocbt_blks = pag->pagf_btreeblks - +be32_to_cpu (agf->agf_rmap_blocks); +atomic64_add (allocbt_blks, &mp->m_allocbt_blks); + } }#ifdef DEBUG else if (!XFS_FORCED_SHUTDOWN(mp)) {
fs/xfs/libxfs/xfs_alloc_btree.c +2 -0
@@ -71,6 +71,7 @@ xfs_allocbt_alloc_block(return 0 ; } +atomic64_inc (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_reuse (cur->bc_mp, cur->bc_ag.agno, bno,1 , false);xfs_trans_agbtree_delta (cur->bc_tp,1 );
@@ -95,6 +96,7 @@ xfs_allocbt_free_block(if (error)return error; +atomic64_dec (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_insert (cur->bc_tp,be32_to_cpu (agf->agf_seqno), bno,1 ,XFS_EXTENT_BUSY_SKIP_DISCARD );xfs_trans_agbtree_delta (cur->bc_tp,-1 );
fs/xfs/xfs_mount.h +6 -0
@@ -170,6 +170,12 @@ typedef struct xfs_mount {* extents or anything related to the rt device. */ struct percpu_counter m_delalloc_blks; +/* +* Global count of allocation btree blocks in use across all AGs. Only +* used when perag reservation is enabled. Helps prevent block +* reservation from attempting to reserve allocation btree blocks. +*/ +atomic64_t m_allocbt_blks;struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */
Signature · 1 line
2.26.3
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
Quoted 30 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {
pag->pagf_btreeblks gets incremented everytime a block is allocated to refill AGFL (via xfs_alloc_get_freelist()). Apart from the allobt trees, blocks for Rmap btree also get allocated from AGFL. Hence pag->pagf_btreeblks must be larger than agf->agf_rmap_blocks.
Can you please describe the scenario in which pag->pagf_btreeblks has a value that is <= agf->agf_rmap_blocks?
--
chandan
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
Quoted 30 lines · Chandan Babu R
Quoted 29 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);
Quoted 17 lines
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 11 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {
pag->pagf_btreeblksgets incremented everytime a block is allocated to refill AGFL (viaxfs_alloc_get_freelist()). Apart from the allobt trees, blocks for Rmap btree also get allocated from AGFL. Hencepag->pagf_btreeblksmust be larger thanagf->agf_rmap_blocks.
This function is actually to consume a block from the AGFL (as opposed to refill it).
Quoted 3 lines
Can you please describe the scenario in which
pag->pagf_btreeblkshas a value that is <=agf->agf_rmap_blocks?
Ah, this was just an initialization quirk. I originally had an assert here and based the logic on the assumption that pagf_btreeblks >= agf_rmap_blocks, but alas:
# mkfs.xfs -f -mrmapbt <dev> ... # xfs_db -c "agf 0" -c "p rmapblocks" -c "p btreeblks" <dev> rmapblocks = 1 btreeblks = 0 #
Brian
Quoted 3 lines
--
chandan
Chandan Babu R
Reviewed-byRe: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
Quoted 49 lines · Brian Foster
Quoted 30 lines · Chandan Babu R
Quoted 29 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);Quoted 17 lines
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 11 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {
pag->pagf_btreeblksgets incremented everytime a block is allocated to refill AGFL (viaxfs_alloc_get_freelist()). Apart from the allobt trees, blocks for Rmap btree also get allocated from AGFL. Hencepag->pagf_btreeblksmust be larger thanagf->agf_rmap_blocks.
Quoted 2 lines
This function is actually to consume a block from the AGFL (as opposed to refill it).
Sorry, I meant to say "allocate a block from AGFL".
Quoted 9 lines
Quoted 4 lines
Can you please describe the scenario in which
pag->pagf_btreeblkshas a value that is <=agf->agf_rmap_blocks?Ah, this was just an initialization quirk. I originally had an assert here and based the logic on the assumption that
pagf_btreeblks>=agf_rmap_blocks, but alas:
Quoted 6 lines
# mkfs.xfs -f -mrmapbt <dev> ... # xfs_db -c "agf 0" -c "p rmapblocks" -c "p btreeblks" <dev> rmapblocks = 1 btreeblks = 0 #
Thanks for clarifying my doubt.
The patch looks good to me.
Signature · 1 line
chandan
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
In reply to Brian FosterQuoted 11 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>
OK, makes sense
Quoted 74 lines
--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +12
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) { + allocbt_blks = pag->pagf_btreeblks - +be32_to_cpu (agf->agf_rmap_blocks); +atomic64_add (allocbt_blks, &mp->m_allocbt_blks); + } }#ifdef DEBUG else if (!XFS_FORCED_SHUTDOWN(mp)) {fs/xfs/libxfs/xfs_alloc_btree.c +2
-0@@ -71,6 +71,7 @@ xfs_allocbt_alloc_block(return 0 ; } +atomic64_inc (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_reuse (cur->bc_mp, cur->bc_ag.agno, bno,1 , false);xfs_trans_agbtree_delta (cur->bc_tp,1 );@@ -95,6 +96,7 @@ xfs_allocbt_free_block(if (error)return error; +atomic64_dec (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_insert (cur->bc_tp,be32_to_cpu (agf->agf_seqno), bno,1 ,XFS_EXTENT_BUSY_SKIP_DISCARD );xfs_trans_agbtree_delta (cur->bc_tp,-1 );fs/xfs/xfs_mount.h +6
-0@@ -170,6 +170,12 @@ typedef struct xfs_mount {* extents or anything related to the rt device. */ struct percpu_counter m_delalloc_blks; +/* +* Global count of allocation btree blocks in use across all AGs. Only +* used when perag reservation is enabled. Helps prevent block +* reservation from attempting to reserve allocation btree blocks. +*/ +atomic64_t m_allocbt_blks;struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
In reply to Brian FosterQuoted 30 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {
As pointed out elsewhere in the thread, agf_rmap_blocks counts the total number of blocks in the rmapbt (whereas agf_btreeblks counts the number of non-root blocks in all three free space btrees). Does this need a change?
int delta = (int)pag->pagf_btreeblks - (be32_to_cpu(...) - 1); if (delta > 0) atomic64_add(delta, &mp->m_allocbt_blks);
--D
Quoted 47 lines
fs/xfs/libxfs/xfs_alloc.c +4
-0+ allocbt_blks = pag->pagf_btreeblks - +be32_to_cpu (agf->agf_rmap_blocks); +atomic64_add (allocbt_blks, &mp->m_allocbt_blks); + } }#ifdef DEBUG else if (!XFS_FORCED_SHUTDOWN(mp)) {fs/xfs/libxfs/xfs_alloc_btree.c +2
-0@@ -71,6 +71,7 @@ xfs_allocbt_alloc_block(return 0 ; } +atomic64_inc (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_reuse (cur->bc_mp, cur->bc_ag.agno, bno,1 , false);xfs_trans_agbtree_delta (cur->bc_tp,1 );@@ -95,6 +96,7 @@ xfs_allocbt_free_block(if (error)return error; +atomic64_dec (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_insert (cur->bc_tp,be32_to_cpu (agf->agf_seqno), bno,1 ,XFS_EXTENT_BUSY_SKIP_DISCARD );xfs_trans_agbtree_delta (cur->bc_tp,-1 );fs/xfs/xfs_mount.h +6
-0@@ -170,6 +170,12 @@ typedef struct xfs_mount {* extents or anything related to the rt device. */ struct percpu_counter m_delalloc_blks; +/* +* Global count of allocation btree blocks in use across all AGs. Only +* used when perag reservation is enabled. Helps prevent block +* reservation from attempting to reserve allocation btree blocks. +*/ +atomic64_t m_allocbt_blks;struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */ Signature · 1 line
2.26.3
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
Quoted 47 lines · Darrick J. Wong
Quoted 30 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {As pointed out elsewhere in the thread,
agf_rmap_blockscounts the total number of blocks in the rmapbt (whereasagf_btreeblkscounts the number of non-root blocks in all three free space btrees). Does this need a change?
Quoted 4 lines
int delta = (int)pag->pagf_btreeblks - (be32_to_cpu(...) - 1); if (delta > 0) atomic64_add(delta, &mp->m_allocbt_blks);
Hm yes, this makes more sense. Will fix and update the comment..
Brian
Quoted 50 lines
--D
Quoted 47 lines
fs/xfs/libxfs/xfs_alloc.c +4
-0+ allocbt_blks = pag->pagf_btreeblks - +be32_to_cpu (agf->agf_rmap_blocks); +atomic64_add (allocbt_blks, &mp->m_allocbt_blks); + } }#ifdef DEBUG else if (!XFS_FORCED_SHUTDOWN(mp)) {fs/xfs/libxfs/xfs_alloc_btree.c +2
-0@@ -71,6 +71,7 @@ xfs_allocbt_alloc_block(return 0 ; } +atomic64_inc (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_reuse (cur->bc_mp, cur->bc_ag.agno, bno,1 , false);xfs_trans_agbtree_delta (cur->bc_tp,1 );@@ -95,6 +96,7 @@ xfs_allocbt_free_block(if (error)return error; +atomic64_dec (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_insert (cur->bc_tp,be32_to_cpu (agf->agf_seqno), bno,1 ,XFS_EXTENT_BUSY_SKIP_DISCARD );xfs_trans_agbtree_delta (cur->bc_tp,-1 );fs/xfs/xfs_mount.h +6
-0@@ -170,6 +170,12 @@ typedef struct xfs_mount {* extents or anything related to the rt device. */ struct percpu_counter m_delalloc_blks; +/* +* Global count of allocation btree blocks in use across all AGs. Only +* used when perag reservation is enabled. Helps prevent block +* reservation from attempting to reserve allocation btree blocks. +*/ +atomic64_t m_allocbt_blks;struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */ Signature · 1 line
2.26.3
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
Quoted 48 lines · Brian Foster
Quoted 47 lines · Darrick J. Wong
Quoted 30 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {As pointed out elsewhere in the thread,
agf_rmap_blockscounts the total number of blocks in the rmapbt (whereasagf_btreeblkscounts the number of non-root blocks in all three free space btrees). Does this need a change?
Quoted 7 lines
Quoted 4 lines
int delta = (int)pag->pagf_btreeblks - (be32_to_cpu(...) - 1); if (delta > 0) atomic64_add(delta, &mp->m_allocbt_blks);Hm yes, this makes more sense. Will fix and update the comment..
I ended up with the following:
...
/*
* Update the in-core allocbt counter. Filter out the rmapbt
* subset of the btreeblks counter because the rmapbt is managed
* by perag reservation. Subtract one for the rmapbt root block
* because the rmap counter includes it while the btreeblks
* counter only tracks non-root blocks.
*/
allocbt_blks = pag->pagf_btreeblks;
if (xfs_sb_version_hasrmapbt(&mp->m_sb))
allocbt_blks -= be32_to_cpu(agf->agf_rmap_blocks) - 1;
if (allocbt_blks > 0)
atomic64_add(allocbt_blks, &mp->m_allocbt_blks);
...Any thoughts before I post v5?
Brian
Quoted 52 lines
Brian
Quoted 50 lines
--D
Quoted 47 lines
fs/xfs/libxfs/xfs_alloc.c +4
-0+ allocbt_blks = pag->pagf_btreeblks - +be32_to_cpu (agf->agf_rmap_blocks); +atomic64_add (allocbt_blks, &mp->m_allocbt_blks); + } }#ifdef DEBUG else if (!XFS_FORCED_SHUTDOWN(mp)) {fs/xfs/libxfs/xfs_alloc_btree.c +2
-0@@ -71,6 +71,7 @@ xfs_allocbt_alloc_block(return 0 ; } +atomic64_inc (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_reuse (cur->bc_mp, cur->bc_ag.agno, bno,1 , false);xfs_trans_agbtree_delta (cur->bc_tp,1 );@@ -95,6 +96,7 @@ xfs_allocbt_free_block(if (error)return error; +atomic64_dec (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_insert (cur->bc_tp,be32_to_cpu (agf->agf_seqno), bno,1 ,XFS_EXTENT_BUSY_SKIP_DISCARD );xfs_trans_agbtree_delta (cur->bc_tp,-1 );fs/xfs/xfs_mount.h +6
-0@@ -170,6 +170,12 @@ typedef struct xfs_mount {* extents or anything related to the rt device. */ struct percpu_counter m_delalloc_blks; +/* +* Global count of allocation btree blocks in use across all AGs. Only +* used when perag reservation is enabled. Helps prevent block +* reservation from attempting to reserve allocation btree blocks. +*/ +atomic64_t m_allocbt_blks;struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */ Signature · 1 line
2.26.3
Re: [PATCH v4 2/3] xfs: introduce in-core global counter of allocbt blocks
Quoted 74 lines · Brian Foster
Quoted 48 lines · Brian Foster
Quoted 47 lines · Darrick J. Wong
Quoted 30 lines · Brian Foster
Introduce an in-core counter to track the sum of all allocbt blocks used by the filesystem. This value is currently tracked per-ag via the ->agf_btreeblks field in the AGF, which also happens to include rmapbt blocks. A global, in-core count of allocbt blocks is required to identify the subset of global ->m_fdblocks that consists of unavailable blocks currently used for allocation btrees. To support this calculation at block reservation time, construct a similar global counter for allocbt blocks, populate it on first read of each AGF and update it as allocbt blocks are used and released.
Signed-off-by Brian Foster <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 12 ++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 20 insertions(+)fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3036,6 +3036,7 @@ xfs_alloc_read_agf(struct xfs_agf *agf;/* ag freelist header */ struct xfs_perag *pag;/* per allocation group data */ int error; +uint32_t allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3076
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3066,6 +3067,17 @@ xfs_alloc_read_agf( pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); pag->pagf_init =1 ; pag->pagf_agflreset =xfs_agfl_needs_reset (mp, agf); + +/* +* Update the global in-core allocbt block counter. Filter +* rmapbt blocks from the on-disk counter because those are +* managed by perag reservation. +*/ +if (pag->pagf_btreeblks >be32_to_cpu (agf->agf_rmap_blocks)) {As pointed out elsewhere in the thread,
agf_rmap_blockscounts the total number of blocks in the rmapbt (whereasagf_btreeblkscounts the number of non-root blocks in all three free space btrees). Does this need a change?Quoted 7 lines
Quoted 4 lines
int delta = (int)pag->pagf_btreeblks - (be32_to_cpu(...) - 1); if (delta > 0) atomic64_add(delta, &mp->m_allocbt_blks);Hm yes, this makes more sense. Will fix and update the comment..
I ended up with the following:
... /* * Update the in-core allocbt counter. Filter out the rmapbt * subset of the btreeblks counter because the rmapbt is managed * by perag reservation. Subtract one for the rmapbt root block * because the rmap counter includes it while the btreeblks * counter only tracks non-root blocks. */ allocbt_blks = pag->pagf_btreeblks; if (xfs_sb_version_hasrmapbt(&mp->m_sb)) allocbt_blks -= be32_to_cpu(agf->agf_rmap_blocks) - 1; if (allocbt_blks > 0) atomic64_add(allocbt_blks, &mp->m_allocbt_blks); ...
Quoted 1 line
Any thoughts before I post v5?
Looks reasonable to me. :)
--D
Quoted 55 lines
Brian
Quoted 52 lines
Brian
Quoted 50 lines
--D
Quoted 47 lines
fs/xfs/libxfs/xfs_alloc.c +4
-0+ allocbt_blks = pag->pagf_btreeblks - +be32_to_cpu (agf->agf_rmap_blocks); +atomic64_add (allocbt_blks, &mp->m_allocbt_blks); + } }#ifdef DEBUG else if (!XFS_FORCED_SHUTDOWN(mp)) {fs/xfs/libxfs/xfs_alloc_btree.c +2
-0@@ -71,6 +71,7 @@ xfs_allocbt_alloc_block(return 0 ; } +atomic64_inc (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_reuse (cur->bc_mp, cur->bc_ag.agno, bno,1 , false);xfs_trans_agbtree_delta (cur->bc_tp,1 );@@ -95,6 +96,7 @@ xfs_allocbt_free_block(if (error)return error; +atomic64_dec (&cur->bc_mp->m_allocbt_blks);xfs_extent_busy_insert (cur->bc_tp,be32_to_cpu (agf->agf_seqno), bno,1 ,XFS_EXTENT_BUSY_SKIP_DISCARD );xfs_trans_agbtree_delta (cur->bc_tp,-1 );fs/xfs/xfs_mount.h +6
-0@@ -170,6 +170,12 @@ typedef struct xfs_mount {* extents or anything related to the rt device. */ struct percpu_counter m_delalloc_blks; +/* +* Global count of allocation btree blocks in use across all AGs. Only +* used when perag reservation is enabled. Helps prevent block +* reservation from attempting to reserve allocation btree blocks. +*/ +atomic64_t m_allocbt_blks;struct radix_tree_root m_perag_tree;/* per-ag accounting info */ spinlock_t m_perag_lock;/* lock for m_perag_tree */ Signature · 1 line
2.26.3
PATCH v4 3/3 xfs: set aside allocation btree blocks from block reservation
In reply to Brian FosterThe blocks used for allocation btrees (bnobt and countbt) are technically considered free space. This is because as free space is used, allocbt blocks are removed and naturally become available for traditional allocation. However, this means that a significant portion of free space may consist of in-use btree blocks if free space is severely fragmented.
On large filesystems with large perag reservations, this can lead to a rare but nasty condition where a significant amount of physical free space is available, but the majority of actual usable blocks consist of in-use allocbt blocks. We have a record of a (~12TB, 32 AG) filesystem with multiple AGs in a state with ~2.5GB or so free blocks tracked across ~300 total allocbt blocks, but effectively at 100% full because the the free space is entirely consumed by refcountbt perag reservation.
Such a large perag reservation is by design on large filesystems. The problem is that because the free space is so fragmented, this AG contributes the 300 or so allocbt blocks to the global counters as free space. If this pattern repeats across enough AGs, the filesystem lands in a state where global block reservation can outrun physical block availability. For example, a streaming buffered write on the affected filesystem continues to allow delayed allocation beyond the point where writeback starts to fail due to physical block allocation failures. The expected behavior is for the delalloc block reservation to fail gracefully with -ENOSPC before physical block allocation failure is a possibility.
To address this problem, set aside in-use allocbt blocks at reservation time and thus ensure they cannot be reserved until truly available for physical allocation. This allows alloc btree metadata to continue to reside in free space, but dynamically adjusts reservation availability based on internal state. Note that the logic requires that the allocbt counter is fully populated at reservation time before it is fully effective. We currently rely on the mount time AGF scan in the perag reservation initialization code for this dependency on filesystems where it's most important (i.e. with active perag reservations).
--- fs/xfs/xfs_mount.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
fs/xfs/xfs_mount.c +14 -1
@@ -1188,6 +1188,7 @@ xfs_mod_fdblocks(int64_t lcounter;long long res_used;s32 batch; +uint64_t set_aside;if (delta >0 ) {/*
@@ -1227,8 +1228,20 @@ xfs_mod_fdblocks(else batch =XFS_FDBLOCKS_BATCH ; +/* +* Set aside allocbt blocks because these blocks are tracked as free +* space but not available for allocation. Technically this means that a +* single reservation cannot consume all remaining free space, but the +* ratio of allocbt blocks to usable free blocks should be rather small. +* The tradeoff without this is that filesystems that maintain high +* perag block reservations can over reserve physical block availability +* and fail physical allocation, which leads to much more serious +* problems (i.e. transaction abort, pagecache discards, etc.) than +* slightly premature -ENOSPC. +*/ + set_aside = mp->m_alloc_set_aside +atomic64_read (&mp->m_allocbt_blks);percpu_counter_add_batch (&mp->m_fdblocks, delta, batch); -if (__percpu_counter_compare (&mp->m_fdblocks, mp->m_alloc_set_aside, +if (__percpu_counter_compare (&mp->m_fdblocks, set_aside,XFS_FDBLOCKS_BATCH ) >=0 ) {/* we had space! */ return 0 ;
Signature · 1 line
2.26.3
Quoted 28 lines · Brian Foster
The blocks used for allocation btrees (bnobt and countbt) are technically considered free space. This is because as free space is used, allocbt blocks are removed and naturally become available for traditional allocation. However, this means that a significant portion of free space may consist of in-use btree blocks if free space is severely fragmented.
On large filesystems with large perag reservations, this can lead to a rare but nasty condition where a significant amount of physical free space is available, but the majority of actual usable blocks consist of in-use allocbt blocks. We have a record of a (~12TB, 32 AG) filesystem with multiple AGs in a state with ~2.5GB or so free blocks tracked across ~300 total allocbt blocks, but effectively at 100% full because the the free space is entirely consumed by refcountbt perag reservation.
Such a large perag reservation is by design on large filesystems. The problem is that because the free space is so fragmented, this AG contributes the 300 or so allocbt blocks to the global counters as free space. If this pattern repeats across enough AGs, the filesystem lands in a state where global block reservation can outrun physical block availability. For example, a streaming buffered write on the affected filesystem continues to allow delayed allocation beyond the point where writeback starts to fail due to physical block allocation failures. The expected behavior is for the delalloc block reservation to fail gracefully with
-ENOSPCbefore physical block allocation failure is a possibility.
Quoted 11 lines
To address this problem, set aside in-use allocbt blocks at reservation time and thus ensure they cannot be reserved until truly available for physical allocation. This allows alloc btree metadata to continue to reside in free space, but dynamically adjusts reservation availability based on internal state. Note that the logic requires that the allocbt counter is fully populated at reservation time before it is fully effective. We currently rely on the mount time AGF scan in the perag reservation initialization code for this dependency on filesystems where it's most important (i.e. with active perag reservations).
The changes look good to me.
Signature · 1 line
chandan
Quoted 39 lines · Brian Foster
The blocks used for allocation btrees (bnobt and countbt) are technically considered free space. This is because as free space is used, allocbt blocks are removed and naturally become available for traditional allocation. However, this means that a significant portion of free space may consist of in-use btree blocks if free space is severely fragmented.
On large filesystems with large perag reservations, this can lead to a rare but nasty condition where a significant amount of physical free space is available, but the majority of actual usable blocks consist of in-use allocbt blocks. We have a record of a (~12TB, 32 AG) filesystem with multiple AGs in a state with ~2.5GB or so free blocks tracked across ~300 total allocbt blocks, but effectively at 100% full because the the free space is entirely consumed by refcountbt perag reservation.
Such a large perag reservation is by design on large filesystems. The problem is that because the free space is so fragmented, this AG contributes the 300 or so allocbt blocks to the global counters as free space. If this pattern repeats across enough AGs, the filesystem lands in a state where global block reservation can outrun physical block availability. For example, a streaming buffered write on the affected filesystem continues to allow delayed allocation beyond the point where writeback starts to fail due to physical block allocation failures. The expected behavior is for the delalloc block reservation to fail gracefully with
-ENOSPCbefore physical block allocation failure is a possibility.To address this problem, set aside in-use allocbt blocks at reservation time and thus ensure they cannot be reserved until truly available for physical allocation. This allows alloc btree metadata to continue to reside in free space, but dynamically adjusts reservation availability based on internal state. Note that the logic requires that the allocbt counter is fully populated at reservation time before it is fully effective. We currently rely on the mount time AGF scan in the perag reservation initialization code for this dependency on filesystems where it's most important (i.e. with active perag reservations).
Quoted 1 line
Signed-off-by Brian Foster <[email protected]>
OK, makes sense, thanks for the comments!
Quoted 39 lines
--- fs/xfs/xfs_mount.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)fs/xfs/xfs_mount.c +14
-1@@ -1188,6 +1188,7 @@ xfs_mod_fdblocks(int64_t lcounter;long long res_used;s32 batch; +uint64_t set_aside;if (delta >0 ) {/* @@ -1227,8 +1228,20 @@ xfs_mod_fdblocks(else batch =XFS_FDBLOCKS_BATCH ; +/* +* Set aside allocbt blocks because these blocks are tracked as free +* space but not available for allocation. Technically this means that a +* single reservation cannot consume all remaining free space, but the +* ratio of allocbt blocks to usable free blocks should be rather small. +* The tradeoff without this is that filesystems that maintain high +* perag block reservations can over reserve physical block availability +* and fail physical allocation, which leads to much more serious +* problems (i.e. transaction abort, pagecache discards, etc.) than +* slightly premature -ENOSPC. +*/ + set_aside = mp->m_alloc_set_aside +atomic64_read (&mp->m_allocbt_blks);percpu_counter_add_batch (&mp->m_fdblocks, delta, batch); -if (__percpu_counter_compare (&mp->m_fdblocks, mp->m_alloc_set_aside, +if (__percpu_counter_compare (&mp->m_fdblocks, set_aside,XFS_FDBLOCKS_BATCH ) >=0 ) {/* we had space! */ return 0 ;
Quoted 39 lines · Brian Foster
The blocks used for allocation btrees (bnobt and countbt) are technically considered free space. This is because as free space is used, allocbt blocks are removed and naturally become available for traditional allocation. However, this means that a significant portion of free space may consist of in-use btree blocks if free space is severely fragmented.
On large filesystems with large perag reservations, this can lead to a rare but nasty condition where a significant amount of physical free space is available, but the majority of actual usable blocks consist of in-use allocbt blocks. We have a record of a (~12TB, 32 AG) filesystem with multiple AGs in a state with ~2.5GB or so free blocks tracked across ~300 total allocbt blocks, but effectively at 100% full because the the free space is entirely consumed by refcountbt perag reservation.
Such a large perag reservation is by design on large filesystems. The problem is that because the free space is so fragmented, this AG contributes the 300 or so allocbt blocks to the global counters as free space. If this pattern repeats across enough AGs, the filesystem lands in a state where global block reservation can outrun physical block availability. For example, a streaming buffered write on the affected filesystem continues to allow delayed allocation beyond the point where writeback starts to fail due to physical block allocation failures. The expected behavior is for the delalloc block reservation to fail gracefully with
-ENOSPCbefore physical block allocation failure is a possibility.To address this problem, set aside in-use allocbt blocks at reservation time and thus ensure they cannot be reserved until truly available for physical allocation. This allows alloc btree metadata to continue to reside in free space, but dynamically adjusts reservation availability based on internal state. Note that the logic requires that the allocbt counter is fully populated at reservation time before it is fully effective. We currently rely on the mount time AGF scan in the perag reservation initialization code for this dependency on filesystems where it's most important (i.e. with active perag reservations).
Quoted 1 line
Signed-off-by Brian Foster <[email protected]>
<nod>
--D
Quoted 41 lines
--- fs/xfs/xfs_mount.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)fs/xfs/xfs_mount.c +14
-1@@ -1188,6 +1188,7 @@ xfs_mod_fdblocks(int64_t lcounter;long long res_used;s32 batch; +uint64_t set_aside;if (delta >0 ) {/* @@ -1227,8 +1228,20 @@ xfs_mod_fdblocks(else batch =XFS_FDBLOCKS_BATCH ; +/* +* Set aside allocbt blocks because these blocks are tracked as free +* space but not available for allocation. Technically this means that a +* single reservation cannot consume all remaining free space, but the +* ratio of allocbt blocks to usable free blocks should be rather small. +* The tradeoff without this is that filesystems that maintain high +* perag block reservations can over reserve physical block availability +* and fail physical allocation, which leads to much more serious +* problems (i.e. transaction abort, pagecache discards, etc.) than +* slightly premature -ENOSPC. +*/ + set_aside = mp->m_alloc_set_aside +atomic64_read (&mp->m_allocbt_blks);percpu_counter_add_batch (&mp->m_fdblocks, delta, batch); -if (__percpu_counter_compare (&mp->m_fdblocks, mp->m_alloc_set_aside, +if (__percpu_counter_compare (&mp->m_fdblocks, set_aside,XFS_FDBLOCKS_BATCH ) >=0 ) {/* we had space! */ return 0 ;Signature · 1 line
2.26.3