xfs: set aside allocation btree blocks from block reservation
v5 cover xfs: set aside allocation btree blocks from block reservation
v5:
- Tweak allocbt counter init logic to filter out rmapbt root block.
v4: https://lore.kernel.org/linux-xfs/[email protected]/
- 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 | 14 ++++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.c | 15 ++++++++++++++- fs/xfs/xfs_mount.h | 6 ++++++ 5 files changed, 59 insertions(+), 12 deletions(-)
Signature · 1 line
2.26.3
PATCH v5 2/3 xfs: introduce in-core global counter of allocbt blocks
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.
--- fs/xfs/libxfs/xfs_alloc.c | 14 ++++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 22 insertions(+)
fs/xfs/libxfs/xfs_alloc.c +14 -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; +int allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);
@@ -3066,6 +3067,19 @@ 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 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); }#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 v5 1/3 xfs: unconditionally read all AGFs on mounts with perag reservation
In reply to Brian Fosterperag 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
PATCH v5 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
Re: [PATCH v5 2/3] xfs: introduce in-core global counter of allocbt blocks
In reply to Brian FosterQuoted 10 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.
Quoted 3 lines
Signed-off-by Brian Foster <[email protected]>Reviewed-by Chandan Babu R <[email protected]>Reviewed-by Allison Henderson <[email protected]>
Looks better, let's see what happens when I throw it at fstests...
--D
Quoted 78 lines
--- fs/xfs/libxfs/xfs_alloc.c | 14 ++++++++++++++ fs/xfs/libxfs/xfs_alloc_btree.c | 2 ++ fs/xfs/xfs_mount.h | 6 ++++++ 3 files changed, 22 insertions(+)fs/xfs/libxfs/xfs_alloc.c +14
-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; +int allocbt_blks;trace_xfs_alloc_read_agf (mp, agno);@@ -3066,6 +3067,19 @@ 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 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); }#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