xfs: per-ag centric allocation alogrithms
cover xfs: per-ag centric allocation alogrithms
This series continues the work towards making shrinking a filesystem possible. We need to be able to stop operations from taking place on AGs that need to be removed by a shrink, so before shrink can be implemented we need to have the infrastructure in place to prevent incursion into AGs that are going to be, or are in the process, of being removed from active duty.
The focus of this is making operations that depend on access to AGs use the perag to access and pin the AG in active use, thereby creating a barrier we can use to delay shrink until all active uses of an AG have been drained and new uses are prevented.
This series starts by fixing some existing issues that are exposed by changes later in the series. They stand alone, so can be picked up independently of the rest of this patchset.
The most complex of these fixes is cleaning up the mess that is the AGF deadlock avoidance algorithm. This algorithm stores the first block that is allocated in a transaction in tp->t_firstblock, then uses this to try to limit future allocations within the transaction to AGs at or higher than the filesystem block stored in tp->t_firstblock. This depends on one of the initial bug fixes in the series to move the deadlock avoidance checks to xfs_alloc_vextent(), and then builds on it to relax the constraints of the avoidance algorithm to only be active when a deadlock is possible.
We also update the algorithm to record allocations from higher AGs that are allocated from, because we when we need to lock more than two AGs we still have to ensure lock order is correct. Therefore we can't lock AGs in the order 1, 3, 2, even though tp->t_firstblock indicates that we've allocated from AG 1 and so AG is valid to lock. It's not valid, because we already hold AG 3 locked, and so tp->t-first_block should actually point at AG 3, not AG 1 in this situation.
It should now be obvious that the deadlock avoidance algorithm should record AGs, not filesystem blocks. So the series then changes the transaction to store the highest AG we've allocated in rather than a filesystem block we allocated. This makes it obvious what the constraints are, and trivial to update as we lock and allocate from various AGs.
With all the bug fixes out of the way, the series then starts converting the code to use active references. Active reference counts are used by high level code that needs to prevent the AG from being taken out from under it by a shrink operation. The high level code needs to be able to handle not getting an active reference gracefully, and the shrink code will need to wait for active references to drain before continuing.
Active references are implemented just as reference counts right now
- an active reference is taken at perag init during mount, and all other active references are dependent on the active reference count being greater than zero. This gives us an initial method of stopping new active references without needing other infrastructure; just drop the reference taken at filesystem mount time and when the refcount then falls to zero no new references can be taken.
In future, this will need to take into account AG control state (e.g. offline, no alloc, etc) as well as the reference count, but right now we can implement a basic barrier for shrink with just reference count manipulations. As such, patches to convert the perag state to atomic opstate fields similar to the xfs_mount and xlog opstate fields follow the initial active perag reference counting patches.
The first target for active reference conversion is the for_each_perag*() iterators. This captures a lot of high level code that should skip offline AGs, and introduces the ability to differentiate between a lookup that didn't have an online AG and the end of the AG iteration range.
From there, the inode allocation AG selection is converted to active references, and the perag is driven deeper into the inode allocation and btree code to replace the xfs_mount. Most of the inode allocation code operates on a single AG once it is selected, hence it should pass the perag as the primary referenced object around for allocation, not the xfs_mount. There is a bit of churn here, but it emphasises that inode allocation is inherently an allocation group based operation.
Next the bmap/alloc interface undergoes a major untangling, reworking xfs_bmap_btalloc() into separate allocation operations for different contexts and failure handling behaviours. This then allows us to completely remove the xfs_alloc_vextent() layer via restructuring the xfs_alloc_vextent/xfs_alloc_ag_vextent() into a set of realtively simple helper function that describe the allocation that they are doing. e.g. xfs_alloc_vextent_exact_bno().
This allows the requirements for accessing AGs to be allocation context dependent. The allocations that require operation on a single AG generally can't tolerate failure after the allocation method and AG has been decided on, and hence the caller needs to manage the active references to ensure the allocation does not race with shrink removing the selected AG for the duration of the operation that requires access to that allocation group.
Other allocations iterate AGs and so the first AG is just a hint - these do not need to pin a perag first as they can tolerate not being able to access an AG by simply skipping over it. These require new perag iteration functions that can start at arbitrary AGs and wrap around at arbitrary AGs, hence a new set for for_each_perag_wrap*() helpers to do this.
Next is the rework of the filestreams allocator. This doesn't change any functionality, but gets rid of the unnecessary multi-pass selection algorithm when the selected AG is not available. It currently does a lookup pass which might iterate all AGs to select an AG, then checks if the AG is acceptible and if not does a "new AG" pass that is essentially identical to the lookup pass. Both of these scans also do the same "longest extent in AG" check before selecting an AG as is done after the AG is selected.
IOWs, the filestreams algorithm can be greatly simplified into a single new AG selection pass if the there is no current association or the currently associated AG doesn't have enough contiguous free space for the allocation to proceed. With this simplification of the filestreams allocator, it's then trivial to convert it to use for_each_perag_wrap() for the AG scan algorithm.
This series passes auto group fstests with rmapbt=1 on both 1kB and 4kB block size configurations without functional or performance regressions. In some cases ENOSPC behaviour is improved, but fstests does not capture those improvements as it only tests for regressions in behaviour.
Version 2:
- AGI, AGF and AGFL access conversion patches removed due to being merged.
- AG geometry conversion patches removed due to being merged
- Rebase on 6.2-rc4
- fixed "firstblock" AGF deadlock avoidance algorithm
- lots of cleanups and bug fixes.
Version 1 [RFC]:
- https://lore.kernel.org/linux-xfs/[email protected]/
PATCH 1/42 xfs: fix low space alloc deadlock
From: Dave Chinner <[email protected]>
I've recently encountered an ABBA deadlock with g/476. The upcoming changes seem to make this much easier to hit, but the underlying problem is a pre-existing one.
Essentially, if we select an AG for allocation, then lock the AGF and then fail to allocate for some reason (e.g. minimum length requirements cannot be satisfied), then we drop out of the allocation with the AGF still locked.
The caller then modifies the allocation constraints - usually loosening them up - and tries again. This can result in trying to access AGFs that are lower than the AGF we already have locked from the failed attempt. e.g. the failed attempt skipped several AGs before failing, so we have locks an AG higher than the start AG. Retrying the allocation from the start AG then causes us to violate AGF lock ordering and this can lead to deadlocks.
The deadlock exists even if allocation succeeds - we can do a followup allocations in the same transaction for BMBT blocks that aren't guaranteed to be in the same AG as the original, and can move into higher AGs. Hence we really need to move the tp->t_firstblock tracking down into xfs_alloc_vextent() where it can be set when we exit with a locked AG.
xfs_alloc_vextent() can also check there if the requested allocation falls within the allow range of AGs set by tp->t_firstblock. If we can't allocate within the range set, we have to fail the allocation. If we are allowed to to non-blocking AGF locking, we can ignore the AG locking order limitations as we can use try-locks for the first iteration over requested AG range.
This invalidates a set of post allocation asserts that check that the allocation is always above tp->t_firstblock if it is set. Because we can use try-locks to avoid the deadlock in some circumstances, having a pre-existing locked AGF doesn't always prevent allocation from lower order AGFs. Hence those ASSERTs need to be removed.
--- fs/xfs/libxfs/xfs_alloc.c | 69 ++++++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_bmap.c | 14 -------- fs/xfs/xfs_trace.h | 1 + 3 files changed, 58 insertions(+), 26 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +57 -12
@@ -3164,10 +3164,13 @@ xfs_alloc_vextent(xfs_alloctype_t type;/* input allocation type */ int bump_rotor =0 ;xfs_agnumber_t rotorstep = xfs_rotorstep;/* inode32 agf stepper */ +xfs_agnumber_t minimum_agno =0 ; mp = args->mp; type = args->otype = args->type; args->agbno =NULLAGBLOCK ; +if (args->tp->t_firstblock !=NULLFSBLOCK ) + minimum_agno =XFS_FSB_TO_AGNO (mp, args->tp->t_firstblock);/* * Just fix this up, for the case where the last a.g. is shorter * (or there's only one a.g.) and the caller couldn't easily figure
@@ -3201,6 +3204,13 @@ xfs_alloc_vextent(*/ args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); args->pag =xfs_perag_get (mp, args->agno); + +if (minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); + error =0 ; +break ; + } + error =xfs_alloc_fix_freelist (args,0 );if (error) {trace_xfs_alloc_vextent_nofix (args);
@@ -3232,6 +3242,8 @@ xfs_alloc_vextent(case XFS_ALLOCTYPE_FIRST_AG :/* * Rotate through the allocation groups looking for a winner. +* If we are blocking, we must obey minimum_agno contraints for +* avoiding ABBA deadlocks on AGF locking. */ if (type ==XFS_ALLOCTYPE_FIRST_AG ) {/*
@@ -3239,7 +3251,7 @@ xfs_alloc_vextent(*/ args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); args->type =XFS_ALLOCTYPE_THIS_AG ; - sagno =0 ; + sagno = minimum_agno; flags =0 ; }else {/*
@@ -3248,6 +3260,7 @@ xfs_alloc_vextent( args->agno = sagno =XFS_FSB_TO_AGNO (mp, args->fsbno); flags =XFS_ALLOC_FLAG_TRYLOCK ; } +/* * Loop over allocation groups twice; first time with * trylock set, second time without.
@@ -3276,19 +3289,21 @@ xfs_alloc_vextent(if (args->agno == sagno && type ==XFS_ALLOCTYPE_START_BNO ) args->type =XFS_ALLOCTYPE_THIS_AG ; +/* -* For the first allocation, we can try any AG to get -* space. However, if we already have allocated a -* block, we don't want to try AGs whose number is below -* sagno. Otherwise, we may end up with out-of-order -* locking of AGF, which might cause deadlock. -*/ +* If we are try-locking, we can't deadlock on AGF +* locks, so we can wrap all the way back to the first +* AG. Otherwise, wrap back to the start AG so we can't +* deadlock, and let the end of scan handler decide what +* to do next. +*/ if (++(args->agno) == mp->m_sb.sb_agcount) { -if (args->tp->t_firstblock !=NULLFSBLOCK ) - args->agno = sagno; -else +if (flags &XFS_ALLOC_FLAG_TRYLOCK ) args->agno =0 ; +else + args->agno = sagno; } +/* * Reached the starting a.g., must either be done * or switch to non-trylock mode.
@@ -3300,7 +3315,14 @@ xfs_alloc_vextent(break ; } +/* +* Blocking pass next, so we must obey minimum +* agno constraints to avoid ABBA AGF deadlocks. +*/ flags =0 ; +if (minimum_agno > sagno) + sagno = minimum_agno; +if (type ==XFS_ALLOCTYPE_START_BNO ) { args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno);
@@ -3322,9 +3344,9 @@ xfs_alloc_vextent(ASSERT (0 );/* NOTREACHED */ } -if (args->agbno ==NULLAGBLOCK ) +if (args->agbno ==NULLAGBLOCK ) { args->fsbno =NULLFSBLOCK ; -else { + }else { args->fsbno =XFS_AGB_TO_FSB (mp, args->agno, args->agbno);#ifdef DEBUG ASSERT (args->len >= args->minlen);
@@ -3335,6 +3357,29 @@ xfs_alloc_vextent(#endif } + +/* +* We end up here with a locked AGF. If we failed, the caller is likely +* going to try to allocate again with different parameters, and that +* can widen the AGs that are searched for free space. If we have to do +* BMBT block allocation, we have to do a new allocation. +* +* Hence leaving this function with the AGF locked opens up potential +* ABBA AGF deadlocks because a future allocation attempt in this +* transaction may attempt to lock a lower number AGF. +* +* We can't release the AGF until the transaction is commited, so at +* this point we must update the "firstblock" tracker to point at this +* AG if the tracker is empty or points to a lower AG. This allows the +* next allocation attempt to be modified appropriately to avoid +* deadlocks. +*/ +if (args->agbp && + (args->tp->t_firstblock ==NULLFSBLOCK || + args->pag->pag_agno > minimum_agno)) { + args->tp->t_firstblock =XFS_AGB_TO_FSB (mp, + args->pag->pag_agno,0 ); + }xfs_perag_put (args->pag);return 0 ; error0:
fs/xfs/libxfs/xfs_bmap.c +0 -14
@@ -3413,21 +3413,7 @@ xfs_bmap_process_allocated_extent( xfs_fileoff_t orig_offset, xfs_extlen_t orig_length) { - int nullfb; - - nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; - -/* -* check the allocation happened at the same or higher AG than -* the first block that was allocated. -*/ -ASSERT (nullfb || -XFS_FSB_TO_AGNO (args->mp, ap->tp->t_firstblock) <= -XFS_FSB_TO_AGNO (args->mp, args->fsbno)); - ap->blkno = args->fsbno; -if (nullfb) - ap->tp->t_firstblock = args->fsbno; ap->length = args->len;/* * If the extent size hint is active, we tried to round the
fs/xfs/xfs_trace.h +1 -0
@@ -1877,6 +1877,7 @@ DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough);DEFINE_ALLOC_EVENT (xfs_alloc_small_done);DEFINE_ALLOC_EVENT (xfs_alloc_small_error);DEFINE_ALLOC_EVENT (xfs_alloc_vextent_badargs); +DEFINE_ALLOC_EVENT (xfs_alloc_vextent_skip_deadlock);DEFINE_ALLOC_EVENT (xfs_alloc_vextent_nofix);DEFINE_ALLOC_EVENT (xfs_alloc_vextent_noagbp);DEFINE_ALLOC_EVENT (xfs_alloc_vextent_loopfailed);
Signature · 1 line
2.39.0
Re: [PATCH 01/42] xfs: fix low space alloc deadlock
Quoted 33 lines · Dave Chinner
From: Dave Chinner <[email protected]>
I've recently encountered an ABBA deadlock with g/476. The upcoming changes seem to make this much easier to hit, but the underlying problem is a pre-existing one.
Essentially, if we select an AG for allocation, then lock the AGF and then fail to allocate for some reason (e.g. minimum length requirements cannot be satisfied), then we drop out of the allocation with the AGF still locked.
The caller then modifies the allocation constraints - usually loosening them up - and tries again. This can result in trying to access AGFs that are lower than the AGF we already have locked from the failed attempt. e.g. the failed attempt skipped several AGs before failing, so we have locks an AG higher than the start AG. Retrying the allocation from the start AG then causes us to violate AGF lock ordering and this can lead to deadlocks.
The deadlock exists even if allocation succeeds - we can do a followup allocations in the same transaction for BMBT blocks that aren't guaranteed to be in the same AG as the original, and can move into higher AGs. Hence we really need to move the
tp->t_firstblocktracking down intoxfs_alloc_vextent()where it can be set when we exit with a locked AG.
xfs_alloc_vextent()can also check there if the requested allocation falls within the allow range of AGs set bytp->t_firstblock. If we can't allocate within the range set, we have to fail the allocation. If we are allowed to to non-blocking AGF locking, we can ignore the AG locking order limitations as we can use try-locks for the first iteration over requested AG range.
Quoted 8 lines
This invalidates a set of post allocation asserts that check that the allocation is always above
tp->t_firstblockif it is set. Because we can use try-locks to avoid the deadlock in some circumstances, having a pre-existing locked AGF doesn't always prevent allocation from lower order AGFs. Hence those ASSERTs need to be removed.Signed-off-by Dave Chinner <[email protected]>
This makes sense to me. I kinda wish git had a way of making subsets of sets to help break up large series like this. Like a bug fix subset and then the new feature subset.
Quoted 224 lines
---
fs/xfs/libxfs/xfs_alloc.c | 69 ++++++++++++++++++++++++++++++++----- --
fs/xfs/libxfs/xfs_bmap.c | 14 -------- fs/xfs/xfs_trace.h | 1 +3 files changed, 58 insertions(+), 26 deletions(-)fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3164,10 +3164,13 @@ xfs_alloc_vextent(xfs_alloctype_t type; /* input allocation type */ int bump_rotor = 0; xfs_agnumber_t rotorstep =
xfs_rotorstep; /* inode32 agf stepper */
+ xfs_agnumber_t minimum_agno = 0;
mp =args->mp;
type =args->otype=args->type;
args->agbno = NULLAGBLOCK;
+ if (args->tp->t_firstblock!= NULLFSBLOCK)
+ minimum_agno = XFS_FSB_TO_AGNO(mp, args->tp-Quoted 1 line
t_firstblock);/*
* Just fix this up, for the case where the last a.g. is shorter
* (or there's only one a.g.) and the caller couldn't easily figurefs/xfs/libxfs/xfs_alloc.c +7
-0@@ -3201,6 +3204,13 @@ xfs_alloc_vextent(*/ args->agno = XFS_FSB_TO_AGNO(mp, args->fsbno); args->pag = xfs_perag_get(mp, args->agno); + + if (minimum_agno > args->agno) { + trace_xfs_alloc_vextent_skip_deadlock(args); + error = 0; + break; + } + error = xfs_alloc_fix_freelist(args, 0); if (error) { trace_xfs_alloc_vextent_nofix(args);@@ -3232,6 +3242,8 @@ xfs_alloc_vextent(case
XFS_ALLOCTYPE_FIRST_AG:
/*
* Rotate through the allocation groups looking for a winner.
+ * If we are blocking, we must obeyminimum_agnocontraints for
+ * avoiding ABBA deadlocks on AGF locking. */
if (type ==XFS_ALLOCTYPE_FIRST_AG) {
/*fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3239,7 +3251,7 @@ xfs_alloc_vextent(*/ args->agno = XFS_FSB_TO_AGNO(mp, args-
Quoted 1 line
fsbno);
args->type =
XFS_ALLOCTYPE_THIS_AG; - sagno = 0;
+ sagno =minimum_agno; flags = 0;
} else {
/*fs/xfs/libxfs/xfs_alloc.c +1
-0@@ -3248,6 +3260,7 @@ xfs_alloc_vextent( args->agno = sagno = XFS_FSB_TO_AGNO(mp, args->fsbno); flags = XFS_ALLOC_FLAG_TRYLOCK; } + /** Loop over allocation groups twice; first time with * trylock set, second time without.
fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3276,19 +3289,21 @@ xfs_alloc_vextent(if (
args->agno== sagno &&
type ==XFS_ALLOCTYPE_START_BNO)args->type=XFS_ALLOCTYPE_THIS_AG; +
/*
- * For the first allocation, we can try any AG to get
- * space. However, if we already have allocated a
- * block, we don't want to try AGs whose number is below
- * sagno. Otherwise, we may end up with out- of-order
- * locking of AGF, which might cause deadlock. - */
+ * If we are try-locking, we can't deadlock on AGF
+ * locks, so we can wrap all the way back to the first
+ * AG. Otherwise, wrap back to the start AG so we can't
+ * deadlock, and let the end of scan handler decide what
+ * to do next.
+ */
if (++(args->agno) ==mp->m_sb.sb_agcount) { - if (args->tp->t_firstblock!= NULLFSBLOCK)
- args->agno = sagno; - else
+ if (flags &XFS_ALLOC_FLAG_TRYLOCK)args->agno= 0;
+ else
+ args->agno = sagno; }
+
/*
* Reached the starting a.g., must either be done
* or switch to non-trylock mode.fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3300,7 +3315,14 @@ xfs_alloc_vextent( break; }
+ /*
+ * Blocking pass next, so we must obey minimum
+ * agno constraints to avoid ABBA AGF deadlocks.
+ */
flags = 0;
+ if (minimum_agno> sagno) + sagno =minimum_agno; +
if (type ==XFS_ALLOCTYPE_START_BNO) {
args->agbno = XFS_FSB_TO_AGBNO(mp,
args->fsbno);fs/xfs/libxfs/xfs_alloc.c +2
-2@@ -3322,9 +3344,9 @@ xfs_alloc_vextent( ASSERT(0); /* NOTREACHED */ } - if (args->agbno == NULLAGBLOCK) + if (args->agbno == NULLAGBLOCK) { args->fsbno = NULLFSBLOCK; - else { + } else {args->fsbno = XFS_AGB_TO_FSB(mp,
args->agno, args-Quoted 1 line
agbno);
#ifdef DEBUG
ASSERT(args->len >=args->minlen);fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3335,6 +3357,29 @@ xfs_alloc_vextent( #endif
}
+
+ /*
+ * We end up here with a locked AGF. If we failed, the caller is likely
+ * going to try to allocate again with different parameters, and that
+ * can widen the AGs that are searched for free space. If we have to do
+ * BMBT block allocation, we have to do a new allocation. + *
+ * Hence leaving this function with the AGF locked opens up potential
+ * ABBA AGF deadlocks because a future allocation attempt in this
+ * transaction may attempt to lock a lower number AGF. + *
+ * We can't release the AGF until the transaction is commited, so at
+ * this point we must update the "firstblock" tracker to point at this
+ * AG if the tracker is empty or points to a lower AG. This allows the
+ * next allocation attempt to be modified appropriately to avoid
+ * deadlocks.
+ */
+ if (args->agbp&&
+ (args->tp->t_firstblock== NULLFSBLOCK ||
+args->pag->pag_agno>minimum_agno)) {
+ args->tp->t_firstblock = XFS_AGB_TO_FSB(mp, + args->pag->pag_agno, 0); + }
xfs_perag_put(args->pag);
return 0;
error0:fs/xfs/libxfs/xfs_bmap.c +0
-6@@ -3413,21 +3413,7 @@ xfs_bmap_process_allocated_extent( xfs_fileoff_t orig_offset, xfs_extlen_t orig_length) { - int nullfb; - - nullfb = ap->tp->t_firstblock == NULLFSBLOCK; - - /* -* check the allocation happened at the same or higher AG than
- * the first block that was allocated.
- */
- ASSERT(nullfb ||
- XFS_FSB_TO_AGNO(args->mp,ap->tp->t_firstblock) <= - XFS_FSB_TO_AGNO(args->mp,args->fsbno)); -
ap->blkno =args->fsbno;
- if (nullfb)
- ap->tp->t_firstblock =args->fsbno;ap->length=args->len;
/*
* If the extent size hint is active, we tried to round thefs/xfs/xfs_trace.h +1
-0@@ -1877,6 +1877,7 @@ DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough); DEFINE_ALLOC_EVENT(xfs_alloc_small_done); DEFINE_ALLOC_EVENT(xfs_alloc_small_error); DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs); +DEFINE_ALLOC_EVENT (xfs_alloc_vextent_skip_deadlock); DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix); DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp); DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed);
Re: [PATCH 01/42] xfs: fix low space alloc deadlock
In reply to Dave ChinnerSuppose there are two threads doing delayed allocation and both of them trigger the btree splitting. Due to delayed allocation, thread A holds the lock of AGF 1, thread B holds the lock of AGF 3:
agno(low -> high): 1 3
A B
Then both of them initiate a btree split work(AS from A and BS from B), but due to memory pressure described by commit c85007e2e3942da1f9361e4b5a9388ea3a8dcc5b ("xfs: don't use BMBT btree split workers for IO completion"), the two works are processed by the rescuer thread, AS first, then BS. After trying each AG with the TRYLOCK flag but failing all, AS retries with blocking allocation, until it reaches AG 3, then deadlocks there: AGF 3 lock was held by thread B, but its split work BS was queued after AS and has no chance to be processed. Locking order is followed, but still deadlock occurs.
We didn't actually trigger such deadlock, but encountered a similar hungtask reported by commit c85007e2e3942da1f9361e4b5a9388ea3a8dcc5b ("xfs: don't use BMBT btree split workers for IO completion"). That commit has fixed our hungtask. But while analyzing the vmcore, we found there are some other btree split works queued on the rescuer thread, initiated from delayed allocation threads, each of which has held an AGF lock. That leads us to this patch and thinking about such a case.
So is this possible? It seems currently once queued into the rescuer thread, a split work has no way to know whether there is another concurrent split work initiator holding the lock it requires.
PATCH 2/42 xfs: prefer free inodes at ENOSPC over chunk allocation
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
When an XFS filesystem has free inodes in chunks already allocated on disk, it will still allocate new inode chunks if the target AG has no free inodes in it. Normally, this is a good idea as it preserves locality of all the inodes in a given directory.
However, at ENOSPC this can lead to using the last few remaining free filesystem blocks to allocate a new chunk when there are many, many free inodes that could be allocated without consuming free space. This results in speeding up the consumption of the last few blocks and inode create operations then returning ENOSPC when there free inodes available because we don't have enough block left in the filesystem for directory creation reservations to proceed.
Hence when we are near ENOSPC, we should be attempting to preserve the remaining blocks for directory block allocation rather than using them for unnecessary inode chunk creation.
This particular behaviour is exposed by xfs/294, when it drives to ENOSPC on empty file creation whilst there are still thousands of free inodes available for allocation in other AGs in the filesystem.
Hence, when we are within 1% of ENOSPC, change the inode allocation behaviour to prefer to use existing free inodes over allocating new inode chunks, even though it results is poorer locality of the data set. It is more important for the allocations to be space efficient near ENOSPC than to have optimal locality for performance, so lets modify the inode AG selection code to reflect that fact.
This allows generic/294 to not only pass with this allocator rework patchset, but to increase the number of post-ENOSPC empty inode allocations to from ~600 to ~9080 before we hit ENOSPC on the directory create transaction reservation.
--- fs/xfs/libxfs/xfs_ialloc.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
fs/xfs/libxfs/xfs_ialloc.c +17 -0
@@ -1737,6 +1737,7 @@ xfs_dialloc(struct xfs_perag *pag;struct xfs_ino_geometry *igeo =M_IGEO (mp);bool ok_alloc = true; +bool low_space = false;int flags;xfs_ino_t ino;
@@ -1767,6 +1768,20 @@ xfs_dialloc( ok_alloc = false; } +/* +* If we are near to ENOSPC, we want to prefer allocation from AGs that +* have free inodes in them rather than use up free space allocating new +* inode chunks. Hence we turn off allocation for the first non-blocking +* pass through the AGs if we are near ENOSPC to consume free inodes +* that we can immediately allocate, but then we allow allocation on the +* second pass if we fail to find an AG with free inodes in it. +*/ +if (percpu_counter_read_positive (&mp->m_fdblocks) < + mp->m_low_space[XFS_LOWSP_1_PCNT ]) { + ok_alloc = false; + low_space = true; + } +/* * Loop until we find an allocation group that either has free inodes * or in which we can allocate some inodes. Iterate through the
@@ -1795,6 +1810,8 @@ xfs_dialloc(break ; } flags =0 ; +if (low_space) + ok_alloc = true; }xfs_perag_put (pag); }
Signature · 1 line
2.39.0
Re: [PATCH 02/42] xfs: prefer free inodes at ENOSPC over chunk allocation
Quoted 30 lines · Dave Chinner
From: Dave Chinner <[email protected]>
When an XFS filesystem has free inodes in chunks already allocated on disk, it will still allocate new inode chunks if the target AG has no free inodes in it. Normally, this is a good idea as it preserves locality of all the inodes in a given directory.
However, at ENOSPC this can lead to using the last few remaining free filesystem blocks to allocate a new chunk when there are many, many free inodes that could be allocated without consuming free space. This results in speeding up the consumption of the last few blocks and inode create operations then returning ENOSPC when there free inodes available because we don't have enough block left in the filesystem for directory creation reservations to proceed.
Hence when we are near ENOSPC, we should be attempting to preserve the remaining blocks for directory block allocation rather than using them for unnecessary inode chunk creation.
This particular behaviour is exposed by xfs/294, when it drives to ENOSPC on empty file creation whilst there are still thousands of free inodes available for allocation in other AGs in the filesystem.
Hence, when we are within 1% of ENOSPC, change the inode allocation behaviour to prefer to use existing free inodes over allocating new inode chunks, even though it results is poorer locality of the data set. It is more important for the allocations to be space efficient near ENOSPC than to have optimal locality for performance, so lets modify the inode AG selection code to reflect that fact.
Quoted 6 lines
This allows generic/294 to not only pass with this allocator rework patchset, but to increase the number of post-ENOSPC empty inode allocations to from ~600 to ~9080 before we hit ENOSPC on the directory create transaction reservation.
Signed-off-by Dave Chinner <[email protected]>
Ok, makes sense
Quoted 54 lines
---
fs/xfs/libxfs/xfs_ialloc.c | 17 +++++++++++++++++1 file changed, 17 insertions(+)fs/xfs/libxfs/xfs_ialloc.c +1
-0@@ -1737,6 +1737,7 @@ xfs_dialloc( struct xfs_perag *pag; struct xfs_ino_geometry *igeo = M_IGEO(mp); bool ok_alloc = true; + bool low_space = false; int flags; xfs_ino_t ino;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1767,6 +1768,20 @@ xfs_dialloc( ok_alloc = false; }
+ /*
+ * If we are near to ENOSPC, we want to prefer allocation from AGs that
+ * have free inodes in them rather than use up free space allocating new
+ * inode chunks. Hence we turn off allocation for the first non-blocking
+ * pass through the AGs if we are near ENOSPC to consume free inodes
+ * that we can immediately allocate, but then we allow allocation on the
+ * second pass if we fail to find an AG with free inodes in it.
+ */
+ if (percpu_counter_read_positive(&mp->m_fdblocks)< + mp->m_low_space[XFS_LOWSP_1_PCNT]) { + ok_alloc = false;
+ low_space = true;
+ }
+
/*
* Loop until we find an allocation group that either has free inodes
* or in which we can allocate some inodes. Iterate through thefs/xfs/libxfs/xfs_ialloc.c +2
-0@@ -1795,6 +1810,8 @@ xfs_dialloc( break; } flags = 0; + if (low_space) + ok_alloc = true; } xfs_perag_put(pag); }
PATCH 3/42 xfs: block reservation too large for minleft allocation
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
When we enter xfs_bmbt_alloc_block() without having first allocated a data extent (i.e. tp->t_firstblock == NULLFSBLOCK) because we are doing something like unwritten extent conversion, the transaction block reservation is used as the minleft value.
This works for operations like unwritten extent conversion, but it assumes that the block reservation is only for a BMBT split. THis is not always true, and sometimes results in larger than necessary minleft values being set. We only actually need enough space for a btree split, something we already handle correctly in xfs_bmapi_write() via the xfs_bmapi_minleft() calculation.
We should use xfs_bmapi_minleft() in xfs_bmbt_alloc_block() to calculate the number of blocks a BMBT split on this inode is going to require, not use the transaction block reservation that contains the maximum number of blocks this transaction may consume in it...
--- fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/libxfs/xfs_bmap.h | 2 ++ fs/xfs/libxfs/xfs_bmap_btree.c | 19 +++++++++---------- 3 files changed, 12 insertions(+), 11 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +1 -1
@@ -4242,7 +4242,7 @@ xfs_bmapi_convert_unwritten(return 0 ; } -static inline xfs_extlen_t +xfs_extlen_t xfs_bmapi_minleft( struct xfs_trans *tp, struct xfs_inode *ip,
fs/xfs/libxfs/xfs_bmap.h +2 -0
@@ -220,6 +220,8 @@ int xfs_bmap_add_extent_unwritten_real(struct xfs_trans *tp, struct xfs_inode *ip, int whichfork, struct xfs_iext_cursor *icur, struct xfs_btree_cur **curp, struct xfs_bmbt_irec *new, int *logflagsp); +xfs_extlen_t xfs_bmapi_minleft (struct xfs_trans *tp,struct xfs_inode *ip, +int fork);enum xfs_bmap_intent_type {XFS_BMAP_MAP =1 ,
fs/xfs/libxfs/xfs_bmap_btree.c +9 -10
@@ -213,18 +213,16 @@ xfs_bmbt_alloc_block(if (args.fsbno ==NULLFSBLOCK ) { args.fsbno =be64_to_cpu (start->l); args.type =XFS_ALLOCTYPE_START_BNO ; +/* -* Make sure there is sufficient room left in the AG to -* complete a full tree split for an extent insert. If -* we are converting the middle part of an extent then -* we may need space for two tree splits. -* -* We are relying on the caller to make the correct block -* reservation for this operation to succeed. If the -* reservation amount is insufficient then we may fail a -* block allocation here and corrupt the filesystem. +* If we are coming here from something like unwritten extent +* conversion, there has been no data extent allocation already +* done, so we have to ensure that we attempt to locate the +* entire set of bmbt allocations in the same AG, as +* xfs_bmapi_write() would have reserved. */ - args.minleft = args.tp->t_blk_res; + args.minleft =xfs_bmapi_minleft (cur->bc_tp, cur->bc_ino.ip, + cur->bc_ino.whichfork); }else if (cur->bc_tp->t_flags &XFS_TRANS_LOWMODE ) { args.type =XFS_ALLOCTYPE_START_BNO ; }else {
@@ -248,6 +246,7 @@ xfs_bmbt_alloc_block(* successful activate the lowspace algorithm. */ args.fsbno =0 ; + args.minleft =0 ; args.type =XFS_ALLOCTYPE_FIRST_AG ; error =xfs_alloc_vextent (&args);if (error)
Signature · 1 line
2.39.0
Re: [PATCH 03/42] xfs: block reservation too large for minleft allocation
Quoted 14 lines · Dave Chinner
From: Dave Chinner <[email protected]>
When we enter
xfs_bmbt_alloc_block()without having first allocated a data extent (i.e.tp->t_firstblock== NULLFSBLOCK) because we are doing something like unwritten extent conversion, the transaction block reservation is used as the minleft value.This works for operations like unwritten extent conversion, but it assumes that the block reservation is only for a BMBT split. THis is not always true, and sometimes results in larger than necessary minleft values being set. We only actually need enough space for a btree split, something we already handle correctly in
xfs_bmapi_write()via thexfs_bmapi_minleft()calculation.
Quoted 6 lines
We should use
xfs_bmapi_minleft()inxfs_bmbt_alloc_block()to calculate the number of blocks a BMBT split on this inode is going to require, not use the transaction block reservation that contains the maximum number of blocks this transaction may consume in it...Signed-off-by Dave Chinner <[email protected]>
Ok, makes sense
Quoted 85 lines
---
fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/libxfs/xfs_bmap.h | 2 ++fs/xfs/libxfs/xfs_bmap_btree.c| 19 +++++++++----------3 files changed, 12 insertions(+), 11 deletions(-)fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -4242,7 +4242,7 @@ xfs_bmapi_convert_unwritten( return 0; }fs/xfs/libxfs/xfs_bmap.c +1
-1-static inline xfs_extlen_t +xfs_extlen_txfs_bmapi_minleft(
struct xfs_trans *tp,
struct xfs_inode *ip,fs/xfs/libxfs/xfs_bmap.h +0
-0@@ -220,6 +220,8 @@ int xfs_bmap_add_extent_unwritten_real(struct xfs_trans *tp, struct xfs_inode *ip, int whichfork,struct
xfs_iext_cursor*icur, structxfs_btree_cur**curp,
structxfs_bmbt_irec*new, int *logflagsp); +xfs_extlen_t xfs_bmapi_minleft(structxfs_trans*tp, structxfs_inode*ip,
+ int fork);
enumxfs_bmap_intent_type{
XFS_BMAP_MAP = 1,fs/xfs/libxfs/xfs_bmap_btree.c +1
-1@@ -213,18 +213,16 @@ xfs_bmbt_alloc_block( if (args.fsbno == NULLFSBLOCK) { args.fsbno = be64_to_cpu(start->l); args.type = XFS_ALLOCTYPE_START_BNO; + /* -* Make sure there is sufficient room left in the AG to
- * complete a full tree split for an extent insert. If
- * we are converting the middle part of an extent then
- * we may need space for two tree splits. - *
- * We are relying on the caller to make the correct block
- * reservation for this operation to succeed. If the - * reservation amount is insufficient then we may fail a
- * block allocation here and corrupt the filesystem. + * If we are coming here from something like unwritten extent
+ * conversion, there has been no data extent allocation already
+ * done, so we have to ensure that we attempt to locate the
+ * entire set of bmbt allocations in the same AG, as + *xfs_bmapi_write()would have reserved. */
- args.minleft =args.tp->t_blk_res;
+ args.minleft = xfs_bmapi_minleft(cur->bc_tp, cur-Quoted 1 line
bc_ino.ip,
+ cur-
Quoted 1 line
bc_ino.whichfork);
} else if (
cur->bc_tp->t_flags&XFS_TRANS_LOWMODE) { args.type =XFS_ALLOCTYPE_START_BNO; } else {fs/xfs/libxfs/xfs_bmap_btree.c +1
-0@@ -248,6 +246,7 @@ xfs_bmbt_alloc_block(* successful activate the lowspace algorithm. */ args.fsbno = 0; + args.minleft = 0; args.type = XFS_ALLOCTYPE_FIRST_AG; error = xfs_alloc_vextent(&args); if (error)
PATCH 4/42 xfs: drop firstblock constraints from allocation setup
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Now that xfs_alloc_vextent() does all the AGF deadlock prevention filtering for multiple allocations in a single transaction, we no longer need the allocation setup code to care about what AGs we might already have locked.
Hence we can remove all the "nullfb" conditional logic in places like xfs_bmap_btalloc() and instead have them focus simply on setting up locality constraints. If the allocation fails due to AGF lock filtering in xfs_alloc_vextent, then we just fall back as we normally do to more relaxed allocation constraints.
As a result, any allocation that allows AG scanning (i.e. not confined to a single AG) and does not force a worst case full filesystem scan will now be able to attempt allocation from AGs lower than that defined by tp->t_firstblock. This is because xfs_alloc_vextent() allows try-locking of the AGFs and hence enables low space algorithms to at least -try- to get space from AGs lower than the one that we have currently locked and allocated from. This is a significant improvement in the low space allocation algorithm.
--- fs/xfs/libxfs/xfs_bmap.c | 168 +++++++++++---------------------- fs/xfs/libxfs/xfs_bmap.h | 1 + fs/xfs/libxfs/xfs_bmap_btree.c | 30 +++--- 3 files changed, 67 insertions(+), 132 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +55 -113
@@ -645,16 +645,9 @@ xfs_bmap_extents_to_btree( args.tp = tp; args.mp = mp;xfs_rmap_ino_bmbt_owner (&args.oinfo, ip->i_ino, whichfork); -if (tp->t_firstblock ==NULLFSBLOCK ) { - args.type =XFS_ALLOCTYPE_START_BNO ; - args.fsbno =XFS_INO_TO_FSB (mp, ip->i_ino); - }else if (tp->t_flags &XFS_TRANS_LOWMODE ) { - args.type =XFS_ALLOCTYPE_START_BNO ; - args.fsbno = tp->t_firstblock; - }else { - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.fsbno = tp->t_firstblock; - } + + args.type =XFS_ALLOCTYPE_START_BNO ; + args.fsbno =XFS_INO_TO_FSB (mp, ip->i_ino); args.minlen = args.maxlen = args.prod =1 ; args.wasdel = wasdel; *logflagsp =0 ;
@@ -662,17 +655,14 @@ xfs_bmap_extents_to_btree(if (error) goto out_root_realloc; +/* +* Allocation can't fail, the space was reserved. +*/ if (WARN_ON_ONCE (args.fsbno ==NULLFSBLOCK )) { error = -ENOSPC ; goto out_root_realloc; } -/* -* Allocation can't fail, the space was reserved. -*/ -ASSERT (tp->t_firstblock ==NULLFSBLOCK || - args.agno >=XFS_FSB_TO_AGNO (mp, tp->t_firstblock)); - tp->t_firstblock = args.fsbno; cur->bc_ino.allocated++; ip->i_nblocks++;xfs_trans_mod_dquot_byino (tp, ip,XFS_TRANS_DQ_BCOUNT ,1L );
@@ -804,13 +794,8 @@ xfs_bmap_local_to_extents(* Allocate a block. We know we need only one, since the * file currently fits in an inode. */ -if (tp->t_firstblock ==NULLFSBLOCK ) { - args.fsbno =XFS_INO_TO_FSB (args.mp, ip->i_ino); - args.type =XFS_ALLOCTYPE_START_BNO ; - }else { - args.fsbno = tp->t_firstblock; - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - } + args.fsbno =XFS_INO_TO_FSB (args.mp, ip->i_ino); + args.type =XFS_ALLOCTYPE_START_BNO ; args.total = total; args.minlen = args.maxlen = args.prod =1 ; error =xfs_alloc_vextent (&args);
@@ -820,7 +805,6 @@ xfs_bmap_local_to_extents(/* Can't fail, the space was reserved. */ ASSERT (args.fsbno !=NULLFSBLOCK );ASSERT (args.len ==1 ); - tp->t_firstblock = args.fsbno; error =xfs_trans_get_buf (tp, args.mp->m_ddev_targp,XFS_FSB_TO_DADDR (args.mp, args.fsbno), args.mp->m_bsize,0 , &bp);
@@ -854,8 +838,7 @@ xfs_bmap_local_to_extents( ifp->if_nextents =1 ; ip->i_nblocks =1 ; -xfs_trans_mod_dquot_byino (tp, ip, -XFS_TRANS_DQ_BCOUNT ,1L ); +xfs_trans_mod_dquot_byino (tp, ip,XFS_TRANS_DQ_BCOUNT ,1L ); flags |=xfs_ilog_fext (whichfork); done:
@@ -3025,9 +3008,7 @@ xfs_bmap_adjacent( struct xfs_bmalloca *ap) /* bmap alloc argument struct */ {xfs_fsblock_t adjust;/* adjustment to block numbers */ -xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ xfs_mount_t *mp;/* mount point structure */ -int nullfb;/* true if ap->firstblock isn't set */ int rt;/* true if inode is realtime */ #define ISVALID (x,y) \
@@ -3038,11 +3019,8 @@ xfs_bmap_adjacent( XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) mp = ap->ip->i_mount; - nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; rt =XFS_IS_REALTIME_INODE (ap->ip) && (ap->datatype &XFS_ALLOC_USERDATA ); - fb_agno = nullfb ?NULLAGNUMBER :XFS_FSB_TO_AGNO (mp, - ap->tp->t_firstblock);/* * If allocating at eof, and there's a previous real block, * try to use its last block as our starting point.
@@ -3101,13 +3079,6 @@ xfs_bmap_adjacent( prevbno += adjust; else prevdiff += adjust; -/* -* If the firstblock forbids it, can't use it, -* must use default. -*/ -if (!rt && !nullfb && -XFS_FSB_TO_AGNO (mp, prevbno) != fb_agno) - prevbno =NULLFSBLOCK ; }/* * No previous block or can't follow it, just default.
@@ -3143,13 +3114,6 @@ xfs_bmap_adjacent( gotdiff += adjust - ap->length; }else gotdiff += adjust; -/* -* If the firstblock forbids it, can't use it, -* must use default. -*/ -if (!rt && !nullfb && -XFS_FSB_TO_AGNO (mp, gotbno) != fb_agno) - gotbno =NULLFSBLOCK ; }/* * No next block, just default.
@@ -3236,7 +3200,7 @@ xfs_bmap_select_minlen( } STATIC int -xfs_bmap_btalloc_nullfb ( +xfs_bmap_btalloc_select_lengths (struct xfs_bmalloca *ap,struct xfs_alloc_arg *args,xfs_extlen_t *blen)
@@ -3247,8 +3211,13 @@ xfs_bmap_btalloc_nullfb(int error; args->type =XFS_ALLOCTYPE_START_BNO ; - args->total = ap->total; +if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { + args->total = ap->minlen; + args->minlen = ap->minlen; +return 0 ; + } + args->total = ap->total; startag = ag =XFS_FSB_TO_AGNO (mp, args->fsbno);if (startag ==NULLAGNUMBER ) startag = ag =0 ;
@@ -3280,6 +3249,13 @@ xfs_bmap_btalloc_filestreams(int notinit =0 ;int error; +if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { + args->type =XFS_ALLOCTYPE_FIRST_AG ; + args->total = ap->minlen; + args->minlen = ap->minlen; +return 0 ; + } + args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total;
@@ -3460,19 +3436,15 @@ xfs_bmap_exact_minlen_extent_alloc(xfs_bmap_compute_alignments (ap, &args); -if (ap->tp->t_firstblock ==NULLFSBLOCK ) { -/* -* Unlike the longest extent available in an AG, we don't track -* the length of an AG's shortest extent. -* XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and -* hence we can afford to start traversing from the 0th AG since -* we need not be concerned about a drop in performance in -* "debug only" code paths. -*/ - ap->blkno =XFS_AGB_TO_FSB (mp,0 ,0 ); - }else { - ap->blkno = ap->tp->t_firstblock; - } +/* +* Unlike the longest extent available in an AG, we don't track +* the length of an AG's shortest extent. +* XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and +* hence we can afford to start traversing from the 0th AG since +* we need not be concerned about a drop in performance in +* "debug only" code paths. +*/ + ap->blkno =XFS_AGB_TO_FSB (mp,0 ,0 ); args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ;
@@ -3515,13 +3487,11 @@ xfs_bmap_btalloc(struct xfs_mount *mp = ap->ip->i_mount;struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp };xfs_alloctype_t atype =0 ; -xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ xfs_agnumber_t ag;xfs_fileoff_t orig_offset;xfs_extlen_t orig_length;xfs_extlen_t blen;xfs_extlen_t nextminlen =0 ; -int nullfb;/* true if ap->firstblock isn't set */ int isaligned;int tryagain;int error;
@@ -3533,34 +3503,17 @@ xfs_bmap_btalloc( stripe_align =xfs_bmap_compute_alignments (ap, &args); - nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; - fb_agno = nullfb ?NULLAGNUMBER :XFS_FSB_TO_AGNO (mp, - ap->tp->t_firstblock); -if (nullfb) { -if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) { - ag =xfs_filestream_lookup_ag (ap->ip); - ag = (ag !=NULLAGNUMBER ) ? ag :0 ; - ap->blkno =XFS_AGB_TO_FSB (mp, ag,0 ); - }else { - ap->blkno =XFS_INO_TO_FSB (mp, ap->ip->i_ino); - } - }else - ap->blkno = ap->tp->t_firstblock; +if ((ap->datatype &XFS_ALLOC_USERDATA ) && +xfs_inode_is_filestream (ap->ip)) { + ag =xfs_filestream_lookup_ag (ap->ip); + ag = (ag !=NULLAGNUMBER ) ? ag :0 ; + ap->blkno =XFS_AGB_TO_FSB (mp, ag,0 ); + }else { + ap->blkno =XFS_INO_TO_FSB (mp, ap->ip->i_ino); + }xfs_bmap_adjacent (ap); -/* -* If allowed, use ap->blkno; otherwise must use firstblock since -* it's in the right allocation group. -*/ -if (nullfb ||XFS_FSB_TO_AGNO (mp, ap->blkno) == fb_agno) - ; -else - ap->blkno = ap->tp->t_firstblock; -/* -* Normal allocation, done through xfs_alloc_vextent. -*/ tryagain = isaligned =0 ; args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ;
@@ -3568,30 +3521,19 @@ xfs_bmap_btalloc(/* Trim the allocation back to the maximum an AG can fit. */ args.maxlen =min (ap->length, mp->m_ag_max_usable); blen =0 ; -if (nullfb) { -/* -* Search for an allocation group with a single extent large -* enough for the request. If one isn't found, then adjust -* the minimum allocation size to the largest space found. -*/ -if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) - error =xfs_bmap_btalloc_filestreams (ap, &args, &blen); -else - error =xfs_bmap_btalloc_nullfb (ap, &args, &blen); -if (error) -return error; - }else if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { -if (xfs_inode_is_filestream (ap->ip)) - args.type =XFS_ALLOCTYPE_FIRST_AG ; -else - args.type =XFS_ALLOCTYPE_START_BNO ; - args.total = args.minlen = ap->minlen; - }else { - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.total = ap->total; - args.minlen = ap->minlen; - } + +/* +* Search for an allocation group with a single extent large +* enough for the request. If one isn't found, then adjust +* the minimum allocation size to the largest space found. +*/ +if ((ap->datatype &XFS_ALLOC_USERDATA ) && +xfs_inode_is_filestream (ap->ip)) + error =xfs_bmap_btalloc_filestreams (ap, &args, &blen); +else + error =xfs_bmap_btalloc_select_lengths (ap, &args, &blen); +if (error) +return error;/* * If we are not low on available data blocks, and the underlying
@@ -3678,7 +3620,7 @@ xfs_bmap_btalloc(if ((error =xfs_alloc_vextent (&args)))return error; } -if (args.fsbno ==NULLFSBLOCK && nullfb && +if (args.fsbno ==NULLFSBLOCK && args.minlen > ap->minlen) { args.minlen = ap->minlen; args.type =XFS_ALLOCTYPE_START_BNO ;
@@ -3686,7 +3628,7 @@ xfs_bmap_btalloc(if ((error =xfs_alloc_vextent (&args)))return error; } -if (args.fsbno ==NULLFSBLOCK && nullfb) { +if (args.fsbno ==NULLFSBLOCK ) { args.fsbno =0 ; args.type =XFS_ALLOCTYPE_FIRST_AG ; args.total = ap->minlen;
fs/xfs/libxfs/xfs_bmap.h +1 -0
@@ -269,4 +269,5 @@ extern struct kmem_cache *xfs_bmap_intent_cache;int __init xfs_bmap_intent_init_cache (void );void xfs_bmap_intent_destroy_cache (void ); +#endif /* __XFS_BMAP_H__ */
fs/xfs/libxfs/xfs_bmap_btree.c +11 -19
@@ -206,28 +206,21 @@ xfs_bmbt_alloc_block(memset (&args,0 ,sizeof (args)); args.tp = cur->bc_tp; args.mp = cur->bc_mp; - args.fsbno = cur->bc_tp->t_firstblock;xfs_rmap_ino_bmbt_owner (&args.oinfo, cur->bc_ino.ip->i_ino, cur->bc_ino.whichfork); -if (args.fsbno ==NULLFSBLOCK ) { - args.fsbno =be64_to_cpu (start->l); - args.type =XFS_ALLOCTYPE_START_BNO ; + args.fsbno =be64_to_cpu (start->l); + args.type =XFS_ALLOCTYPE_START_BNO ; -/* -* If we are coming here from something like unwritten extent -* conversion, there has been no data extent allocation already -* done, so we have to ensure that we attempt to locate the -* entire set of bmbt allocations in the same AG, as -* xfs_bmapi_write() would have reserved. -*/ +/* +* If we are coming here from something like unwritten extent +* conversion, there has been no data extent allocation already done, so +* we have to ensure that we attempt to locate the entire set of bmbt +* allocations in the same AG, as xfs_bmapi_write() would have reserved. +*/ +if (cur->bc_tp->t_firstblock ==NULLFSBLOCK ) args.minleft =xfs_bmapi_minleft (cur->bc_tp, cur->bc_ino.ip, - cur->bc_ino.whichfork); - }else if (cur->bc_tp->t_flags &XFS_TRANS_LOWMODE ) { - args.type =XFS_ALLOCTYPE_START_BNO ; - }else { - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - } + cur->bc_ino.whichfork); args.minlen = args.maxlen = args.prod =1 ; args.wasdel = cur->bc_ino.flags &XFS_BTCUR_BMBT_WASDEL ;
@@ -247,7 +240,7 @@ xfs_bmbt_alloc_block(*/ args.fsbno =0 ; args.minleft =0 ; - args.type =XFS_ALLOCTYPE_FIRST_AG ; + args.type =XFS_ALLOCTYPE_START_BNO ; error =xfs_alloc_vextent (&args);if (error) goto error0;
@@ -259,7 +252,6 @@ xfs_bmbt_alloc_block( }ASSERT (args.len ==1 ); - cur->bc_tp->t_firstblock = args.fsbno; cur->bc_ino.allocated++; cur->bc_ino.ip->i_nblocks++;xfs_trans_log_inode (args.tp, cur->bc_ino.ip,XFS_ILOG_CORE );
Signature · 1 line
2.39.0
Re: [PATCH 04/42] xfs: drop firstblock constraints from allocation setup
Quoted 382 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Now that
xfs_alloc_vextent()does all the AGF deadlock prevention filtering for multiple allocations in a single transaction, we no longer need the allocation setup code to care about what AGs we might already have locked.Hence we can remove all the "nullfb" conditional logic in places like
xfs_bmap_btalloc()and instead have them focus simply on setting up locality constraints. If the allocation fails due to AGF lock filtering inxfs_alloc_vextent, then we just fall back as we normally do to more relaxed allocation constraints.As a result, any allocation that allows AG scanning (i.e. not confined to a single AG) and does not force a worst case full filesystem scan will now be able to attempt allocation from AGs lower than that defined by
tp->t_firstblock. This is becausexfs_alloc_vextent()allows try-locking of the AGFs and hence enables low space algorithms to at least -try- to get space from AGs lower than the one that we have currently locked and allocated from. This is a significant improvement in the low space allocation algorithm.Signed-off-by Dave Chinner <[email protected]>---
fs/xfs/libxfs/xfs_bmap.c | 168 +++++++++++-------------------- --
fs/xfs/libxfs/xfs_bmap.h | 1 +fs/xfs/libxfs/xfs_bmap_btree.c| 30 +++---3 files changed, 67 insertions(+), 132 deletions(-)fs/xfs/libxfs/xfs_bmap.c +3
-10@@ -645,16 +645,9 @@ xfs_bmap_extents_to_btree( args.tp = tp; args.mp = mp; xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork); - if (tp->t_firstblock == NULLFSBLOCK) { - args.type = XFS_ALLOCTYPE_START_BNO; - args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); - } else if (tp->t_flags & XFS_TRANS_LOWMODE) { - args.type = XFS_ALLOCTYPE_START_BNO; - args.fsbno = tp->t_firstblock; - } else { - args.type = XFS_ALLOCTYPE_NEAR_BNO; - args.fsbno = tp->t_firstblock; - } + + args.type = XFS_ALLOCTYPE_START_BNO; + args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); args.minlen = args.maxlen = args.prod = 1; args.wasdel = wasdel; *logflagsp = 0;@@ -662,17 +655,14 @@ xfs_bmap_extents_to_btree( if (error) goto out_root_realloc;
+ /*
+ * Allocation can't fail, the space was reserved. + */
if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { error =-ENOSPC;
gotoout_root_realloc;
}
- /*
- * Allocation can't fail, the space was reserved. - */
- ASSERT(tp->t_firstblock == NULLFSBLOCK ||
- args.agno >=XFS_FSB_TO_AGNO(mp, tp->t_firstblock)); - tp->t_firstblock = args.fsbno; cur->bc_ino.allocated++;
ip->i_nblocks++;
xfs_trans_mod_dquot_byino(tp, ip,XFS_TRANS_DQ_BCOUNT, 1L);fs/xfs/libxfs/xfs_bmap.c +2
-8@@ -804,13 +794,8 @@ xfs_bmap_local_to_extents(* Allocate a block. We know we need only one, since the * file currently fits in an inode. */ - if (tp->t_firstblock == NULLFSBLOCK) { - args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); - args.type = XFS_ALLOCTYPE_START_BNO; - } else { - args.fsbno = tp->t_firstblock; - args.type = XFS_ALLOCTYPE_NEAR_BNO; - } + args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); + args.type = XFS_ALLOCTYPE_START_BNO; args.total = total; args.minlen = args.maxlen = args.prod = 1; error = xfs_alloc_vextent(&args);@@ -820,7 +805,6 @@ xfs_bmap_local_to_extents( /* Can't fail, the space was reserved. */ ASSERT(args.fsbno != NULLFSBLOCK); ASSERT(args.len == 1); - tp->t_firstblock = args.fsbno; error = xfs_trans_get_buf(tp, args.mp->m_ddev_targp, XFS_FSB_TO_DADDR(args.mp, args.fsbno), args.mp->m_bsize, 0, &bp);@@ -854,8 +838,7 @@ xfs_bmap_local_to_extents(
ifp->if_nextents = 1;
ip->i_nblocks = 1;
- xfs_trans_mod_dquot_byino(tp, ip,
- XFS_TRANS_DQ_BCOUNT, 1L);
+ xfs_trans_mod_dquot_byino(tp, ip,XFS_TRANS_DQ_BCOUNT, 1L); flags |=xfs_ilog_fext(whichfork);
done:fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3025,9 +3008,7 @@ xfs_bmap_adjacent(struct xfs_bmalloca *ap) /* bmap alloc argument struct */
{
xfs_fsblock_t adjust; /* adjustment to block numbers */
- xfs_agnumber_t fb_agno; /* ag number of ap-Quoted 1 line
firstblock */
xfs_mount_t *mp; /* mount point structure */ - int nullfb; /* true if
ap->firstblockisn't set */
int rt; /* true if inode is realtime */
#define ISVALID(x,y) \fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3038,11 +3019,8 @@ xfs_bmap_adjacent( XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)
mp =ap->ip->i_mount;
- nullfb =ap->tp->t_firstblock== NULLFSBLOCK; rt =XFS_IS_REALTIME_INODE(ap->ip)&& (ap->datatype&XFS_ALLOC_USERDATA); - fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, - ap->tp-Quoted 1 line
t_firstblock);/*
* If allocating at eof, and there's a previous real block,
* try to use its last block as our starting point.fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3101,13 +3079,6 @@ xfs_bmap_adjacent( prevbno += adjust;else
prevdiff += adjust;
- /*
- * If the firstblock forbids it, can't use it,
- * must use default.
- */
- if (!rt && !nullfb &&
-XFS_FSB_TO_AGNO(mp, prevbno)!=fb_agno) - prevbno = NULLFSBLOCK;
}
/*
* No previous block or can't follow it, just default.fs/xfs/libxfs/xfs_bmap.c +0
-7@@ -3143,13 +3114,6 @@ xfs_bmap_adjacent( gotdiff += adjust - ap->length; } else gotdiff += adjust; - /* - * If the firstblock forbids it, can't use it, - * must use default. - */ - if (!rt && !nullfb && - XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno) - gotbno = NULLFSBLOCK; } /** No next block, just default.
fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3236,7 +3200,7 @@ xfs_bmap_select_minlen( }
STATIC intfs/xfs/libxfs/xfs_bmap.c +1
-1-xfs_bmap_btalloc_nullfb( +xfs_bmap_btalloc_select_lengths(struct xfs_bmalloca *ap,
struct xfs_alloc_arg *args,
xfs_extlen_t *blen)fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3247,8 +3211,13 @@ xfs_bmap_btalloc_nullfb( int error;
args->type =XFS_ALLOCTYPE_START_BNO;
- args->total =ap->total;
+ if (ap->tp->t_flags&XFS_TRANS_LOWMODE) { + args->total =ap->minlen;
+ args->minlen =ap->minlen;
+ return 0;
+ }
+ args->total =ap->total;
startag = ag =XFS_FSB_TO_AGNO(mp, args->fsbno); if (startag == NULLAGNUMBER)
startag = ag = 0;fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3280,6 +3249,13 @@ xfs_bmap_btalloc_filestreams( int notinit = 0; int error;
+ if (ap->tp->t_flags&XFS_TRANS_LOWMODE) { + args->type =XFS_ALLOCTYPE_FIRST_AG; + args->total =ap->minlen;
+ args->minlen =ap->minlen;
+ return 0;
+ }
+
args->type =XFS_ALLOCTYPE_NEAR_BNO;args->total=ap->total;fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3460,19 +3436,15 @@ xfs_bmap_exact_minlen_extent_alloc(
xfs_bmap_compute_alignments(ap, &args);
- if (ap->tp->t_firstblock== NULLFSBLOCK) {
- /*
- * Unlike the longest extent available in an AG, we don't track
- * the length of an AG's shortest extent. - *XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENTis a debug only knob and
- * hence we can afford to start traversing from the 0th AG since
- * we need not be concerned about a drop in performance in
- * "debug only" code paths.
- */
- ap->blkno =XFS_AGB_TO_FSB(mp, 0, 0);
- } else {
- ap->blkno =ap->tp->t_firstblock;
- }
+ /*
+ * Unlike the longest extent available in an AG, we don't track
+ * the length of an AG's shortest extent.
+ *XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENTis a debug only knob and
+ * hence we can afford to start traversing from the 0th AG since
+ * we need not be concerned about a drop in performance in + * "debug only" code paths.
+ */
+ ap->blkno =XFS_AGB_TO_FSB(mp, 0, 0);
args.fsbno =ap->blkno;
args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE;fs/xfs/libxfs/xfs_bmap.c +0
-1@@ -3515,13 +3487,11 @@ xfs_bmap_btalloc( struct xfs_mount *mp = ap->ip->i_mount; struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp }; xfs_alloctype_t atype = 0; - xfs_agnumber_t fb_agno; /* ag number of ap-Quoted 1 line
firstblock */
xfs_agnumber_t ag;
xfs_fileoff_t orig_offset; xfs_extlen_t orig_length; xfs_extlen_t blen;
xfs_extlen_t nextminlen = 0;
- int nullfb; /* true ifap->firstblockisn't set */
int isaligned;
int tryagain;
int error;fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3533,34 +3503,17 @@ xfs_bmap_btalloc(
stripe_align =xfs_bmap_compute_alignments(ap, &args);
- nullfb =ap->tp->t_firstblock== NULLFSBLOCK; - fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, - ap->tp-Quoted 1 line
t_firstblock);- if (nullfb) {
- if ((ap->datatype&XFS_ALLOC_USERDATA) && -xfs_inode_is_filestream(ap->ip)) { - ag =xfs_filestream_lookup_ag(ap->ip); - ag = (ag != NULLAGNUMBER) ? ag : 0; - ap->blkno =XFS_AGB_TO_FSB(mp, ag, 0); - } else {
- ap->blkno = XFS_INO_TO_FSB(mp, ap->ip-Quoted 1 line
i_ino);- }
- } else
- ap->blkno =ap->tp->t_firstblock;
+ if ((ap->datatype&XFS_ALLOC_USERDATA) &&
+xfs_inode_is_filestream(ap->ip)) {
+ ag =xfs_filestream_lookup_ag(ap->ip);
+ ag = (ag != NULLAGNUMBER) ? ag : 0;
+ ap->blkno =XFS_AGB_TO_FSB(mp, ag, 0);
+ } else {
+ ap->blkno =XFS_INO_TO_FSB(mp, ap->ip->i_ino); + }
xfs_bmap_adjacent(ap);
- /*
- * If allowed, useap->blkno; otherwise must use firstblock since
- * it's in the right allocation group.
- */
- if (nullfb ||XFS_FSB_TO_AGNO(mp, ap->blkno)==fb_agno) - ;
- else
- ap->blkno =ap->tp->t_firstblock;
- /*
- * Normal allocation, done throughxfs_alloc_vextent. - */
tryagain = isaligned = 0;
args.fsbno =ap->blkno;
args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE;fs/xfs/libxfs/xfs_bmap.c +0
-3@@ -3568,30 +3521,19 @@ xfs_bmap_btalloc( /* Trim the allocation back to the maximum an AG can fit. */ args.maxlen = min(ap->length, mp->m_ag_max_usable); blen = 0; - if (nullfb) { - /* -* Search for an allocation group with a single extent large
- * enough for the request. If one isn't found, then adjust
- * the minimum allocation size to the largest space found.
- */
- if ((ap->datatype&XFS_ALLOC_USERDATA) && -xfs_inode_is_filestream(ap->ip))
- error =xfs_bmap_btalloc_filestreams(ap, &args, &blen);
- else
- error =xfs_bmap_btalloc_nullfb(ap, &args, &blen);
- if (error)
- return error;
- } else if (ap->tp->t_flags&XFS_TRANS_LOWMODE) { - if (xfs_inode_is_filestream(ap->ip))
- args.type =XFS_ALLOCTYPE_FIRST_AG; - else
- args.type =XFS_ALLOCTYPE_START_BNO; - args.total = args.minlen =ap->minlen;
- } else {
- args.type =XFS_ALLOCTYPE_NEAR_BNO;
- args.total =ap->total;
- args.minlen =ap->minlen;
- }
+
+ /*
+ * Search for an allocation group with a single extent large + * enough for the request. If one isn't found, then adjust + * the minimum allocation size to the largest space found. + */
+ if ((ap->datatype&XFS_ALLOC_USERDATA) &&
+xfs_inode_is_filestream(ap->ip))
+ error =xfs_bmap_btalloc_filestreams(ap, &args, &blen);
+ else
+ error =xfs_bmap_btalloc_select_lengths(ap, &args, &blen);
+ if (error)
+ return error;
/*
* If we are not low on available data blocks, and the underlyingfs/xfs/libxfs/xfs_bmap.c +2
-2@@ -3678,7 +3620,7 @@ xfs_bmap_btalloc( if ((error = xfs_alloc_vextent(&args))) return error; } - if (args.fsbno == NULLFSBLOCK && nullfb && + if (args.fsbno == NULLFSBLOCK && args.minlen > ap->minlen) { args.minlen = ap->minlen; args.type = XFS_ALLOCTYPE_START_BNO;@@ -3686,7 +3628,7 @@ xfs_bmap_btalloc( if ((error = xfs_alloc_vextent(&args))) return error; } - if (args.fsbno == NULLFSBLOCK && nullfb) { + if (args.fsbno == NULLFSBLOCK) { args.fsbno = 0; args.type = XFS_ALLOCTYPE_FIRST_AG; args.total = ap->minlen;fs/xfs/libxfs/xfs_bmap.h +0
-0@@ -269,4 +269,5 @@ extern struct kmem_cache *xfs_bmap_intent_cache; int __init xfs_bmap_intent_init_cache(void); void xfs_bmap_intent_destroy_cache(void);
Quoted 2 lines
+
Stray new line?
Otherwise looks like a nice clean up
Quoted 70 lines
#endif /*
__XFS_BMAP_H__*/fs/xfs/libxfs/xfs_bmap_btree.c +0
-1@@ -206,28 +206,21 @@ xfs_bmbt_alloc_block( memset(&args, 0, sizeof(args)); args.tp = cur->bc_tp; args.mp = cur->bc_mp; - args.fsbno = cur->bc_tp->t_firstblock; xfs_rmap_ino_bmbt_owner(&args.oinfo, cur->bc_ino.ip->i_ino, cur->bc_ino.whichfork);
- if (args.fsbno == NULLFSBLOCK) {
- args.fsbno =be64_to_cpu(start->l);
- args.type =XFS_ALLOCTYPE_START_BNO;
+ args.fsbno =be64_to_cpu(start->l);
+ args.type =XFS_ALLOCTYPE_START_BNO;
- /*
- * If we are coming here from something like unwritten extent
- * conversion, there has been no data extent allocation already
- * done, so we have to ensure that we attempt to locate the
- * entire set of bmbt allocations in the same AG, as - *xfs_bmapi_write()would have reserved. - */
+ /*
+ * If we are coming here from something like unwritten extent + * conversion, there has been no data extent allocation already done, so
+ * we have to ensure that we attempt to locate the entire set of bmbt
+ * allocations in the same AG, asxfs_bmapi_write()would have reserved.
+ */
+ if (cur->bc_tp->t_firstblock== NULLFSBLOCK) args.minleft = xfs_bmapi_minleft(cur->bc_tp, cur-Quoted 1 line
bc_ino.ip,
- cur-
Quoted 1 line
bc_ino.whichfork);
- } else if (
cur->bc_tp->t_flags&XFS_TRANS_LOWMODE) { - args.type =XFS_ALLOCTYPE_START_BNO;
- } else {
- args.type =XFS_ALLOCTYPE_NEAR_BNO;
- }
+ cur->bc_ino.whichfork);
args.minlen = args.maxlen = args.prod = 1; args.wasdel =cur->bc_ino.flags&XFS_BTCUR_BMBT_WASDEL;fs/xfs/libxfs/xfs_bmap_btree.c +1
-1@@ -247,7 +240,7 @@ xfs_bmbt_alloc_block(*/ args.fsbno = 0; args.minleft = 0; - args.type = XFS_ALLOCTYPE_FIRST_AG; + args.type = XFS_ALLOCTYPE_START_BNO; error = xfs_alloc_vextent(&args); if (error) goto error0;@@ -259,7 +252,6 @@ xfs_bmbt_alloc_block( }
ASSERT(args.len == 1);
- cur->bc_tp->t_firstblock = args.fsbno; cur->bc_ino.allocated++; cur->bc_ino.ip->i_nblocks++;xfs_trans_log_inode(args.tp, cur->bc_ino.ip, XFS_ILOG_CORE);
PATCH 5/42 xfs: t_firstblock is tracking AGs not blocks
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
The tp->t_firstblock field is now raelly tracking the highest AG we have locked, not the block number of the highest allocation we've made. It's purpose is to prevent AGF locking deadlocks, so rename it to "highest AG" and simplify the implementation to just track the agno rather than a fsbno.
--- fs/xfs/libxfs/xfs_alloc.c | 12 +++++------- fs/xfs/libxfs/xfs_bmap.c | 4 ++-- fs/xfs/libxfs/xfs_bmap_btree.c | 6 +++--- fs/xfs/xfs_bmap_util.c | 2 +- fs/xfs/xfs_inode.c | 2 +- fs/xfs/xfs_reflink.c | 2 +- fs/xfs/xfs_trace.h | 8 ++++---- fs/xfs/xfs_trans.c | 4 ++-- fs/xfs/xfs_trans.h | 2 +- 9 files changed, 20 insertions(+), 22 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +5 -7
@@ -3169,8 +3169,8 @@ xfs_alloc_vextent( mp = args->mp; type = args->otype = args->type; args->agbno =NULLAGBLOCK ; -if (args->tp->t_firstblock !=NULLFSBLOCK ) - minimum_agno =XFS_FSB_TO_AGNO (mp, args->tp->t_firstblock); +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno;/* * Just fix this up, for the case where the last a.g. is shorter * (or there's only one a.g.) and the caller couldn't easily figure
@@ -3375,11 +3375,9 @@ xfs_alloc_vextent(* deadlocks. */ if (args->agbp && - (args->tp->t_firstblock ==NULLFSBLOCK || - args->pag->pag_agno > minimum_agno)) { - args->tp->t_firstblock =XFS_AGB_TO_FSB (mp, - args->pag->pag_agno,0 ); - } + (args->tp->t_highest_agno ==NULLAGNUMBER || + args->pag->pag_agno > minimum_agno)) + args->tp->t_highest_agno = args->pag->pag_agno;xfs_perag_put (args->pag);return 0 ; error0:
fs/xfs/libxfs/xfs_bmap.c +2 -2
@@ -4192,7 +4192,7 @@ xfs_bmapi_minleft( {struct xfs_ifork *ifp =xfs_ifork_ptr (ip, fork); -if (tp && tp->t_firstblock !=NULLFSBLOCK ) +if (tp && tp->t_highest_agno !=NULLAGNUMBER )return 0 ;if (ifp->if_format !=XFS_DINODE_FMT_BTREE )return 1 ;
@@ -6084,7 +6084,7 @@ xfs_bmap_finish_one( {int error =0 ; -ASSERT (tp->t_firstblock ==NULLFSBLOCK ); +ASSERT (tp->t_highest_agno ==NULLAGNUMBER ); trace_xfs_bmap_deferred(tp->t_mountp, XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type,
fs/xfs/libxfs/xfs_bmap_btree.c +3 -3
@@ -184,11 +184,11 @@ xfs_bmbt_update_cursor(struct xfs_btree_cur *src, struct xfs_btree_cur *dst) { - ASSERT((dst->bc_tp->t_firstblock != NULLFSBLOCK) || + ASSERT((dst->bc_tp->t_highest_agno != NULLAGNUMBER) || (dst->bc_ino.ip->i_diflags & XFS_DIFLAG_REALTIME)); dst->bc_ino.allocated += src->bc_ino.allocated; - dst->bc_tp->t_firstblock = src->bc_tp->t_firstblock; + dst->bc_tp->t_highest_agno = src->bc_tp->t_highest_agno; src->bc_ino.allocated =0 ; }
@@ -218,7 +218,7 @@ xfs_bmbt_alloc_block(* we have to ensure that we attempt to locate the entire set of bmbt * allocations in the same AG, as xfs_bmapi_write() would have reserved. */ -if (cur->bc_tp->t_firstblock ==NULLFSBLOCK ) +if (cur->bc_tp->t_highest_agno ==NULLAGNUMBER ) args.minleft =xfs_bmapi_minleft (cur->bc_tp, cur->bc_ino.ip, cur->bc_ino.whichfork);
fs/xfs/xfs_bmap_util.c +1 -1
@@ -1410,7 +1410,7 @@ xfs_swap_extent_rmap(/* Unmap the old blocks in the source file. */ while (tirec.br_blockcount) { -ASSERT (tp->t_firstblock ==NULLFSBLOCK ); +ASSERT (tp->t_highest_agno ==NULLAGNUMBER );trace_xfs_swap_extent_rmap_remap_piece (tip, &tirec);/* Read extent from the source file */
fs/xfs/xfs_inode.c +1 -1
@@ -1367,7 +1367,7 @@ xfs_itruncate_extents_flags( unmap_len =XFS_MAX_FILEOFF - first_unmap_block +1 ;while (unmap_len >0 ) { -ASSERT (tp->t_firstblock ==NULLFSBLOCK ); +ASSERT (tp->t_highest_agno ==NULLAGNUMBER ); error =__xfs_bunmapi (tp, ip, first_unmap_block, &unmap_len, flags,XFS_ITRUNC_MAX_EXTENTS );if (error)
fs/xfs/xfs_reflink.c +1 -1
@@ -610,7 +610,7 @@ xfs_reflink_cancel_cow_blocks(if (error)break ; }else if (del.br_state ==XFS_EXT_UNWRITTEN || cancel_real) { -ASSERT ((*tpp)->t_firstblock ==NULLFSBLOCK ); +ASSERT ((*tpp)->t_highest_agno ==NULLAGNUMBER );/* Free the CoW orphan record. */ xfs_refcount_free_cow_extent(*tpp, del.br_startblock,
fs/xfs/xfs_trace.h +4 -4
@@ -1801,7 +1801,7 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __field(char, wasfromfl) __field(int, resv) __field(int, datatype) -__field (xfs_fsblock_t, firstblock) +__field (xfs_agnumber_t, highest_agno) ),TP_fast_assign ( __entry->dev = args->mp->m_super->s_dev;
@@ -1822,12 +1822,12 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __entry->wasfromfl = args->wasfromfl; __entry->resv = args->resv; __entry->datatype = args->datatype; - __entry->firstblock = args->tp->t_firstblock; + __entry->highest_agno = args->tp->t_highest_agno; ), TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u " "prod %u minleft %u total %u alignment %u minalignslop %u " "len %u type %s otype %s wasdel %d wasfromfl %d resv %d " - "datatype 0x%x firstblock 0x%llx", + "datatype 0x%x highest_agno 0x%x", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno, __entry->agbno,
@@ -1846,7 +1846,7 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __entry->wasfromfl, __entry->resv, __entry->datatype, - (unsigned long long)__entry->firstblock) + __entry->highest_agno) )#define DEFINE_ALLOC_EVENT (name) \
fs/xfs/xfs_trans.c +2 -2
@@ -102,7 +102,7 @@ xfs_trans_dup(INIT_LIST_HEAD (&ntp->t_items);INIT_LIST_HEAD (&ntp->t_busy);INIT_LIST_HEAD (&ntp->t_dfops); - ntp->t_firstblock =NULLFSBLOCK ; + ntp->t_highest_agno =NULLAGNUMBER ;ASSERT (tp->t_flags &XFS_TRANS_PERM_LOG_RES );ASSERT (tp->t_ticket !=NULL );
@@ -278,7 +278,7 @@ xfs_trans_alloc(INIT_LIST_HEAD (&tp->t_items);INIT_LIST_HEAD (&tp->t_busy);INIT_LIST_HEAD (&tp->t_dfops); - tp->t_firstblock =NULLFSBLOCK ; + tp->t_highest_agno =NULLAGNUMBER ; error =xfs_trans_reserve (tp, resp, blocks, rtextents);if (error == -ENOSPC && want_retry) {
fs/xfs/xfs_trans.h +1 -1
@@ -132,7 +132,7 @@ typedef struct xfs_trans {unsigned int t_rtx_res;/* # of rt extents resvd */ unsigned int t_rtx_res_used;/* # of resvd rt extents used */ unsigned int t_flags;/* misc flags */ -xfs_fsblock_t t_firstblock;/* first block allocated */ +xfs_agnumber_t t_highest_agno;/* highest AGF locked */ struct xlog_ticket *t_ticket;/* log mgr ticket */ struct xfs_mount *t_mountp;/* ptr to fs mount struct */ struct xfs_dquot_acct *t_dqinfo;/* acctg info for dquots */
Signature · 1 line
2.39.0
Re: [PATCH 05/42] xfs: t_firstblock is tracking AGs not blocks
Quoted 9 lines · Dave Chinner
From: Dave Chinner <[email protected]>
The
tp->t_firstblockfield is now raelly tracking the highest AG we have locked, not the block number of the highest allocation we've made. It's purpose is to prevent AGF locking deadlocks, so rename it to "highest AG" and simplify the implementation to just track the agno rather than a fsbno.Signed-off-by Dave Chinner <[email protected]>
Looks a like a straight forward rename
Quoted 224 lines
---
fs/xfs/libxfs/xfs_alloc.c | 12 +++++-------
fs/xfs/libxfs/xfs_bmap.c | 4 ++--
fs/xfs/libxfs/xfs_bmap_btree.c | 6 +++---
fs/xfs/xfs_bmap_util.c | 2 +-
fs/xfs/xfs_inode.c | 2 +-
fs/xfs/xfs_reflink.c | 2 +-fs/xfs/xfs_trace.h | 8 ++++---- fs/xfs/xfs_trans.c | 4 ++-- fs/xfs/xfs_trans.h | 2 +- 9 files changed, 20 insertions(+), 22 deletions(-)fs/xfs/libxfs/xfs_alloc.c +2
-2@@ -3169,8 +3169,8 @@ xfs_alloc_vextent( mp = args->mp; type = args->otype = args->type; args->agbno = NULLAGBLOCK; - if (args->tp->t_firstblock != NULLFSBLOCK) - minimum_agno = XFS_FSB_TO_AGNO(mp, args->tp- >t_firstblock); + if (args->tp->t_highest_agno != NULLAGNUMBER) + minimum_agno = args->tp->t_highest_agno; /** Just fix this up, for the case where the last a.g. is shorter
* (or there's only one a.g.) and the caller couldn't easily figurefs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3375,11 +3375,9 @@ xfs_alloc_vextent(* deadlocks. */ if (
args->agbp&&
- (args->tp->t_firstblock== NULLFSBLOCK || -args->pag->pag_agno>minimum_agno)) {
- args->tp->t_firstblock = XFS_AGB_TO_FSB(mp, - args->pag->pag_agno, 0); - }
+ (args->tp->t_highest_agno== NULLAGNUMBER || +args->pag->pag_agno>minimum_agno))
+ args->tp->t_highest_agno =args->pag->pag_agno;xfs_perag_put(args->pag);
return 0;
error0:fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -4192,7 +4192,7 @@ xfs_bmapi_minleft( { struct xfs_ifork *ifp = xfs_ifork_ptr(ip, fork);
- if (tp &&tp->t_firstblock!= NULLFSBLOCK) + if (tp &&tp->t_highest_agno!= NULLAGNUMBER) return 0;
if (ifp->if_format!=XFS_DINODE_FMT_BTREE) return 1;fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -6084,7 +6084,7 @@ xfs_bmap_finish_one( { int error = 0;
- ASSERT(tp->t_firstblock == NULLFSBLOCK);
+ ASSERT(tp->t_highest_agno == NULLAGNUMBER);
trace_xfs_bmap_deferred(tp->t_mountp,XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type,fs/xfs/libxfs/xfs_bmap_btree.c +1
-1@@ -184,11 +184,11 @@ xfs_bmbt_update_cursor( struct xfs_btree_cur *src, struct xfs_btree_cur *dst) { - ASSERT((dst->bc_tp->t_firstblock != NULLFSBLOCK) || + ASSERT((dst->bc_tp->t_highest_agno != NULLAGNUMBER) || (dst->bc_ino.ip->i_diflags & XFS_DIFLAG_REALTIME));
dst->bc_ino.allocated +=src->bc_ino.allocated; - dst->bc_tp->t_firstblock =src->bc_tp->t_firstblock; + dst->bc_tp->t_highest_agno =src->bc_tp->t_highest_agno;
src->bc_ino.allocated = 0;
}fs/xfs/libxfs/xfs_bmap_btree.c +0
-0@@ -218,7 +218,7 @@ xfs_bmbt_alloc_block( * we have to ensure that we attempt to locate the entire setof bmbt
* allocations in the same AG, asxfs_bmapi_write()would have reserved.
*/
- if (cur->bc_tp->t_firstblock== NULLFSBLOCK)
+ if (cur->bc_tp->t_highest_agno== NULLAGNUMBER) args.minleft = xfs_bmapi_minleft(cur->bc_tp, cur-Quoted 1 line
bc_ino.ip,
cur->bc_ino.whichfork);
fs/xfs/xfs_bmap_util.c +0
-0@@ -1410,7 +1410,7 @@ xfs_swap_extent_rmap(
/* Unmap the old blocks in the source file. */ while (tirec.br_blockcount) {
- ASSERT(tp->t_firstblock == NULLFSBLOCK); + ASSERT(tp->t_highest_agno == NULLAGNUMBER);trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec);
/* Read extent from the source file */fs/xfs/xfs_inode.c +0
-0@@ -1367,7 +1367,7 @@ xfs_itruncate_extents_flags(
unmap_len =XFS_MAX_FILEOFF-first_unmap_block+ 1; while (unmap_len> 0) {
- ASSERT(tp->t_firstblock == NULLFSBLOCK); + ASSERT(tp->t_highest_agno == NULLAGNUMBER); error = __xfs_bunmapi(tp, ip,first_unmap_block,&unmap_len,
flags,XFS_ITRUNC_MAX_EXTENTS); if (error)fs/xfs/xfs_reflink.c +1
-1@@ -610,7 +610,7 @@ xfs_reflink_cancel_cow_blocks( if (error) break; } else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) { - ASSERT((*tpp)->t_firstblock == NULLFSBLOCK); + ASSERT((*tpp)->t_highest_agno ==NULLAGNUMBER );
/* Free the CoW orphan record. */ xfs_refcount_free_cow_extent(*tpp, del.br_startblock,fs/xfs/xfs_trace.h +1
-1@@ -1801,7 +1801,7 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __field(char, wasfromfl) __field(int, resv) __field(int, datatype) - __field(xfs_fsblock_t, firstblock) + __field(xfs_agnumber_t, highest_agno) ),TP_fast_assign(
__entry->dev =args->mp->m_super->s_dev;fs/xfs/xfs_trace.h +1
-1@@ -1822,12 +1822,12 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __entry->wasfromfl = args->wasfromfl; __entry->resv = args->resv; __entry->datatype = args->datatype; - __entry->firstblock = args->tp->t_firstblock; + __entry->highest_agno = args->tp->t_highest_agno; ),TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u "
"prod %u minleft %u total %u alignment %u minalignslop %u "
"len %u type %s otype %s wasdel %d wasfromfl %d resv %d "
- "datatype 0x%x firstblock 0x%llx",
+ "datatype 0x%xhighest_agno0x%x",MAJOR(__entry->dev),MINOR(__entry->dev),__entry->agno,
__entry->agbno,fs/xfs/xfs_trace.h +1
-1@@ -1846,7 +1846,7 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __entry->wasfromfl, __entry->resv, __entry->datatype, - (unsigned long long)__entry->firstblock) + __entry->highest_agno) )
#defineDEFINE_ALLOC_EVENT(name)\fs/xfs/xfs_trans.c +1
-1@@ -102,7 +102,7 @@ xfs_trans_dup( INIT_LIST_HEAD(&ntp->t_items); INIT_LIST_HEAD(&ntp->t_busy); INIT_LIST_HEAD(&ntp->t_dfops); - ntp->t_firstblock = NULLFSBLOCK; + ntp->t_highest_agno = NULLAGNUMBER;
ASSERT(tp->t_flags &XFS_TRANS_PERM_LOG_RES);ASSERT(tp->t_ticket != NULL);fs/xfs/xfs_trans.c +1
-1@@ -278,7 +278,7 @@ xfs_trans_alloc( INIT_LIST_HEAD(&tp->t_items); INIT_LIST_HEAD(&tp->t_busy); INIT_LIST_HEAD(&tp->t_dfops); - tp->t_firstblock = NULLFSBLOCK; + tp->t_highest_agno = NULLAGNUMBER;
error =xfs_trans_reserve(tp, resp, blocks, rtextents); if (error ==-ENOSPC&&want_retry) {fs/xfs/xfs_trans.h +0
-0@@ -132,7 +132,7 @@ typedef struct xfs_trans {unsigned int t_rtx_res; /* # of rt extents resvd */
unsigned int t_rtx_res_used; /* # of resvd rt extents used */
unsigned int t_flags; /* misc flags */ - xfs_fsblock_t t_firstblock; /* first block allocated */
+ xfs_agnumber_t t_highest_agno; /* highest AGF locked */
struct xlog_ticket *t_ticket; /* log mgr ticket */ struct xfs_mount *t_mountp; /* ptr to fs mount struct */
struct xfs_dquot_acct *t_dqinfo; /* acctg info for dquots */
PATCH 6/42 xfs: don't assert fail on transaction cancel with deferred ops
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
We can error out of an allocation transaction when updating BMBT blocks when things go wrong. This can be a btree corruption, and unexpected ENOSPC, etc. In these cases, we already have deferred ops queued for the first allocation that has been done, and we just want to cancel out the transaction and shut down the filesystem on error.
In fact, we do just that for production systems - the assert that we can't have a transaction with defer ops attached unless we are already shut down is bogus and gets in the way of debugging whatever issue is actually causing the transaction to be cancelled.
Remove the assert because it is causing spurious test failures to hang test machines.
--- fs/xfs/xfs_trans.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/xfs/xfs_trans.c +2 -2
@@ -1078,10 +1078,10 @@ xfs_trans_cancel(/* * It's never valid to cancel a transaction with deferred ops attached, * because the transaction is effectively dirty. Complain about this -* loudly before freeing the in-memory defer items. +* loudly before freeing the in-memory defer items and shutting down the +* filesystem. */ if (!list_empty (&tp->t_dfops)) { -ASSERT (xfs_is_shutdown (mp) ||list_empty (&tp->t_dfops));ASSERT (tp->t_flags &XFS_TRANS_PERM_LOG_RES ); dirty = true;xfs_defer_cancel (tp);
Signature · 1 line
2.39.0
Re: [PATCH 06/42] xfs: don't assert fail on transaction cancel with deferred ops
Quoted 13 lines · Dave Chinner
From: Dave Chinner <[email protected]>
We can error out of an allocation transaction when updating BMBT blocks when things go wrong. This can be a btree corruption, and unexpected ENOSPC, etc. In these cases, we already have deferred ops queued for the first allocation that has been done, and we just want to cancel out the transaction and shut down the filesystem on error.
In fact, we do just that for production systems - the assert that we can't have a transaction with defer ops attached unless we are already shut down is bogus and gets in the way of debugging whatever issue is actually causing the transaction to be cancelled.
Quoted 4 lines
Remove the assert because it is causing spurious test failures to hang test machines.
Signed-off-by Dave Chinner <[email protected]>
Ok, makes sense
Quoted 25 lines
---
fs/xfs/xfs_trans.c | 4 ++--1 file changed, 2 insertions(+), 2 deletions(-)fs/xfs/xfs_trans.c +0
-0@@ -1078,10 +1078,10 @@ xfs_trans_cancel( /** It's never valid to cancel a transaction with deferred ops attached, * because the transaction is effectively dirty. Complain about this
- * loudly before freeing the in-memory defer items. + * loudly before freeing the in-memory defer items and shutting down the
+ * filesystem.
*/
if (!list_empty(&tp->t_dfops)) {
- ASSERT(xfs_is_shutdown(mp) || list_empty(&tp-Quoted 1 line
t_dfops));ASSERT(tp->t_flags &
XFS_TRANS_PERM_LOG_RES); dirty = true;
xfs_defer_cancel(tp);
PATCH 7/42 xfs: active perag reference counting
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
We need to be able to dynamically remove instantiated AGs from memory safely, either for shrinking the filesystem or paging AG state in and out of memory (e.g. supporting millions of AGs). This means we need to be able to safely exclude operations from accessing perags while dynamic removal is in progress.
To do this, introduce the concept of active and passive references. Active references are required for high level operations that make use of an AG for a given operation (e.g. allocation) and pin the perag in memory for the duration of the operation that is operating on the perag (e.g. transaction scope). This means we can fail to get an active reference to an AG, hence callers of the new active reference API must be able to handle lookup failure gracefully.
Passive references are used in low level code, where we might need to access the perag structure for the purposes of completing high level operations. For example, buffers need to use passive references because:
- we need to be able to do metadata IO during operations like grow and shrink transactions where high level active references to the AG have already been blocked
- buffers need to pin the perag until they are reclaimed from memory, something that high level code has no direct control over.
- unused cached buffers should not prevent a shrink from being started.
Hence we have active references that will form exclusion barriers for operations to be performed on an AG, and passive references that will prevent reclaim of the perag until all objects with passive references have been reclaimed themselves.
This patch introduce xfs_perag_grab()/xfs_perag_rele() as the API for active AG reference functionality. We also need to convert the for_each_perag*() iterators to use active references, which will start the process of converting high level code over to using active references. Conversion of non-iterator based code to active references will be done in followup patches.
Note that the implementation using reference counting is really just a development vehicle for the API to ensure we don't have any leaks in the callers. Once we need to remove perag structures from memory dyanmically, we will need a much more robust per-ag state transition mechanism for preventing new references from being taken while we wait for existing references to drain before removal from memory can occur....
--- fs/xfs/libxfs/xfs_ag.c | 70 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_ag.h | 31 ++++++++++++----- fs/xfs/scrub/bmap.c | 2 +- fs/xfs/scrub/fscounters.c | 4 +-- fs/xfs/xfs_fsmap.c | 4 +-- fs/xfs/xfs_icache.c | 2 +- fs/xfs/xfs_iwalk.c | 6 ++-- fs/xfs/xfs_reflink.c | 2 +- fs/xfs/xfs_trace.h | 3 ++ 9 files changed, 105 insertions(+), 19 deletions(-)
fs/xfs/libxfs/xfs_ag.c +70 -0
@@ -94,6 +94,68 @@ xfs_perag_put(trace_xfs_perag_put (pag->pag_mount, pag->pag_agno, ref, _RET_IP_); } +/* +* Active references for perag structures. This is for short term access to the +* per ag structures for walking trees or accessing state. If an AG is being +* shrunk or is offline, then this will fail to find that AG and return NULL +* instead. +*/ +struct xfs_perag * +xfs_perag_grab ( +struct xfs_mount *mp, +xfs_agnumber_t agno) +{ +struct xfs_perag *pag; + +rcu_read_lock (); + pag =radix_tree_lookup (&mp->m_perag_tree, agno); +if (pag) { +trace_xfs_perag_grab (mp, pag->pag_agno, +atomic_read (&pag->pag_active_ref), _RET_IP_); +if (!atomic_inc_not_zero (&pag->pag_active_ref)) + pag =NULL ; + } +rcu_read_unlock (); +return pag; +} + +/* +* search from @first to find the next perag with the given tag set. +*/ +struct xfs_perag * +xfs_perag_grab_tag ( +struct xfs_mount *mp, +xfs_agnumber_t first, +int tag) +{ +struct xfs_perag *pag; +int found; + +rcu_read_lock (); + found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, + (void **)&pag, first,1 , tag); +if (found <=0 ) { +rcu_read_unlock (); +return NULL ; + } +trace_xfs_perag_grab_tag (mp, pag->pag_agno, +atomic_read (&pag->pag_active_ref), _RET_IP_); +if (!atomic_inc_not_zero (&pag->pag_active_ref)) + pag =NULL ; +rcu_read_unlock (); +return pag; +} + +void +xfs_perag_rele ( +struct xfs_perag *pag) +{ +trace_xfs_perag_rele (pag->pag_mount, pag->pag_agno, +atomic_read (&pag->pag_active_ref), _RET_IP_); +if (atomic_dec_and_test (&pag->pag_active_ref)) +wake_up (&pag->pag_active_wq); +} +/* * xfs_initialize_perag_data *
@@ -196,6 +258,10 @@ xfs_free_perag(cancel_delayed_work_sync (&pag->pag_blockgc_work);xfs_buf_hash_destroy (pag); +/* drop the mount's active reference */ +xfs_perag_rele (pag); +XFS_IS_CORRUPT (pag->pag_mount, +atomic_read (&pag->pag_active_ref) !=0 );call_rcu (&pag->rcu_head, __xfs_free_perag); } }
@@ -314,6 +380,7 @@ xfs_initialize_perag(INIT_DELAYED_WORK (&pag->pag_blockgc_work, xfs_blockgc_worker);INIT_RADIX_TREE (&pag->pag_ici_root,GFP_ATOMIC );init_waitqueue_head (&pag->pagb_wait); +init_waitqueue_head (&pag->pag_active_wq); pag->pagb_count =0 ; pag->pagb_tree =RB_ROOT ;#endif /* __KERNEL__ */
@@ -322,6 +389,9 @@ xfs_initialize_perag(if (error) goto out_remove_pag; +/* Active ref owned by mount indicates AG is online. */ +atomic_set (&pag->pag_active_ref,1 ); +/* first new pag is fully initialized */ if (first_initialised ==NULLAGNUMBER ) first_initialised = index;
fs/xfs/libxfs/xfs_ag.h +22 -9
@@ -32,7 +32,9 @@ struct xfs_ag_resv {struct xfs_perag {struct xfs_mount *pag_mount;/* owner filesystem */ xfs_agnumber_t pag_agno;/* AG this structure belongs to */ -atomic_t pag_ref;/* perag reference count */ +atomic_t pag_ref;/* passive reference count */ +atomic_t pag_active_ref;/* active reference count */ +wait_queue_head_t pag_active_wq;/* woken active_ref falls to zero */ char pagf_init;/* this agf's entry is initialized */ char pagi_init;/* this agi's entry is initialized */ char pagf_metadata;/* the agf is preferred to be metadata */
@@ -111,11 +113,18 @@ int xfs_initialize_perag(struct xfs_mount *mp, xfs_agnumber_t agcount,int xfs_initialize_perag_data (struct xfs_mount *mp,xfs_agnumber_t agno);void xfs_free_perag (struct xfs_mount *mp); +/* Passive AG references */ struct xfs_perag *xfs_perag_get (struct xfs_mount *mp,xfs_agnumber_t agno);struct xfs_perag *xfs_perag_get_tag (struct xfs_mount *mp,xfs_agnumber_t agno,unsigned int tag);void xfs_perag_put (struct xfs_perag *pag); +/* Active AG references */ +struct xfs_perag *xfs_perag_grab (struct xfs_mount *,xfs_agnumber_t ); +struct xfs_perag *xfs_perag_grab_tag (struct xfs_mount *,xfs_agnumber_t , +int tag); +void xfs_perag_rele (struct xfs_perag *pag); +/* * Per-ag geometry infomation and validation */
@@ -193,14 +202,18 @@ xfs_perag_next(struct xfs_mount *mp = pag->pag_mount; *agno = pag->pag_agno +1 ; -xfs_perag_put (pag); -if (*agno > end_agno) -return NULL ; -return xfs_perag_get (mp, *agno); +xfs_perag_rele (pag); +while (*agno <= end_agno) { + pag =xfs_perag_grab (mp, *agno); +if (pag) +return pag; + (*agno)++; + } +return NULL ; }#define for_each_perag_range (mp, agno, end_agno, pag) \ - for ((pag) = xfs_perag_get((mp), (agno)); \ + for ((pag) = xfs_perag_grab((mp), (agno)); \ (pag) != NULL; \ (pag) = xfs_perag_next((pag), &(agno), (end_agno)))
@@ -213,11 +226,11 @@ xfs_perag_next( for_each_perag_from((mp), (agno), (pag))#define for_each_perag_tag (mp, agno, pag, tag) \ - for ((agno) = 0, (pag) = xfs_perag_get_tag((mp), 0, (tag)); \ + for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ (pag) != NULL; \ (agno) = (pag)->pag_agno + 1, \ - xfs_perag_put(pag), \ - (pag) = xfs_perag_get_tag((mp), (agno), (tag))) + xfs_perag_rele(pag), \ + (pag) = xfs_perag_grab_tag((mp), (agno), (tag)))struct aghdr_init_data {/* per ag data */
fs/xfs/scrub/bmap.c +1 -1
@@ -662,7 +662,7 @@ xchk_bmap_check_rmaps( error =xchk_bmap_check_ag_rmaps (sc, whichfork, pag);if (error || (sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT )) { -xfs_perag_put (pag); +xfs_perag_rele (pag);return error; } }
fs/xfs/scrub/fscounters.c +2 -2
@@ -117,7 +117,7 @@ xchk_fscount_warmup(if (agi_bp)xfs_buf_relse (agi_bp);if (pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);return error; }
@@ -249,7 +249,7 @@ xchk_fscount_aggregate_agcounts( }if (pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);if (error) {xchk_set_incomplete (sc);return error;
fs/xfs/xfs_fsmap.c +2 -2
@@ -688,11 +688,11 @@ __xfs_getfsmap_datadev( info->agf_bp =NULL ; }if (info->pag) { -xfs_perag_put (info->pag); +xfs_perag_rele (info->pag); info->pag =NULL ; }else if (pag) {/* loop termination case */ -xfs_perag_put (pag); +xfs_perag_rele (pag); }return error;
fs/xfs/xfs_icache.c +1 -1
@@ -1767,7 +1767,7 @@ xfs_icwalk(if (error) { last_error = error;if (error == -EFSCORRUPTED ) { -xfs_perag_put (pag); +xfs_perag_rele (pag);break ; } }
fs/xfs/xfs_iwalk.c +3 -3
@@ -591,7 +591,7 @@ xfs_iwalk( }if (iwag.pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);xfs_iwalk_free (&iwag);return error; }
@@ -683,7 +683,7 @@ xfs_iwalk_threaded(break ; }if (pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);if (polled)xfs_pwork_poll (&pctl);return xfs_pwork_destroy (&pctl);
@@ -776,7 +776,7 @@ xfs_inobt_walk( }if (iwag.pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);xfs_iwalk_free (&iwag);return error; }
fs/xfs/xfs_reflink.c +1 -1
@@ -927,7 +927,7 @@ xfs_reflink_recover_cow(for_each_perag (mp, agno, pag) { error =xfs_refcount_recover_cow_leftovers (mp, pag);if (error) { -xfs_perag_put (pag); +xfs_perag_rele (pag);break ; } }
fs/xfs/xfs_trace.h +3 -0
@@ -189,6 +189,9 @@ DEFINE_EVENT(xfs_perag_class, name, \DEFINE_PERAG_REF_EVENT (xfs_perag_get);DEFINE_PERAG_REF_EVENT (xfs_perag_get_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_put); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_rele);DEFINE_PERAG_REF_EVENT (xfs_perag_set_inode_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_clear_inode_tag);
Signature · 1 line
2.39.0
Re: [PATCH 07/42] xfs: active perag reference counting
Quoted 48 lines · Dave Chinner
From: Dave Chinner <[email protected]>
We need to be able to dynamically remove instantiated AGs from memory safely, either for shrinking the filesystem or paging AG state in and out of memory (e.g. supporting millions of AGs). This means we need to be able to safely exclude operations from accessing perags while dynamic removal is in progress.
To do this, introduce the concept of active and passive references. Active references are required for high level operations that make use of an AG for a given operation (e.g. allocation) and pin the perag in memory for the duration of the operation that is operating on the perag (e.g. transaction scope). This means we can fail to get an active reference to an AG, hence callers of the new active reference API must be able to handle lookup failure gracefully.
Passive references are used in low level code, where we might need to access the perag structure for the purposes of completing high level operations. For example, buffers need to use passive references because:
- we need to be able to do metadata IO during operations like grow and shrink transactions where high level active references to the AG have already been blocked
- buffers need to pin the perag until they are reclaimed from memory, something that high level code has no direct control over.
- unused cached buffers should not prevent a shrink from being started.Hence we have active references that will form exclusion barriers for operations to be performed on an AG, and passive references that will prevent reclaim of the perag until all objects with passive references have been reclaimed themselves.
This patch introduce xfs_perag_grab()/xfs_perag_rele() as the API for active AG reference functionality. We also need to convert the for_each_perag*() iterators to use active references, which will start the process of converting high level code over to using active references. Conversion of non-iterator based code to active references will be done in followup patches.
Note that the implementation using reference counting is really just a development vehicle for the API to ensure we don't have any leaks in the callers. Once we need to remove perag structures from memory dyanmically, we will need a much more robust per-ag state transition mechanism for preventing new references from being taken while we wait for existing references to drain before removal from memory can occur....
Quoted 1 line
Signed-off-by Dave Chinner <[email protected]>
ok, I was able to follow it
Quoted 332 lines
fs/xfs/libxfs/xfs_ag.c | 70
+++++++++++++++++++++++++++++++++++++++
fs/xfs/libxfs/xfs_ag.h | 31 ++++++++++++-----
fs/xfs/scrub/bmap.c | 2 +-
fs/xfs/scrub/fscounters.c | 4 +--
fs/xfs/xfs_fsmap.c | 4 +--
fs/xfs/xfs_icache.c | 2 +-
fs/xfs/xfs_iwalk.c | 6 ++--
fs/xfs/xfs_reflink.c | 2 +-
fs/xfs/xfs_trace.h | 3 ++9 files changed, 105 insertions(+), 19 deletions(-)fs/xfs/libxfs/xfs_ag.c +0
-0@@ -94,6 +94,68 @@ xfs_perag_put( trace_xfs_perag_put(pag->pag_mount, pag->pag_agno, ref, _RET_IP_); }
+/*
+ * Active references for perag structures. This is for short term access to the
+ * per ag structures for walking trees or accessing state. If an AG is being
+ * shrunk or is offline, then this will fail to find that AG and return NULL
+ * instead.
+ */fs/xfs/libxfs/xfs_ag.c +12
-0+struct xfs_perag * +xfs_perag_grab ( + struct xfs_mount *mp, + xfs_agnumber_t agno) +{ + struct xfs_perag *pag; + + rcu_read_lock(); + pag = radix_tree_lookup(&mp->m_perag_tree, agno); + if (pag) { + trace_xfs_perag_grab(mp, pag->pag_agno, + atomic_read(&pag->pag_active_ref),_RET_IP_);
+ if (!atomic_inc_not_zero(&pag->pag_active_ref)) + pag = NULL;
+ }
+ rcu_read_unlock();
+ return pag;fs/xfs/libxfs/xfs_ag.c +17
-0+} + +/* +* search from @first to find the next perag with the given tag set. +*/ +struct xfs_perag * +xfs_perag_grab_tag ( + struct xfs_mount *mp, + xfs_agnumber_t first, + int tag) +{ + struct xfs_perag *pag; + int found; + + rcu_read_lock(); + found = radix_tree_gang_lookup_tag(&mp->m_perag_tree, + (void **)&pag, first, 1,tag);
+ if (found <= 0) {
+ rcu_read_unlock();
+ return NULL;
+ }
+ trace_xfs_perag_grab_tag(mp,pag->pag_agno,
+ atomic_read(&pag->pag_active_ref), _RET_IP_); + if (!atomic_inc_not_zero(&pag->pag_active_ref))
+ pag = NULL;
+ rcu_read_unlock();
+ return pag;fs/xfs/libxfs/xfs_ag.c +12
-0+} + +void +xfs_perag_rele ( + struct xfs_perag *pag) +{ + trace_xfs_perag_rele(pag->pag_mount, pag->pag_agno, + atomic_read(&pag->pag_active_ref), _RET_IP_); + if (atomic_dec_and_test(&pag->pag_active_ref)) + wake_up(&pag->pag_active_wq); +} +/*
*xfs_initialize_perag_data
*fs/xfs/libxfs/xfs_ag.c +0
-0@@ -196,6 +258,10 @@ xfs_free_perag( cancel_delayed_work_sync(&pag->pag_blockgc_work); xfs_buf_hash_destroy(pag);
+ /* drop the mount's active reference */
+ xfs_perag_rele(pag);
+ XFS_IS_CORRUPT(pag->pag_mount,
+ atomic_read(&pag->pag_active_ref) != 0);
call_rcu(&pag->rcu_head,__xfs_free_perag); }
}fs/xfs/libxfs/xfs_ag.c +1
-0@@ -314,6 +380,7 @@ xfs_initialize_perag( INIT_DELAYED_WORK(&pag->pag_blockgc_work, xfs_blockgc_worker); INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC); init_waitqueue_head(&pag->pagb_wait); + init_waitqueue_head(&pag->pag_active_wq); pag->pagb_count = 0; pag->pagb_tree = RB_ROOT;#endif /*
__KERNEL__*/fs/xfs/libxfs/xfs_ag.c +0
-0@@ -322,6 +389,9 @@ xfs_initialize_perag( if (error) goto out_remove_pag;
+ /* Active ref owned by mount indicates AG is online. */
+ atomic_set(&pag->pag_active_ref, 1);
+
/* first new pag is fully initialized */ if (first_initialised== NULLAGNUMBER)first_initialised= index;fs/xfs/libxfs/xfs_ag.h +0
-0@@ -32,7 +32,9 @@ struct xfs_ag_resv { struct xfs_perag {struct
xfs_mount*pag_mount; /* owner filesystem */ xfs_agnumber_t pag_agno; /* AG this structure belongs to */
- atomic_t pag_ref; /* perag reference count */ + atomic_t pag_ref; /* passive reference count */ + atomic_t pag_active_ref; /* active reference count */ + wait_queue_head_t pag_active_wq;/* wokenactive_reffalls to zero */
char pagf_init; /* this agf's entry is initialized */
char pagi_init; /* this agi's entry is initialized */
char pagf_metadata; /* the agf is preferred to be metadata */fs/xfs/libxfs/xfs_ag.h +0
-0@@ -111,11 +113,18 @@ int xfs_initialize_perag(struct xfs_mount *mp, xfs_agnumber_t agcount,int
xfs_initialize_perag_data(struct xfs_mount *mp, xfs_agnumber_t agno);
voidxfs_free_perag(struct xfs_mount *mp);
+/* Passive AG references */
structxfs_perag*xfs_perag_get(structxfs_mount*mp,xfs_agnumber_tagno);
structxfs_perag*xfs_perag_get_tag(structxfs_mount*mp,xfs_agnumber_tagno,
unsigned int tag);
voidxfs_perag_put(struct xfs_perag *pag);fs/xfs/libxfs/xfs_ag.h +2
-0+/* Active AG references */ +struct xfs_perag *xfs_perag_grab(struct xfs_mount *,
xfs_agnumber_t);
+structxfs_perag*xfs_perag_grab_tag(structxfs_mount*,xfs_agnumber_t,
+ int tag);fs/xfs/libxfs/xfs_ag.h +2
-0+void xfs_perag_rele (struct xfs_perag *pag); +/*
* Per-ag geometry infomation and validation
*/fs/xfs/libxfs/xfs_ag.h +0
-0@@ -193,14 +202,18 @@ xfs_perag_next( struct xfs_mount *mp = pag->pag_mount;
*agno =pag->pag_agno+ 1;
- xfs_perag_put(pag);
- if (*agno >end_agno)
- return NULL;
- returnxfs_perag_get(mp, *agno);
+ xfs_perag_rele(pag);
+ while (*agno <=end_agno) {
+ pag =xfs_perag_grab(mp, *agno);
+ if (pag)
+ return pag;
+ (*agno)++;
+ }
+ return NULL;
}
#definefor_each_perag_range(mp, agno, end_agno, pag)\
- for ((pag) =xfs_perag_get((mp), (agno)); \
+ for ((pag) =xfs_perag_grab((mp), (agno)); \
(pag) != NULL; \
(pag) =xfs_perag_next((pag), &(agno), (end_agno)))fs/xfs/libxfs/xfs_ag.h +0
-0@@ -213,11 +226,11 @@ xfs_perag_next( for_each_perag_from((mp), (agno), (pag))
#definefor_each_perag_tag(mp, agno, pag, tag)\
- for ((agno) = 0, (pag) =xfs_perag_get_tag((mp), 0, (tag)); \
+ for ((agno) = 0, (pag) =xfs_perag_grab_tag((mp), 0, (tag)); \
(pag) != NULL; \
(agno) = (pag)->pag_agno + 1, \
- xfs_perag_put(pag), \
- (pag) =xfs_perag_get_tag((mp), (agno), (tag))) + xfs_perag_rele(pag), \
+ (pag) =xfs_perag_grab_tag((mp), (agno), (tag)))
structaghdr_init_data{
/* per ag data */fs/xfs/scrub/bmap.c +0
-0@@ -662,7 +662,7 @@ xchk_bmap_check_rmaps( error = xchk_bmap_check_ag_rmaps(sc, whichfork, pag);if (error ||
(sc->sm->sm_flags&XFS_SCRUB_OFLAG_CORRUPT)) { - xfs_perag_put(pag);
+ xfs_perag_rele(pag);
return error;
}
}fs/xfs/scrub/fscounters.c +1
-1@@ -117,7 +117,7 @@ xchk_fscount_warmup( if (agi_bp) xfs_buf_relse(agi_bp); if (pag) - xfs_perag_put(pag); + xfs_perag_rele(pag); return error; }fs/xfs/scrub/fscounters.c +0
-0@@ -249,7 +249,7 @@ xchk_fscount_aggregate_agcounts(
}
if (pag)
- xfs_perag_put(pag);
+ xfs_perag_rele(pag);
if (error) {
xchk_set_incomplete(sc);
return error;fs/xfs/xfs_fsmap.c +2
-2@@ -688,11 +688,11 @@ __xfs_getfsmap_datadev( info->agf_bp = NULL; } if (info->pag) { - xfs_perag_put(info->pag); + xfs_perag_rele(info->pag); info->pag = NULL; } else if (pag) { /* loop termination case */ - xfs_perag_put(pag); + xfs_perag_rele(pag); }
return error;fs/xfs/xfs_icache.c +1
-1@@ -1767,7 +1767,7 @@ xfs_icwalk( if (error) { last_error = error; if (error == -EFSCORRUPTED) { - xfs_perag_put(pag); + xfs_perag_rele(pag); break; } }fs/xfs/xfs_iwalk.c +0
-0@@ -591,7 +591,7 @@ xfs_iwalk( }
if (iwag.pag)
- xfs_perag_put(pag);
+ xfs_perag_rele(pag);
xfs_iwalk_free(&iwag);
return error;
}fs/xfs/xfs_iwalk.c +1
-1@@ -683,7 +683,7 @@ xfs_iwalk_threaded( break; } if (pag) - xfs_perag_put(pag); + xfs_perag_rele(pag); if (polled) xfs_pwork_poll(&pctl); return xfs_pwork_destroy(&pctl);@@ -776,7 +776,7 @@ xfs_inobt_walk( }
if (iwag.pag)
- xfs_perag_put(pag);
+ xfs_perag_rele(pag);
xfs_iwalk_free(&iwag);
return error;
}fs/xfs/xfs_reflink.c +1
-1@@ -927,7 +927,7 @@ xfs_reflink_recover_cow( for_each_perag(mp, agno, pag) { error = xfs_refcount_recover_cow_leftovers(mp, pag); if (error) { - xfs_perag_put(pag); + xfs_perag_rele(pag); break; } }fs/xfs/xfs_trace.h +3
-0@@ -189,6 +189,9 @@ DEFINE_EVENT(xfs_perag_class, name, \ DEFINE_PERAG_REF_EVENT(xfs_perag_get); DEFINE_PERAG_REF_EVENT(xfs_perag_get_tag); DEFINE_PERAG_REF_EVENT(xfs_perag_put); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_rele); DEFINE_PERAG_REF_EVENT(xfs_perag_set_inode_tag); DEFINE_PERAG_REF_EVENT(xfs_perag_clear_inode_tag);
Re: [PATCH 07/42] xfs: active perag reference counting
In reply to Dave ChinnerQuoted 28 lines · Dave Chinner
From: Dave Chinner <[email protected]>
We need to be able to dynamically remove instantiated AGs from memory safely, either for shrinking the filesystem or paging AG state in and out of memory (e.g. supporting millions of AGs). This means we need to be able to safely exclude operations from accessing perags while dynamic removal is in progress.
To do this, introduce the concept of active and passive references. Active references are required for high level operations that make use of an AG for a given operation (e.g. allocation) and pin the perag in memory for the duration of the operation that is operating on the perag (e.g. transaction scope). This means we can fail to get an active reference to an AG, hence callers of the new active reference API must be able to handle lookup failure gracefully.
Passive references are used in low level code, where we might need to access the perag structure for the purposes of completing high level operations. For example, buffers need to use passive references because:
- we need to be able to do metadata IO during operations like grow and shrink transactions where high level active references to the AG have already been blocked
- buffers need to pin the perag until they are reclaimed from memory, something that high level code has no direct control over.
- unused cached buffers should not prevent a shrink from being started.
Quoted 4 lines
Hence we have active references that will form exclusion barriers for operations to be performed on an AG, and passive references that will prevent reclaim of the perag until all objects with passive references have been reclaimed themselves.
This is going to be fun to rebase the online fsck series on top of. :)
If I'm understanding correctly, active perag refs are for high level code that wants to call down into an AG to do some operation (allocating, freeing, scanning, whatever)? So I think online fsck uniformly wants xfs_perag_grab/rele, right?
Passive refs are (I think) for lower level code that's wants to call up into an AG to finish off something that was already started? And probably by upper level code? So the amount of code that actually wants a passive reference is pretty small?
Quoted 6 lines
This patch introduce xfs_perag_grab()/xfs_perag_rele() as the API for active AG reference functionality. We also need to convert the for_each_perag*() iterators to use active references, which will start the process of converting high level code over to using active references. Conversion of non-iterator based code to active references will be done in followup patches.
Is there any code that iterates perag structures via passive references? I think the answer to this is 'no'?
The code changes look all right. If the answers to the above questions are "yes", "yes", "yes", and "no", then:
--D
Quoted 323 lines
Note that the implementation using reference counting is really just a development vehicle for the API to ensure we don't have any leaks in the callers. Once we need to remove perag structures from memory dyanmically, we will need a much more robust per-ag state transition mechanism for preventing new references from being taken while we wait for existing references to drain before removal from memory can occur....
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_ag.c | 70 +++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_ag.h | 31 ++++++++++++----- fs/xfs/scrub/bmap.c | 2 +- fs/xfs/scrub/fscounters.c | 4 +-- fs/xfs/xfs_fsmap.c | 4 +-- fs/xfs/xfs_icache.c | 2 +- fs/xfs/xfs_iwalk.c | 6 ++-- fs/xfs/xfs_reflink.c | 2 +- fs/xfs/xfs_trace.h | 3 ++ 9 files changed, 105 insertions(+), 19 deletions(-)fs/xfs/libxfs/xfs_ag.c +70
-0@@ -94,6 +94,68 @@ xfs_perag_put(trace_xfs_perag_put (pag->pag_mount, pag->pag_agno, ref, _RET_IP_); } +/* +* Active references for perag structures. This is for short term access to the +* per ag structures for walking trees or accessing state. If an AG is being +* shrunk or is offline, then this will fail to find that AG and return NULL +* instead. +*/ +struct xfs_perag * +xfs_perag_grab ( +struct xfs_mount *mp, +xfs_agnumber_t agno) +{ +struct xfs_perag *pag; + +rcu_read_lock (); + pag =radix_tree_lookup (&mp->m_perag_tree, agno); +if (pag) { +trace_xfs_perag_grab (mp, pag->pag_agno, +atomic_read (&pag->pag_active_ref), _RET_IP_); +if (!atomic_inc_not_zero (&pag->pag_active_ref)) + pag =NULL ; + } +rcu_read_unlock (); +return pag; +} + +/* +* search from @first to find the next perag with the given tag set. +*/ +struct xfs_perag * +xfs_perag_grab_tag ( +struct xfs_mount *mp, +xfs_agnumber_t first, +int tag) +{ +struct xfs_perag *pag; +int found; + +rcu_read_lock (); + found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, + (void **)&pag, first,1 , tag); +if (found <=0 ) { +rcu_read_unlock (); +return NULL ; + } +trace_xfs_perag_grab_tag (mp, pag->pag_agno, +atomic_read (&pag->pag_active_ref), _RET_IP_); +if (!atomic_inc_not_zero (&pag->pag_active_ref)) + pag =NULL ; +rcu_read_unlock (); +return pag; +} + +void +xfs_perag_rele ( +struct xfs_perag *pag) +{ +trace_xfs_perag_rele (pag->pag_mount, pag->pag_agno, +atomic_read (&pag->pag_active_ref), _RET_IP_); +if (atomic_dec_and_test (&pag->pag_active_ref)) +wake_up (&pag->pag_active_wq); +} +/* * xfs_initialize_perag_data * @@ -196,6 +258,10 @@ xfs_free_perag(cancel_delayed_work_sync (&pag->pag_blockgc_work);xfs_buf_hash_destroy (pag); +/* drop the mount's active reference */ +xfs_perag_rele (pag); +XFS_IS_CORRUPT (pag->pag_mount, +atomic_read (&pag->pag_active_ref) !=0 );call_rcu (&pag->rcu_head, __xfs_free_perag); } }@@ -314,6 +380,7 @@ xfs_initialize_perag(INIT_DELAYED_WORK (&pag->pag_blockgc_work, xfs_blockgc_worker);INIT_RADIX_TREE (&pag->pag_ici_root,GFP_ATOMIC );init_waitqueue_head (&pag->pagb_wait); +init_waitqueue_head (&pag->pag_active_wq); pag->pagb_count =0 ; pag->pagb_tree =RB_ROOT ;#endif /* __KERNEL__ */ @@ -322,6 +389,9 @@ xfs_initialize_perag(if (error) goto out_remove_pag; +/* Active ref owned by mount indicates AG is online. */ +atomic_set (&pag->pag_active_ref,1 ); +/* first new pag is fully initialized */ if (first_initialised ==NULLAGNUMBER ) first_initialised = index;fs/xfs/libxfs/xfs_ag.h +22
-9@@ -32,7 +32,9 @@ struct xfs_ag_resv {struct xfs_perag {struct xfs_mount *pag_mount;/* owner filesystem */ xfs_agnumber_t pag_agno;/* AG this structure belongs to */ -atomic_t pag_ref;/* perag reference count */ +atomic_t pag_ref;/* passive reference count */ +atomic_t pag_active_ref;/* active reference count */ +wait_queue_head_t pag_active_wq;/* woken active_ref falls to zero */ char pagf_init;/* this agf's entry is initialized */ char pagi_init;/* this agi's entry is initialized */ char pagf_metadata;/* the agf is preferred to be metadata */ @@ -111,11 +113,18 @@ int xfs_initialize_perag(struct xfs_mount *mp, xfs_agnumber_t agcount,int xfs_initialize_perag_data (struct xfs_mount *mp,xfs_agnumber_t agno);void xfs_free_perag (struct xfs_mount *mp); +/* Passive AG references */ struct xfs_perag *xfs_perag_get (struct xfs_mount *mp,xfs_agnumber_t agno);struct xfs_perag *xfs_perag_get_tag (struct xfs_mount *mp,xfs_agnumber_t agno,unsigned int tag);void xfs_perag_put (struct xfs_perag *pag); +/* Active AG references */ +struct xfs_perag *xfs_perag_grab (struct xfs_mount *,xfs_agnumber_t ); +struct xfs_perag *xfs_perag_grab_tag (struct xfs_mount *,xfs_agnumber_t , +int tag); +void xfs_perag_rele (struct xfs_perag *pag); +/* * Per-ag geometry infomation and validation */ @@ -193,14 +202,18 @@ xfs_perag_next(struct xfs_mount *mp = pag->pag_mount; *agno = pag->pag_agno +1 ; -xfs_perag_put (pag); -if (*agno > end_agno) -return NULL ; -return xfs_perag_get (mp, *agno); +xfs_perag_rele (pag); +while (*agno <= end_agno) { + pag =xfs_perag_grab (mp, *agno); +if (pag) +return pag; + (*agno)++; + } +return NULL ; }#define for_each_perag_range (mp, agno, end_agno, pag) \ - for ((pag) = xfs_perag_get((mp), (agno)); \ + for ((pag) = xfs_perag_grab((mp), (agno)); \ (pag) != NULL; \ (pag) = xfs_perag_next((pag), &(agno), (end_agno)))@@ -213,11 +226,11 @@ xfs_perag_next( for_each_perag_from((mp), (agno), (pag))#define for_each_perag_tag (mp, agno, pag, tag) \ - for ((agno) = 0, (pag) = xfs_perag_get_tag((mp), 0, (tag)); \ + for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ (pag) != NULL; \ (agno) = (pag)->pag_agno + 1, \ - xfs_perag_put(pag), \ - (pag) = xfs_perag_get_tag((mp), (agno), (tag))) + xfs_perag_rele(pag), \ + (pag) = xfs_perag_grab_tag((mp), (agno), (tag)))struct aghdr_init_data {/* per ag data */ fs/xfs/scrub/bmap.c +1
-1@@ -662,7 +662,7 @@ xchk_bmap_check_rmaps( error =xchk_bmap_check_ag_rmaps (sc, whichfork, pag);if (error || (sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT )) { -xfs_perag_put (pag); +xfs_perag_rele (pag);return error; } }fs/xfs/scrub/fscounters.c +2
-2@@ -117,7 +117,7 @@ xchk_fscount_warmup(if (agi_bp)xfs_buf_relse (agi_bp);if (pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);return error; }@@ -249,7 +249,7 @@ xchk_fscount_aggregate_agcounts( }if (pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);if (error) {xchk_set_incomplete (sc);return error;fs/xfs/xfs_fsmap.c +2
-2@@ -688,11 +688,11 @@ __xfs_getfsmap_datadev( info->agf_bp =NULL ; }if (info->pag) { -xfs_perag_put (info->pag); +xfs_perag_rele (info->pag); info->pag =NULL ; }else if (pag) {/* loop termination case */ -xfs_perag_put (pag); +xfs_perag_rele (pag); }return error;fs/xfs/xfs_icache.c +1
-1@@ -1767,7 +1767,7 @@ xfs_icwalk(if (error) { last_error = error;if (error == -EFSCORRUPTED ) { -xfs_perag_put (pag); +xfs_perag_rele (pag);break ; } }fs/xfs/xfs_iwalk.c +3
-3@@ -591,7 +591,7 @@ xfs_iwalk( }if (iwag.pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);xfs_iwalk_free (&iwag);return error; }@@ -683,7 +683,7 @@ xfs_iwalk_threaded(break ; }if (pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);if (polled)xfs_pwork_poll (&pctl);return xfs_pwork_destroy (&pctl);@@ -776,7 +776,7 @@ xfs_inobt_walk( }if (iwag.pag) -xfs_perag_put (pag); +xfs_perag_rele (pag);xfs_iwalk_free (&iwag);return error; }fs/xfs/xfs_reflink.c +1
-1@@ -927,7 +927,7 @@ xfs_reflink_recover_cow(for_each_perag (mp, agno, pag) { error =xfs_refcount_recover_cow_leftovers (mp, pag);if (error) { -xfs_perag_put (pag); +xfs_perag_rele (pag);break ; } }fs/xfs/xfs_trace.h +3
-0@@ -189,6 +189,9 @@ DEFINE_EVENT(xfs_perag_class, name, \DEFINE_PERAG_REF_EVENT (xfs_perag_get);DEFINE_PERAG_REF_EVENT (xfs_perag_get_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_put); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_rele);DEFINE_PERAG_REF_EVENT (xfs_perag_set_inode_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_clear_inode_tag);Signature · 1 line
2.39.0
Re: [PATCH 07/42] xfs: active perag reference counting
Quoted 34 lines · Darrick J. Wong
Quoted 28 lines · Dave Chinner
From: Dave Chinner <[email protected]>
We need to be able to dynamically remove instantiated AGs from memory safely, either for shrinking the filesystem or paging AG state in and out of memory (e.g. supporting millions of AGs). This means we need to be able to safely exclude operations from accessing perags while dynamic removal is in progress.
To do this, introduce the concept of active and passive references. Active references are required for high level operations that make use of an AG for a given operation (e.g. allocation) and pin the perag in memory for the duration of the operation that is operating on the perag (e.g. transaction scope). This means we can fail to get an active reference to an AG, hence callers of the new active reference API must be able to handle lookup failure gracefully.
Passive references are used in low level code, where we might need to access the perag structure for the purposes of completing high level operations. For example, buffers need to use passive references because:
- we need to be able to do metadata IO during operations like grow and shrink transactions where high level active references to the AG have already been blocked
- buffers need to pin the perag until they are reclaimed from memory, something that high level code has no direct control over.
- unused cached buffers should not prevent a shrink from being started.Quoted 4 lines
Hence we have active references that will form exclusion barriers for operations to be performed on an AG, and passive references that will prevent reclaim of the perag until all objects with passive references have been reclaimed themselves.
Quoted 6 lines
This is going to be fun to rebase the online fsck series on top of. :)
If I'm understanding correctly, active perag refs are for high level code that wants to call down into an AG to do some operation (allocating, freeing, scanning, whatever)? So I think online fsck uniformly wants xfs_perag_grab/rele, right?
That depends. For scrubbing, yes, active references are probably going to be needed. For repair of AG structures where the AG needs to be taken offline, we will likely have to take the AG offline to prevent allocation from being attempted in them. Yes, we currently use the AGF/AGI lock to prevent that, but this results in blocking user applications during allocation until repair is done with the AG. We really want application allocation to naturally skip AGs under repair, not block until the repair is done....
As such, I think the answer is scrub should use active references as it scans, but repair needs to use passive references once the AG has had it's state changed to "offline" as active references will only be available on "fully online" AGs.
Quoted 2 lines
Passive refs are (I think) for lower level code that's wants to call up into an AG to finish off something that was already started?
Yes, like buffers carrying a passive reference to pin the perag while there are cached buffers indexed by the perag buffer hash. Here we only care about the existence of the perag structure, as we need to do IO to the AG metadata regardless of whether the perag is active or not.
Quoted 3 lines
And
probably by upper level code? So the amount of code that actually wants a passive reference is pretty small?
I don't think it's "small" - all the back end code that uses the perag as the root of indexing structures will likely need passive references.
The mental model I'm using is that active references are for tracking user-facing and user-data operations that require perag access. That's things like inode allocation, data extent allocation, etc which will need to skip over AGs that aren't available for storing new user data/metadata at the current time.
Anything that is internal (e.g. metadata buffers, inode cache walks for reclaim) that needs to run regardless of user operation just needs an existence guarantee over the life of the object. This is what passive references provide - the perag cannot be freed from memory while there are still passive references to it.
Hence I'm looking at active references as a mechanism that can provide an access barrier/drain for serialising per-ag operational state changes, not to provide per-ag existence guarantees. Passive references provide low level existence guarantees, active references allow online/offline/no-alloc/shrinking/etc operational state changes to be made safely.
Quoted 9 lines
Quoted 6 lines
This patch introduce xfs_perag_grab()/xfs_perag_rele() as the API for active AG reference functionality. We also need to convert the for_each_perag*() iterators to use active references, which will start the process of converting high level code over to using active references. Conversion of non-iterator based code to active references will be done in followup patches.
Is there any code that iterates perag structures via passive references? I think the answer to this is 'no'?
I think the answer is yes - inode cache walking is a good example of this. That will (eventually) have to grab a passive reference to the perag and check the return - if it fails the perag has just been torn down so we need to skip it. If it succeeds then we have a reference that pins the perag in memory and we can safely walk the inode cache structures in that perag.
Some of the operations that the inode cache walks perform (e.g. block trimming) might need active references to per-ags to perform their work (e.g. because a different AG is offline being repaired and so we cannot free the post-eof blocks without blocking on that offline AG). However, we don't want to skip inode cache walks just because an AG is not allowing new allocations to be made in it....
Quoted 3 lines
The code changes look all right. If the answers to the above questions are "yes", "yes", "yes", and "no", then:
Reviewed-by Darrick J. Wong <[email protected]>
The answers are a whole lot more nuanced than that, unfortunately. Which means that some of the repair infrastructure will need to be done differently as the state changes for shrink are introduced. I don't think there's any show-stoppers here, though.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 8/42 xfs: rework the perag trace points to be perag centric
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
So that they all output the same information in the traces to make debugging refcount issues easier.
This means that all the lookup/drop functions no longer need to use the full memory barrier atomic operations (atomic*_return()) so will have less overhead when tracing is off. The set/clear tag tracepoints no longer abuse the reference count to pass the tag - the tag being cleared is obvious from the _RET_IP_ that is recorded in the trace point.
--- fs/xfs/libxfs/xfs_ag.c | 25 +++++++++---------------- fs/xfs/xfs_icache.c | 4 ++-- fs/xfs/xfs_trace.h | 21 +++++++++++---------- 3 files changed, 22 insertions(+), 28 deletions(-)
fs/xfs/libxfs/xfs_ag.c +9 -16
@@ -44,16 +44,15 @@ xfs_perag_get( xfs_agnumber_t agno) {struct xfs_perag *pag; -int ref =0 ;rcu_read_lock (); pag =radix_tree_lookup (&mp->m_perag_tree, agno);if (pag) { +trace_xfs_perag_get (pag, _RET_IP_);ASSERT (atomic_read (&pag->pag_ref) >=0 ); - ref =atomic_inc_return (&pag->pag_ref); +atomic_inc (&pag->pag_ref); }rcu_read_unlock (); -trace_xfs_perag_get (mp, agno, ref, _RET_IP_);return pag; }
@@ -68,7 +67,6 @@ xfs_perag_get_tag( {struct xfs_perag *pag;int found; -int ref;rcu_read_lock (); found = radix_tree_gang_lookup_tag(&mp->m_perag_tree,
@@ -77,9 +75,9 @@ xfs_perag_get_tag(rcu_read_unlock ();return NULL ; } - ref =atomic_inc_return (&pag->pag_ref); +trace_xfs_perag_get_tag (pag, _RET_IP_); +atomic_inc (&pag->pag_ref);rcu_read_unlock (); -trace_xfs_perag_get_tag (mp, pag->pag_agno, ref, _RET_IP_);return pag; }
@@ -87,11 +85,9 @@ voidxfs_perag_put ( struct xfs_perag *pag) { -int ref; - +trace_xfs_perag_put (pag, _RET_IP_);ASSERT (atomic_read (&pag->pag_ref) >0 ); - ref =atomic_dec_return (&pag->pag_ref); -trace_xfs_perag_put (pag->pag_mount, pag->pag_agno, ref, _RET_IP_); +atomic_dec (&pag->pag_ref); }/*
@@ -110,8 +106,7 @@ xfs_perag_grab(rcu_read_lock (); pag =radix_tree_lookup (&mp->m_perag_tree, agno);if (pag) { -trace_xfs_perag_grab (mp, pag->pag_agno, -atomic_read (&pag->pag_active_ref), _RET_IP_); +trace_xfs_perag_grab (pag, _RET_IP_);if (!atomic_inc_not_zero (&pag->pag_active_ref)) pag =NULL ; }
@@ -138,8 +133,7 @@ xfs_perag_grab_tag(rcu_read_unlock ();return NULL ; } -trace_xfs_perag_grab_tag (mp, pag->pag_agno, -atomic_read (&pag->pag_active_ref), _RET_IP_); +trace_xfs_perag_grab_tag (pag, _RET_IP_);if (!atomic_inc_not_zero (&pag->pag_active_ref)) pag =NULL ;rcu_read_unlock ();
@@ -150,8 +144,7 @@ voidxfs_perag_rele ( struct xfs_perag *pag) { -trace_xfs_perag_rele (pag->pag_mount, pag->pag_agno, -atomic_read (&pag->pag_active_ref), _RET_IP_); +trace_xfs_perag_rele (pag, _RET_IP_);if (atomic_dec_and_test (&pag->pag_active_ref))wake_up (&pag->pag_active_wq); }
fs/xfs/xfs_icache.c +2 -2
@@ -255,7 +255,7 @@ xfs_perag_set_inode_tag(break ; } -trace_xfs_perag_set_inode_tag (mp, pag->pag_agno, tag, _RET_IP_); +trace_xfs_perag_set_inode_tag (pag, _RET_IP_); }/* Clear a tag on both the AG incore inode tree and the AG radix tree. */
@@ -289,7 +289,7 @@ xfs_perag_clear_inode_tag(radix_tree_tag_clear (&mp->m_perag_tree, pag->pag_agno, tag);spin_unlock (&mp->m_perag_lock); -trace_xfs_perag_clear_inode_tag (mp, pag->pag_agno, tag, _RET_IP_); +trace_xfs_perag_clear_inode_tag (pag, _RET_IP_); }/*
fs/xfs/xfs_trace.h +11 -10
@@ -159,33 +159,34 @@ TRACE_EVENT(xlog_intent_recovery_failed, );DECLARE_EVENT_CLASS (xfs_perag_class, - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int refcount, - unsigned long caller_ip), -TP_ARGS (mp, agno, refcount, caller_ip), + TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), +TP_ARGS (pag, caller_ip),TP_STRUCT__entry ( __field(dev_t, dev) __field(xfs_agnumber_t, agno) __field(int, refcount) + __field(int, active_refcount) __field(unsigned long, caller_ip) ),TP_fast_assign ( - __entry->dev = mp->m_super->s_dev; - __entry->agno = agno; - __entry->refcount = refcount; + __entry->dev = pag->pag_mount->m_super->s_dev; + __entry->agno = pag->pag_agno; + __entry->refcount = atomic_read(&pag->pag_ref); + __entry->active_refcount = atomic_read(&pag->pag_active_ref); __entry->caller_ip = caller_ip; ), -TP_printk ("dev %d:%d agno 0x%x refcount %d caller %pS" , +TP_printk ("dev %d:%d agno 0x%x passive refs %d active refs %d caller %pS" ,MAJOR (__entry->dev),MINOR (__entry->dev), __entry->agno, __entry->refcount, + __entry->active_refcount, (char *)__entry->caller_ip) );#define DEFINE_PERAG_REF_EVENT (name) \ DEFINE_EVENT(xfs_perag_class, name, \ - TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int refcount, \ - unsigned long caller_ip), \ - TP_ARGS(mp, agno, refcount, caller_ip)) + TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), \ + TP_ARGS(pag, caller_ip))DEFINE_PERAG_REF_EVENT (xfs_perag_get);DEFINE_PERAG_REF_EVENT (xfs_perag_get_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_put);
Signature · 1 line
2.39.0
Re: [PATCH 08/42] xfs: rework the perag trace points to be perag centric
Quoted 5 lines · Dave Chinner
From: Dave Chinner <[email protected]>
So that they all output the same information in the traces to make debugging refcount issues easier.
Quoted 8 lines
This means that all the lookup/drop functions no longer need to use the full memory barrier atomic operations (atomic*_return()) so will have less overhead when tracing is off. The set/clear tag tracepoints no longer abuse the reference count to pass the tag - the tag being cleared is obvious from the _RET_IP_ that is recorded in the trace point.
Signed-off-by Dave Chinner <[email protected]>
Ok, makes sense
Quoted 173 lines
fs/xfs/libxfs/xfs_ag.c | 25 +++++++++---------------- fs/xfs/xfs_icache.c | 4 ++-- fs/xfs/xfs_trace.h | 21 +++++++++++----------
3 files changed, 22 insertions(+), 28 deletions(-)fs/xfs/libxfs/xfs_ag.c +0
-1@@ -44,16 +44,15 @@ xfs_perag_get( xfs_agnumber_t agno) { struct xfs_perag *pag; - int ref = 0;
rcu_read_lock();
pag =radix_tree_lookup(&mp->m_perag_tree, agno); if (pag) {
+ trace_xfs_perag_get(pag, _RET_IP_);ASSERT(atomic_read(&pag->pag_ref) >= 0); - ref =atomic_inc_return(&pag->pag_ref); + atomic_inc(&pag->pag_ref);
}
rcu_read_unlock();
- trace_xfs_perag_get(mp, agno, ref, _RET_IP_); return pag;
}fs/xfs/libxfs/xfs_ag.c +0
-1@@ -68,7 +67,6 @@ xfs_perag_get_tag( { struct xfs_perag *pag; int found; - int ref;
rcu_read_lock();
found = radix_tree_gang_lookup_tag(&mp->m_perag_tree,fs/xfs/libxfs/xfs_ag.c +2
-2@@ -77,9 +75,9 @@ xfs_perag_get_tag( rcu_read_unlock(); return NULL; } - ref = atomic_inc_return(&pag->pag_ref); + trace_xfs_perag_get_tag(pag, _RET_IP_); + atomic_inc(&pag->pag_ref); rcu_read_unlock(); - trace_xfs_perag_get_tag(mp, pag->pag_agno, ref, _RET_IP_); return pag; }fs/xfs/libxfs/xfs_ag.c +0
-0@@ -87,11 +85,9 @@ voidxfs_perag_put(
struct xfs_perag *pag)
{
- int ref;
-
+ trace_xfs_perag_put(pag, _RET_IP_);ASSERT(atomic_read(&pag->pag_ref) > 0);
- ref =atomic_dec_return(&pag->pag_ref);
- trace_xfs_perag_put(pag->pag_mount,pag->pag_agno, ref, _RET_IP_);
+ atomic_dec(&pag->pag_ref);
}
/*fs/xfs/libxfs/xfs_ag.c +1
-2@@ -110,8 +106,7 @@ xfs_perag_grab( rcu_read_lock(); pag = radix_tree_lookup(&mp->m_perag_tree, agno); if (pag) { - trace_xfs_perag_grab(mp, pag->pag_agno, - atomic_read(&pag->pag_active_ref), _RET_IP_); + trace_xfs_perag_grab(pag, _RET_IP_); if (!atomic_inc_not_zero(&pag->pag_active_ref)) pag = NULL;}
fs/xfs/libxfs/xfs_ag.c +1
-2@@ -138,8 +133,7 @@ xfs_perag_grab_tag( rcu_read_unlock(); return NULL; } - trace_xfs_perag_grab_tag(mp, pag->pag_agno, - atomic_read(&pag->pag_active_ref), _RET_IP_); + trace_xfs_perag_grab_tag(pag, _RET_IP_); if (!atomic_inc_not_zero(&pag->pag_active_ref)) pag = NULL; rcu_read_unlock();@@ -150,8 +144,7 @@ voidxfs_perag_rele(
struct xfs_perag *pag)
{
- trace_xfs_perag_rele(pag->pag_mount,pag->pag_agno, - atomic_read(&pag->pag_active_ref), _RET_IP_); + trace_xfs_perag_rele(pag, _RET_IP_);
if (atomic_dec_and_test(&pag->pag_active_ref))wake_up(&pag->pag_active_wq);
}fs/xfs/xfs_icache.c +0
-0@@ -255,7 +255,7 @@ xfs_perag_set_inode_tag( break; }
- trace_xfs_perag_set_inode_tag(mp,pag->pag_agno, tag, _RET_IP_);
+ trace_xfs_perag_set_inode_tag(pag, _RET_IP_);
}
/* Clear a tag on both the AG incore inode tree and the AG radix tree. */fs/xfs/xfs_icache.c +0
-0@@ -289,7 +289,7 @@ xfs_perag_clear_inode_tag( radix_tree_tag_clear(&mp->m_perag_tree, pag->pag_agno, tag); spin_unlock(&mp->m_perag_lock);
- trace_xfs_perag_clear_inode_tag(mp,pag->pag_agno, tag, _RET_IP_);
+ trace_xfs_perag_clear_inode_tag(pag, _RET_IP_); }
/*fs/xfs/xfs_trace.h +0
-0@@ -159,33 +159,34 @@ TRACE_EVENT(xlog_intent_recovery_failed, );
DECLARE_EVENT_CLASS(xfs_perag_class,
- TP_PROTO(structxfs_mount*mp,xfs_agnumber_tagno, int refcount,
- unsigned longcaller_ip),
- TP_ARGS(mp, agno, refcount,caller_ip),
+ TP_PROTO(structxfs_perag*pag, unsigned longcaller_ip), + TP_ARGS(pag,caller_ip),
TP_STRUCT__entry(
__field(dev_t, dev)__field(xfs_agnumber_t, agno)__field(int, refcount)
+ __field(int,active_refcount)__field(unsigned long, caller_ip)
),
TP_fast_assign(
- __entry->dev =mp->m_super->s_dev;
- __entry->agno = agno;
- __entry->refcount = refcount;
+ __entry->dev =pag->pag_mount->m_super->s_dev; + __entry->agno =pag->pag_agno;
+ __entry->refcount =atomic_read(&pag->pag_ref); + __entry->active_refcount = atomic_read(&pag-Quoted 1 line
pag_active_ref);__entry->caller_ip =
caller_ip;
),
- TP_printk("dev %d:%d agno 0x%x refcount %d caller %pS", + TP_printk("dev %d:%d agno 0x%x passive refs %d active refs %d caller %pS",
MAJOR(__entry->dev),MINOR(__entry->dev),__entry->agno,
__entry->refcount,
+__entry->active_refcount,
(char *)__entry->caller_ip)
);
#define DEFINE_PERAG_REF_EVENT(name) \
DEFINE_EVENT(xfs_perag_class, name, \
- TP_PROTO(structxfs_mount*mp,xfs_agnumber_tagno, int refcount, \
- unsigned long
caller_ip), \
- TP_ARGS(mp, agno, refcount,caller_ip))
+ TP_PROTO(structxfs_perag*pag, unsigned longcaller_ip), \
+ TP_ARGS(pag,caller_ip))DEFINE_PERAG_REF_EVENT(xfs_perag_get);DEFINE_PERAG_REF_EVENT(xfs_perag_get_tag);DEFINE_PERAG_REF_EVENT(xfs_perag_put);
PATCH 9/42 xfs: convert xfs_imap() to take a perag
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Callers have referenced perags but they don't pass it into xfs_imap() so it takes it's own reference. Fix that so we can change inode allocation over to using active references.
--- fs/xfs/libxfs/xfs_ialloc.c | 43 +++++++++++++------------------------- fs/xfs/libxfs/xfs_ialloc.h | 3 ++- fs/xfs/scrub/common.c | 13 ++++++++---- fs/xfs/xfs_icache.c | 2 +- 4 files changed, 27 insertions(+), 34 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +15 -28
@@ -2217,15 +2217,15 @@ xfs_difree( STATIC intxfs_imap_lookup ( -struct xfs_mount *mp, -struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_trans *tp,xfs_agino_t agino,xfs_agblock_t agbno,xfs_agblock_t *chunk_agbno,xfs_agblock_t *offset_agbno,int flags) { +struct xfs_mount *mp = pag->pag_mount;struct xfs_inobt_rec_incore rec;struct xfs_btree_cur *cur;struct xfs_buf *agbp;
@@ -2280,12 +2280,13 @@ xfs_imap_lookup(*/ int xfs_imap ( -struct xfs_mount *mp,/* file system mount structure */ +struct xfs_perag *pag,struct xfs_trans *tp,/* transaction pointer */ xfs_ino_t ino,/* inode to locate */ struct xfs_imap *imap,/* location map structure */ uint flags)/* flags for inode btree lookup */ { +struct xfs_mount *mp = pag->pag_mount;xfs_agblock_t agbno;/* block number of inode in the alloc group */ xfs_agino_t agino;/* inode number within alloc group */ xfs_agblock_t chunk_agbno;/* first block in inode chunk */
@@ -2293,17 +2294,15 @@ xfs_imap(int error;/* error code */ int offset;/* index of inode in its buffer */ xfs_agblock_t offset_agbno;/* blks from chunk start to inode */ -struct xfs_perag *pag;ASSERT (ino !=NULLFSINO );/* * Split up the inode number into its parts. */ - pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ino)); agino =XFS_INO_TO_AGINO (mp, ino); agbno =XFS_AGINO_TO_AGBNO (mp, agino); -if (!pag || agbno >= mp->m_sb.sb_agblocks || +if (agbno >= mp->m_sb.sb_agblocks || ino !=XFS_AGINO_TO_INO (mp, pag->pag_agno, agino)) { error = -EINVAL ;#ifdef DEBUG
@@ -2312,20 +2311,14 @@ xfs_imap(* as they can be invalid without implying corruption. */ if (flags &XFS_IGET_UNTRUSTED ) - goto out_drop; -if (!pag) { -xfs_alert (mp, -"%s: agno (%d) >= mp->m_sb.sb_agcount (%d)" , - __func__,XFS_INO_TO_AGNO (mp, ino), - mp->m_sb.sb_agcount); - } +return error;if (agbno >= mp->m_sb.sb_agblocks) {xfs_alert (mp,"%s: agbno (0x%llx) >= mp->m_sb.sb_agblocks (0x%lx)" , __func__, (unsigned long long )agbno, (unsigned long )mp->m_sb.sb_agblocks); } -if (pag && ino !=XFS_AGINO_TO_INO (mp, pag->pag_agno, agino)) { +if (ino !=XFS_AGINO_TO_INO (mp, pag->pag_agno, agino)) { xfs_alert(mp, "%s: ino (0x%llx) != XFS_AGINO_TO_INO() (0x%llx)", __func__, ino,
@@ -2333,7 +2326,7 @@ xfs_imap( }xfs_stack_trace ();#endif /* DEBUG */ - goto out_drop; +return error; }/*
@@ -2344,10 +2337,10 @@ xfs_imap(* in all cases where an untrusted inode number is passed. */ if (flags &XFS_IGET_UNTRUSTED ) { - error =xfs_imap_lookup (mp, tp, pag, agino, agbno, + error =xfs_imap_lookup (pag, tp, agino, agbno, &chunk_agbno, &offset_agbno, flags);if (error) - goto out_drop; +return error; goto out_map; }
@@ -2363,8 +2356,7 @@ xfs_imap( imap->im_len =XFS_FSB_TO_BB (mp,1 ); imap->im_boffset = (unsigned short )(offset << mp->m_sb.sb_inodelog); - error =0 ; - goto out_drop; +return 0 ; }/*
@@ -2376,10 +2368,10 @@ xfs_imap( offset_agbno = agbno &M_IGEO (mp)->inoalign_mask; chunk_agbno = agbno - offset_agbno; }else { - error =xfs_imap_lookup (mp, tp, pag, agino, agbno, + error =xfs_imap_lookup (pag, tp, agino, agbno, &chunk_agbno, &offset_agbno, flags);if (error) - goto out_drop; +return error; } out_map:
@@ -2407,14 +2399,9 @@ xfs_imap( __func__, (unsigned long long ) imap->im_blkno, (unsigned long long ) imap->im_len, XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)); - error = -EINVAL ; - goto out_drop; +return -EINVAL ; } - error =0 ; -out_drop: -if (pag) -xfs_perag_put (pag); -return error; +return 0 ; }/*
fs/xfs/libxfs/xfs_ialloc.h +2 -1
@@ -12,6 +12,7 @@ struct xfs_imap;struct xfs_mount ;struct xfs_trans ;struct xfs_btree_cur ; +struct xfs_perag ;/* Move inodes in clusters of this size */ #define XFS_INODE_BIG_CLUSTER_SIZE 8192
@@ -47,7 +48,7 @@ int xfs_difree(struct xfs_trans *tp, struct xfs_perag *pag,*/ int xfs_imap( - struct xfs_mount *mp, /* file system mount structure */ + struct xfs_perag *pag, struct xfs_trans *tp, /* transaction pointer */ xfs_ino_t ino, /* inode to locate */ struct xfs_imap *imap, /* location map structure */
fs/xfs/scrub/common.c +9 -4
@@ -636,6 +636,7 @@ xchk_get_inode( {struct xfs_imap imap;struct xfs_mount *mp = sc->mp; +struct xfs_perag *pag;struct xfs_inode *ip_in =XFS_I (file_inode (sc->file));struct xfs_inode *ip =NULL ;int error;
@@ -671,10 +672,14 @@ xchk_get_inode(* Otherwise, we really couldn't find it so tell userspace * that it no longer exists. */ - error =xfs_imap (sc->mp, sc->tp, sc->sm->sm_ino, &imap, -XFS_IGET_UNTRUSTED |XFS_IGET_DONTCACHE ); -if (error) -return -ENOENT ; + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, sc->sm->sm_ino)); +if (pag) { + error =xfs_imap (pag, sc->tp, sc->sm->sm_ino, &imap, +XFS_IGET_UNTRUSTED |XFS_IGET_DONTCACHE ); +xfs_perag_put (pag); +if (error) +return -ENOENT ; + } error = -EFSCORRUPTED ; fallthrough;default :
fs/xfs/xfs_icache.c +1 -1
@@ -586,7 +586,7 @@ xfs_iget_cache_miss(if (!ip)return -ENOMEM ; - error =xfs_imap (mp, tp, ip->i_ino, &ip->i_imap, flags); + error =xfs_imap (pag, tp, ip->i_ino, &ip->i_imap, flags);if (error) goto out_destroy;
Signature · 1 line
2.39.0
Re: [PATCH 09/42] xfs: convert xfs_imap() to take a perag
Quoted 37 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Callers have referenced perags but they don't pass it into
xfs_imap()so it takes it's own reference. Fix that so we can change inode allocation over to using active references.Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_ialloc.c | 43 +++++++++++++------------------------- fs/xfs/libxfs/xfs_ialloc.h | 3 ++- fs/xfs/scrub/common.c | 13 ++++++++---- fs/xfs/xfs_icache.c | 2 +- 4 files changed, 27 insertions(+), 34 deletions(-)fs/xfs/libxfs/xfs_ialloc.c +2
-2@@ -2217,15 +2217,15 @@ xfs_difree( STATIC intxfs_imap_lookup ( -struct xfs_mount *mp, -struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_trans *tp,xfs_agino_t agino,xfs_agblock_t agbno,xfs_agblock_t *chunk_agbno,xfs_agblock_t *offset_agbno,int flags) { +struct xfs_mount *mp = pag->pag_mount;struct xfs_inobt_rec_incore rec;struct xfs_btree_cur *cur;struct xfs_buf *agbp;
fs/xfs/libxfs/xfs_ialloc.c xfs_imap_lookup( · line 2284
Quoted 6 lines
fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -2280,12 +2280,13 @@ xfs_imap_lookup(*/ int xfs_imap( - struct xfs_mount *mp, /* file system mount structure */ + struct xfs_perag *pag, struct xfs_trans *tp, /* transaction pointer */
Stupid nit: fix the extra space ^ problem here.
--D
Quoted 180 lines
fs/xfs/libxfs/xfs_ialloc.c +12
-25xfs_ino_t ino,/* inode to locate */ struct xfs_imap *imap, /* location map structure */ uint flags) /* flags for inode btree lookup */ { + struct xfs_mount *mp = pag->pag_mount;xfs_agblock_t agbno;/* block number of inode in the alloc group */ xfs_agino_t agino;/* inode number within alloc group */ xfs_agblock_t chunk_agbno;/* first block in inode chunk */ @@ -2293,17 +2294,15 @@ xfs_imap(int error;/* error code */ int offset;/* index of inode in its buffer */ xfs_agblock_t offset_agbno;/* blks from chunk start to inode */ -struct xfs_perag *pag;ASSERT (ino !=NULLFSINO );/* * Split up the inode number into its parts. */ - pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ino)); agino =XFS_INO_TO_AGINO (mp, ino); agbno =XFS_AGINO_TO_AGBNO (mp, agino); -if (!pag || agbno >= mp->m_sb.sb_agblocks || +if (agbno >= mp->m_sb.sb_agblocks || ino !=XFS_AGINO_TO_INO (mp, pag->pag_agno, agino)) { error = -EINVAL ;#ifdef DEBUG @@ -2312,20 +2311,14 @@ xfs_imap(* as they can be invalid without implying corruption. */ if (flags &XFS_IGET_UNTRUSTED ) - goto out_drop; -if (!pag) { -xfs_alert (mp, -"%s: agno (%d) >= mp->m_sb.sb_agcount (%d)" , - __func__,XFS_INO_TO_AGNO (mp, ino), - mp->m_sb.sb_agcount); - } +return error;if (agbno >= mp->m_sb.sb_agblocks) {xfs_alert (mp,"%s: agbno (0x%llx) >= mp->m_sb.sb_agblocks (0x%lx)" , __func__, (unsigned long long )agbno, (unsigned long )mp->m_sb.sb_agblocks); } -if (pag && ino !=XFS_AGINO_TO_INO (mp, pag->pag_agno, agino)) { +if (ino !=XFS_AGINO_TO_INO (mp, pag->pag_agno, agino)) { xfs_alert(mp, "%s: ino (0x%llx) != XFS_AGINO_TO_INO() (0x%llx)", __func__, ino,@@ -2333,7 +2326,7 @@ xfs_imap( }xfs_stack_trace ();#endif /* DEBUG */ - goto out_drop; +return error; }/* @@ -2344,10 +2337,10 @@ xfs_imap(* in all cases where an untrusted inode number is passed. */ if (flags &XFS_IGET_UNTRUSTED ) { - error =xfs_imap_lookup (mp, tp, pag, agino, agbno, + error =xfs_imap_lookup (pag, tp, agino, agbno, &chunk_agbno, &offset_agbno, flags);if (error) - goto out_drop; +return error; goto out_map; }@@ -2363,8 +2356,7 @@ xfs_imap( imap->im_len =XFS_FSB_TO_BB (mp,1 ); imap->im_boffset = (unsigned short )(offset << mp->m_sb.sb_inodelog); - error =0 ; - goto out_drop; +return 0 ; }/* @@ -2376,10 +2368,10 @@ xfs_imap( offset_agbno = agbno &M_IGEO (mp)->inoalign_mask; chunk_agbno = agbno - offset_agbno; }else { - error =xfs_imap_lookup (mp, tp, pag, agino, agbno, + error =xfs_imap_lookup (pag, tp, agino, agbno, &chunk_agbno, &offset_agbno, flags);if (error) - goto out_drop; +return error; } out_map:@@ -2407,14 +2399,9 @@ xfs_imap( __func__, (unsigned long long ) imap->im_blkno, (unsigned long long ) imap->im_len, XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)); - error = -EINVAL ; - goto out_drop; +return -EINVAL ; } - error =0 ; -out_drop: -if (pag) -xfs_perag_put (pag); -return error; +return 0 ; }/* fs/xfs/libxfs/xfs_ialloc.h +2
-1@@ -12,6 +12,7 @@ struct xfs_imap;struct xfs_mount ;struct xfs_trans ;struct xfs_btree_cur ; +struct xfs_perag ;/* Move inodes in clusters of this size */ #define XFS_INODE_BIG_CLUSTER_SIZE 8192@@ -47,7 +48,7 @@ int xfs_difree(struct xfs_trans *tp, struct xfs_perag *pag,*/ int xfs_imap( - struct xfs_mount *mp, /* file system mount structure */ + struct xfs_perag *pag, struct xfs_trans *tp, /* transaction pointer */ xfs_ino_t ino, /* inode to locate */ struct xfs_imap *imap, /* location map structure */fs/xfs/scrub/common.c +9
-4@@ -636,6 +636,7 @@ xchk_get_inode( {struct xfs_imap imap;struct xfs_mount *mp = sc->mp; +struct xfs_perag *pag;struct xfs_inode *ip_in =XFS_I (file_inode (sc->file));struct xfs_inode *ip =NULL ;int error;@@ -671,10 +672,14 @@ xchk_get_inode(* Otherwise, we really couldn't find it so tell userspace * that it no longer exists. */ - error =xfs_imap (sc->mp, sc->tp, sc->sm->sm_ino, &imap, -XFS_IGET_UNTRUSTED |XFS_IGET_DONTCACHE ); -if (error) -return -ENOENT ; + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, sc->sm->sm_ino)); +if (pag) { + error =xfs_imap (pag, sc->tp, sc->sm->sm_ino, &imap, +XFS_IGET_UNTRUSTED |XFS_IGET_DONTCACHE ); +xfs_perag_put (pag); +if (error) +return -ENOENT ; + } error = -EFSCORRUPTED ; fallthrough;default :fs/xfs/xfs_icache.c +1
-1@@ -586,7 +586,7 @@ xfs_iget_cache_miss(if (!ip)return -ENOMEM ; - error =xfs_imap (mp, tp, ip->i_ino, &ip->i_imap, flags); + error =xfs_imap (pag, tp, ip->i_ino, &ip->i_imap, flags);if (error) goto out_destroy;Signature · 1 line
2.39.0
PATCH 10/42 xfs: use active perag references for inode allocation
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Convert the inode allocation routines to use active perag references or references held by callers rather than grab their own. Also drive the perag further inwards to replace xfs_mounts when doing operations on a specific AG.
--- fs/xfs/libxfs/xfs_ag.c | 3 +- fs/xfs/libxfs/xfs_ialloc.c | 63 +++++++++++++++++++------------------- fs/xfs/libxfs/xfs_ialloc.h | 2 +- 3 files changed, 33 insertions(+), 35 deletions(-)
fs/xfs/libxfs/xfs_ag.c +1 -2
@@ -925,8 +925,7 @@ xfs_ag_shrink_space(* Make sure that the last inode cluster cannot overlap with the new * end of the AG, even if it's sparse. */ - error =xfs_ialloc_check_shrink (*tpp, pag->pag_agno, agibp, - aglen - delta); + error =xfs_ialloc_check_shrink (pag, *tpp, agibp, aglen - delta);if (error)return error;
fs/xfs/libxfs/xfs_ialloc.c +31 -32
246 lines not on this page · raw message
fs/xfs/libxfs/xfs_ialloc.h +1 -1
@@ -107,7 +107,7 @@ int xfs_ialloc_cluster_alignment(struct xfs_mount *mp);void xfs_ialloc_setup_geometry (struct xfs_mount *mp);xfs_ino_t xfs_ialloc_calc_rootino (struct xfs_mount *mp,int sunit); -int xfs_ialloc_check_shrink (struct xfs_trans *tp,xfs_agnumber_t agno, +int xfs_ialloc_check_shrink (struct xfs_perag *pag,struct xfs_trans *tp,struct xfs_buf *agibp,xfs_agblock_t new_length);#endif /* __XFS_IALLOC_H__ */
Signature · 1 line
2.39.0
Re: [PATCH 10/42] xfs: use active perag references for inode allocation
Quoted 8 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Convert the inode allocation routines to use active perag references or references held by callers rather than grab their own. Also drive the perag further inwards to replace
xfs_mountswhen doing operations on a specific AG.Signed-off-by Dave Chinner <[email protected]>
Ok, looks ok to me
Quoted 333 lines
---
fs/xfs/libxfs/xfs_ag.c | 3 +-fs/xfs/libxfs/xfs_ialloc.c| 63 +++++++++++++++++++----------------- --
fs/xfs/libxfs/xfs_ialloc.h | 2 +-3 files changed, 33 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_ag.c +0
-0@@ -925,8 +925,7 @@ xfs_ag_shrink_space( * Make sure that the last inode cluster cannot overlap withthe new
* end of the AG, even if it's sparse.
*/
- error =xfs_ialloc_check_shrink(*tpp, pag->pag_agno, agibp, - aglen - delta);
+ error =xfs_ialloc_check_shrink(pag, *tpp, agibp, aglen - delta);
if (error)
return error;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -169,14 +169,14 @@ xfs_inobt_insert_rec(*/ STATIC int
xfs_inobt_insert(
- struct xfs_mount *mp,
+ struct xfs_perag *pag,
struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag, xfs_agino_t newino, xfs_agino_t newlen, xfs_btnum_t btnum)
{
+ struct xfs_mount *mp =pag->pag_mount; struct xfs_btree_cur *cur; xfs_agino_t thisino;
int i;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -514,14 +514,14 @@ __xfs_inobt_rec_merge(*/ STATIC int
xfs_inobt_insert_sprec(
- struct xfs_mount *mp,
+ struct xfs_perag *pag,
struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag,
int btnum,
struct xfs_inobt_rec_incore *nrec, /* in/out: new/merged rec. */
bool merge) /* merge or replace */
{
+ struct xfs_mount *mp =pag->pag_mount; struct xfs_btree_cur *cur;
int error;
int i;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -609,9 +609,9 @@ xfs_inobt_insert_sprec(*/ STATIC int
xfs_ialloc_ag_alloc(
+ struct xfs_perag *pag,
struct xfs_trans *tp,
- struct xfs_buf *agbp,
- struct xfs_perag *pag)
+ struct xfs_buf *agbp)
{
struct xfs_agi *agi;
struct xfs_alloc_arg args;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -831,7 +831,7 @@ xfs_ialloc_ag_alloc( * if necessary. If a merge does occur, rec isupdated to the
* merged record.
*/
- error = xfs_inobt_insert_sprec(args.mp, tp, agbp, pag,
+ error =xfs_inobt_insert_sprec(pag, tp, agbp, XFS_BTNUM_INO, &rec, true); if (error ==-EFSCORRUPTED) { xfs_alert(args.mp,fs/xfs/libxfs/xfs_ialloc.c +2
-2@@ -856,20 +856,20 @@ xfs_ialloc_ag_alloc(* existing record with this one. */ if (xfs_has_finobt(args.mp)) { - error = xfs_inobt_insert_sprec(args.mp, tp, agbp, pag, + error = xfs_inobt_insert_sprec(pag, tp, agbp, XFS_BTNUM_FINO, &rec, false); if (error) return error; } } else { /* full chunk - insert new records to both btrees */ - error = xfs_inobt_insert(args.mp, tp, agbp, pag, newino, newlen, + error = xfs_inobt_insert(pag, tp, agbp, newino, newlen, XFS_BTNUM_INO); if (error) return error;
if (xfs_has_finobt(args.mp)) {
- error = xfs_inobt_insert(args.mp, tp, agbp, pag, newino,
+ error = xfs_inobt_insert(pag, tp, agbp, newino,
newlen,XFS_BTNUM_FINO);
if (error)
return error;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -981,9 +981,9 @@ xfs_inobt_first_free_inode(*/ STATIC int
xfs_dialloc_ag_inobt(
+ struct xfs_perag *pag,
struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag,
xfs_ino_t parent,
xfs_ino_t *inop)
{fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1429,9 +1429,9 @@ xfs_dialloc_ag_update_inobt(*/ static int
xfs_dialloc_ag(
+ struct xfs_perag *pag,
struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag,
xfs_ino_t parent,
xfs_ino_t *inop)
{fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1448,7 +1448,7 @@ xfs_dialloc_ag( int i;
if (!xfs_has_finobt(mp))
- returnxfs_dialloc_ag_inobt(tp, agbp, pag, parent, inop);
+ returnxfs_dialloc_ag_inobt(pag, tp, agbp, parent, inop);
/*
* If pagino is 0 (this is the root inode allocation) use newino.fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1594,8 +1594,8 @@ xfs_ialloc_next_ag(
static bool
xfs_dialloc_good_ag(
- struct xfs_trans *tp,
struct xfs_perag *pag,
+ struct xfs_trans *tp,
umode_t mode,
int flags,
bool ok_alloc)fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1606,6 +1606,8 @@ xfs_dialloc_good_ag( int needspace; int error;
+ if (!pag)
+ return false;
if (!pag->pagi_inodeok)
return false;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1665,8 +1667,8 @@ xfs_dialloc_good_ag(
static int
xfs_dialloc_try_ag(
- struct xfs_trans **tpp,
struct xfs_perag *pag,
+ struct xfs_trans **tpp,
xfs_ino_t parent,
xfs_ino_t *new_ino,
bool ok_alloc)fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1689,7 +1691,7 @@ xfs_dialloc_try_ag( goto out_release; }
- error =xfs_ialloc_ag_alloc(*tpp, agbp, pag); + error =xfs_ialloc_ag_alloc(pag, *tpp, agbp); if (error < 0)
gotoout_release;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1705,7 +1707,7 @@ xfs_dialloc_try_ag( }
/* Allocate an inode in the found AG */
- error =xfs_dialloc_ag(*tpp, agbp, pag, parent, &ino); + error =xfs_dialloc_ag(pag, *tpp, agbp, parent, &ino); if (!error)
*new_ino = ino;
return error;fs/xfs/libxfs/xfs_ialloc.c +3
-3@@ -1790,9 +1792,9 @@ xfs_dialloc( agno = start_agno; flags = XFS_ALLOC_FLAG_TRYLOCK; for (;;) { - pag = xfs_perag_get(mp, agno); - if (xfs_dialloc_good_ag(*tpp, pag, mode, flags, ok_alloc)) { - error = xfs_dialloc_try_ag(tpp, pag, parent, + pag = xfs_perag_grab(mp, agno); + if (xfs_dialloc_good_ag(pag, *tpp, mode, flags, ok_alloc)) { + error = xfs_dialloc_try_ag(pag, tpp, parent, &ino, ok_alloc);if (error !=
-EAGAIN)
break;fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -1813,12 +1815,12 @@ xfs_dialloc( if (low_space) ok_alloc = true; } - xfs_perag_put(pag); + xfs_perag_rele(pag); }
if (!error)
*new_ino = ino;
- xfs_perag_put(pag);
+ xfs_perag_rele(pag);
return error;
}fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1902,14 +1904,14 @@ xfs_difree_inode_chunk(
STATIC int
xfs_difree_inobt(
- struct xfs_mount *mp,
+ struct xfs_perag *pag, struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag, xfs_agino_t agino, struct xfs_icluster *xic, struct xfs_inobt_rec_incore *orec)
{
+ struct xfs_mount *mp =pag->pag_mount; struct xfs_agi *agi =agbp->b_addr; struct xfs_btree_cur *cur; struct xfs_inobt_rec_incore rec;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2036,13 +2038,13 @@ xfs_difree_inobt(*/ STATIC int
xfs_difree_finobt(
- struct xfs_mount *mp,
+ struct xfs_perag *pag,
struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag, xfs_agino_t agino,
struct xfs_inobt_rec_incore *ibtrec) /* inobt record */ {
+ struct xfs_mount *mp =pag->pag_mount; struct xfs_btree_cur *cur;
struct xfs_inobt_rec_incore rec;
int offset = agino - ibtrec-Quoted 1 line
ir_startino;fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -2196,7 +2198,7 @@ xfs_difree( /** Fix up the inode allocation btree. */ - error = xfs_difree_inobt(mp, tp, agbp, pag, agino, xic, &rec); + error = xfs_difree_inobt(pag, tp, agbp, agino, xic, &rec); if (error) goto error0;fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -2204,7 +2206,7 @@ xfs_difree(* Fix up the free inode btree. */ if (xfs_has_finobt(mp)) { - error = xfs_difree_finobt(mp, tp, agbp, pag, agino, &rec); + error = xfs_difree_finobt(pag, tp, agbp, agino, &rec); if (error)goto error0;
}fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2928,15 +2930,14 @@ xfs_ialloc_calc_rootino(*/ int
xfs_ialloc_check_shrink(
+ struct xfs_perag *pag,
struct xfs_trans *tp,
- xfs_agnumber_t agno,
struct xfs_buf *agibp, xfs_agblock_t new_length)
{
structxfs_inobt_rec_incorerec;
struct xfs_btree_cur *cur;
struct xfs_mount *mp =tp->t_mountp; - struct xfs_perag *pag;
xfs_agino_t agino =XFS_AGB_TO_AGINO(mp, new_length);
int has;
int error;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2944,7 +2945,6 @@ xfs_ialloc_check_shrink( if (!xfs_has_sparseinodes(mp)) return 0;
- pag =xfs_perag_get(mp, agno);
cur =xfs_inobt_init_cursor(mp, tp, agibp, pag, XFS_BTNUM_INO);
/* Look up the inobt record that would correspond to the new EOFS. */fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2968,6 +2968,5 @@ xfs_ialloc_check_shrink( }out:
xfs_btree_del_cursor(cur, error);
- xfs_perag_put(pag);
return error;
}fs/xfs/libxfs/xfs_ialloc.h +0
-0@@ -107,7 +107,7 @@ int xfs_ialloc_cluster_alignment(struct xfs_mount *mp); void xfs_ialloc_setup_geometry(struct xfs_mount *mp); xfs_ino_t xfs_ialloc_calc_rootino(struct xfs_mount *mp, int sunit);
-int xfs_ialloc_check_shrink(structxfs_trans*tp,xfs_agnumber_tagno,
+int xfs_ialloc_check_shrink(structxfs_perag*pag, structxfs_trans*tp,
structxfs_buf*agibp,xfs_agblock_tnew_length);
#endif /*__XFS_IALLOC_H__*/
PATCH 11/42 xfs: inobt can use perags in many more places than it does
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Lots of code in the inobt infrastructure is passed both xfs_mount and perags. We only need perags for the per-ag inode allocation code, so reduce the duplication by passing only the perags as the primary object.
This ends up reducing the code size by a bit:
text data bss dec hex filename
orig 1138878 323979 548 1463405 16546d (TOTALS)
patched 1138709 323979 548 1463236 1653c4 (TOTALS)
--- fs/xfs/libxfs/xfs_ag_resv.c | 2 +- fs/xfs/libxfs/xfs_ialloc.c | 25 +++++++++++---------- fs/xfs/libxfs/xfs_ialloc_btree.c | 37 ++++++++++++++------------------ fs/xfs/libxfs/xfs_ialloc_btree.h | 20 ++++++++--------- fs/xfs/scrub/agheader_repair.c | 7 +++--- fs/xfs/scrub/common.c | 8 +++---- fs/xfs/xfs_iwalk.c | 4 ++-- 7 files changed, 47 insertions(+), 56 deletions(-)
fs/xfs/libxfs/xfs_ag_resv.c +1 -1
@@ -264,7 +264,7 @@ xfs_ag_resv_init(if (error) goto out; - error =xfs_finobt_calc_reserves (mp, tp, pag, &ask, &used); + error =xfs_finobt_calc_reserves (pag, tp, &ask, &used);if (error) goto out;
fs/xfs/libxfs/xfs_ialloc.c +12 -13
@@ -176,13 +176,12 @@ xfs_inobt_insert( xfs_agino_t newlen, xfs_btnum_t btnum) { -struct xfs_mount *mp = pag->pag_mount;struct xfs_btree_cur *cur;xfs_agino_t thisino;int i;int error; - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag, btnum); + cur =xfs_inobt_init_cursor (pag, tp, agbp, btnum); for (thisino = newino; thisino < newino + newlen;
@@ -527,7 +526,7 @@ xfs_inobt_insert_sprec(int i;struct xfs_inobt_rec_incore rec; - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag, btnum); + cur =xfs_inobt_init_cursor (pag, tp, agbp, btnum);/* the new record is pre-aligned so we know where to look */ error =xfs_inobt_lookup (cur, nrec->ir_startino,XFS_LOOKUP_EQ , &i);
@@ -1004,7 +1003,7 @@ xfs_dialloc_ag_inobt(ASSERT (pag->pagi_freecount >0 ); restart_pagno: - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag,XFS_BTNUM_INO ); + cur =xfs_inobt_init_cursor (pag, tp, agbp,XFS_BTNUM_INO );/* * If pagino is 0 (this is the root inode allocation) use newino. * This must work because we've just allocated some.
@@ -1457,7 +1456,7 @@ xfs_dialloc_ag(if (!pagino) pagino =be32_to_cpu (agi->agi_newino); - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag,XFS_BTNUM_FINO ); + cur =xfs_inobt_init_cursor (pag, tp, agbp,XFS_BTNUM_FINO ); error =xfs_check_agi_freecount (cur);if (error)
@@ -1500,7 +1499,7 @@ xfs_dialloc_ag(* the original freecount. If all is well, make the equivalent update to * the inobt using the finobt record and offset information. */ - icur =xfs_inobt_init_cursor (mp, tp, agbp, pag,XFS_BTNUM_INO ); + icur =xfs_inobt_init_cursor (pag, tp, agbp,XFS_BTNUM_INO ); error =xfs_check_agi_freecount (icur);if (error)
@@ -1926,7 +1925,7 @@ xfs_difree_inobt(/* * Initialize the cursor. */ - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag,XFS_BTNUM_INO ); + cur =xfs_inobt_init_cursor (pag, tp, agbp,XFS_BTNUM_INO ); error =xfs_check_agi_freecount (cur);if (error)
@@ -2051,7 +2050,7 @@ xfs_difree_finobt(int error;int i; - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag,XFS_BTNUM_FINO ); + cur =xfs_inobt_init_cursor (pag, tp, agbp,XFS_BTNUM_FINO ); error =xfs_inobt_lookup (cur, ibtrec->ir_startino,XFS_LOOKUP_EQ , &i);if (error)
@@ -2248,7 +2247,7 @@ xfs_imap_lookup(* we have a record, we need to ensure it contains the inode number * we are looking up. */ - cur =xfs_inobt_init_cursor (mp, tp, agbp, pag,XFS_BTNUM_INO ); + cur =xfs_inobt_init_cursor (pag, tp, agbp,XFS_BTNUM_INO ); error =xfs_inobt_lookup (cur, agino,XFS_LOOKUP_LE , &i);if (!error) {if (i)
@@ -2937,17 +2936,17 @@ xfs_ialloc_check_shrink( {struct xfs_inobt_rec_incore rec;struct xfs_btree_cur *cur; -struct xfs_mount *mp = tp->t_mountp; -xfs_agino_t agino =XFS_AGB_TO_AGINO (mp, new_length); +xfs_agino_t agino;int has;int error; -if (!xfs_has_sparseinodes (mp)) +if (!xfs_has_sparseinodes (pag->pag_mount))return 0 ; - cur =xfs_inobt_init_cursor (mp, tp, agibp, pag,XFS_BTNUM_INO ); + cur =xfs_inobt_init_cursor (pag, tp, agibp,XFS_BTNUM_INO );/* Look up the inobt record that would correspond to the new EOFS. */ + agino =XFS_AGB_TO_AGINO (pag->pag_mount, new_length); error =xfs_inobt_lookup (cur, agino,XFS_LOOKUP_LE , &has);if (error || !has) goto out;
fs/xfs/libxfs/xfs_ialloc_btree.c +16 -21
@@ -36,8 +36,8 @@ STATIC struct xfs_btree_cur *xfs_inobt_dup_cursor ( struct xfs_btree_cur *cur) { -return xfs_inobt_init_cursor (cur->bc_mp, cur->bc_tp, - cur->bc_ag.agbp, cur->bc_ag.pag, cur->bc_btnum); +return xfs_inobt_init_cursor (cur->bc_ag.pag, cur->bc_tp, + cur->bc_ag.agbp, cur->bc_btnum); }STATIC void
@@ -427,11 +427,11 @@ static const struct xfs_btree_ops xfs_finobt_ops = {*/ static struct xfs_btree_cur *xfs_inobt_init_common ( -struct xfs_mount *mp,/* file system mount point */ -struct xfs_trans *tp,/* transaction pointer */ struct xfs_perag *pag, +struct xfs_trans *tp,/* transaction pointer */ xfs_btnum_t btnum)/* ialloc or free ino btree */ { +struct xfs_mount *mp = pag->pag_mount;struct xfs_btree_cur *cur; cur = xfs_btree_alloc_cursor(mp, tp, btnum,
@@ -456,16 +456,15 @@ xfs_inobt_init_common(/* Create an inode btree cursor. */ struct xfs_btree_cur *xfs_inobt_init_cursor ( -struct xfs_mount *mp, +struct xfs_perag *pag,struct xfs_trans *tp,struct xfs_buf *agbp, -struct xfs_perag *pag,xfs_btnum_t btnum) {struct xfs_btree_cur *cur;struct xfs_agi *agi = agbp->b_addr; - cur =xfs_inobt_init_common (mp, tp, pag, btnum); + cur =xfs_inobt_init_common (pag, tp, btnum);if (btnum ==XFS_BTNUM_INO ) cur->bc_nlevels =be32_to_cpu (agi->agi_level);else
@@ -477,14 +476,13 @@ xfs_inobt_init_cursor(/* Create an inode btree cursor with a fake root for staging. */ struct xfs_btree_cur *xfs_inobt_stage_cursor ( -struct xfs_mount *mp, -struct xbtree_afakeroot *afake,struct xfs_perag *pag, +struct xbtree_afakeroot *afake,xfs_btnum_t btnum) {struct xfs_btree_cur *cur; - cur =xfs_inobt_init_common (mp,NULL , pag, btnum); + cur =xfs_inobt_init_common (pag,NULL , btnum);xfs_btree_stage_afakeroot (cur, afake);return cur; }
@@ -708,9 +706,8 @@ xfs_inobt_max_size(/* Read AGI and create inobt cursor. */ int xfs_inobt_cur ( -struct xfs_mount *mp, -struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_trans *tp,xfs_btnum_t which,struct xfs_btree_cur **curpp,struct xfs_buf **agi_bpp)
@@ -725,16 +722,15 @@ xfs_inobt_cur(if (error)return error; - cur =xfs_inobt_init_cursor (mp, tp, *agi_bpp, pag, which); + cur =xfs_inobt_init_cursor (pag, tp, *agi_bpp, which); *curpp = cur;return 0 ; }static int xfs_inobt_count_blocks ( -struct xfs_mount *mp, -struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_trans *tp,xfs_btnum_t btnum,xfs_extlen_t *tree_blocks) {
@@ -742,7 +738,7 @@ xfs_inobt_count_blocks(struct xfs_btree_cur *cur =NULL ;int error; - error =xfs_inobt_cur (mp, tp, pag, btnum, &cur, &agbp); + error =xfs_inobt_cur (pag, tp, btnum, &cur, &agbp);if (error)return error;
@@ -779,22 +775,21 @@ xfs_finobt_read_blocks(*/ int xfs_finobt_calc_reserves ( -struct xfs_mount *mp, -struct xfs_trans *tp,struct xfs_perag *pag, +struct xfs_trans *tp,xfs_extlen_t *ask,xfs_extlen_t *used) {xfs_extlen_t tree_len =0 ;int error; -if (!xfs_has_finobt (mp)) +if (!xfs_has_finobt (pag->pag_mount))return 0 ; -if (xfs_has_inobtcounts (mp)) +if (xfs_has_inobtcounts (pag->pag_mount)) error =xfs_finobt_read_blocks (pag, tp, &tree_len);else - error =xfs_inobt_count_blocks (mp, tp, pag,XFS_BTNUM_FINO , + error =xfs_inobt_count_blocks (pag, tp,XFS_BTNUM_FINO , &tree_len);if (error)return error;
fs/xfs/libxfs/xfs_ialloc_btree.h +9 -11
@@ -46,12 +46,10 @@ struct xfs_perag; (maxrecs) * sizeof(xfs_inobt_key_t) + \ ((index) - 1) * sizeof(xfs_inobt_ptr_t))) -extern struct xfs_btree_cur *xfs_inobt_init_cursor (struct xfs_mount *mp, -struct xfs_trans *tp,struct xfs_buf *agbp, -struct xfs_perag *pag,xfs_btnum_t btnum); -struct xfs_btree_cur *xfs_inobt_stage_cursor (struct xfs_mount *mp, -struct xbtree_afakeroot *afake,struct xfs_perag *pag, -xfs_btnum_t btnum); +extern struct xfs_btree_cur *xfs_inobt_init_cursor (struct xfs_perag *pag, +struct xfs_trans *tp,struct xfs_buf *agbp,xfs_btnum_t btnum); +struct xfs_btree_cur *xfs_inobt_stage_cursor (struct xfs_perag *pag, +struct xbtree_afakeroot *afake,xfs_btnum_t btnum);extern int xfs_inobt_maxrecs (struct xfs_mount *,int ,int );/* ir_holemask to inode allocation bitmap conversion */
@@ -64,13 +62,13 @@ int xfs_inobt_rec_check_count(struct xfs_mount *,#define xfs_inobt_rec_check_count (mp, rec) 0#endif /* DEBUG */ -int xfs_finobt_calc_reserves (struct xfs_mount *mp,struct xfs_trans *tp, -struct xfs_perag *pag,xfs_extlen_t *ask,xfs_extlen_t *used); +int xfs_finobt_calc_reserves (struct xfs_perag *perag,struct xfs_trans *tp, +xfs_extlen_t *ask,xfs_extlen_t *used);extern xfs_extlen_t xfs_iallocbt_calc_size (struct xfs_mount *mp,unsigned long long len); -int xfs_inobt_cur (struct xfs_mount *mp,struct xfs_trans *tp, -struct xfs_perag *pag,xfs_btnum_t btnum, -struct xfs_btree_cur **curpp,struct xfs_buf **agi_bpp); +int xfs_inobt_cur (struct xfs_perag *pag,struct xfs_trans *tp, +xfs_btnum_t btnum,struct xfs_btree_cur **curpp, +struct xfs_buf **agi_bpp);void xfs_inobt_commit_staged_btree (struct xfs_btree_cur *cur,struct xfs_trans *tp,struct xfs_buf *agbp);
fs/xfs/scrub/agheader_repair.c +3 -4
@@ -873,8 +873,7 @@ xrep_agi_calc_from_btrees(xfs_agino_t freecount;int error; - cur =xfs_inobt_init_cursor (mp, sc->tp, agi_bp, - sc->sa.pag,XFS_BTNUM_INO ); + cur =xfs_inobt_init_cursor (sc->sa.pag, sc->tp, agi_bp,XFS_BTNUM_INO ); error =xfs_ialloc_count_inodes (cur, &count, &freecount);if (error) goto err;
@@ -894,8 +893,8 @@ xrep_agi_calc_from_btrees(if (xfs_has_finobt (mp) &&xfs_has_inobtcounts (mp)) {xfs_agblock_t blocks; - cur =xfs_inobt_init_cursor (mp, sc->tp, agi_bp, - sc->sa.pag,XFS_BTNUM_FINO ); + cur =xfs_inobt_init_cursor (sc->sa.pag, sc->tp, agi_bp, +XFS_BTNUM_FINO ); error =xfs_btree_count_blocks (cur, &blocks);if (error) goto err;
fs/xfs/scrub/common.c +4 -4
@@ -478,15 +478,15 @@ xchk_ag_btcur_init(/* Set up a inobt cursor for cross-referencing. */ if (sa->agi_bp &&xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_INO )) { - sa->ino_cur =xfs_inobt_init_cursor (mp, sc->tp, sa->agi_bp, - sa->pag,XFS_BTNUM_INO ); + sa->ino_cur =xfs_inobt_init_cursor (sa->pag, sc->tp, sa->agi_bp, +XFS_BTNUM_INO ); }/* Set up a finobt cursor for cross-referencing. */ if (sa->agi_bp &&xfs_has_finobt (mp) &&xchk_ag_btree_healthy_enough (sc, sa->pag,XFS_BTNUM_FINO )) { - sa->fino_cur =xfs_inobt_init_cursor (mp, sc->tp, sa->agi_bp, - sa->pag,XFS_BTNUM_FINO ); + sa->fino_cur =xfs_inobt_init_cursor (sa->pag, sc->tp, sa->agi_bp, +XFS_BTNUM_FINO ); }/* Set up a rmapbt cursor for cross-referencing. */
fs/xfs/xfs_iwalk.c +2 -2
@@ -275,7 +275,7 @@ xfs_iwalk_ag_start(/* Set up a fresh cursor and empty the inobt cache. */ iwag->nr_recs =0 ; - error =xfs_inobt_cur (mp, tp, pag,XFS_BTNUM_INO , curpp, agi_bpp); + error =xfs_inobt_cur (pag, tp,XFS_BTNUM_INO , curpp, agi_bpp);if (error)return error;
@@ -390,7 +390,7 @@ xfs_iwalk_run_callbacks( }/* ...and recreate the cursor just past where we left off. */ - error =xfs_inobt_cur (mp, iwag->tp, iwag->pag,XFS_BTNUM_INO , curpp, + error =xfs_inobt_cur (iwag->pag, iwag->tp,XFS_BTNUM_INO , curpp, agi_bpp);if (error)return error;
Signature · 1 line
2.39.0
Re: [PATCH 11/42] xfs: inobt can use perags in many more places than it does
Quoted 7 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Lots of code in the inobt infrastructure is passed both
xfs_mountand perags. We only need perags for the per-ag inode allocation code, so reduce the duplication by passing only the perags as the primary object.
Quoted 7 lines
This ends up reducing the code size by a bit:
text data bss dec hex filename orig 1138878 323979 548 1463405 16546d (TOTALS) patched 1138709 323979 548 1463236 1653c4 (TOTALS)
Signed-off-by Dave Chinner <[email protected]>
Alrighty, looks like a nice clean up
Quoted 418 lines
---
fs/xfs/libxfs/xfs_ag_resv.c | 2 +- fs/xfs/libxfs/xfs_ialloc.c | 25 +++++++++++----------fs/xfs/libxfs/xfs_ialloc_btree.c| 37 ++++++++++++++---------------- --
fs/xfs/libxfs/xfs_ialloc_btree.h | 20 ++++++++--------- fs/xfs/scrub/agheader_repair.c | 7 +++--- fs/xfs/scrub/common.c | 8 +++---- fs/xfs/xfs_iwalk.c | 4 ++--7 files changed, 47 insertions(+), 56 deletions(-)fs/xfs/libxfs/xfs_ag_resv.c +0
-0@@ -264,7 +264,7 @@ xfs_ag_resv_init( if (error) goto out;
- error =xfs_finobt_calc_reserves(mp, tp, pag, &ask, &used);
+ error =xfs_finobt_calc_reserves(pag, tp, &ask, &used);
if (error)
goto out;fs/xfs/libxfs/xfs_ialloc.c +0
-1@@ -176,13 +176,12 @@ xfs_inobt_insert( xfs_agino_t newlen, xfs_btnum_t btnum) { - struct xfs_mount *mp = pag->pag_mount; struct xfs_btree_cur *cur; xfs_agino_t thisino; int i; int error;
- cur =xfs_inobt_init_cursor(mp, tp, agbp, pag, btnum); + cur =xfs_inobt_init_cursor(pag, tp, agbp, btnum);
for (thisino = newino;
thisino < newino + newlen;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -527,7 +526,7 @@ xfs_inobt_insert_sprec( int i; struct xfs_inobt_rec_incore rec;
- cur =xfs_inobt_init_cursor(mp, tp, agbp, pag, btnum); + cur =xfs_inobt_init_cursor(pag, tp, agbp, btnum);
/* the new record is pre-aligned so we know where to look */ error =xfs_inobt_lookup(cur, nrec->ir_startino, XFS_LOOKUP_EQ, &i);fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1004,7 +1003,7 @@ xfs_dialloc_ag_inobt( ASSERT(pag->pagi_freecount > 0);
restart_pagno:
- cur =xfs_inobt_init_cursor(mp, tp, agbp, pag, XFS_BTNUM_INO);
+ cur =xfs_inobt_init_cursor(pag, tp, agbp, XFS_BTNUM_INO); /*
* If pagino is 0 (this is the root inode allocation) use newino.
* This must work because we've just allocated some.fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1457,7 +1456,7 @@ xfs_dialloc_ag( if (!pagino) pagino = be32_to_cpu(agi->agi_newino);
- cur =xfs_inobt_init_cursor(mp, tp, agbp, pag, XFS_BTNUM_FINO);
+ cur =xfs_inobt_init_cursor(pag, tp, agbp, XFS_BTNUM_FINO);
error =xfs_check_agi_freecount(cur);
if (error)fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1500,7 +1499,7 @@ xfs_dialloc_ag( * the original freecount. If all is well, make theequivalent update to
* the inobt using the finobt record and offset information. */
- icur =xfs_inobt_init_cursor(mp, tp, agbp, pag, XFS_BTNUM_INO);
+ icur =xfs_inobt_init_cursor(pag, tp, agbp, XFS_BTNUM_INO);
error =xfs_check_agi_freecount(icur);
if (error)fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -1926,7 +1925,7 @@ xfs_difree_inobt( /** Initialize the cursor. */ - cur = xfs_inobt_init_cursor(mp, tp, agbp, pag, XFS_BTNUM_INO); + cur = xfs_inobt_init_cursor(pag, tp, agbp, XFS_BTNUM_INO);
error =xfs_check_agi_freecount(cur);
if (error)fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2051,7 +2050,7 @@ xfs_difree_finobt( int error; int i;
- cur =xfs_inobt_init_cursor(mp, tp, agbp, pag, XFS_BTNUM_FINO);
+ cur =xfs_inobt_init_cursor(pag, tp, agbp, XFS_BTNUM_FINO);
error =xfs_inobt_lookup(cur, ibtrec->ir_startino, XFS_LOOKUP_EQ, &i);
if (error)fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2248,7 +2247,7 @@ xfs_imap_lookup( * we have a record, we need to ensure it contains the inodenumber
* we are looking up.
*/
- cur =xfs_inobt_init_cursor(mp, tp, agbp, pag, XFS_BTNUM_INO);
+ cur =xfs_inobt_init_cursor(pag, tp, agbp, XFS_BTNUM_INO); error =xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &i); if (!error) {
if (i)fs/xfs/libxfs/xfs_ialloc.c +1
-2@@ -2937,17 +2936,17 @@ xfs_ialloc_check_shrink( { struct xfs_inobt_rec_incore rec; struct xfs_btree_cur *cur; - struct xfs_mount *mp = tp->t_mountp; - xfs_agino_t agino = XFS_AGB_TO_AGINO(mp, new_length); + xfs_agino_t agino; int has; int error;
- if (!xfs_has_sparseinodes(mp))
+ if (!xfs_has_sparseinodes(pag->pag_mount))
return 0;
- cur =xfs_inobt_init_cursor(mp, tp, agibp, pag, XFS_BTNUM_INO);
+ cur =xfs_inobt_init_cursor(pag, tp, agibp, XFS_BTNUM_INO);
/* Look up the inobt record that would correspond to the new EOFS. */
+ agino =XFS_AGB_TO_AGINO(pag->pag_mount, new_length); error =xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &has); if (error || !has)
goto out;fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -36,8 +36,8 @@ STATIC struct xfs_btree_cur *xfs_inobt_dup_cursor(
struct xfs_btree_cur *cur)
{
- return xfs_inobt_init_cursor(cur->bc_mp,cur->bc_tp, - cur->bc_ag.agbp,cur->bc_ag.pag, cur-Quoted 1 line
bc_btnum);+ return xfs_inobt_init_cursor(cur->bc_ag.pag,
cur->bc_tp, + cur->bc_ag.agbp,cur->bc_btnum); }
STATIC voidfs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -427,11 +427,11 @@ static const struct xfs_btree_opsxfs_finobt_ops = { */ static struct
xfs_btree_cur*
xfs_inobt_init_common(
- struct xfs_mount *mp, /* file system mount point */
- struct xfs_trans *tp, /* transaction pointer */
struct xfs_perag *pag,
+ struct xfs_trans *tp, /* transaction pointer */
xfs_btnum_t btnum) /* ialloc or free ino btree */
{
+ struct xfs_mount *mp =pag->pag_mount; struct xfs_btree_cur *cur;
cur = xfs_btree_alloc_cursor(mp, tp, btnum,fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -456,16 +456,15 @@ xfs_inobt_init_common( /* Create an inode btree cursor. */struct
xfs_btree_cur*
xfs_inobt_init_cursor(
- struct xfs_mount *mp,
+ struct xfs_perag *pag,
struct xfs_trans *tp,
struct xfs_buf *agbp,
- struct xfs_perag *pag,
xfs_btnum_t btnum)
{
struct xfs_btree_cur *cur;
struct xfs_agi *agi =agbp->b_addr;
- cur =xfs_inobt_init_common(mp, tp, pag, btnum); + cur =xfs_inobt_init_common(pag, tp, btnum); if (btnum ==XFS_BTNUM_INO)
cur->bc_nlevels =be32_to_cpu(agi->agi_level); elsefs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -477,14 +476,13 @@ xfs_inobt_init_cursor( /* Create an inode btree cursor with a fake root for staging. */struct
xfs_btree_cur*
xfs_inobt_stage_cursor(
- struct xfs_mount *mp,
- struct xbtree_afakeroot *afake,
struct xfs_perag *pag,
+ struct xbtree_afakeroot *afake, xfs_btnum_t btnum)
{
struct xfs_btree_cur *cur;
- cur =xfs_inobt_init_common(mp, NULL, pag, btnum); + cur =xfs_inobt_init_common(pag, NULL, btnum);xfs_btree_stage_afakeroot(cur, afake); return cur;
}fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -708,9 +706,8 @@ xfs_inobt_max_size( /* Read AGI and create inobt cursor. */int
xfs_inobt_cur(
- struct xfs_mount *mp,
- struct xfs_trans *tp,
struct xfs_perag *pag,
+ struct xfs_trans *tp,
xfs_btnum_t which,
struct xfs_btree_cur **curpp,
struct xfs_buf **agi_bpp)fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -725,16 +722,15 @@ xfs_inobt_cur( if (error) return error;
- cur =xfs_inobt_init_cursor(mp, tp, *agi_bpp, pag, which); + cur =xfs_inobt_init_cursor(pag, tp, *agi_bpp, which); *curpp = cur;
return 0;
}
static int
xfs_inobt_count_blocks(
- struct xfs_mount *mp,
- struct xfs_trans *tp,
struct xfs_perag *pag,
+ struct xfs_trans *tp,
xfs_btnum_t btnum,
xfs_extlen_t *tree_blocks)
{fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -742,7 +738,7 @@ xfs_inobt_count_blocks( struct xfs_btree_cur *cur = NULL; int error;
- error =xfs_inobt_cur(mp, tp, pag, btnum, &cur, &agbp); + error =xfs_inobt_cur(pag, tp, btnum, &cur, &agbp); if (error)
return error;fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -779,22 +775,21 @@ xfs_finobt_read_blocks(*/ int
xfs_finobt_calc_reserves(
- struct xfs_mount *mp,
- struct xfs_trans *tp,
struct xfs_perag *pag,
+ struct xfs_trans *tp,
xfs_extlen_t *ask,
xfs_extlen_t *used)
{
xfs_extlen_t tree_len = 0;
int error;
- if (!xfs_has_finobt(mp))
+ if (!xfs_has_finobt(pag->pag_mount))
return 0;
- if (xfs_has_inobtcounts(mp))
+ if (xfs_has_inobtcounts(pag->pag_mount))
error =xfs_finobt_read_blocks(pag, tp, &tree_len); else
- error = xfs_inobt_count_blocks(mp, tp, pag,XFS_BTNUM_FINO,
+ error = xfs_inobt_count_blocks(pag, tp,XFS_BTNUM_FINO,
&tree_len);
if (error)
return error;fs/xfs/libxfs/xfs_ialloc_btree.h +0
-0@@ -46,12 +46,10 @@ struct xfs_perag; (maxrecs) * sizeof(xfs_inobt_key_t) + \ ((index) - 1) * sizeof(xfs_inobt_ptr_t)))
-extern structxfs_btree_cur*xfs_inobt_init_cursor(structxfs_mount*mp,
- structxfs_trans*tp, structxfs_buf*agbp, - structxfs_perag*pag,xfs_btnum_tbtnum); -structxfs_btree_cur*xfs_inobt_stage_cursor(structxfs_mount*mp, - structxbtree_afakeroot*afake, structxfs_perag*pag,
- xfs_btnum_t btnum);
+extern structxfs_btree_cur*xfs_inobt_init_cursor(structxfs_perag*pag,
+ structxfs_trans*tp, structxfs_buf*agbp,xfs_btnum_tbtnum);
+structxfs_btree_cur*xfs_inobt_stage_cursor(structxfs_perag*pag, + structxbtree_afakeroot*afake,xfs_btnum_tbtnum); extern intxfs_inobt_maxrecs(struct xfs_mount *, int, int);
/*ir_holemaskto inode allocation bitmap conversion */fs/xfs/libxfs/xfs_ialloc_btree.h +0
-0@@ -64,13 +62,13 @@ int xfs_inobt_rec_check_count(struct xfs_mount *, #define xfs_inobt_rec_check_count(mp, rec) 0 #endif /* DEBUG */
-int xfs_finobt_calc_reserves(structxfs_mount*mp, structxfs_trans*tp,
- structxfs_perag*pag,xfs_extlen_t*ask,xfs_extlen_t*used);
+int xfs_finobt_calc_reserves(structxfs_perag*perag, structxfs_trans*tp,
+ xfs_extlen_t *ask,xfs_extlen_t*used); externxfs_extlen_txfs_iallocbt_calc_size(struct xfs_mount *mp, unsigned long long len);
-int xfs_inobt_cur(structxfs_mount*mp, structxfs_trans*tp, - structxfs_perag*pag,xfs_btnum_tbtnum, - structxfs_btree_cur**curpp, structxfs_buf**agi_bpp);
+int xfs_inobt_cur(structxfs_perag*pag, structxfs_trans*tp, + xfs_btnum_t btnum, structxfs_btree_cur**curpp, + structxfs_buf**agi_bpp);
voidxfs_inobt_commit_staged_btree(struct xfs_btree_cur *cur, struct xfs_trans *tp, struct xfs_buf *agbp);fs/xfs/scrub/agheader_repair.c +0
-0@@ -873,8 +873,7 @@ xrep_agi_calc_from_btrees( xfs_agino_t freecount; int error;
- cur =xfs_inobt_init_cursor(mp, sc->tp, agi_bp, - sc->sa.pag, XFS_BTNUM_INO);
+ cur =xfs_inobt_init_cursor(sc->sa.pag, sc->tp, agi_bp, XFS_BTNUM_INO);
error =xfs_ialloc_count_inodes(cur, &count, &freecount); if (error)
goto err;fs/xfs/scrub/agheader_repair.c +0
-0@@ -894,8 +893,8 @@ xrep_agi_calc_from_btrees( if (xfs_has_finobt(mp) && xfs_has_inobtcounts(mp)) { xfs_agblock_t blocks;
- cur = xfs_inobt_init_cursor(mp,sc->tp,agi_bp, - sc->sa.pag,XFS_BTNUM_FINO); + cur = xfs_inobt_init_cursor(sc->sa.pag,sc->tp,agi_bp,
+ XFS_BTNUM_FINO); error =xfs_btree_count_blocks(cur, &blocks); if (error)
goto err;fs/xfs/scrub/common.c +0
-0@@ -478,15 +478,15 @@ xchk_ag_btcur_init( /* Set up a inobt cursor for cross-referencing. */if (
sa->agi_bp&&
xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_INO)) {
- sa->ino_cur = xfs_inobt_init_cursor(mp,sc->tp, sa-Quoted 1 line
agi_bp,- sa->pag,
XFS_BTNUM_INO); + sa->ino_cur = xfs_inobt_init_cursor(sa->pag,sc->tp,sa->agi_bp,
+ XFS_BTNUM_INO);
}
/* Set up a finobt cursor for cross-referencing. */ if (sa->agi_bp&&xfs_has_finobt(mp)&&xchk_ag_btree_healthy_enough(sc, sa->pag, XFS_BTNUM_FINO)) {
- sa->fino_cur = xfs_inobt_init_cursor(mp,sc->tp, sa-Quoted 1 line
agi_bp,- sa->pag,
XFS_BTNUM_FINO); + sa->fino_cur = xfs_inobt_init_cursor(sa->pag,sc->tp,sa->agi_bp,
+ XFS_BTNUM_FINO);
}
/* Set up a rmapbt cursor for cross-referencing. */fs/xfs/xfs_iwalk.c +0
-0@@ -275,7 +275,7 @@ xfs_iwalk_ag_start(
/* Set up a fresh cursor and empty the inobt cache. */iwag->nr_recs= 0;
- error =xfs_inobt_cur(mp, tp, pag, XFS_BTNUM_INO, curpp, agi_bpp);
+ error =xfs_inobt_cur(pag, tp, XFS_BTNUM_INO, curpp, agi_bpp);
if (error)
return error;fs/xfs/xfs_iwalk.c +0
-0@@ -390,7 +390,7 @@ xfs_iwalk_run_callbacks( }
/* ...and recreate the cursor just past where we left off. */ - error = xfs_inobt_cur(mp,iwag->tp,iwag->pag,XFS_BTNUM_INO, curpp,
+ error = xfs_inobt_cur(iwag->pag,iwag->tp,XFS_BTNUM_INO, curpp,
agi_bpp);
if (error)
return error;
PATCH 12/42 xfs: convert xfs_ialloc_next_ag() to an atomic
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
This is currently a spinlock lock protected rotor which can be implemented with a single atomic operation. Change it to be more efficient and get rid of the m_agirotor_lock. Noticed while converting the inode allocation AG selection loop to active perag references.
--- fs/xfs/libxfs/xfs_ialloc.c | 17 +---------------- fs/xfs/libxfs/xfs_sb.c | 3 ++- fs/xfs/xfs_mount.h | 3 +-- fs/xfs/xfs_super.c | 1 - 4 files changed, 4 insertions(+), 20 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +1 -16
@@ -1576,21 +1576,6 @@ xfs_dialloc_roll(return error; } -static xfs_agnumber_t -xfs_ialloc_next_ag ( -xfs_mount_t *mp) -{ -xfs_agnumber_t agno; - -spin_lock (&mp->m_agirotor_lock); - agno = mp->m_agirotor; -if (++mp->m_agirotor >= mp->m_maxagi) - mp->m_agirotor =0 ; -spin_unlock (&mp->m_agirotor_lock); - -return agno; -} - static bool xfs_dialloc_good_ag( struct xfs_perag *pag,
@@ -1748,7 +1733,7 @@ xfs_dialloc(* an AG has enough space for file creation. */ if (S_ISDIR (mode)) - start_agno =xfs_ialloc_next_ag (mp); + start_agno =atomic_inc_return (&mp->m_agirotor) % mp->m_maxagi;else { start_agno =XFS_INO_TO_AGNO (mp, parent);if (start_agno >= mp->m_maxagi)
fs/xfs/libxfs/xfs_sb.c +2 -1
@@ -909,7 +909,8 @@ xfs_sb_mount_common(struct xfs_mount *mp, struct xfs_sb *sbp) { - mp->m_agfrotor = mp->m_agirotor = 0; + mp->m_agfrotor = 0; +atomic_set (&mp->m_agirotor,0 ); mp->m_maxagi = mp->m_sb.sb_agcount; mp->m_blkbit_log = sbp->sb_blocklog +XFS_NBBYLOG ; mp->m_blkbb_log = sbp->sb_blocklog -BBSHIFT ;
fs/xfs/xfs_mount.h +1 -2
@@ -210,8 +210,7 @@ typedef struct xfs_mount {struct xfs_error_cfg m_error_cfg[XFS_ERR_CLASS_MAX ][XFS_ERR_ERRNO_MAX ];struct xstats m_stats;/* per-fs stats */ xfs_agnumber_t m_agfrotor;/* last ag where space found */ -xfs_agnumber_t m_agirotor;/* last ag dir inode alloced */ -spinlock_t m_agirotor_lock;/* .. and lock protecting it */ +atomic_t m_agirotor;/* last ag dir inode alloced */ /* Memory shrinker to throttle and reprioritize inodegc */ struct shrinker m_inodegc_shrinker;
fs/xfs/xfs_super.c +0 -1
@@ -1922,7 +1922,6 @@ static int xfs_init_fs_context(return -ENOMEM ;spin_lock_init (&mp->m_sb_lock); -spin_lock_init (&mp->m_agirotor_lock);INIT_RADIX_TREE (&mp->m_perag_tree,GFP_ATOMIC );spin_lock_init (&mp->m_perag_lock);mutex_init (&mp->m_growlock);
Signature · 1 line
2.39.0
Re: [PATCH 12/42] xfs: convert xfs_ialloc_next_ag() to an atomic
Quoted 9 lines · Dave Chinner
From: Dave Chinner <[email protected]>
This is currently a spinlock lock protected rotor which can be implemented with a single atomic operation. Change it to be more efficient and get rid of the
m_agirotor_lock. Noticed while converting the inode allocation AG selection loop to active perag references.Signed-off-by Dave Chinner <[email protected]>
Ok, makes sense
Quoted 88 lines
---
fs/xfs/libxfs/xfs_ialloc.c | 17 +---------------- fs/xfs/libxfs/xfs_sb.c | 3 ++- fs/xfs/xfs_mount.h | 3 +-- fs/xfs/xfs_super.c | 1 -4 files changed, 4 insertions(+), 20 deletions(-)fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1576,21 +1576,6 @@ xfs_dialloc_roll( return error; }fs/xfs/libxfs/xfs_ialloc.c +0
-15-static xfs_agnumber_t -xfs_ialloc_next_ag ( - xfs_mount_t *mp) -{ - xfs_agnumber_t agno; - - spin_lock(&mp->m_agirotor_lock); - agno = mp->m_agirotor; - if (++mp->m_agirotor >= mp->m_maxagi) - mp->m_agirotor = 0; - spin_unlock(&mp->m_agirotor_lock); - - return agno; -} -static bool
xfs_dialloc_good_ag(
struct xfs_perag *pag,fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -1748,7 +1733,7 @@ xfs_dialloc(* an AG has enough space for file creation. */ if (S_ISDIR(mode)) - start_agno = xfs_ialloc_next_ag(mp); + start_agno = atomic_inc_return(&mp->m_agirotor) % mp- >m_maxagi; else { start_agno = XFS_INO_TO_AGNO(mp, parent);if (
start_agno>=mp->m_maxagi)fs/xfs/libxfs/xfs_sb.c +2
-1@@ -909,7 +909,8 @@ xfs_sb_mount_common( struct xfs_mount *mp, struct xfs_sb *sbp) { - mp->m_agfrotor = mp->m_agirotor = 0; + mp->m_agfrotor = 0; + atomic_set(&mp->m_agirotor, 0); mp->m_maxagi = mp->m_sb.sb_agcount; mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG; mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;fs/xfs/xfs_mount.h +0
-0@@ -210,8 +210,7 @@ typedef struct xfs_mount {struct
xfs_error_cfg m_error_cfg[XFS_ERR_CLASS_MAX][XFS_ERR_ERRNO_MAX]; struct xstats m_stats; /* per-fs stats */ xfs_agnumber_t m_agfrotor; /* last ag where space found */
- xfs_agnumber_t m_agirotor; /* last ag dir inode alloced */
- spinlock_t m_agirotor_lock;/* .. and lock protecting it */
+ atomic_t m_agirotor; /* last ag dir inode alloced */
/* Memory shrinker to throttle and reprioritize inodegc */ struct shrinker m_inodegc_shrinker;fs/xfs/xfs_super.c +0
-0@@ -1922,7 +1922,6 @@ static int xfs_init_fs_context( return -ENOMEM;
spin_lock_init(&mp->m_sb_lock);
- spin_lock_init(&mp->m_agirotor_lock);INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);spin_lock_init(&mp->m_perag_lock);mutex_init(&mp->m_growlock);
PATCH 13/42 xfs: perags need atomic operational state
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
We currently don't have any flags or operational state in the xfs_perag except for the pagf_init and pagi_init flags. And the agflreset flag. Oh, there's also the pagf_metadata and pagi_inodeok flags, too.
For controlling per-ag operations, we are going to need some atomic state flags. Hence add an opstate field similar to what we already have in the mount and log, and convert all these state flags across to atomic bit operations.
--- fs/xfs/libxfs/xfs_ag.h | 27 ++++++++++++++---- fs/xfs/libxfs/xfs_alloc.c | 23 ++++++++------- fs/xfs/libxfs/xfs_alloc_btree.c | 2 +- fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/libxfs/xfs_ialloc.c | 14 ++++----- fs/xfs/libxfs/xfs_ialloc_btree.c | 4 +-- fs/xfs/libxfs/xfs_refcount_btree.c | 2 +- fs/xfs/libxfs/xfs_rmap_btree.c | 2 +- fs/xfs/scrub/agheader_repair.c | 28 +++++++++--------- fs/xfs/scrub/fscounters.c | 9 ++++-- fs/xfs/scrub/repair.c | 2 +- fs/xfs/xfs_filestream.c | 5 ++-- fs/xfs/xfs_super.c | 46 ++++++++++++++++++------------ 13 files changed, 101 insertions(+), 65 deletions(-)
fs/xfs/libxfs/xfs_ag.h +22 -5
@@ -35,13 +35,9 @@ struct xfs_perag {atomic_t pag_ref;/* passive reference count */ atomic_t pag_active_ref;/* active reference count */ wait_queue_head_t pag_active_wq;/* woken active_ref falls to zero */ -char pagf_init;/* this agf's entry is initialized */ -char pagi_init;/* this agi's entry is initialized */ -char pagf_metadata;/* the agf is preferred to be metadata */ -char pagi_inodeok;/* The agi is ok for inodes */ +unsigned long pag_opstate;uint8_t pagf_levels[XFS_BTNUM_AGF ];/* # of levels in bno & cnt btree */ -bool pagf_agflreset;/* agfl requires reset before use */ uint32_t pagf_flcount;/* count of blocks in freelist */ xfs_extlen_t pagf_freeblks;/* total free blocks */ xfs_extlen_t pagf_longest;/* longest free space */
@@ -108,6 +104,27 @@ struct xfs_perag {#endif /* __KERNEL__ */ }; +/* +* Per-AG operational state. These are atomic flag bits. +*/ +#define XFS_AGSTATE_AGF_INIT 0 +#define XFS_AGSTATE_AGI_INIT 1 +#define XFS_AGSTATE_PREFERS_METADATA 2 +#define XFS_AGSTATE_ALLOWS_INODES 3 +#define XFS_AGSTATE_AGFL_NEEDS_RESET 4 + +#define __XFS_AG_OPSTATE (name,NAME ) \ +static inline bool xfs_perag_ ## name (struct xfs_perag *pag) \ +{ \ + return test_bit(XFS_AGSTATE_ ## NAME, &pag->pag_opstate); \ +} + +__XFS_AG_OPSTATE(initialised_agf, AGF_INIT) +__XFS_AG_OPSTATE(initialised_agi, AGI_INIT) +__XFS_AG_OPSTATE(prefers_metadata, PREFERS_METADATA) +__XFS_AG_OPSTATE(allows_inodes, ALLOWS_INODES) +__XFS_AG_OPSTATE(agfl_needs_reset, AGFL_NEEDS_RESET) +int xfs_initialize_perag (struct xfs_mount *mp,xfs_agnumber_t agcount,xfs_rfsblock_t dcount,xfs_agnumber_t *maxagi);int xfs_initialize_perag_data (struct xfs_mount *mp,xfs_agnumber_t agno);
fs/xfs/libxfs/xfs_alloc.c +13 -10
@@ -2435,7 +2435,7 @@ xfs_agfl_reset(struct xfs_mount *mp = tp->t_mountp;struct xfs_agf *agf = agbp->b_addr; -ASSERT (pag->pagf_agflreset); +ASSERT (xfs_perag_agfl_needs_reset (pag));trace_xfs_agfl_reset (mp, agf,0 , _RET_IP_); xfs_warn(mp,
@@ -2450,7 +2450,7 @@ xfs_agfl_reset( XFS_AGF_FLCOUNT); pag->pagf_flcount =0 ; - pag->pagf_agflreset = false; +clear_bit (XFS_AGSTATE_AGFL_NEEDS_RESET , &pag->pag_opstate); }/*
@@ -2605,7 +2605,7 @@ xfs_alloc_fix_freelist(/* deferred ops (AGFL block frees) require permanent transactions */ ASSERT (tp->t_flags &XFS_TRANS_PERM_LOG_RES ); -if (!pag->pagf_init) { +if (!xfs_perag_initialised_agf (pag)) { error =xfs_alloc_read_agf (pag, tp, flags, &agbp);if (error) {/* Couldn't lock the AGF so skip this AG. */
@@ -2620,7 +2620,8 @@ xfs_alloc_fix_freelist(* somewhere else if we are not being asked to try harder at this * point */ -if (pag->pagf_metadata && (args->datatype &XFS_ALLOC_USERDATA ) && +if (xfs_perag_prefers_metadata (pag) && + (args->datatype &XFS_ALLOC_USERDATA ) && (flags &XFS_ALLOC_FLAG_TRYLOCK )) {ASSERT (!(flags &XFS_ALLOC_FLAG_FREEING )); goto out_agbp_relse;
@@ -2646,7 +2647,7 @@ xfs_alloc_fix_freelist( }/* reset a padding mismatched agfl before final free space check */ -if (pag->pagf_agflreset) +if (xfs_perag_agfl_needs_reset (pag))xfs_agfl_reset (tp, agbp, pag);/* If there isn't enough total space or single-extent, reject it. */
@@ -2803,7 +2804,7 @@ xfs_alloc_get_freelist(if (be32_to_cpu (agf->agf_flfirst) ==xfs_agfl_size (mp)) agf->agf_flfirst =0 ; -ASSERT (!pag->pagf_agflreset); +ASSERT (!xfs_perag_agfl_needs_reset (pag));be32_add_cpu (&agf->agf_flcount,-1 ); pag->pagf_flcount--;
@@ -2892,7 +2893,7 @@ xfs_alloc_put_freelist(if (be32_to_cpu (agf->agf_fllast) ==xfs_agfl_size (mp)) agf->agf_fllast =0 ; -ASSERT (!pag->pagf_agflreset); +ASSERT (!xfs_perag_agfl_needs_reset (pag));be32_add_cpu (&agf->agf_flcount,1 ); pag->pagf_flcount++;
@@ -3099,7 +3100,7 @@ xfs_alloc_read_agf(return error; agf = agfbp->b_addr; -if (!pag->pagf_init) { +if (!xfs_perag_initialised_agf (pag)) { pag->pagf_freeblks =be32_to_cpu (agf->agf_freeblks); pag->pagf_btreeblks =be32_to_cpu (agf->agf_btreeblks); pag->pagf_flcount =be32_to_cpu (agf->agf_flcount);
@@ -3111,8 +3112,8 @@ xfs_alloc_read_agf( pag->pagf_levels[XFS_BTNUM_RMAPi] =be32_to_cpu (agf->agf_levels[XFS_BTNUM_RMAPi]); pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); - pag->pagf_init =1 ; - pag->pagf_agflreset =xfs_agfl_needs_reset (pag->pag_mount, agf); +if (xfs_agfl_needs_reset (pag->pag_mount, agf)) +set_bit (XFS_AGSTATE_AGFL_NEEDS_RESET , &pag->pag_opstate);/* * Update the in-core allocbt counter. Filter out the rmapbt
@@ -3127,6 +3128,8 @@ xfs_alloc_read_agf(if (allocbt_blks >0 )atomic64_add (allocbt_blks, &pag->pag_mount->m_allocbt_blks); + +set_bit (XFS_AGSTATE_AGF_INIT , &pag->pag_opstate); }#ifdef DEBUG else if (!xfs_is_shutdown(pag->pag_mount)) {
fs/xfs/libxfs/xfs_alloc_btree.c +1 -1
@@ -315,7 +315,7 @@ xfs_allocbt_verify( level =be16_to_cpu (block->bb_level);if (bp->b_ops->magic[0 ] ==cpu_to_be32 (XFS_ABTC_MAGIC )) btnum = XFS_BTNUM_CNTi; -if (pag && pag->pagf_init) { +if (pag &&xfs_perag_initialised_agf (pag)) {if (level >= pag->pagf_levels[btnum])return __this_address; }else if (level >= mp->m_alloc_maxlevels)
fs/xfs/libxfs/xfs_bmap.c +1 -1
@@ -3147,7 +3147,7 @@ xfs_bmap_longest_free_extent(int error =0 ; pag =xfs_perag_get (mp, ag); -if (!pag->pagf_init) { +if (!xfs_perag_initialised_agf (pag)) { error =xfs_alloc_read_agf (pag, tp,XFS_ALLOC_FLAG_TRYLOCK ,NULL );if (error) {
fs/xfs/libxfs/xfs_ialloc.c +7 -7
@@ -998,8 +998,8 @@ xfs_dialloc_ag_inobt(int i, j;int searchdistance =10 ; -ASSERT (pag->pagi_init); -ASSERT (pag->pagi_inodeok); +ASSERT (xfs_perag_initialised_agi (pag)); +ASSERT (xfs_perag_allows_inodes (pag));ASSERT (pag->pagi_freecount >0 ); restart_pagno:
@@ -1592,10 +1592,10 @@ xfs_dialloc_good_ag(if (!pag)return false; -if (!pag->pagi_inodeok) +if (!xfs_perag_allows_inodes (pag))return false; -if (!pag->pagi_init) { +if (!xfs_perag_initialised_agi (pag)) { error =xfs_ialloc_read_agi (pag, tp,NULL );if (error)return false;
@@ -1606,7 +1606,7 @@ xfs_dialloc_good_ag(if (!ok_alloc)return false; -if (!pag->pagf_init) { +if (!xfs_perag_initialised_agf (pag)) { error =xfs_alloc_read_agf (pag, tp, flags,NULL );if (error)return false;
@@ -2603,10 +2603,10 @@ xfs_ialloc_read_agi(return error; agi = agibp->b_addr; -if (!pag->pagi_init) { +if (!xfs_perag_initialised_agi (pag)) { pag->pagi_freecount =be32_to_cpu (agi->agi_freecount); pag->pagi_count =be32_to_cpu (agi->agi_count); - pag->pagi_init =1 ; +set_bit (XFS_AGSTATE_AGI_INIT , &pag->pag_opstate); }/*
fs/xfs/libxfs/xfs_ialloc_btree.c +2 -2
@@ -291,8 +291,8 @@ xfs_inobt_verify(* Similarly, during log recovery we will have a perag structure * attached, but the agi information will not yet have been initialised * from the on disk AGI. We don't currently use any of this information, -* but beware of the landmine (i.e. need to check pag->pagi_init) if we -* ever do. +* but beware of the landmine (i.e. need to check +* xfs_perag_initialised_agi(pag)) if we ever do. */ if (xfs_has_crc (mp)) { fa =xfs_btree_sblock_v5hdr_verify (bp);
fs/xfs/libxfs/xfs_refcount_btree.c +1 -1
@@ -227,7 +227,7 @@ xfs_refcountbt_verify(return fa; level =be16_to_cpu (block->bb_level); -if (pag && pag->pagf_init) { +if (pag &&xfs_perag_initialised_agf (pag)) {if (level >= pag->pagf_refcount_level)return __this_address; }else if (level >= mp->m_refc_maxlevels)
fs/xfs/libxfs/xfs_rmap_btree.c +1 -1
@@ -313,7 +313,7 @@ xfs_rmapbt_verify(return fa; level =be16_to_cpu (block->bb_level); -if (pag && pag->pagf_init) { +if (pag &&xfs_perag_initialised_agf (pag)) {if (level >= pag->pagf_levels[XFS_BTNUM_RMAPi])return __this_address; }else if (level >= mp->m_rmap_maxlevels)
fs/xfs/scrub/agheader_repair.c +15 -13
@@ -191,14 +191,15 @@ xrep_agf_init_header( struct xfs_agf *old_agf) {struct xfs_mount *mp = sc->mp; +struct xfs_perag *pag = sc->sa.pag;struct xfs_agf *agf = agf_bp->b_addr;memcpy (old_agf, agf,sizeof (*old_agf));memset (agf,0 ,BBTOB (agf_bp->b_length)); agf->agf_magicnum =cpu_to_be32 (XFS_AGF_MAGIC ); agf->agf_versionnum =cpu_to_be32 (XFS_AGF_VERSION ); - agf->agf_seqno =cpu_to_be32 (sc->sa.pag->pag_agno); - agf->agf_length =cpu_to_be32 (sc->sa.pag->block_count); + agf->agf_seqno =cpu_to_be32 (pag->pag_agno); + agf->agf_length =cpu_to_be32 (pag->block_count); agf->agf_flfirst = old_agf->agf_flfirst; agf->agf_fllast = old_agf->agf_fllast; agf->agf_flcount = old_agf->agf_flcount;
@@ -206,8 +207,8 @@ xrep_agf_init_header(uuid_copy (&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);/* Mark the incore AGF data stale until we're done fixing things. */ -ASSERT (sc->sa.pag->pagf_init); - sc->sa.pag->pagf_init =0 ; +ASSERT (xfs_perag_initialised_agf (pag)); +clear_bit (XFS_AGSTATE_AGF_INIT , &pag->pag_opstate); }/* Set btree root information in an AGF. */
@@ -333,7 +334,7 @@ xrep_agf_commit_new( pag->pagf_levels[XFS_BTNUM_RMAPi] =be32_to_cpu (agf->agf_levels[XFS_BTNUM_RMAPi]); pag->pagf_refcount_level =be32_to_cpu (agf->agf_refcount_level); - pag->pagf_init =1 ; +set_bit (XFS_AGSTATE_AGF_INIT , &pag->pag_opstate);return 0 ; }
@@ -434,7 +435,7 @@ xrep_agf( out_revert:/* Mark the incore AGF state stale and revert the AGF. */ - sc->sa.pag->pagf_init =0 ; +clear_bit (XFS_AGSTATE_AGF_INIT , &sc->sa.pag->pag_opstate);memcpy (agf, &old_agf,sizeof (old_agf));return error; }
@@ -618,7 +619,7 @@ xrep_agfl_update_agf(xfs_force_summary_recalc (sc->mp);/* Update the AGF counters. */ -if (sc->sa.pag->pagf_init) +if (xfs_perag_initialised_agf (sc->sa.pag)) sc->sa.pag->pagf_flcount = flcount; agf->agf_flfirst =cpu_to_be32 (0 ); agf->agf_flcount =cpu_to_be32 (flcount);
@@ -822,14 +823,15 @@ xrep_agi_init_header( struct xfs_agi *old_agi) {struct xfs_agi *agi = agi_bp->b_addr; +struct xfs_perag *pag = sc->sa.pag;struct xfs_mount *mp = sc->mp;memcpy (old_agi, agi,sizeof (*old_agi));memset (agi,0 ,BBTOB (agi_bp->b_length)); agi->agi_magicnum =cpu_to_be32 (XFS_AGI_MAGIC ); agi->agi_versionnum =cpu_to_be32 (XFS_AGI_VERSION ); - agi->agi_seqno =cpu_to_be32 (sc->sa.pag->pag_agno); - agi->agi_length =cpu_to_be32 (sc->sa.pag->block_count); + agi->agi_seqno =cpu_to_be32 (pag->pag_agno); + agi->agi_length =cpu_to_be32 (pag->block_count); agi->agi_newino =cpu_to_be32 (NULLAGINO ); agi->agi_dirino =cpu_to_be32 (NULLAGINO );if (xfs_has_crc (mp))
@@ -840,8 +842,8 @@ xrep_agi_init_header( sizeof(agi->agi_unlinked));/* Mark the incore AGF data stale until we're done fixing things. */ -ASSERT (sc->sa.pag->pagi_init); - sc->sa.pag->pagi_init =0 ; +ASSERT (xfs_perag_initialised_agi (pag)); +clear_bit (XFS_AGSTATE_AGI_INIT , &pag->pag_opstate); }/* Set btree root information in an AGI. */
@@ -928,7 +930,7 @@ xrep_agi_commit_new( pag = sc->sa.pag; pag->pagi_count =be32_to_cpu (agi->agi_count); pag->pagi_freecount =be32_to_cpu (agi->agi_freecount); - pag->pagi_init =1 ; +set_bit (XFS_AGSTATE_AGI_INIT , &pag->pag_opstate);return 0 ; }
@@ -993,7 +995,7 @@ xrep_agi( out_revert:/* Mark the incore AGI state stale and revert the AGI. */ - sc->sa.pag->pagi_init =0 ; +clear_bit (XFS_AGSTATE_AGI_INIT , &sc->sa.pag->pag_opstate);memcpy (agi, &old_agi,sizeof (old_agi));return error; }
fs/xfs/scrub/fscounters.c +6 -3
@@ -86,7 +86,8 @@ xchk_fscount_warmup(for_each_perag (mp, agno, pag) {if (xchk_should_terminate (sc, &error))break ; -if (pag->pagi_init && pag->pagf_init) +if (xfs_perag_initialised_agi (pag) && +xfs_perag_initialised_agf (pag))continue ;/* Lock both AG headers. */
@@ -101,7 +102,8 @@ xchk_fscount_warmup(* These are supposed to be initialized by the header read * function. */ -if (!pag->pagi_init || !pag->pagf_init) { +if (!xfs_perag_initialised_agi (pag) || + !xfs_perag_initialised_agf (pag)) { error = -EFSCORRUPTED ;break ; }
@@ -220,7 +222,8 @@ xchk_fscount_aggregate_agcounts(break ;/* This somehow got unset since the warmup? */ -if (!pag->pagi_init || !pag->pagf_init) { +if (!xfs_perag_initialised_agi (pag) || + !xfs_perag_initialised_agf (pag)) { error = -EFSCORRUPTED ;break ; }
fs/xfs/scrub/repair.c +1 -1
@@ -206,7 +206,7 @@ xrep_calc_ag_resblks(return 0 ; pag =xfs_perag_get (mp, sm->sm_agno); -if (pag->pagi_init) { +if (xfs_perag_initialised_agi (pag)) {/* Use in-core icount if possible. */ icount = pag->pagi_count; }else {
fs/xfs/xfs_filestream.c +3 -2
@@ -125,7 +125,7 @@ xfs_filestream_pick_ag( pag =xfs_perag_get (mp, ag); -if (!pag->pagf_init) { +if (!xfs_perag_initialised_agf (pag)) { err =xfs_alloc_read_agf (pag,NULL , trylock,NULL );if (err) {if (err != -EAGAIN ) {
@@ -159,7 +159,8 @@ xfs_filestream_pick_ag( xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));if (((minlen && longest >= minlen) || (!minlen && pag->pagf_freeblks >= minfree)) && - (!pag->pagf_metadata || !(flags &XFS_PICK_USERDATA ) || + (!xfs_perag_prefers_metadata (pag) || + !(flags &XFS_PICK_USERDATA ) || (flags &XFS_PICK_LOWSPACE ))) {/* Break out, retaining the reference on the AG. */
fs/xfs/xfs_super.c +28 -18
58 lines not on this page · raw message
Signature · 1 line
2.39.0
Re: [PATCH 13/42] xfs: perags need atomic operational state
Quoted 7 lines · Dave Chinner
From: Dave Chinner <[email protected]>
We currently don't have any flags or operational state in the
xfs_peragexcept for thepagf_initandpagi_initflags. And the agflreset flag. Oh, there's also thepagf_metadataandpagi_inodeokflags, too.
Quoted 6 lines
For controlling per-ag operations, we are going to need some atomic state flags. Hence add an opstate field similar to what we already have in the mount and log, and convert all these state flags across to atomic bit operations.
Signed-off-by Dave Chinner <[email protected]>
Seems like a reasonable conversion
Quoted 571 lines
---
fs/xfs/libxfs/xfs_ag.h | 27 ++++++++++++++---- fs/xfs/libxfs/xfs_alloc.c | 23 ++++++++------- fs/xfs/libxfs/xfs_alloc_btree.c | 2 +- fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/libxfs/xfs_ialloc.c | 14 ++++----- fs/xfs/libxfs/xfs_ialloc_btree.c | 4 +--fs/xfs/libxfs/xfs_refcount_btree.c| 2 +- fs/xfs/libxfs/xfs_rmap_btree.c | 2 +- fs/xfs/scrub/agheader_repair.c | 28 +++++++++--------- fs/xfs/scrub/fscounters.c | 9 ++++-- fs/xfs/scrub/repair.c | 2 +- fs/xfs/xfs_filestream.c | 5 ++-- fs/xfs/xfs_super.c | 46 ++++++++++++++++++---------- --13 files changed, 101 insertions(+), 65 deletions(-)fs/xfs/libxfs/xfs_ag.h +0
-0@@ -35,13 +35,9 @@ struct xfs_perag {atomic_t pag_ref; /* passive reference count */ atomic_t pag_active_ref; /* active reference count */
wait_queue_head_tpag_active_wq;/* wokenactive_reffalls to zero */
- char pagf_init; /* this agf's entry is initialized */
- char pagi_init; /* this agi's entry is initialized */
- char pagf_metadata; /* the agf is preferred to be metadata */
- char pagi_inodeok; /* The agi is ok for inodes */
+ unsigned long pag_opstate;
uint8_t pagf_levels[XFS_BTNUM_AGF];
/* # of levels in bno & cnt btree */
- bool pagf_agflreset; /* agfl requires reset before use */
uint32_t pagf_flcount; /* count of blocks in freelist */
xfs_extlen_t pagf_freeblks; /* total free blocks */ xfs_extlen_t pagf_longest; /* longest free space */fs/xfs/libxfs/xfs_ag.h +0
-0@@ -108,6 +104,27 @@ struct xfs_perag { #endif /* __KERNEL__ */ };fs/xfs/libxfs/xfs_ag.h +21
-0+/* +* Per-AG operational state. These are atomic flag bits. +*/ +#define XFS_AGSTATE_AGF_INIT 0 +#define XFS_AGSTATE_AGI_INIT 1 +#define XFS_AGSTATE_PREFERS_METADATA 2 +#define XFS_AGSTATE_ALLOWS_INODES 3 +#define XFS_AGSTATE_AGFL_NEEDS_RESET 4 + +#define __XFS_AG_OPSTATE (name,NAME ) \ +static inline bool xfs_perag_ ## name (struct xfs_perag *pag) \ +{ \ + return test_bit(XFS_AGSTATE_ ## NAME, &pag->pag_opstate); \ +} + +__XFS_AG_OPSTATE(initialised_agf, AGF_INIT) +__XFS_AG_OPSTATE(initialised_agi, AGI_INIT) +__XFS_AG_OPSTATE(prefers_metadata, PREFERS_METADATA) +__XFS_AG_OPSTATE(allows_inodes, ALLOWS_INODES) +__XFS_AG_OPSTATE (agfl_needs_reset,AGFL_NEEDS_RESET ) +int xfs_initialize_perag(struct
xfs_mount*mp,xfs_agnumber_tagcount,
xfs_rfsblock_t dcount,xfs_agnumber_t*maxagi);
intxfs_initialize_perag_data(struct xfs_mount *mp, xfs_agnumber_t agno);fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2435,7 +2435,7 @@ xfs_agfl_reset( struct xfs_mount *mp = tp->t_mountp; struct xfs_agf *agf = agbp->b_addr;
- ASSERT(pag->pagf_agflreset);
+ ASSERT(xfs_perag_agfl_needs_reset(pag));trace_xfs_agfl_reset(mp, agf, 0, _RET_IP_);
xfs_warn(mp,fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2450,7 +2450,7 @@ xfs_agfl_reset( XFS_AGF_FLCOUNT);
pag->pagf_flcount = 0;
- pag->pagf_agflreset = false;
+ clear_bit(XFS_AGSTATE_AGFL_NEEDS_RESET,&pag->pag_opstate); }
/*fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2605,7 +2605,7 @@ xfs_alloc_fix_freelist( /* deferred ops (AGFL block frees) require permanenttransactions */
ASSERT(tp->t_flags &XFS_TRANS_PERM_LOG_RES);
- if (!pag->pagf_init) {
+ if (!xfs_perag_initialised_agf(pag)) {
error =xfs_alloc_read_agf(pag, tp, flags, &agbp); if (error) {
/* Couldn't lock the AGF so skip this AG. */fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2620,7 +2620,8 @@ xfs_alloc_fix_freelist( * somewhere else if we are not being asked to try harder atthis
* point
*/
- if (pag->pagf_metadata&& (args->datatype&XFS_ALLOC_USERDATA) &&
+ if (xfs_perag_prefers_metadata(pag)&&
+ (args->datatype&XFS_ALLOC_USERDATA) && (flags &XFS_ALLOC_FLAG_TRYLOCK)) {ASSERT(!(flags & XFS_ALLOC_FLAG_FREEING)); gotoout_agbp_relse;fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2646,7 +2647,7 @@ xfs_alloc_fix_freelist( }
/* reset a padding mismatched agfl before final free space check */
- if (pag->pagf_agflreset)
+ if (xfs_perag_agfl_needs_reset(pag))xfs_agfl_reset(tp, agbp, pag);
/* If there isn't enough total space or single-extent, reject it. */fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2803,7 +2804,7 @@ xfs_alloc_get_freelist( if (be32_to_cpu(agf->agf_flfirst) == xfs_agfl_size(mp)) agf->agf_flfirst = 0;
- ASSERT(!pag->pagf_agflreset);
+ ASSERT(!xfs_perag_agfl_needs_reset(pag));
be32_add_cpu(&agf->agf_flcount, -1);
pag->pagf_flcount--;fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -2892,7 +2893,7 @@ xfs_alloc_put_freelist( if (be32_to_cpu(agf->agf_fllast) == xfs_agfl_size(mp)) agf->agf_fllast = 0;
- ASSERT(!pag->pagf_agflreset);
+ ASSERT(!xfs_perag_agfl_needs_reset(pag));
be32_add_cpu(&agf->agf_flcount, 1);
pag->pagf_flcount++;fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3099,7 +3100,7 @@ xfs_alloc_read_agf( return error;
agf =agfbp->b_addr;
- if (!pag->pagf_init) {
+ if (!xfs_perag_initialised_agf(pag)) {pag->pagf_freeblks=be32_to_cpu(agf->agf_freeblks);pag->pagf_btreeblks= be32_to_cpu(agf-Quoted 1 line
agf_btreeblks);pag->pagf_flcount =
be32_to_cpu(agf->agf_flcount);fs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3111,8 +3112,8 @@ xfs_alloc_read_agf(pag->pagf_levels[XFS_BTNUM_RMAPi] = be32_to_cpu(agf-
Quoted 1 line
agf_levels[XFS_BTNUM_RMAPi]);
pag->pagf_refcount_level = be32_to_cpu(agf-
Quoted 1 line
agf_refcount_level);- pag->pagf_init = 1;
- pag->pagf_agflreset = xfs_agfl_needs_reset(pag-Quoted 1 line
pag_mount, agf);+ if (
xfs_agfl_needs_reset(pag->pag_mount, agf)) + set_bit(XFS_AGSTATE_AGFL_NEEDS_RESET, &pag-Quoted 1 line
pag_opstate);
/*
* Update the in-core allocbt counter. Filter out the rmapbtfs/xfs/libxfs/xfs_alloc.c +0
-0@@ -3127,6 +3128,8 @@ xfs_alloc_read_agf( if (allocbt_blks > 0) atomic64_add(allocbt_blks,&pag->pag_mount-
Quoted 1 line
m_allocbt_blks);+
+ set_bit(XFS_AGSTATE_AGF_INIT,&pag->pag_opstate); }
#ifdef DEBUG
else if (!xfs_is_shutdown(pag->pag_mount)) {fs/xfs/libxfs/xfs_alloc_btree.c +1
-1@@ -315,7 +315,7 @@ xfs_allocbt_verify( level = be16_to_cpu(block->bb_level); if (bp->b_ops->magic[0] == cpu_to_be32(XFS_ABTC_MAGIC)) btnum = XFS_BTNUM_CNTi; - if (pag && pag->pagf_init) { + if (pag && xfs_perag_initialised_agf(pag)) { if (level >= pag->pagf_levels[btnum]) return __this_address; } else if (level >= mp->m_alloc_maxlevels)fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3147,7 +3147,7 @@ xfs_bmap_longest_free_extent( int error = 0;
pag =xfs_perag_get(mp, ag);
- if (!pag->pagf_init) {
+ if (!xfs_perag_initialised_agf(pag)) { error = xfs_alloc_read_agf(pag, tp,XFS_ALLOC_FLAG_TRYLOCK,
NULL);
if (error) {fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -998,8 +998,8 @@ xfs_dialloc_ag_inobt( int i, j; int searchdistance = 10;
- ASSERT(pag->pagi_init);
- ASSERT(pag->pagi_inodeok);
+ ASSERT(xfs_perag_initialised_agi(pag));
+ ASSERT(xfs_perag_allows_inodes(pag));
ASSERT(pag->pagi_freecount > 0);
restart_pagno:fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1592,10 +1592,10 @@ xfs_dialloc_good_ag(
if (!pag)
return false;
- if (!pag->pagi_inodeok)
+ if (!xfs_perag_allows_inodes(pag))
return false;
- if (!pag->pagi_init) {
+ if (!xfs_perag_initialised_agi(pag)) { error =xfs_ialloc_read_agi(pag, tp, NULL); if (error)
return false;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1606,7 +1606,7 @@ xfs_dialloc_good_ag( if (!ok_alloc) return false;
- if (!pag->pagf_init) {
+ if (!xfs_perag_initialised_agf(pag)) {
error =xfs_alloc_read_agf(pag, tp, flags, NULL); if (error)
return false;fs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -2603,10 +2603,10 @@ xfs_ialloc_read_agi( return error;
agi =agibp->b_addr;
- if (!pag->pagi_init) {
+ if (!xfs_perag_initialised_agi(pag)) {pag->pagi_freecount= be32_to_cpu(agi-Quoted 1 line
agi_freecount);pag->pagi_count =
be32_to_cpu(agi->agi_count); - pag->pagi_init = 1;
+ set_bit(XFS_AGSTATE_AGI_INIT,&pag->pag_opstate); }
/*fs/xfs/libxfs/xfs_ialloc_btree.c +0
-0@@ -291,8 +291,8 @@ xfs_inobt_verify( * Similarly, during log recovery we will have a peragstructure
* attached, but the agi information will not yet have been initialised
* from the on disk AGI. We don't currently use any of this information,
- * but beware of the landmine (i.e. need to check pag-Quoted 1 line
pagi_init) if we- * ever do.
+ * but beware of the landmine (i.e. need to check + *xfs_perag_initialised_agi(pag)) if we ever do. */
if (xfs_has_crc(mp)) {
fa =xfs_btree_sblock_v5hdr_verify(bp);fs/xfs/libxfs/xfs_refcount_btree.c +0
-0@@ -227,7 +227,7 @@ xfs_refcountbt_verify( return fa;
level =be16_to_cpu(block->bb_level); - if (pag &&pag->pagf_init) {
+ if (pag &&xfs_perag_initialised_agf(pag)) { if (level >=pag->pagf_refcount_level) return__this_address; } else if (level >=mp->m_refc_maxlevels)fs/xfs/libxfs/xfs_rmap_btree.c +0
-0@@ -313,7 +313,7 @@ xfs_rmapbt_verify( return fa;
level =be16_to_cpu(block->bb_level);
- if (pag &&pag->pagf_init) {
+ if (pag &&xfs_perag_initialised_agf(pag)) { if (level >= pag->pagf_levels[XFS_BTNUM_RMAPi]) return__this_address;
} else if (level >=mp->m_rmap_maxlevels)fs/xfs/scrub/agheader_repair.c +1
-0@@ -191,14 +191,15 @@ xrep_agf_init_header( struct xfs_agf *old_agf) { struct xfs_mount *mp = sc->mp; + struct xfs_perag *pag = sc->sa.pag; struct xfs_agf *agf = agf_bp->b_addr;
memcpy(old_agf, agf,sizeof(*old_agf));memset(agf, 0, BBTOB(agf_bp->b_length));agf->agf_magicnum=cpu_to_be32(XFS_AGF_MAGIC);agf->agf_versionnum=cpu_to_be32(XFS_AGF_VERSION); - agf->agf_seqno =cpu_to_be32(sc->sa.pag->pag_agno); - agf->agf_length =cpu_to_be32(sc->sa.pag->block_count); + agf->agf_seqno =cpu_to_be32(pag->pag_agno); + agf->agf_length =cpu_to_be32(pag->block_count);agf->agf_flfirst=old_agf->agf_flfirst;agf->agf_fllast=old_agf->agf_fllast;agf->agf_flcount=old_agf->agf_flcount;fs/xfs/scrub/agheader_repair.c +0
-0@@ -206,8 +207,8 @@ xrep_agf_init_header( uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);
/* Mark the incore AGF data stale until we're done fixing things. */
- ASSERT(sc->sa.pag->pagf_init);
- sc->sa.pag->pagf_init = 0;
+ ASSERT(xfs_perag_initialised_agf(pag));
+ clear_bit(XFS_AGSTATE_AGF_INIT,&pag->pag_opstate); }
/* Set btree root information in an AGF. */fs/xfs/scrub/agheader_repair.c +0
-0@@ -333,7 +334,7 @@ xrep_agf_commit_new(pag->pagf_levels[XFS_BTNUM_RMAPi] =
be32_to_cpu(agf-Quoted 1 line
agf_levels[XFS_BTNUM_RMAPi]);
pag->pagf_refcount_level = be32_to_cpu(agf-
Quoted 1 line
agf_refcount_level);- pag->pagf_init = 1;
+ set_bit(XFS_AGSTATE_AGF_INIT,&pag->pag_opstate);
return 0;
}fs/xfs/scrub/agheader_repair.c +0
-0@@ -434,7 +435,7 @@ xrep_agf(
out_revert:
/* Mark the incore AGF state stale and revert the AGF. */ - sc->sa.pag->pagf_init = 0;
+ clear_bit(XFS_AGSTATE_AGF_INIT,&sc->sa.pag->pag_opstate);memcpy(agf, &old_agf, sizeof(old_agf));
return error;
}fs/xfs/scrub/agheader_repair.c +0
-0@@ -618,7 +619,7 @@ xrep_agfl_update_agf( xfs_force_summary_recalc(sc->mp);
/* Update the AGF counters. */
- if (sc->sa.pag->pagf_init)
+ if (xfs_perag_initialised_agf(sc->sa.pag))sc->sa.pag->pagf_flcount= flcount;agf->agf_flfirst=cpu_to_be32(0);agf->agf_flcount=cpu_to_be32(flcount);fs/xfs/scrub/agheader_repair.c +1
-0@@ -822,14 +823,15 @@ xrep_agi_init_header( struct xfs_agi *old_agi) { struct xfs_agi *agi = agi_bp->b_addr; + struct xfs_perag *pag = sc->sa.pag; struct xfs_mount *mp = sc->mp;
memcpy(old_agi, agi,sizeof(*old_agi));memset(agi, 0, BBTOB(agi_bp->b_length));agi->agi_magicnum=cpu_to_be32(XFS_AGI_MAGIC);agi->agi_versionnum=cpu_to_be32(XFS_AGI_VERSION); - agi->agi_seqno =cpu_to_be32(sc->sa.pag->pag_agno); - agi->agi_length =cpu_to_be32(sc->sa.pag->block_count); + agi->agi_seqno =cpu_to_be32(pag->pag_agno); + agi->agi_length =cpu_to_be32(pag->block_count);agi->agi_newino=cpu_to_be32(NULLAGINO);agi->agi_dirino=cpu_to_be32(NULLAGINO);
if (xfs_has_crc(mp))fs/xfs/scrub/agheader_repair.c +0
-0@@ -840,8 +842,8 @@ xrep_agi_init_header( sizeof(agi->agi_unlinked));
/* Mark the incore AGF data stale until we're done fixing things. */
- ASSERT(sc->sa.pag->pagi_init);
- sc->sa.pag->pagi_init = 0;
+ ASSERT(xfs_perag_initialised_agi(pag));
+ clear_bit(XFS_AGSTATE_AGI_INIT,&pag->pag_opstate); }
/* Set btree root information in an AGI. */fs/xfs/scrub/agheader_repair.c +1
-1@@ -928,7 +930,7 @@ xrep_agi_commit_new( pag = sc->sa.pag; pag->pagi_count = be32_to_cpu(agi->agi_count); pag->pagi_freecount = be32_to_cpu(agi->agi_freecount); - pag->pagi_init = 1; + set_bit(XFS_AGSTATE_AGI_INIT, &pag->pag_opstate);
return 0;
}fs/xfs/scrub/agheader_repair.c +0
-0@@ -993,7 +995,7 @@ xrep_agi(
out_revert:
/* Mark the incore AGI state stale and revert the AGI. */ - sc->sa.pag->pagi_init = 0;
+ clear_bit(XFS_AGSTATE_AGI_INIT,&sc->sa.pag->pag_opstate);memcpy(agi, &old_agi, sizeof(old_agi));
return error;
}fs/xfs/scrub/fscounters.c +2
-1@@ -86,7 +86,8 @@ xchk_fscount_warmup( for_each_perag(mp, agno, pag) { if (xchk_should_terminate(sc, &error)) break; - if (pag->pagi_init && pag->pagf_init) + if (xfs_perag_initialised_agi(pag) && + xfs_perag_initialised_agf(pag)) continue;
/* Lock both AG headers. */fs/xfs/scrub/fscounters.c +0
-0@@ -101,7 +102,8 @@ xchk_fscount_warmup( * These are supposed to be initialized by the headerread
* function.
*/
- if (!pag->pagi_init || !pag->pagf_init) { + if (!xfs_perag_initialised_agi(pag) || + !xfs_perag_initialised_agf(pag)) { error =-EFSCORRUPTED; break;
}fs/xfs/scrub/fscounters.c +0
-0@@ -220,7 +222,8 @@ xchk_fscount_aggregate_agcounts( break;
/* This somehow got unset since the warmup? */ - if (!pag->pagi_init || !pag->pagf_init) { + if (!xfs_perag_initialised_agi(pag) || + !xfs_perag_initialised_agf(pag)) { error =-EFSCORRUPTED; break;
}fs/xfs/scrub/repair.c +0
-0@@ -206,7 +206,7 @@ xrep_calc_ag_resblks( return 0;
pag =xfs_perag_get(mp, sm->sm_agno); - if (pag->pagi_init) {
+ if (xfs_perag_initialised_agi(pag)) { /* Use in-core icount if possible. */ icount =pag->pagi_count;
} else {fs/xfs/xfs_filestream.c +0
-0@@ -125,7 +125,7 @@ xfs_filestream_pick_ag(
pag =xfs_perag_get(mp, ag);
- if (!pag->pagf_init) {
+ if (!xfs_perag_initialised_agf(pag)) { err =xfs_alloc_read_agf(pag, NULL, trylock, NULL);
if (err) {
if (err !=-EAGAIN) {fs/xfs/xfs_filestream.c +0
-0@@ -159,7 +159,8 @@ xfs_filestream_pick_ag( xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));if (((minlen && longest >= minlen) || (!minlen &&
pag->pagf_freeblks>= minfree)) && - (!pag->pagf_metadata || !(flags &XFS_PICK_USERDATA) ||
+ (!xfs_perag_prefers_metadata(pag) || + !(flags &XFS_PICK_USERDATA) || (flags &XFS_PICK_LOWSPACE))) {
/* Break out, retaining the reference on the AG. */fs/xfs/xfs_super.c +0
-0@@ -247,6 +247,32 @@ xfs_fs_show_options( return 0; }fs/xfs/xfs_super.c +8
-0+static bool +xfs_set_inode_alloc_perag ( + struct xfs_perag *pag, + xfs_ino_t ino, + xfs_agnumber_t max_metadata) +{ + if (!xfs_is_inode32(pag->pag_mount)) { + set_bit(XFS_AGSTATE_ALLOWS_INODES, &pag-Quoted 1 line
pag_opstate);+ clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag-
Quoted 1 line
pag_opstate);+ return false;
+ }
+
+ if (ino >XFS_MAXINUMBER_32) {
+ clear_bit(XFS_AGSTATE_ALLOWS_INODES, &pag-Quoted 1 line
pag_opstate);+ clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag-
Quoted 1 line
pag_opstate);+ return false;
+ }
+
+ set_bit(XFS_AGSTATE_ALLOWS_INODES,&pag->pag_opstate); + if (pag->pag_agno<max_metadata)
+ set_bit(XFS_AGSTATE_PREFERS_METADATA, &pag-Quoted 1 line
pag_opstate);+ else
+ clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag-Quoted 1 line
pag_opstate);+ return true;
fs/xfs/xfs_super.c +2
-0+} +/*
* Set parameters for inode allocation heuristics, taking into account
* filesystem size and inode32/inode64 mount options; i.e. specificallyfs/xfs/xfs_super.c +0
-0@@ -310,24 +336,8 @@ xfs_set_inode_alloc( ino = XFS_AGINO_TO_INO(mp, index, agino);
pag =xfs_perag_get(mp, index);fs/xfs/xfs_super.c +1
-18- - if (xfs_is_inode32(mp)) { - if (ino > XFS_MAXINUMBER_32) { - pag->pagi_inodeok = 0; - pag->pagf_metadata = 0; - } else { - pag->pagi_inodeok = 1; - maxagi++; - if (index < max_metadata) - pag->pagf_metadata = 1; - else - pag->pagf_metadata = 0; - } - } else { - pag->pagi_inodeok = 1; - pag->pagf_metadata = 0; - } - + if (xfs_set_inode_alloc_perag(pag, ino,
max_metadata))
+ maxagi++;
xfs_perag_put(pag);
}
PATCH 14/42 xfs: introduce xfs_for_each_perag_wrap()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
In several places we iterate every AG from a specific start agno and wrap back to the first AG when we reach the end of the filesystem to continue searching. We don't have a primitive for this iteration yet, so add one for conversion of these algorithms to per-ag based iteration.
The filestream AG select code is a mess, and this initially makes it worse. The per-ag selection needs to be driven completely into the filestream code to clean this up and it will be done in a future patch that makes the filestream allocator use active per-ag references correctly.
--- fs/xfs/libxfs/xfs_ag.h | 45 +++++++++++++++++++++- fs/xfs/libxfs/xfs_bmap.c | 76 ++++++++++++++++++++++---------------- fs/xfs/libxfs/xfs_ialloc.c | 32 ++++++++-------- 3 files changed, 104 insertions(+), 49 deletions(-)
fs/xfs/libxfs/xfs_ag.h +44 -1
@@ -237,7 +237,6 @@ xfs_perag_next(#define for_each_perag_from (mp, agno, pag) \ for_each_perag_range((mp), (agno), (mp)->m_sb.sb_agcount - 1, (pag)) -#define for_each_perag (mp, agno, pag) \ (agno) = 0; \ for_each_perag_from((mp), (agno), (pag))
@@ -249,6 +248,50 @@ xfs_perag_next( xfs_perag_rele(pag), \ (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) +static inline struct xfs_perag * +xfs_perag_next_wrap ( +struct xfs_perag *pag, +xfs_agnumber_t *agno, +xfs_agnumber_t stop_agno, +xfs_agnumber_t wrap_agno) +{ +struct xfs_mount *mp = pag->pag_mount; + + *agno = pag->pag_agno +1 ; +xfs_perag_rele (pag); +while (*agno != stop_agno) { +if (*agno >= wrap_agno) + *agno =0 ; +if (*agno == stop_agno) +break ; + + pag =xfs_perag_grab (mp, *agno); +if (pag) +return pag; + (*agno)++; + } +return NULL ; +} + +/* +* Iterate all AGs from start_agno through wrap_agno, then 0 through +* (start_agno - 1). +*/ +#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag) \ + for ((agno) = (start_agno), (pag) = xfs_perag_grab((mp), (agno)); \ + (pag) != NULL; \ + (pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \ + (wrap_agno))) + +/* +* Iterate all AGs from start_agno through to the end of the filesystem, then 0 +* through (start_agno - 1). +*/ +#define for_each_perag_wrap (mp, start_agno, agno, pag) \ + for_each_perag_wrap_at((mp), (start_agno), (mp)->m_sb.sb_agcount, \ + (agno), (pag)) + +struct aghdr_init_data {/* per ag data */ xfs_agblock_t agno;/* ag to init */
fs/xfs/libxfs/xfs_bmap.c +45 -31
151 lines not on this page · raw message
fs/xfs/libxfs/xfs_ialloc.c +15 -17
@@ -1725,7 +1725,7 @@ xfs_dialloc(bool ok_alloc = true;bool low_space = false;int flags; -xfs_ino_t ino; +xfs_ino_t ino =NULLFSINO ;/* * Directories, symlinks, and regular files frequently allocate at least
@@ -1773,39 +1773,37 @@ xfs_dialloc(* or in which we can allocate some inodes. Iterate through the * allocation groups upward, wrapping at the end. */ - agno = start_agno; flags =XFS_ALLOC_FLAG_TRYLOCK ; -for (;;) { - pag =xfs_perag_grab (mp, agno); +retry: +for_each_perag_wrap_at (mp, start_agno, mp->m_maxagi, agno, pag) {if (xfs_dialloc_good_ag (pag, *tpp, mode, flags, ok_alloc)) { error =xfs_dialloc_try_ag (pag, tpp, parent, &ino, ok_alloc);if (error != -EAGAIN )break ; + error =0 ; }if (xfs_is_shutdown (mp)) { error = -EFSCORRUPTED ;break ; } -if (++agno == mp->m_maxagi) - agno =0 ; -if (agno == start_agno) { -if (!flags) { - error = -ENOSPC ; -break ; - } + } +if (pag) +xfs_perag_rele (pag); +if (error) +return error; +if (ino ==NULLFSINO ) { +if (flags) { flags =0 ;if (low_space) ok_alloc = true; + goto retry; } -xfs_perag_rele (pag); +return -ENOSPC ; } - -if (!error) - *new_ino = ino; -xfs_perag_rele (pag); -return error; + *new_ino = ino; +return 0 ; }/*
Signature · 1 line
2.39.0
Re: [PATCH 14/42] xfs: introduce xfs_for_each_perag_wrap()
Quoted 178 lines · Dave Chinner
From: Dave Chinner <[email protected]>
In several places we iterate every AG from a specific start agno and wrap back to the first AG when we reach the end of the filesystem to continue searching. We don't have a primitive for this iteration yet, so add one for conversion of these algorithms to per-ag based iteration.
The filestream AG select code is a mess, and this initially makes it worse. The per-ag selection needs to be driven completely into the filestream code to clean this up and it will be done in a future patch that makes the filestream allocator use active per-ag references correctly.
Signed-off-by Dave Chinner <[email protected]>---
fs/xfs/libxfs/xfs_ag.h | 45 +++++++++++++++++++++- fs/xfs/libxfs/xfs_bmap.c | 76 ++++++++++++++++++++++-------------- --
fs/xfs/libxfs/xfs_ialloc.c | 32 ++++++++--------3 files changed, 104 insertions(+), 49 deletions(-)fs/xfs/libxfs/xfs_ag.h +0
-0@@ -237,7 +237,6 @@ xfs_perag_next( #define for_each_perag_from(mp, agno, pag) \ for_each_perag_range((mp), (agno), (mp)->m_sb.sb_agcount - 1, (pag))
-
#definefor_each_perag(mp, agno, pag)\
(agno) = 0; \
for_each_perag_from((mp), (agno), (pag))fs/xfs/libxfs/xfs_ag.h +0
-0@@ -249,6 +248,50 @@ xfs_perag_next( xfs_perag_rele(pag), \ (pag) = xfs_perag_grab_tag((mp), (agno), (tag)))fs/xfs/libxfs/xfs_ag.h +30
-0+static inline struct xfs_perag * +xfs_perag_next_wrap ( + struct xfs_perag *pag, + xfs_agnumber_t *agno, + xfs_agnumber_t stop_agno, + xfs_agnumber_t wrap_agno) +{ + struct xfs_mount *mp = pag->pag_mount; + + *agno = pag->pag_agno + 1; + xfs_perag_rele(pag); + while (*agno != stop_agno) { + if (*agno >= wrap_agno) + *agno = 0; + if (*agno == stop_agno) + break; + + pag = xfs_perag_grab(mp, *agno); + if (pag) + return pag; + (*agno)++; + } + return NULL; +} + +/* +* Iterate all AGs from start_agno through wrap_agno, then 0 through +* (start_agno - 1). +*/ +#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag)\
+ for ((agno) = (start_agno), (pag) =xfs_perag_grab((mp), (agno)); \
+ (pag) != NULL; \
+ (pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \
+ (wrap_agno)))fs/xfs/libxfs/xfs_ag.h +3
-0+ +/* +* Iterate all AGs from start_agno through to the end of the filesystem, then 0
+ * through (start_agno- 1).
+ */
+#definefor_each_perag_wrap(mp, start_agno, agno, pag)\
+ for_each_perag_wrap_at((mp), (start_agno), (mp)-Quoted 1 line
m_sb.sb_agcount, \
+ (agno), (pag))
fs/xfs/libxfs/xfs_ag.h +2
-0+ +struct
aghdr_init_data{
/* per ag data */
xfs_agblock_t agno; /* ag to init */fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3136,17 +3136,14 @@ xfs_bmap_adjacent(
static int
xfs_bmap_longest_free_extent(
+ struct xfs_perag *pag, struct xfs_trans *tp,
- xfs_agnumber_t ag, xfs_extlen_t *blen,
int *notinit)
{
- struct xfs_mount *mp =tp->t_mountp; - struct xfs_perag *pag; xfs_extlen_t longest; int error = 0;
- pag =xfs_perag_get(mp, ag);
if (!xfs_perag_initialised_agf(pag)) { error = xfs_alloc_read_agf(pag, tp,XFS_ALLOC_FLAG_TRYLOCK,
NULL);fs/xfs/libxfs/xfs_bmap.c +1
-1@@ -3156,19 +3153,17 @@ xfs_bmap_longest_free_extent( *notinit = 1; error = 0; } - goto out; + return error; } }
longest = xfs_alloc_longest_free_extent(pag,
- xfs_alloc_min_freelist(mp, pag), + xfs_alloc_min_freelist(pag-Quoted 1 line
pag_mount, pag),xfs_ag_resv_needed(pag,
XFS_AG_RESV_NONE));
if (*blen < longest)
*blen = longest;
-out:
- xfs_perag_put(pag);
- return error;
+ return 0;
}
static voidfs/xfs/libxfs/xfs_bmap.c +3
-2@@ -3206,9 +3201,10 @@ xfs_bmap_btalloc_select_lengths( xfs_extlen_t *blen) { struct xfs_mount *mp = ap->ip->i_mount; - xfs_agnumber_t ag, startag; + struct xfs_perag *pag; + xfs_agnumber_t agno, startag; int notinit = 0; - int error; + int error = 0;
args->type =XFS_ALLOCTYPE_START_BNO; if (ap->tp->t_flags&XFS_TRANS_LOWMODE) {fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3218,21 +3214,21 @@ xfs_bmap_btalloc_select_lengths( }
args->total =ap->total;
- startag = ag =XFS_FSB_TO_AGNO(mp, args->fsbno); + startag =XFS_FSB_TO_AGNO(mp, args->fsbno);
if (startag == NULLAGNUMBER)
- startag = ag = 0;
+ startag = 0;
- while (*blen <args->maxlen) {
- error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
+ *blen = 0;
+ for_each_perag_wrap(mp, startag, agno, pag) {
+ error = xfs_bmap_longest_free_extent(pag,args->tp, blen,
¬init); if (error)
- return error;
-
- if (++ag ==mp->m_sb.sb_agcount)
- ag = 0;
- if (ag == startag)
+ break;
Quoted 8 lines
+ if (*blen >=
args->maxlen) break;
}
+ if (pag)
+ xfs_perag_rele(pag);
xfs_bmap_select_minlen(ap, args, blen, notinit); return 0;
Hmm, did you want to return error here? Since now we only break on error in the loop body above?
Otherwise looks good.
Allison
Quoted 146 lines
fs/xfs/libxfs/xfs_bmap.c +2
-1@@ -3245,7 +3241,8 @@ xfs_bmap_btalloc_filestreams( xfs_extlen_t *blen) { struct xfs_mount *mp = ap->ip->i_mount; - xfs_agnumber_t ag; + struct xfs_perag *pag; + xfs_agnumber_t start_agno; int notinit = 0; int error;fs/xfs/libxfs/xfs_bmap.c +0
-0@@ -3259,33 +3256,50 @@ xfs_bmap_btalloc_filestreams( args->type = XFS_ALLOCTYPE_NEAR_BNO; args->total = ap->total;
- ag =XFS_FSB_TO_AGNO(mp, args->fsbno);
- if (ag == NULLAGNUMBER)
- ag = 0;
+ start_agno =XFS_FSB_TO_AGNO(mp, args->fsbno);
+ if (start_agno== NULLAGNUMBER)
+ start_agno = 0;
- error =xfs_bmap_longest_free_extent(args->tp, ag, blen, ¬init);
- if (error)
- return error;
+ pag =xfs_perag_grab(mp, start_agno);
+ if (pag) {
+ error = xfs_bmap_longest_free_extent(pag,args->tp, blen,
+ ¬init);
+ xfs_perag_rele(pag);
+ if (error)
+ return error;
+ }
if (*blen <args->maxlen) {
- error =xfs_filestream_new_ag(ap, &ag);
+ xfs_agnumber_t agno =start_agno;
+
+ error =xfs_filestream_new_ag(ap, &agno); if (error)
return error;
+ if (agno == NULLAGNUMBER)
+ gotoout_select;
- error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
- ¬init); + pag =xfs_perag_grab(mp, agno);
+ if (!pag)
+ gotoout_select;
+
+ error =xfs_bmap_longest_free_extent(pag, args->tp, + blen, ¬init);
+ xfs_perag_rele(pag);
if (error)
return error;
+ start_agno = agno;
+
}
+out_select:
xfs_bmap_select_minlen(ap, args, blen, notinit);
/*
* Set the failure fallback case to look in the selected AG as stream
* may have moved.
*/
- ap->blkno =args->fsbno=XFS_AGB_TO_FSB(mp, ag, 0); + ap->blkno =args->fsbno=XFS_AGB_TO_FSB(mp, start_agno, 0); return 0;
}fs/xfs/libxfs/xfs_ialloc.c +1
-1@@ -1725,7 +1725,7 @@ xfs_dialloc( bool ok_alloc = true; bool low_space = false; int flags; - xfs_ino_t ino; + xfs_ino_t ino = NULLFSINO;
/*
* Directories, symlinks, and regular files frequently allocate at leastfs/xfs/libxfs/xfs_ialloc.c +0
-0@@ -1773,39 +1773,37 @@ xfs_dialloc( * or in which we can allocate some inodes. Iterate throughthe
* allocation groups upward, wrapping at the end. */
- agno =start_agno;
flags =XFS_ALLOC_FLAG_TRYLOCK;
- for (;;) {
- pag =xfs_perag_grab(mp, agno);
+retry:
+ for_each_perag_wrap_at(mp,start_agno,mp->m_maxagi, agno, pag) {
if (xfs_dialloc_good_ag(pag, *tpp, mode, flags, ok_alloc)) {
error =xfs_dialloc_try_ag(pag, tpp, parent, &ino, ok_alloc); if (error !=-EAGAIN)
break;
+ error = 0;
}
if (xfs_is_shutdown(mp)) {
error =-EFSCORRUPTED;
break;
}
- if (++agno ==mp->m_maxagi)
- agno = 0;
- if (agno ==start_agno) {
- if (!flags) {
- error =-ENOSPC;
- break;
- }
+ }
+ if (pag)
+ xfs_perag_rele(pag);
+ if (error)
+ return error;
+ if (ino == NULLFSINO) {
+ if (flags) {
flags = 0;
if (low_space)
ok_alloc = true;
+ goto retry;
}
- xfs_perag_rele(pag);
+ return-ENOSPC;
}
-
- if (!error)
- *new_ino = ino;
- xfs_perag_rele(pag);
- return error;
+ *new_ino = ino;
+ return 0;
}
/*
Re: [PATCH 14/42] xfs: introduce xfs_for_each_perag_wrap()
Quoted 28 lines · Allison Henderson
Quoted 27 lines · Dave Chinner
(quoted diff) +0
-0@@ -3218,21 +3214,21 @@ xfs_bmap_btalloc_select_lengths( }
args->total =ap->total;
- startag = ag =XFS_FSB_TO_AGNO(mp, args->fsbno); + startag =XFS_FSB_TO_AGNO(mp, args->fsbno);
if (startag == NULLAGNUMBER)
- startag = ag = 0;
+ startag = 0;
- while (*blen <args->maxlen) {
- error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
+ *blen = 0;
+ for_each_perag_wrap(mp, startag, agno, pag) {
+ error = xfs_bmap_longest_free_extent(pag,args->tp, blen,
¬init); if (error)
- return error;
-
- if (++ag ==mp->m_sb.sb_agcount)
- ag = 0;
- if (ag == startag)
+ break;
+ if (*blen >=args->maxlen)
break;
Quoted 8 lines
Quoted 6 lines
}
+ if (pag)
+ xfs_perag_rele(pag);
xfs_bmap_select_minlen(ap, args, blen, notinit); return 0;Hmm, did you want to return error here? Since now we only break on error in the loop body above?
Yup, good catch Allison, that needs fixing.
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 14/42] xfs: introduce xfs_for_each_perag_wrap()
In reply to Dave ChinnerQuoted 69 lines · Dave Chinner
From: Dave Chinner <[email protected]>
In several places we iterate every AG from a specific start agno and wrap back to the first AG when we reach the end of the filesystem to continue searching. We don't have a primitive for this iteration yet, so add one for conversion of these algorithms to per-ag based iteration.
The filestream AG select code is a mess, and this initially makes it worse. The per-ag selection needs to be driven completely into the filestream code to clean this up and it will be done in a future patch that makes the filestream allocator use active per-ag references correctly.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_ag.h | 45 +++++++++++++++++++++- fs/xfs/libxfs/xfs_bmap.c | 76 ++++++++++++++++++++++---------------- fs/xfs/libxfs/xfs_ialloc.c | 32 ++++++++-------- 3 files changed, 104 insertions(+), 49 deletions(-)fs/xfs/libxfs/xfs_ag.h +32
-1@@ -237,7 +237,6 @@ xfs_perag_next(#define for_each_perag_from (mp, agno, pag) \ for_each_perag_range((mp), (agno), (mp)->m_sb.sb_agcount - 1, (pag)) -#define for_each_perag (mp, agno, pag) \ (agno) = 0; \ for_each_perag_from((mp), (agno), (pag))@@ -249,6 +248,50 @@ xfs_perag_next( xfs_perag_rele(pag), \ (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) +static inline struct xfs_perag * +xfs_perag_next_wrap ( +struct xfs_perag *pag, +xfs_agnumber_t *agno, +xfs_agnumber_t stop_agno, +xfs_agnumber_t wrap_agno) +{ +struct xfs_mount *mp = pag->pag_mount; + + *agno = pag->pag_agno +1 ; +xfs_perag_rele (pag); +while (*agno != stop_agno) { +if (*agno >= wrap_agno) + *agno =0 ; +if (*agno == stop_agno) +break ; + + pag =xfs_perag_grab (mp, *agno); +if (pag) +return pag; + (*agno)++; + } +return NULL ; +} + +/* +* Iterate all AGs from start_agno through wrap_agno, then 0 through +* (start_agno - 1). +*/ +#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag) \ + for ((agno) = (start_agno), (pag) = xfs_perag_grab((mp), (agno)); \ + (pag) != NULL; \
fs/xfs/libxfs/xfs_ag.h xfs_perag_next( · line 292
Quoted 10 lines
fs/xfs/libxfs/xfs_ag.h +10
-0+ (pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \ + (wrap_agno))) + +/* +* Iterate all AGs from start_agno through to the end of the filesystem, then 0 +* through (start_agno - 1). +*/ +#define for_each_perag_wrap (mp, start_agno, agno, pag) \ + for_each_perag_wrap_at((mp), (start_agno), (mp)->m_sb.sb_agcount, \ + (agno), (pag))
This seems like a useful new iterator. I like that the opencoded loops finally got cleaned up.
Quoted 9 lines
fs/xfs/libxfs/xfs_ag.h +2
-0+ +struct aghdr_init_data {/* per ag data */ xfs_agblock_t agno;/* ag to init */ fs/xfs/libxfs/xfs_bmap.c +0
-0
<snip>
Quoted 21 lines
fs/xfs/libxfs/xfs_bmap.c +5
-8@@ -3218,21 +3214,21 @@ xfs_bmap_btalloc_select_lengths( } args->total = ap->total; - startag = ag =XFS_FSB_TO_AGNO (mp, args->fsbno); + startag =XFS_FSB_TO_AGNO (mp, args->fsbno);if (startag ==NULLAGNUMBER ) - startag = ag =0 ; + startag =0 ; -while (*blen < args->maxlen) { - error =xfs_bmap_longest_free_extent (args->tp, ag, blen, + *blen =0 ; +for_each_perag_wrap (mp, startag, agno, pag) { + error =xfs_bmap_longest_free_extent (pag, args->tp, blen, ¬init);if (error) -return error; - -if (++ag == mp->m_sb.sb_agcount) - ag =0 ;
fs/xfs/libxfs/xfs_bmap.c xfs_bmap_btalloc_select_lengths( · line 3234
Quoted 10 lines
fs/xfs/libxfs/xfs_bmap.c +4
-1-if (ag == startag) +break ; +if (*blen >= args->maxlen)break ; } +if (pag) +xfs_perag_rele (pag);xfs_bmap_select_minlen (ap, args, blen, notinit);return 0 ;
Same question as Allison -- if xfs_bmap_longest_free_extent returned a non-EAGAIN error code, don't we want to return that to the caller?
--D
Quoted 141 lines
fs/xfs/libxfs/xfs_bmap.c +29
-11@@ -3245,7 +3241,8 @@ xfs_bmap_btalloc_filestreams( xfs_extlen_t *blen) {struct xfs_mount *mp = ap->ip->i_mount; -xfs_agnumber_t ag; +struct xfs_perag *pag; +xfs_agnumber_t start_agno;int notinit =0 ;int error;@@ -3259,33 +3256,50 @@ xfs_bmap_btalloc_filestreams( args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total; - ag =XFS_FSB_TO_AGNO (mp, args->fsbno); -if (ag ==NULLAGNUMBER ) - ag =0 ; + start_agno =XFS_FSB_TO_AGNO (mp, args->fsbno); +if (start_agno ==NULLAGNUMBER ) + start_agno =0 ; - error =xfs_bmap_longest_free_extent (args->tp, ag, blen, ¬init); -if (error) -return error; + pag =xfs_perag_grab (mp, start_agno); +if (pag) { + error =xfs_bmap_longest_free_extent (pag, args->tp, blen, + ¬init); +xfs_perag_rele (pag); +if (error) +return error; + }if (*blen < args->maxlen) { - error =xfs_filestream_new_ag (ap, &ag); +xfs_agnumber_t agno = start_agno; + + error =xfs_filestream_new_ag (ap, &agno);if (error)return error; +if (agno ==NULLAGNUMBER ) + goto out_select; - error =xfs_bmap_longest_free_extent (args->tp, ag, blen, - ¬init); + pag =xfs_perag_grab (mp, agno); +if (!pag) + goto out_select; + + error =xfs_bmap_longest_free_extent (pag, args->tp, + blen, ¬init); +xfs_perag_rele (pag);if (error)return error; + start_agno = agno; + } +out_select:xfs_bmap_select_minlen (ap, args, blen, notinit);/* * Set the failure fallback case to look in the selected AG as stream * may have moved. */ - ap->blkno = args->fsbno =XFS_AGB_TO_FSB (mp, ag,0 ); + ap->blkno = args->fsbno =XFS_AGB_TO_FSB (mp, start_agno,0 );return 0 ; }fs/xfs/libxfs/xfs_ialloc.c +15
-17@@ -1725,7 +1725,7 @@ xfs_dialloc(bool ok_alloc = true;bool low_space = false;int flags; -xfs_ino_t ino; +xfs_ino_t ino =NULLFSINO ;/* * Directories, symlinks, and regular files frequently allocate at least @@ -1773,39 +1773,37 @@ xfs_dialloc(* or in which we can allocate some inodes. Iterate through the * allocation groups upward, wrapping at the end. */ - agno = start_agno; flags =XFS_ALLOC_FLAG_TRYLOCK ; -for (;;) { - pag =xfs_perag_grab (mp, agno); +retry: +for_each_perag_wrap_at (mp, start_agno, mp->m_maxagi, agno, pag) {if (xfs_dialloc_good_ag (pag, *tpp, mode, flags, ok_alloc)) { error =xfs_dialloc_try_ag (pag, tpp, parent, &ino, ok_alloc);if (error != -EAGAIN )break ; + error =0 ; }if (xfs_is_shutdown (mp)) { error = -EFSCORRUPTED ;break ; } -if (++agno == mp->m_maxagi) - agno =0 ; -if (agno == start_agno) { -if (!flags) { - error = -ENOSPC ; -break ; - } + } +if (pag) +xfs_perag_rele (pag); +if (error) +return error; +if (ino ==NULLFSINO ) { +if (flags) { flags =0 ;if (low_space) ok_alloc = true; + goto retry; } -xfs_perag_rele (pag); +return -ENOSPC ; } - -if (!error) - *new_ino = ino; -xfs_perag_rele (pag); -return error; + *new_ino = ino; +return 0 ; }/* Signature · 1 line
2.39.0
PATCH 15/42 xfs: rework xfs_alloc_vextent()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
It's a multiplexing mess that can be greatly simplified, and really needs to be simplified to allow active per-ag references to propagate from initial AG selection code the the bmapi code.
This splits the code out into separate a parameter checking function, an iterator function, and allocation completion functions and then implements the individual policies using these functions.
--- fs/xfs/libxfs/xfs_alloc.c | 464 +++++++++++++++++++++++--------------- 1 file changed, 285 insertions(+), 179 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +285 -179
@@ -3151,29 +3151,20 @@ xfs_alloc_read_agf( }/* -* Allocate an extent (variable-size). -* Depending on the allocation type, we either look in a single allocation -* group or loop over the allocation groups to find the result. +* Pre-proces allocation arguments to set initial state that we don't require +* callers to set up correctly, as well as bounds check the allocation args +* that are set up. */ -int /* error */ -xfs_alloc_vextent ( -struct xfs_alloc_arg *args)/* allocation argument structure */ +static int +xfs_alloc_vextent_check_args ( +struct xfs_alloc_arg *args) { -xfs_agblock_t agsize;/* allocation group size */ -int error; -int flags;/* XFS_ALLOC_FLAG_... locking flags */ -struct xfs_mount *mp;/* mount structure pointer */ -xfs_agnumber_t sagno;/* starting allocation group number */ -xfs_alloctype_t type;/* input allocation type */ -int bump_rotor =0 ; -xfs_agnumber_t rotorstep = xfs_rotorstep;/* inode32 agf stepper */ -xfs_agnumber_t minimum_agno =0 ; +struct xfs_mount *mp = args->mp; +xfs_agblock_t agsize; - mp = args->mp; - type = args->otype = args->type; + args->otype = args->type; args->agbno =NULLAGBLOCK ; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; +/* * Just fix this up, for the case where the last a.g. is shorter * (or there's only one a.g.) and the caller couldn't easily figure
@@ -3195,199 +3186,314 @@ xfs_alloc_vextent( args->mod >= args->prod) { args->fsbno =NULLFSBLOCK ;trace_xfs_alloc_vextent_badargs (args); +return -ENOSPC ; + } +return 0 ; +} + +/* +* Post-process allocation results to set the allocated block number correctly +* for the caller. +* +* XXX: xfs_alloc_vextent() should really be returning ENOSPC for ENOSPC, not +* hiding it behind a "successful" NULLFSBLOCK allocation. +*/ +static void +xfs_alloc_vextent_set_fsbno ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; + +/* +* We can end up here with a locked AGF. If we failed, the caller is +* likely going to try to allocate again with different parameters, and +* that can widen the AGs that are searched for free space. If we have +* to do BMBT block allocation, we have to do a new allocation. +* +* Hence leaving this function with the AGF locked opens up potential +* ABBA AGF deadlocks because a future allocation attempt in this +* transaction may attempt to lock a lower number AGF. +* +* We can't release the AGF until the transaction is commited, so at +* this point we must update the "first allocation" tracker to point at +* this AG if the tracker is empty or points to a lower AG. This allows +* the next allocation attempt to be modified appropriately to avoid +* deadlocks. +*/ +if (args->agbp && + (args->tp->t_highest_agno ==NULLAGNUMBER || + args->agno > minimum_agno)) + args->tp->t_highest_agno = args->agno; + +/* Allocation failed with ENOSPC if NULLAGBLOCK was returned. */ +if (args->agbno ==NULLAGBLOCK ) { + args->fsbno =NULLFSBLOCK ; +return ; + } + + args->fsbno =XFS_AGB_TO_FSB (mp, args->agno, args->agbno); +#ifdef DEBUG +ASSERT (args->len >= args->minlen); +ASSERT (args->len <= args->maxlen); +ASSERT (args->agbno % args->alignment ==0 ); +XFS_AG_CHECK_DADDR (mp,XFS_FSB_TO_DADDR (mp, args->fsbno), args->len); +#endif +} + +/* +* Allocate within a single AG only. +*/ +static int +xfs_alloc_vextent_this_ag ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; +int error; + + error =xfs_alloc_vextent_check_args (args); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; + } + + args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); +if (minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); + args->fsbno =NULLFSBLOCK ;return 0 ; } -switch (type) { -case XFS_ALLOCTYPE_THIS_AG : -case XFS_ALLOCTYPE_NEAR_BNO : -case XFS_ALLOCTYPE_THIS_BNO : -/* -* These three force us into a single a.g. -*/ - args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); - args->pag =xfs_perag_get (mp, args->agno); + args->pag =xfs_perag_get (mp, args->agno); + error =xfs_alloc_fix_freelist (args,0 ); +if (error) { +trace_xfs_alloc_vextent_nofix (args); + goto out_error; + } +if (!args->agbp) { +trace_xfs_alloc_vextent_noagbp (args); + args->fsbno =NULLFSBLOCK ; + goto out_error; + } + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + error =xfs_alloc_ag_vextent (args); -if (minimum_agno > args->agno) { -trace_xfs_alloc_vextent_skip_deadlock (args); - error =0 ; -break ; - } +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +out_error: +xfs_perag_put (args->pag); +return error; +} + +/* +* Iterate all AGs trying to allocate an extent starting from @start_ag. +* +* If the incoming allocation type is XFS_ALLOCTYPE_NEAR_BNO, it means the +* allocation attempts in @start_agno have locality information. If we fail to +* allocate in that AG, then we revert to anywhere-in-AG for all the other AGs +* we attempt to allocation in as there is no locality optimisation possible for +* those allocations. +* +* When we wrap the AG iteration at the end of the filesystem, we have to be +* careful not to wrap into AGs below ones we already have locked in the +* transaction if we are doing a blocking iteration. This will result in an +* out-of-order locking of AGFs and hence can cause deadlocks. +*/ +static int +xfs_alloc_vextent_iterate_ags ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno, +xfs_agnumber_t start_agno, +uint32_t flags) +{ +struct xfs_mount *mp = args->mp; +int error =0 ; - error =xfs_alloc_fix_freelist (args,0 ); +ASSERT (start_agno >= minimum_agno); + +/* +* Loop over allocation groups twice; first time with +* trylock set, second time without. +*/ + args->agno = start_agno; +for (;;) { + args->pag =xfs_perag_get (mp, args->agno); + error =xfs_alloc_fix_freelist (args, flags);if (error) {trace_xfs_alloc_vextent_nofix (args); - goto error0; - } -if (!args->agbp) { -trace_xfs_alloc_vextent_noagbp (args);break ; } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); -if ((error =xfs_alloc_ag_vextent (args))) - goto error0; -break ; -case XFS_ALLOCTYPE_START_BNO :/* -* Try near allocation first, then anywhere-in-ag after -* the first a.g. fails. +* If we get a buffer back then the allocation will fly. */ -if ((args->datatype &XFS_ALLOC_INITIAL_USER_DATA ) && -xfs_is_inode32 (mp)) { - args->fsbno =XFS_AGB_TO_FSB (mp, - ((mp->m_agfrotor / rotorstep) % - mp->m_sb.sb_agcount),0 ); - bump_rotor =1 ; +if (args->agbp) { + error =xfs_alloc_ag_vextent (args); +break ; } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); - args->type =XFS_ALLOCTYPE_NEAR_BNO ; - fallthrough; -case XFS_ALLOCTYPE_FIRST_AG : + +trace_xfs_alloc_vextent_loopfailed (args); +/* -* Rotate through the allocation groups looking for a winner. -* If we are blocking, we must obey minimum_agno contraints for -* avoiding ABBA deadlocks on AGF locking. +* Didn't work, figure out the next iteration. */ -if (type ==XFS_ALLOCTYPE_FIRST_AG ) { -/* -* Start with allocation group given by bno. -*/ - args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); +if (args->agno == start_agno && + args->otype ==XFS_ALLOCTYPE_START_BNO ) args->type =XFS_ALLOCTYPE_THIS_AG ; - sagno = minimum_agno; - flags =0 ; - }else { -/* -* Start with the given allocation group. -*/ - args->agno = sagno =XFS_FSB_TO_AGNO (mp, args->fsbno); - flags =XFS_ALLOC_FLAG_TRYLOCK ; + +/* +* If we are try-locking, we can't deadlock on AGF locks so we +* can wrap all the way back to the first AG. Otherwise, wrap +* back to the start AG so we can't deadlock and let the end of +* scan handler decide what to do next. +*/ +if (++(args->agno) == mp->m_sb.sb_agcount) { +if (flags &XFS_ALLOC_FLAG_TRYLOCK ) + args->agno =0 ; +else + args->agno = minimum_agno; }/* -* Loop over allocation groups twice; first time with -* trylock set, second time without. +* Reached the starting a.g., must either be done +* or switch to non-trylock mode. */ -for (;;) { - args->pag =xfs_perag_get (mp, args->agno); - error =xfs_alloc_fix_freelist (args, flags); -if (error) { -trace_xfs_alloc_vextent_nofix (args); - goto error0; - } -/* -* If we get a buffer back then the allocation will fly. -*/ -if (args->agbp) { -if ((error =xfs_alloc_ag_vextent (args))) - goto error0; +if (args->agno == start_agno) { +if (flags ==0 ) { + args->agbno =NULLAGBLOCK ; +trace_xfs_alloc_vextent_allfailed (args);break ; } -trace_xfs_alloc_vextent_loopfailed (args); + flags =0 ; +if (args->otype ==XFS_ALLOCTYPE_START_BNO ) { + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + args->type =XFS_ALLOCTYPE_NEAR_BNO ; + } + } +xfs_perag_put (args->pag); + args->pag =NULL ; + } +if (args->pag) { +xfs_perag_put (args->pag); + args->pag =NULL ; + } +return error; +} -/* -* Didn't work, figure out the next iteration. -*/ -if (args->agno == sagno && - type ==XFS_ALLOCTYPE_START_BNO ) - args->type =XFS_ALLOCTYPE_THIS_AG ; +/* +* Iterate from the AGs from the start AG to the end of the filesystem, trying +* to allocate blocks. It starts with a near allocation attempt in the initial +* AG, then falls back to anywhere-in-ag after the first AG fails. It will wrap +* back to zero if allowed by previous allocations in this transaction, +* otherwise will wrap back to the start AG and run a second blocking pass to +* the end of the filesystem. +*/ +static int +xfs_alloc_vextent_start_ag ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; +xfs_agnumber_t start_agno; +xfs_agnumber_t rotorstep = xfs_rotorstep; +bool bump_rotor = false; +int error; -/* -* If we are try-locking, we can't deadlock on AGF -* locks, so we can wrap all the way back to the first -* AG. Otherwise, wrap back to the start AG so we can't -* deadlock, and let the end of scan handler decide what -* to do next. -*/ -if (++(args->agno) == mp->m_sb.sb_agcount) { -if (flags &XFS_ALLOC_FLAG_TRYLOCK ) - args->agno =0 ; -else - args->agno = sagno; - } + error =xfs_alloc_vextent_check_args (args); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; + } -/* -* Reached the starting a.g., must either be done -* or switch to non-trylock mode. -*/ -if (args->agno == sagno) { -if (flags ==0 ) { - args->agbno =NULLAGBLOCK ; -trace_xfs_alloc_vextent_allfailed (args); -break ; - } +if ((args->datatype &XFS_ALLOC_INITIAL_USER_DATA ) && +xfs_is_inode32 (mp)) { + args->fsbno =XFS_AGB_TO_FSB (mp, + ((mp->m_agfrotor / rotorstep) % + mp->m_sb.sb_agcount),0 ); + bump_rotor =1 ; + } + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + args->type =XFS_ALLOCTYPE_NEAR_BNO ; -/* -* Blocking pass next, so we must obey minimum -* agno constraints to avoid ABBA AGF deadlocks. -*/ - flags =0 ; -if (minimum_agno > sagno) - sagno = minimum_agno; - -if (type ==XFS_ALLOCTYPE_START_BNO ) { - args->agbno =XFS_FSB_TO_AGBNO (mp, - args->fsbno); - args->type =XFS_ALLOCTYPE_NEAR_BNO ; - } - } -xfs_perag_put (args->pag); - } -if (bump_rotor) { -if (args->agno == sagno) - mp->m_agfrotor = (mp->m_agfrotor +1 ) % - (mp->m_sb.sb_agcount * rotorstep); -else - mp->m_agfrotor = (args->agno * rotorstep +1 ) % - (mp->m_sb.sb_agcount * rotorstep); - } -break ; -default : -ASSERT (0 ); -/* NOTREACHED */ + error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno, +XFS_ALLOC_FLAG_TRYLOCK ); +if (bump_rotor) { +if (args->agno == start_agno) + mp->m_agfrotor = (mp->m_agfrotor +1 ) % + (mp->m_sb.sb_agcount * rotorstep); +else + mp->m_agfrotor = (args->agno * rotorstep +1 ) % + (mp->m_sb.sb_agcount * rotorstep); } -if (args->agbno ==NULLAGBLOCK ) { - args->fsbno =NULLFSBLOCK ; - }else { - args->fsbno =XFS_AGB_TO_FSB (mp, args->agno, args->agbno); -#ifdef DEBUG -ASSERT (args->len >= args->minlen); -ASSERT (args->len <= args->maxlen); -ASSERT (args->agbno % args->alignment ==0 ); -XFS_AG_CHECK_DADDR (mp,XFS_FSB_TO_DADDR (mp, args->fsbno), - args->len); -#endif +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +return error; +} + +/* +* Iterate from the agno indicated from args->fsbno through to the end of the +* filesystem attempting blocking allocation. This does not wrap or try a second +* pass, so will not recurse into AGs lower than indicated by fsbno. +*/ +static int +xfs_alloc_vextent_first_ag ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; +xfs_agnumber_t start_agno; +int error; + + error =xfs_alloc_vextent_check_args (args); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; } -/* -* We end up here with a locked AGF. If we failed, the caller is likely -* going to try to allocate again with different parameters, and that -* can widen the AGs that are searched for free space. If we have to do -* BMBT block allocation, we have to do a new allocation. -* -* Hence leaving this function with the AGF locked opens up potential -* ABBA AGF deadlocks because a future allocation attempt in this -* transaction may attempt to lock a lower number AGF. -* -* We can't release the AGF until the transaction is commited, so at -* this point we must update the "firstblock" tracker to point at this -* AG if the tracker is empty or points to a lower AG. This allows the -* next allocation attempt to be modified appropriately to avoid -* deadlocks. -*/ -if (args->agbp && - (args->tp->t_highest_agno ==NULLAGNUMBER || - args->pag->pag_agno > minimum_agno)) - args->tp->t_highest_agno = args->pag->pag_agno; -xfs_perag_put (args->pag); -return 0 ; -error0: -xfs_perag_put (args->pag); + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); + + args->type =XFS_ALLOCTYPE_THIS_AG ; + error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, + start_agno,0 ); +xfs_alloc_vextent_set_fsbno (args, minimum_agno);return error; } +/* +* Allocate an extent (variable-size). +* Depending on the allocation type, we either look in a single allocation +* group or loop over the allocation groups to find the result. +*/ +int +xfs_alloc_vextent ( +struct xfs_alloc_arg *args) +{ +xfs_agnumber_t minimum_agno =0 ; + +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + +switch (args->type) { +case XFS_ALLOCTYPE_THIS_AG : +case XFS_ALLOCTYPE_NEAR_BNO : +case XFS_ALLOCTYPE_THIS_BNO : +return xfs_alloc_vextent_this_ag (args, minimum_agno); +case XFS_ALLOCTYPE_START_BNO : +return xfs_alloc_vextent_start_ag (args, minimum_agno); +case XFS_ALLOCTYPE_FIRST_AG : +return xfs_alloc_vextent_first_ag (args, minimum_agno); +default : +ASSERT (0 ); +/* NOTREACHED */ + } +/* Should never get here */ +return -EFSCORRUPTED ; +} +/* Ensure that the freelist is at full capacity. */ int xfs_free_extent_fix_freelist(
Signature · 1 line
2.39.0
Re: [PATCH 15/42] xfs: rework xfs_alloc_vextent()
Quoted 9 lines · Dave Chinner
From: Dave Chinner <[email protected]>
It's a multiplexing mess that can be greatly simplified, and really needs to be simplified to allow active per-ag references to propagate from initial AG selection code the the bmapi code.
This splits the code out into separate a parameter checking function, an iterator function, and allocation completion functions and then implements the individual policies using these functions.
This patch was **so** much easier to read once I imported it and re-exported it with git set to patience diff mode. With that in hand it's far easier to see that the diff really does break up an overlong function and nothing else.
$ cat /etc/gitconfig
[diff]
algorithm = patience--D
Quoted 527 lines
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 464 +++++++++++++++++++++++--------------- 1 file changed, 285 insertions(+), 179 deletions(-)fs/xfs/libxfs/xfs_alloc.c +285
-179@@ -3151,29 +3151,20 @@ xfs_alloc_read_agf( }/* -* Allocate an extent (variable-size). -* Depending on the allocation type, we either look in a single allocation -* group or loop over the allocation groups to find the result. +* Pre-proces allocation arguments to set initial state that we don't require +* callers to set up correctly, as well as bounds check the allocation args +* that are set up. */ -int /* error */ -xfs_alloc_vextent ( -struct xfs_alloc_arg *args)/* allocation argument structure */ +static int +xfs_alloc_vextent_check_args ( +struct xfs_alloc_arg *args) { -xfs_agblock_t agsize;/* allocation group size */ -int error; -int flags;/* XFS_ALLOC_FLAG_... locking flags */ -struct xfs_mount *mp;/* mount structure pointer */ -xfs_agnumber_t sagno;/* starting allocation group number */ -xfs_alloctype_t type;/* input allocation type */ -int bump_rotor =0 ; -xfs_agnumber_t rotorstep = xfs_rotorstep;/* inode32 agf stepper */ -xfs_agnumber_t minimum_agno =0 ; +struct xfs_mount *mp = args->mp; +xfs_agblock_t agsize; - mp = args->mp; - type = args->otype = args->type; + args->otype = args->type; args->agbno =NULLAGBLOCK ; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; +/* * Just fix this up, for the case where the last a.g. is shorter * (or there's only one a.g.) and the caller couldn't easily figure @@ -3195,199 +3186,314 @@ xfs_alloc_vextent( args->mod >= args->prod) { args->fsbno =NULLFSBLOCK ;trace_xfs_alloc_vextent_badargs (args); +return -ENOSPC ; + } +return 0 ; +} + +/* +* Post-process allocation results to set the allocated block number correctly +* for the caller. +* +* XXX: xfs_alloc_vextent() should really be returning ENOSPC for ENOSPC, not +* hiding it behind a "successful" NULLFSBLOCK allocation. +*/ +static void +xfs_alloc_vextent_set_fsbno ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; + +/* +* We can end up here with a locked AGF. If we failed, the caller is +* likely going to try to allocate again with different parameters, and +* that can widen the AGs that are searched for free space. If we have +* to do BMBT block allocation, we have to do a new allocation. +* +* Hence leaving this function with the AGF locked opens up potential +* ABBA AGF deadlocks because a future allocation attempt in this +* transaction may attempt to lock a lower number AGF. +* +* We can't release the AGF until the transaction is commited, so at +* this point we must update the "first allocation" tracker to point at +* this AG if the tracker is empty or points to a lower AG. This allows +* the next allocation attempt to be modified appropriately to avoid +* deadlocks. +*/ +if (args->agbp && + (args->tp->t_highest_agno ==NULLAGNUMBER || + args->agno > minimum_agno)) + args->tp->t_highest_agno = args->agno; + +/* Allocation failed with ENOSPC if NULLAGBLOCK was returned. */ +if (args->agbno ==NULLAGBLOCK ) { + args->fsbno =NULLFSBLOCK ; +return ; + } + + args->fsbno =XFS_AGB_TO_FSB (mp, args->agno, args->agbno); +#ifdef DEBUG +ASSERT (args->len >= args->minlen); +ASSERT (args->len <= args->maxlen); +ASSERT (args->agbno % args->alignment ==0 ); +XFS_AG_CHECK_DADDR (mp,XFS_FSB_TO_DADDR (mp, args->fsbno), args->len); +#endif +} + +/* +* Allocate within a single AG only. +*/ +static int +xfs_alloc_vextent_this_ag ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; +int error; + + error =xfs_alloc_vextent_check_args (args); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; + } + + args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); +if (minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); + args->fsbno =NULLFSBLOCK ;return 0 ; } -switch (type) { -case XFS_ALLOCTYPE_THIS_AG : -case XFS_ALLOCTYPE_NEAR_BNO : -case XFS_ALLOCTYPE_THIS_BNO : -/* -* These three force us into a single a.g. -*/ - args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); - args->pag =xfs_perag_get (mp, args->agno); + args->pag =xfs_perag_get (mp, args->agno); + error =xfs_alloc_fix_freelist (args,0 ); +if (error) { +trace_xfs_alloc_vextent_nofix (args); + goto out_error; + } +if (!args->agbp) { +trace_xfs_alloc_vextent_noagbp (args); + args->fsbno =NULLFSBLOCK ; + goto out_error; + } + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + error =xfs_alloc_ag_vextent (args); -if (minimum_agno > args->agno) { -trace_xfs_alloc_vextent_skip_deadlock (args); - error =0 ; -break ; - } +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +out_error: +xfs_perag_put (args->pag); +return error; +} + +/* +* Iterate all AGs trying to allocate an extent starting from @start_ag. +* +* If the incoming allocation type is XFS_ALLOCTYPE_NEAR_BNO, it means the +* allocation attempts in @start_agno have locality information. If we fail to +* allocate in that AG, then we revert to anywhere-in-AG for all the other AGs +* we attempt to allocation in as there is no locality optimisation possible for +* those allocations. +* +* When we wrap the AG iteration at the end of the filesystem, we have to be +* careful not to wrap into AGs below ones we already have locked in the +* transaction if we are doing a blocking iteration. This will result in an +* out-of-order locking of AGFs and hence can cause deadlocks. +*/ +static int +xfs_alloc_vextent_iterate_ags ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno, +xfs_agnumber_t start_agno, +uint32_t flags) +{ +struct xfs_mount *mp = args->mp; +int error =0 ; - error =xfs_alloc_fix_freelist (args,0 ); +ASSERT (start_agno >= minimum_agno); + +/* +* Loop over allocation groups twice; first time with +* trylock set, second time without. +*/ + args->agno = start_agno; +for (;;) { + args->pag =xfs_perag_get (mp, args->agno); + error =xfs_alloc_fix_freelist (args, flags);if (error) {trace_xfs_alloc_vextent_nofix (args); - goto error0; - } -if (!args->agbp) { -trace_xfs_alloc_vextent_noagbp (args);break ; } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); -if ((error =xfs_alloc_ag_vextent (args))) - goto error0; -break ; -case XFS_ALLOCTYPE_START_BNO :/* -* Try near allocation first, then anywhere-in-ag after -* the first a.g. fails. +* If we get a buffer back then the allocation will fly. */ -if ((args->datatype &XFS_ALLOC_INITIAL_USER_DATA ) && -xfs_is_inode32 (mp)) { - args->fsbno =XFS_AGB_TO_FSB (mp, - ((mp->m_agfrotor / rotorstep) % - mp->m_sb.sb_agcount),0 ); - bump_rotor =1 ; +if (args->agbp) { + error =xfs_alloc_ag_vextent (args); +break ; } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); - args->type =XFS_ALLOCTYPE_NEAR_BNO ; - fallthrough; -case XFS_ALLOCTYPE_FIRST_AG : + +trace_xfs_alloc_vextent_loopfailed (args); +/* -* Rotate through the allocation groups looking for a winner. -* If we are blocking, we must obey minimum_agno contraints for -* avoiding ABBA deadlocks on AGF locking. +* Didn't work, figure out the next iteration. */ -if (type ==XFS_ALLOCTYPE_FIRST_AG ) { -/* -* Start with allocation group given by bno. -*/ - args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); +if (args->agno == start_agno && + args->otype ==XFS_ALLOCTYPE_START_BNO ) args->type =XFS_ALLOCTYPE_THIS_AG ; - sagno = minimum_agno; - flags =0 ; - }else { -/* -* Start with the given allocation group. -*/ - args->agno = sagno =XFS_FSB_TO_AGNO (mp, args->fsbno); - flags =XFS_ALLOC_FLAG_TRYLOCK ; + +/* +* If we are try-locking, we can't deadlock on AGF locks so we +* can wrap all the way back to the first AG. Otherwise, wrap +* back to the start AG so we can't deadlock and let the end of +* scan handler decide what to do next. +*/ +if (++(args->agno) == mp->m_sb.sb_agcount) { +if (flags &XFS_ALLOC_FLAG_TRYLOCK ) + args->agno =0 ; +else + args->agno = minimum_agno; }/* -* Loop over allocation groups twice; first time with -* trylock set, second time without. +* Reached the starting a.g., must either be done +* or switch to non-trylock mode. */ -for (;;) { - args->pag =xfs_perag_get (mp, args->agno); - error =xfs_alloc_fix_freelist (args, flags); -if (error) { -trace_xfs_alloc_vextent_nofix (args); - goto error0; - } -/* -* If we get a buffer back then the allocation will fly. -*/ -if (args->agbp) { -if ((error =xfs_alloc_ag_vextent (args))) - goto error0; +if (args->agno == start_agno) { +if (flags ==0 ) { + args->agbno =NULLAGBLOCK ; +trace_xfs_alloc_vextent_allfailed (args);break ; } -trace_xfs_alloc_vextent_loopfailed (args); + flags =0 ; +if (args->otype ==XFS_ALLOCTYPE_START_BNO ) { + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + args->type =XFS_ALLOCTYPE_NEAR_BNO ; + } + } +xfs_perag_put (args->pag); + args->pag =NULL ; + } +if (args->pag) { +xfs_perag_put (args->pag); + args->pag =NULL ; + } +return error; +} -/* -* Didn't work, figure out the next iteration. -*/ -if (args->agno == sagno && - type ==XFS_ALLOCTYPE_START_BNO ) - args->type =XFS_ALLOCTYPE_THIS_AG ; +/* +* Iterate from the AGs from the start AG to the end of the filesystem, trying +* to allocate blocks. It starts with a near allocation attempt in the initial +* AG, then falls back to anywhere-in-ag after the first AG fails. It will wrap +* back to zero if allowed by previous allocations in this transaction, +* otherwise will wrap back to the start AG and run a second blocking pass to +* the end of the filesystem. +*/ +static int +xfs_alloc_vextent_start_ag ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; +xfs_agnumber_t start_agno; +xfs_agnumber_t rotorstep = xfs_rotorstep; +bool bump_rotor = false; +int error; -/* -* If we are try-locking, we can't deadlock on AGF -* locks, so we can wrap all the way back to the first -* AG. Otherwise, wrap back to the start AG so we can't -* deadlock, and let the end of scan handler decide what -* to do next. -*/ -if (++(args->agno) == mp->m_sb.sb_agcount) { -if (flags &XFS_ALLOC_FLAG_TRYLOCK ) - args->agno =0 ; -else - args->agno = sagno; - } + error =xfs_alloc_vextent_check_args (args); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; + } -/* -* Reached the starting a.g., must either be done -* or switch to non-trylock mode. -*/ -if (args->agno == sagno) { -if (flags ==0 ) { - args->agbno =NULLAGBLOCK ; -trace_xfs_alloc_vextent_allfailed (args); -break ; - } +if ((args->datatype &XFS_ALLOC_INITIAL_USER_DATA ) && +xfs_is_inode32 (mp)) { + args->fsbno =XFS_AGB_TO_FSB (mp, + ((mp->m_agfrotor / rotorstep) % + mp->m_sb.sb_agcount),0 ); + bump_rotor =1 ; + } + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + args->type =XFS_ALLOCTYPE_NEAR_BNO ; -/* -* Blocking pass next, so we must obey minimum -* agno constraints to avoid ABBA AGF deadlocks. -*/ - flags =0 ; -if (minimum_agno > sagno) - sagno = minimum_agno; - -if (type ==XFS_ALLOCTYPE_START_BNO ) { - args->agbno =XFS_FSB_TO_AGBNO (mp, - args->fsbno); - args->type =XFS_ALLOCTYPE_NEAR_BNO ; - } - } -xfs_perag_put (args->pag); - } -if (bump_rotor) { -if (args->agno == sagno) - mp->m_agfrotor = (mp->m_agfrotor +1 ) % - (mp->m_sb.sb_agcount * rotorstep); -else - mp->m_agfrotor = (args->agno * rotorstep +1 ) % - (mp->m_sb.sb_agcount * rotorstep); - } -break ; -default : -ASSERT (0 ); -/* NOTREACHED */ + error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno, +XFS_ALLOC_FLAG_TRYLOCK ); +if (bump_rotor) { +if (args->agno == start_agno) + mp->m_agfrotor = (mp->m_agfrotor +1 ) % + (mp->m_sb.sb_agcount * rotorstep); +else + mp->m_agfrotor = (args->agno * rotorstep +1 ) % + (mp->m_sb.sb_agcount * rotorstep); } -if (args->agbno ==NULLAGBLOCK ) { - args->fsbno =NULLFSBLOCK ; - }else { - args->fsbno =XFS_AGB_TO_FSB (mp, args->agno, args->agbno); -#ifdef DEBUG -ASSERT (args->len >= args->minlen); -ASSERT (args->len <= args->maxlen); -ASSERT (args->agbno % args->alignment ==0 ); -XFS_AG_CHECK_DADDR (mp,XFS_FSB_TO_DADDR (mp, args->fsbno), - args->len); -#endif +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +return error; +} + +/* +* Iterate from the agno indicated from args->fsbno through to the end of the +* filesystem attempting blocking allocation. This does not wrap or try a second +* pass, so will not recurse into AGs lower than indicated by fsbno. +*/ +static int +xfs_alloc_vextent_first_ag ( +struct xfs_alloc_arg *args, +xfs_agnumber_t minimum_agno) +{ +struct xfs_mount *mp = args->mp; +xfs_agnumber_t start_agno; +int error; + + error =xfs_alloc_vextent_check_args (args); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; } -/* -* We end up here with a locked AGF. If we failed, the caller is likely -* going to try to allocate again with different parameters, and that -* can widen the AGs that are searched for free space. If we have to do -* BMBT block allocation, we have to do a new allocation. -* -* Hence leaving this function with the AGF locked opens up potential -* ABBA AGF deadlocks because a future allocation attempt in this -* transaction may attempt to lock a lower number AGF. -* -* We can't release the AGF until the transaction is commited, so at -* this point we must update the "firstblock" tracker to point at this -* AG if the tracker is empty or points to a lower AG. This allows the -* next allocation attempt to be modified appropriately to avoid -* deadlocks. -*/ -if (args->agbp && - (args->tp->t_highest_agno ==NULLAGNUMBER || - args->pag->pag_agno > minimum_agno)) - args->tp->t_highest_agno = args->pag->pag_agno; -xfs_perag_put (args->pag); -return 0 ; -error0: -xfs_perag_put (args->pag); + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); + + args->type =XFS_ALLOCTYPE_THIS_AG ; + error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, + start_agno,0 ); +xfs_alloc_vextent_set_fsbno (args, minimum_agno);return error; } +/* +* Allocate an extent (variable-size). +* Depending on the allocation type, we either look in a single allocation +* group or loop over the allocation groups to find the result. +*/ +int +xfs_alloc_vextent ( +struct xfs_alloc_arg *args) +{ +xfs_agnumber_t minimum_agno =0 ; + +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + +switch (args->type) { +case XFS_ALLOCTYPE_THIS_AG : +case XFS_ALLOCTYPE_NEAR_BNO : +case XFS_ALLOCTYPE_THIS_BNO : +return xfs_alloc_vextent_this_ag (args, minimum_agno); +case XFS_ALLOCTYPE_START_BNO : +return xfs_alloc_vextent_start_ag (args, minimum_agno); +case XFS_ALLOCTYPE_FIRST_AG : +return xfs_alloc_vextent_first_ag (args, minimum_agno); +default : +ASSERT (0 ); +/* NOTREACHED */ + } +/* Should never get here */ +return -EFSCORRUPTED ; +} +/* Ensure that the freelist is at full capacity. */ int xfs_free_extent_fix_freelist(Signature · 1 line
2.39.0
PATCH 16/42 xfs: factor xfs_alloc_vextent_this_ag() for _iterate_ags()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
The core of the per-ag iteration is effectively doing a "this ag" allocation on one AG at a time. Use the same code to implement the core "this ag" allocation in both xfs_alloc_vextent_this_ag() and xfs_alloc_vextent_iterate_ags().
This means we only call xfs_alloc_ag_vextent() from one place so we can easily collapse the call stack in future patches.
--- fs/xfs/libxfs/xfs_alloc.c | 50 ++++++++++++++++++++------------------- 1 file changed, 26 insertions(+), 24 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +26 -24
@@ -3244,6 +3244,28 @@ xfs_alloc_vextent_set_fsbno(/* * Allocate within a single AG only. */ +static int +__xfs_alloc_vextent_this_ag ( +struct xfs_alloc_arg *args) +{ +struct xfs_mount *mp = args->mp; +int error; + + error =xfs_alloc_fix_freelist (args,0 ); +if (error) { +trace_xfs_alloc_vextent_nofix (args); +return error; + } +if (!args->agbp) { +/* cannot allocate in this AG at all */ +trace_xfs_alloc_vextent_noagbp (args); + args->agbno =NULLAGBLOCK ; +return 0 ; + } + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); +return xfs_alloc_ag_vextent (args); +} + static int xfs_alloc_vextent_this_ag( struct xfs_alloc_arg *args,
@@ -3267,21 +3289,9 @@ xfs_alloc_vextent_this_ag( } args->pag =xfs_perag_get (mp, args->agno); - error =xfs_alloc_fix_freelist (args,0 ); -if (error) { -trace_xfs_alloc_vextent_nofix (args); - goto out_error; - } -if (!args->agbp) { -trace_xfs_alloc_vextent_noagbp (args); - args->fsbno =NULLFSBLOCK ; - goto out_error; - } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); - error =xfs_alloc_ag_vextent (args); + error =__xfs_alloc_vextent_this_ag (args);xfs_alloc_vextent_set_fsbno (args, minimum_agno); -out_error:xfs_perag_put (args->pag);return error; }
@@ -3319,24 +3329,16 @@ xfs_alloc_vextent_iterate_ags( args->agno = start_agno;for (;;) { args->pag =xfs_perag_get (mp, args->agno); - error =xfs_alloc_fix_freelist (args, flags); + error =__xfs_alloc_vextent_this_ag (args);if (error) { -trace_xfs_alloc_vextent_nofix (args); + args->agbno =NULLAGBLOCK ;break ; } -/* -* If we get a buffer back then the allocation will fly. -*/ -if (args->agbp) { - error =xfs_alloc_ag_vextent (args); +if (args->agbp)break ; - }trace_xfs_alloc_vextent_loopfailed (args); -/* -* Didn't work, figure out the next iteration. -*/ if (args->agno == start_agno && args->otype ==XFS_ALLOCTYPE_START_BNO ) args->type =XFS_ALLOCTYPE_THIS_AG ;
Signature · 1 line
2.39.0
PATCH 17/42 xfs: combine __xfs_alloc_vextent_this_ag and xfs_alloc_ag_vextent
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
There's a bit of a recursive conundrum around xfs_alloc_ag_vextent(). We can't first call xfs_alloc_ag_vextent() without preparing the AGFL for the allocation, and preparing the AGFL calls xfs_alloc_ag_vextent() to prepare the AGFL for the allocation. This "double allocation" requirement is not really clear from the current xfs_alloc_fix_freelist() calls that are sprinkled through the allocation code.
It's not helped that xfs_alloc_ag_vextent() can actually allocate from the AGFL itself, but there's special code to prevent AGFL prep allocations from allocating from the free list it's trying to prep. The naming is also not consistent: args->wasfromfl is true when we allocated _from_ the free list, but the indication that we are allocating _for_ the free list is via checking that (args->resv == XFS_AG_RESV_AGFL).
So, lets make this "allocation required for allocation" situation clear by moving it all inside xfs_alloc_ag_vextent(). The freelist allocation is a specific XFS_ALLOCTYPE_THIS_AG allocation, which translated directly to xfs_alloc_ag_vextent_size() allocation.
This enables us to replace __xfs_alloc_vextent_this_ag() with a call to xfs_alloc_ag_vextent(), and we drive the freelist fixing further into the per-ag allocation algorithm.
--- fs/xfs/libxfs/xfs_alloc.c | 65 +++++++++++++++++++++------------------ 1 file changed, 35 insertions(+), 30 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +35 -30
@@ -1140,22 +1140,38 @@ xfs_alloc_ag_vextent_small(* and of the form k * prod + mod unless there's nothing that large. * Return the starting a.g. block, or NULLAGBLOCK if we can't do it. */ -STATIC int /* error */ +static int xfs_alloc_ag_vextent ( -xfs_alloc_arg_t *args)/* argument structure for allocation */ +struct xfs_alloc_arg *args) { -int error=0 ; +struct xfs_mount *mp = args->mp; +int error =0 ;ASSERT (args->minlen >0 );ASSERT (args->maxlen >0 );ASSERT (args->minlen <= args->maxlen);ASSERT (args->mod < args->prod);ASSERT (args->alignment >0 ); +ASSERT (args->resv !=XFS_AG_RESV_AGFL ); + + + error =xfs_alloc_fix_freelist (args,0 ); +if (error) { +trace_xfs_alloc_vextent_nofix (args); +return error; + } +if (!args->agbp) { +/* cannot allocate in this AG at all */ +trace_xfs_alloc_vextent_noagbp (args); + args->agbno =NULLAGBLOCK ; +return 0 ; + } + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + args->wasfromfl =0 ;/* * Branch to correct routine based on the type. */ - args->wasfromfl =0 ;switch (args->type) {case XFS_ALLOCTYPE_THIS_AG : error =xfs_alloc_ag_vextent_size (args);
@@ -1176,7 +1192,6 @@ xfs_alloc_ag_vextent(ASSERT (args->len >= args->minlen);ASSERT (args->len <= args->maxlen); -ASSERT (!args->wasfromfl || args->resv !=XFS_AG_RESV_AGFL );ASSERT (args->agbno % args->alignment ==0 );/* if not file data, insert new block into the reverse map btree */
@@ -2721,7 +2736,7 @@ xfs_alloc_fix_freelist( targs.resv =XFS_AG_RESV_AGFL ;/* Allocate as many blocks as possible at once. */ - error =xfs_alloc_ag_vextent (&targs); + error =xfs_alloc_ag_vextent_size (&targs);if (error) goto out_agflbp_relse;
@@ -2735,6 +2750,18 @@ xfs_alloc_fix_freelist(break ; goto out_agflbp_relse; } + +if (!xfs_rmap_should_skip_owner_update (&targs.oinfo)) { + error =xfs_rmap_alloc (tp, agbp, pag, + targs.agbno, targs.len, &targs.oinfo); +if (error) + goto out_agflbp_relse; + } + error =xfs_alloc_update_counters (tp, agbp, + -((long )(targs.len))); +if (error) + goto out_agflbp_relse; +/* * Put each allocated block on the list. */
@@ -3244,28 +3271,6 @@ xfs_alloc_vextent_set_fsbno(/* * Allocate within a single AG only. */ -static int -__xfs_alloc_vextent_this_ag ( -struct xfs_alloc_arg *args) -{ -struct xfs_mount *mp = args->mp; -int error; - - error =xfs_alloc_fix_freelist (args,0 ); -if (error) { -trace_xfs_alloc_vextent_nofix (args); -return error; - } -if (!args->agbp) { -/* cannot allocate in this AG at all */ -trace_xfs_alloc_vextent_noagbp (args); - args->agbno =NULLAGBLOCK ; -return 0 ; - } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); -return xfs_alloc_ag_vextent (args); -} - static int xfs_alloc_vextent_this_ag( struct xfs_alloc_arg *args,
@@ -3289,7 +3294,7 @@ xfs_alloc_vextent_this_ag( } args->pag =xfs_perag_get (mp, args->agno); - error =__xfs_alloc_vextent_this_ag (args); + error =xfs_alloc_ag_vextent (args);xfs_alloc_vextent_set_fsbno (args, minimum_agno);xfs_perag_put (args->pag);
@@ -3329,7 +3334,7 @@ xfs_alloc_vextent_iterate_ags( args->agno = start_agno;for (;;) { args->pag =xfs_perag_get (mp, args->agno); - error =__xfs_alloc_vextent_this_ag (args); + error =xfs_alloc_ag_vextent (args);if (error) { args->agbno =NULLAGBLOCK ;break ;
Signature · 1 line
2.39.0
Re: [PATCH 17/42] xfs: combine __xfs_alloc_vextent_this_ag and xfs_alloc_ag_vextent
Quoted 18 lines · Dave Chinner
From: Dave Chinner <[email protected]>
There's a bit of a recursive conundrum around
xfs_alloc_ag_vextent(). We can't first callxfs_alloc_ag_vextent()without preparing the AGFL for the allocation, and preparing the AGFL callsxfs_alloc_ag_vextent()to prepare the AGFL for the allocation. This "double allocation" requirement is not really clear from the currentxfs_alloc_fix_freelist()calls that are sprinkled through the allocation code.It's not helped that
xfs_alloc_ag_vextent()can actually allocate from the AGFL itself, but there's special code to prevent AGFL prep allocations from allocating from the free list it's trying to prep. The naming is also not consistent:args->wasfromflis true when we allocated _from_ the free list, but the indication that we are allocating _for_ the free list is via checking that (args->resv==XFS_AG_RESV_AGFL).
Quoted 8 lines
So, lets make this "allocation required for allocation" situation clear by moving it all inside
xfs_alloc_ag_vextent(). The freelist allocation is a specificXFS_ALLOCTYPE_THIS_AGallocation, which translated directly toxfs_alloc_ag_vextent_size()allocation.This enables us to replace
__xfs_alloc_vextent_this_ag()with a call toxfs_alloc_ag_vextent(), and we drive the freelist fixing further into the per-ag allocation algorithm.
Hmm. My first reaction to all this was "why do I care about all this slicing and dicing?" and "uugh what confuusing". Then I skipped to the end of the book and observed that the end goal seems to be the elimination of:
args.type = XFS_ALLOC_TYPE_START_AG; args.fsbno = sometarget; /* fill out other fields mysteriously */
by turning them all into explicit functions!
error = xfs_alloc_vextent_start_ag(&args, sometarget);
So I looked at all the replacements and noticed that it's quite a bit easier to understand what each variant on allocation does.
It took me a minute to realize that the additional call to xfs_rmap_should_skip_owner_update is because _alloc_fix_freelist doesn't call what becomes the _vextent_finish function.
--D
Quoted 138 lines
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 65 +++++++++++++++++++++------------------ 1 file changed, 35 insertions(+), 30 deletions(-)fs/xfs/libxfs/xfs_alloc.c +35
-30@@ -1140,22 +1140,38 @@ xfs_alloc_ag_vextent_small(* and of the form k * prod + mod unless there's nothing that large. * Return the starting a.g. block, or NULLAGBLOCK if we can't do it. */ -STATIC int /* error */ +static int xfs_alloc_ag_vextent ( -xfs_alloc_arg_t *args)/* argument structure for allocation */ +struct xfs_alloc_arg *args) { -int error=0 ; +struct xfs_mount *mp = args->mp; +int error =0 ;ASSERT (args->minlen >0 );ASSERT (args->maxlen >0 );ASSERT (args->minlen <= args->maxlen);ASSERT (args->mod < args->prod);ASSERT (args->alignment >0 ); +ASSERT (args->resv !=XFS_AG_RESV_AGFL ); + + + error =xfs_alloc_fix_freelist (args,0 ); +if (error) { +trace_xfs_alloc_vextent_nofix (args); +return error; + } +if (!args->agbp) { +/* cannot allocate in this AG at all */ +trace_xfs_alloc_vextent_noagbp (args); + args->agbno =NULLAGBLOCK ; +return 0 ; + } + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + args->wasfromfl =0 ;/* * Branch to correct routine based on the type. */ - args->wasfromfl =0 ;switch (args->type) {case XFS_ALLOCTYPE_THIS_AG : error =xfs_alloc_ag_vextent_size (args);@@ -1176,7 +1192,6 @@ xfs_alloc_ag_vextent(ASSERT (args->len >= args->minlen);ASSERT (args->len <= args->maxlen); -ASSERT (!args->wasfromfl || args->resv !=XFS_AG_RESV_AGFL );ASSERT (args->agbno % args->alignment ==0 );/* if not file data, insert new block into the reverse map btree */ @@ -2721,7 +2736,7 @@ xfs_alloc_fix_freelist( targs.resv =XFS_AG_RESV_AGFL ;/* Allocate as many blocks as possible at once. */ - error =xfs_alloc_ag_vextent (&targs); + error =xfs_alloc_ag_vextent_size (&targs);if (error) goto out_agflbp_relse;@@ -2735,6 +2750,18 @@ xfs_alloc_fix_freelist(break ; goto out_agflbp_relse; } + +if (!xfs_rmap_should_skip_owner_update (&targs.oinfo)) { + error =xfs_rmap_alloc (tp, agbp, pag, + targs.agbno, targs.len, &targs.oinfo); +if (error) + goto out_agflbp_relse; + } + error =xfs_alloc_update_counters (tp, agbp, + -((long )(targs.len))); +if (error) + goto out_agflbp_relse; +/* * Put each allocated block on the list. */ @@ -3244,28 +3271,6 @@ xfs_alloc_vextent_set_fsbno(/* * Allocate within a single AG only. */ -static int -__xfs_alloc_vextent_this_ag ( -struct xfs_alloc_arg *args) -{ -struct xfs_mount *mp = args->mp; -int error; - - error =xfs_alloc_fix_freelist (args,0 ); -if (error) { -trace_xfs_alloc_vextent_nofix (args); -return error; - } -if (!args->agbp) { -/* cannot allocate in this AG at all */ -trace_xfs_alloc_vextent_noagbp (args); - args->agbno =NULLAGBLOCK ; -return 0 ; - } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); -return xfs_alloc_ag_vextent (args); -} - static int xfs_alloc_vextent_this_ag( struct xfs_alloc_arg *args,@@ -3289,7 +3294,7 @@ xfs_alloc_vextent_this_ag( } args->pag =xfs_perag_get (mp, args->agno); - error =__xfs_alloc_vextent_this_ag (args); + error =xfs_alloc_ag_vextent (args);xfs_alloc_vextent_set_fsbno (args, minimum_agno);xfs_perag_put (args->pag);@@ -3329,7 +3334,7 @@ xfs_alloc_vextent_iterate_ags( args->agno = start_agno;for (;;) { args->pag =xfs_perag_get (mp, args->agno); - error =__xfs_alloc_vextent_this_ag (args); + error =xfs_alloc_ag_vextent (args);if (error) { args->agbno =NULLAGBLOCK ;break ;Signature · 1 line
2.39.0
PATCH 18/42 xfs: use xfs_alloc_vextent_this_ag() where appropriate
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Change obvious callers of single AG allocation to use xfs_alloc_vextent_this_ag(). Drive the per-ag grabbing out to the callers, too, so that callers with active references don't need to do new lookups just for an allocation in a context that already has a perag reference.
The only remaining caller that does single AG allocation through xfs_alloc_vextent() is xfs_bmap_btalloc() with XFS_ALLOCTYPE_NEAR_BNO. That is going to need more untangling before it can be converted cleanly.
--- fs/xfs/libxfs/xfs_ag.c | 3 +- fs/xfs/libxfs/xfs_alloc.c | 26 ++++++++------- fs/xfs/libxfs/xfs_alloc.h | 6 ++++ fs/xfs/libxfs/xfs_bmap.c | 52 +++++++++++++++++------------- fs/xfs/libxfs/xfs_bmap_btree.c | 22 ++++++------- fs/xfs/libxfs/xfs_ialloc.c | 9 ++++-- fs/xfs/libxfs/xfs_ialloc_btree.c | 3 +- fs/xfs/libxfs/xfs_refcount_btree.c | 3 +- fs/xfs/scrub/repair.c | 3 +- 9 files changed, 74 insertions(+), 53 deletions(-)
fs/xfs/libxfs/xfs_ag.c +2 -1
@@ -887,6 +887,7 @@ xfs_ag_shrink_space(struct xfs_alloc_arg args = { .tp = *tpp, .mp = mp, + .pag = pag, .type =XFS_ALLOCTYPE_THIS_BNO , .minlen = delta, .maxlen = delta,
@@ -938,7 +939,7 @@ xfs_ag_shrink_space(return error;/* internal log shouldn't also show up in the free space btrees */ - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_this_ag (&args);if (!error && args.agbno ==NULLAGBLOCK ) error = -ENOSPC ;
fs/xfs/libxfs/xfs_alloc.c +15 -11
@@ -2723,7 +2723,6 @@ xfs_alloc_fix_freelist( targs.agbp = agbp; targs.agno = args->agno; targs.alignment = targs.minlen = targs.prod =1 ; - targs.type =XFS_ALLOCTYPE_THIS_AG ; targs.pag = pag; error =xfs_alloc_read_agfl (pag, tp, &agflbp);if (error)
@@ -3271,14 +3270,17 @@ xfs_alloc_vextent_set_fsbno(/* * Allocate within a single AG only. */ -static int +int xfs_alloc_vextent_this_ag ( -struct xfs_alloc_arg *args, -xfs_agnumber_t minimum_agno) +struct xfs_alloc_arg *args) {struct xfs_mount *mp = args->mp; +xfs_agnumber_t minimum_agno =0 ;int error; +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + error =xfs_alloc_vextent_check_args (args);if (error) {if (error == -ENOSPC )
@@ -3293,11 +3295,8 @@ xfs_alloc_vextent_this_ag(return 0 ; } - args->pag =xfs_perag_get (mp, args->agno); error =xfs_alloc_ag_vextent (args); -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -xfs_perag_put (args->pag);return error; }
@@ -3480,6 +3479,7 @@ xfs_alloc_vextent( struct xfs_alloc_arg *args) {xfs_agnumber_t minimum_agno =0 ; +int error;if (args->tp->t_highest_agno !=NULLAGNUMBER ) minimum_agno = args->tp->t_highest_agno;
@@ -3488,17 +3488,21 @@ xfs_alloc_vextent(case XFS_ALLOCTYPE_THIS_AG :case XFS_ALLOCTYPE_NEAR_BNO :case XFS_ALLOCTYPE_THIS_BNO : -return xfs_alloc_vextent_this_ag (args, minimum_agno); + args->pag =xfs_perag_get (args->mp, +XFS_FSB_TO_AGNO (args->mp, args->fsbno)); + error =xfs_alloc_vextent_this_ag (args); +xfs_perag_put (args->pag); +break ;case XFS_ALLOCTYPE_START_BNO :return xfs_alloc_vextent_start_ag (args, minimum_agno);case XFS_ALLOCTYPE_FIRST_AG :return xfs_alloc_vextent_first_ag (args, minimum_agno);default : + error = -EFSCORRUPTED ;ASSERT (0 ); -/* NOTREACHED */ +break ; } -/* Should never get here */ -return -EFSCORRUPTED ; +return error; }/* Ensure that the freelist is at full capacity. */
fs/xfs/libxfs/xfs_alloc.h +6 -0
@@ -124,6 +124,12 @@ int /* error */xfs_alloc_vextent ( xfs_alloc_arg_t *args);/* allocation argument structure */ +/* +* Allocate an extent in the specific AG defined by args->fsbno. If there is no +* space in that AG, then the allocation will fail. +*/ +int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* * Free an extent. */
fs/xfs/libxfs/xfs_bmap.c +30 -22
102 lines not on this page · raw message
fs/xfs/libxfs/xfs_bmap_btree.c +9 -13
@@ -21,6 +21,7 @@#include "xfs_quota.h" #include "xfs_trace.h" #include "xfs_rmap.h" +#include "xfs_ag.h" static struct kmem_cache *xfs_bmbt_cur_cache;
@@ -200,14 +201,18 @@ xfs_bmbt_alloc_block(union xfs_btree_ptr *new, int *stat) { - xfs_alloc_arg_t args; /* block allocation args */ -int error;/* error return value */ + struct xfs_alloc_arg args; +int error;memset (&args,0 ,sizeof (args)); args.tp = cur->bc_tp; args.mp = cur->bc_mp;xfs_rmap_ino_bmbt_owner (&args.oinfo, cur->bc_ino.ip->i_ino, cur->bc_ino.whichfork); + args.minlen = args.maxlen = args.prod =1 ; + args.wasdel = cur->bc_ino.flags &XFS_BTCUR_BMBT_WASDEL ; +if (!args.wasdel && args.tp->t_blk_res ==0 ) +return -ENOSPC ; args.fsbno =be64_to_cpu (start->l); args.type =XFS_ALLOCTYPE_START_BNO ;
@@ -222,15 +227,9 @@ xfs_bmbt_alloc_block( args.minleft =xfs_bmapi_minleft (cur->bc_tp, cur->bc_ino.ip, cur->bc_ino.whichfork); - args.minlen = args.maxlen = args.prod =1 ; - args.wasdel = cur->bc_ino.flags &XFS_BTCUR_BMBT_WASDEL ; -if (!args.wasdel && args.tp->t_blk_res ==0 ) { - error = -ENOSPC ; - goto error0; - } error =xfs_alloc_vextent (&args);if (error) - goto error0; +return error;if (args.fsbno ==NULLFSBLOCK && args.minleft) {/*
@@ -243,7 +242,7 @@ xfs_bmbt_alloc_block( args.type =XFS_ALLOCTYPE_START_BNO ; error =xfs_alloc_vextent (&args);if (error) - goto error0; +return error; cur->bc_tp->t_flags |=XFS_TRANS_LOWMODE ; }if (WARN_ON_ONCE (args.fsbno ==NULLFSBLOCK )) {
@@ -262,9 +261,6 @@ xfs_bmbt_alloc_block( *stat =1 ;return 0 ; - - error0: -return error; }STATIC int
fs/xfs/libxfs/xfs_ialloc.c +6 -3
@@ -630,6 +630,7 @@ xfs_ialloc_ag_alloc( args.mp = tp->t_mountp; args.fsbno =NULLFSBLOCK ; args.oinfo =XFS_RMAP_OINFO_INODES ; + args.pag = pag;#ifdef DEBUG /* randomly do sparse inode allocations */
@@ -683,7 +684,8 @@ xfs_ialloc_ag_alloc(/* Allow space for the inode btree to split. */ args.minleft = igeo->inobt_maxlevels; -if ((error =xfs_alloc_vextent (&args))) + error =xfs_alloc_vextent_this_ag (&args); +if (error)return error;/*
@@ -731,7 +733,8 @@ xfs_ialloc_ag_alloc(* Allow space for the inode btree to split. */ args.minleft = igeo->inobt_maxlevels; -if ((error =xfs_alloc_vextent (&args))) + error =xfs_alloc_vextent_this_ag (&args); +if (error)return error; }
@@ -780,7 +783,7 @@ xfs_ialloc_ag_alloc( args.mp->m_sb.sb_inoalignmt) - igeo->ialloc_blks; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_this_ag (&args);if (error)return error;
fs/xfs/libxfs/xfs_ialloc_btree.c +2 -1
@@ -103,6 +103,7 @@ __xfs_inobt_alloc_block(memset (&args,0 ,sizeof (args)); args.tp = cur->bc_tp; args.mp = cur->bc_mp; + args.pag = cur->bc_ag.pag; args.oinfo =XFS_RMAP_OINFO_INOBT ; args.fsbno =XFS_AGB_TO_FSB (args.mp, cur->bc_ag.pag->pag_agno, sbno); args.minlen =1 ;
@@ -111,7 +112,7 @@ __xfs_inobt_alloc_block( args.type =XFS_ALLOCTYPE_NEAR_BNO ; args.resv = resv; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_this_ag (&args);if (error)return error;
fs/xfs/libxfs/xfs_refcount_btree.c +2 -1
@@ -67,6 +67,7 @@ xfs_refcountbt_alloc_block(memset (&args,0 ,sizeof (args)); args.tp = cur->bc_tp; args.mp = cur->bc_mp; + args.pag = cur->bc_ag.pag; args.type =XFS_ALLOCTYPE_NEAR_BNO ; args.fsbno =XFS_AGB_TO_FSB (cur->bc_mp, cur->bc_ag.pag->pag_agno,xfs_refc_block (args.mp));
@@ -74,7 +75,7 @@ xfs_refcountbt_alloc_block( args.minlen = args.maxlen = args.prod =1 ; args.resv =XFS_AG_RESV_METADATA ; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_this_ag (&args);if (error) goto out_error; trace_xfs_refcountbt_alloc_block(cur->bc_mp, cur->bc_ag.pag->pag_agno,
fs/xfs/scrub/repair.c +2 -1
@@ -326,6 +326,7 @@ xrep_alloc_ag_block( args.tp = sc->tp; args.mp = sc->mp; + args.pag = sc->sa.pag; args.oinfo = *oinfo; args.fsbno =XFS_AGB_TO_FSB (args.mp, sc->sa.pag->pag_agno,0 ); args.minlen =1 ;
@@ -334,7 +335,7 @@ xrep_alloc_ag_block( args.type =XFS_ALLOCTYPE_THIS_AG ; args.resv = resv; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_this_ag (&args);if (error)return error;if (args.fsbno ==NULLFSBLOCK )
Signature · 1 line
2.39.0
PATCH 19/42 xfs: factor xfs_bmap_btalloc()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
There are several different contexts xfs_bmap_btalloc() handles, and large chunks of the code execute independent allocation contexts. Try to untangle this mess a bit.
--- fs/xfs/libxfs/xfs_bmap.c | 333 +++++++++++++++++++++++---------------- 1 file changed, 196 insertions(+), 137 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +196 -137
@@ -3196,13 +3196,13 @@ xfs_bmap_select_minlen( } } -STATIC int +static int xfs_bmap_btalloc_select_lengths (struct xfs_bmalloca *ap,struct xfs_alloc_arg *args,xfs_extlen_t *blen) { -struct xfs_mount *mp = ap->ip->i_mount; +struct xfs_mount *mp = args->mp;struct xfs_perag *pag;xfs_agnumber_t agno, startag;int notinit =0 ;
@@ -3216,7 +3216,7 @@ xfs_bmap_btalloc_select_lengths( } args->total = ap->total; - startag =XFS_FSB_TO_AGNO (mp, args->fsbno); + startag =XFS_FSB_TO_AGNO (mp, ap->blkno);if (startag ==NULLAGNUMBER ) startag =0 ;
@@ -3258,7 +3258,7 @@ xfs_bmap_btalloc_filestreams( args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total; - start_agno =XFS_FSB_TO_AGNO (mp, args->fsbno); + start_agno =XFS_FSB_TO_AGNO (mp, ap->blkno);if (start_agno ==NULLAGNUMBER ) start_agno =0 ;
@@ -3496,170 +3496,229 @@ xfs_bmap_exact_minlen_extent_alloc(#endif -STATIC int -xfs_bmap_btalloc ( -struct xfs_bmalloca *ap) +/* +* If we are not low on available data blocks and we are allocating at +* EOF, optimise allocation for contiguous file extension and/or stripe +* alignment of the new extent. +* +* NOTE: ap->aeof is only set if the allocation length is >= the +* stripe unit and the allocation offset is at the end of file. +*/ +static int +xfs_bmap_btalloc_at_eof ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args, +xfs_extlen_t blen, +int stripe_align) { -struct xfs_mount *mp = ap->ip->i_mount; -struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp }; -xfs_alloctype_t atype =0 ; -xfs_agnumber_t ag; -xfs_fileoff_t orig_offset; -xfs_extlen_t orig_length; -xfs_extlen_t blen; -xfs_extlen_t nextminlen =0 ; -int isaligned =0 ; +struct xfs_mount *mp = args->mp; +xfs_alloctype_t atype;int error; -int stripe_align; -ASSERT (ap->length); - orig_offset = ap->offset; - orig_length = ap->length; +/* +* If there are already extents in the file, try an exact EOF block +* allocation to extend the file as a contiguous extent. If that fails, +* or it's the first allocation in a file, just try for a stripe aligned +* allocation. +*/ +if (ap->offset) { +xfs_extlen_t nextminlen =0 ; - stripe_align =xfs_bmap_compute_alignments (ap, &args); + atype = args->type; + args->type =XFS_ALLOCTYPE_THIS_BNO ; + args->alignment =1 ; +/* +* Compute the minlen+alignment for the next case. Set slop so +* that the value of minlen+alignment+slop doesn't go up between +* the calls. +*/ +if (blen > stripe_align && blen <= args->maxlen) + nextminlen = blen - stripe_align; +else + nextminlen = args->minlen; +if (nextminlen + stripe_align > args->minlen +1 ) + args->minalignslop = nextminlen + stripe_align - + args->minlen -1 ; +else + args->minalignslop =0 ; + + args->pag =xfs_perag_get (mp,XFS_FSB_TO_AGNO (mp, args->fsbno)); + error =xfs_alloc_vextent_this_ag (args); +xfs_perag_put (args->pag); +if (error) +return error; + +if (args->fsbno !=NULLFSBLOCK ) +return 0 ; +/* +* Exact allocation failed. Reset to try an aligned allocation +* according to the original allocation specification. +*/ + args->pag =NULL ; + args->type = atype; + args->fsbno = ap->blkno; + args->alignment = stripe_align; + args->minlen = nextminlen; + args->minalignslop =0 ; + }else { + args->alignment = stripe_align; + atype = args->type; +/* +* Adjust minlen to try and preserve alignment if we +* can't guarantee an aligned maxlen extent. +*/ +if (blen > args->alignment && + blen <= args->maxlen + args->alignment) + args->minlen = blen - args->alignment; + args->minalignslop =0 ; + } + + error =xfs_alloc_vextent (args); +if (error) +return error; + +if (args->fsbno !=NULLFSBLOCK ) +return 0 ; + +/* +* Allocation failed, so turn return the allocation args to their +* original non-aligned state so the caller can proceed on allocation +* failure as if this function was never called. +*/ + args->type = atype; + args->fsbno = ap->blkno; + args->alignment =1 ; +return 0 ; +} + +static int +xfs_bmap_btalloc_best_length ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args, +int stripe_align) +{ +struct xfs_mount *mp = args->mp; +xfs_extlen_t blen =0 ; +int error; + +/* +* Determine the initial block number we will target for allocation. +*/ if ((ap->datatype &XFS_ALLOC_USERDATA ) &&xfs_inode_is_filestream (ap->ip)) { - ag =xfs_filestream_lookup_ag (ap->ip); - ag = (ag !=NULLAGNUMBER ) ? ag :0 ; - ap->blkno =XFS_AGB_TO_FSB (mp, ag,0 ); +xfs_agnumber_t agno =xfs_filestream_lookup_ag (ap->ip); +if (agno ==NULLAGNUMBER ) + agno =0 ; + ap->blkno =XFS_AGB_TO_FSB (mp, agno,0 ); }else { ap->blkno =XFS_INO_TO_FSB (mp, ap->ip->i_ino); } -xfs_bmap_adjacent (ap); - - args.fsbno = ap->blkno; - args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ; - -/* Trim the allocation back to the maximum an AG can fit. */ - args.maxlen =min (ap->length, mp->m_ag_max_usable); - blen =0 ; + args->fsbno = ap->blkno;/* -* Search for an allocation group with a single extent large -* enough for the request. If one isn't found, then adjust -* the minimum allocation size to the largest space found. +* Search for an allocation group with a single extent large enough for +* the request. If one isn't found, then adjust the minimum allocation +* size to the largest space found. */ if ((ap->datatype &XFS_ALLOC_USERDATA ) &&xfs_inode_is_filestream (ap->ip)) - error =xfs_bmap_btalloc_filestreams (ap, &args, &blen); + error =xfs_bmap_btalloc_filestreams (ap, args, &blen);else - error =xfs_bmap_btalloc_select_lengths (ap, &args, &blen); + error =xfs_bmap_btalloc_select_lengths (ap, args, &blen);if (error)return error;/* -* If we are not low on available data blocks, and the underlying -* logical volume manager is a stripe, and the file offset is zero then -* try to allocate data blocks on stripe unit boundary. NOTE: ap->aeof -* is only set if the allocation length is >= the stripe unit and the -* allocation offset is at the end of file. +* Don't attempt optimal EOF allocation if previous allocations barely +* succeeded due to being near ENOSPC. It is highly unlikely we'll get +* optimal or even aligned allocations in this case, so don't waste time +* trying. */ -if (!(ap->tp->t_flags &XFS_TRANS_LOWMODE ) && ap->aeof) { -if (!ap->offset) { - args.alignment = stripe_align; - atype = args.type; - isaligned =1 ; -/* -* Adjust minlen to try and preserve alignment if we -* can't guarantee an aligned maxlen extent. -*/ -if (blen > args.alignment && - blen <= args.maxlen + args.alignment) - args.minlen = blen - args.alignment; - args.minalignslop =0 ; - }else { -/* -* First try an exact bno allocation. -* If it fails then do a near or start bno -* allocation with alignment turned on. -*/ - atype = args.type; - args.type =XFS_ALLOCTYPE_THIS_BNO ; - args.alignment =1 ; - -/* -* Compute the minlen+alignment for the -* next case. Set slop so that the value -* of minlen+alignment+slop doesn't go up -* between the calls. -*/ -if (blen > stripe_align && blen <= args.maxlen) - nextminlen = blen - stripe_align; -else - nextminlen = args.minlen; -if (nextminlen + stripe_align > args.minlen +1 ) - args.minalignslop = - nextminlen + stripe_align - - args.minlen -1 ; -else - args.minalignslop =0 ; - - args.pag =xfs_perag_get (mp, -XFS_FSB_TO_AGNO (mp, args.fsbno)); - error =xfs_alloc_vextent_this_ag (&args); -xfs_perag_put (args.pag); -if (error) -return error; - -if (args.fsbno !=NULLFSBLOCK ) - goto out_success; -/* -* Exact allocation failed. Now try with alignment -* turned on. -*/ - args.pag =NULL ; - args.type = atype; - args.fsbno = ap->blkno; - args.alignment = stripe_align; - args.minlen = nextminlen; - args.minalignslop =0 ; - isaligned =1 ; - } - }else { - args.alignment =1 ; - args.minalignslop =0 ; +if (ap->aeof && !(ap->tp->t_flags &XFS_TRANS_LOWMODE )) { + error =xfs_bmap_btalloc_at_eof (ap, args, blen, stripe_align); +if (error) +return error; +if (args->fsbno !=NULLFSBLOCK ) +return 0 ; } - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent (args);if (error)return error; +if (args->fsbno !=NULLFSBLOCK ) +return 0 ; -if (isaligned && args.fsbno ==NULLFSBLOCK ) { -/* -* allocation failed, so turn off alignment and -* try again. -*/ - args.type = atype; - args.fsbno = ap->blkno; - args.alignment =0 ; -if ((error =xfs_alloc_vextent (&args))) -return error; - } -if (args.fsbno ==NULLFSBLOCK && - args.minlen > ap->minlen) { - args.minlen = ap->minlen; - args.type =XFS_ALLOCTYPE_START_BNO ; - args.fsbno = ap->blkno; -if ((error =xfs_alloc_vextent (&args))) -return error; - } -if (args.fsbno ==NULLFSBLOCK ) { - args.fsbno =0 ; - args.type =XFS_ALLOCTYPE_FIRST_AG ; - args.total = ap->minlen; -if ((error =xfs_alloc_vextent (&args))) +/* +* Try a locality first full filesystem minimum length allocation whilst +* still maintaining necessary total block reservation requirements. +*/ +if (args->minlen > ap->minlen) { + args->minlen = ap->minlen; + args->type =XFS_ALLOCTYPE_START_BNO ; + args->fsbno = ap->blkno; + error =xfs_alloc_vextent (args); +if (error)return error; - ap->tp->t_flags |=XFS_TRANS_LOWMODE ; } - args.minleft = ap->minleft; - args.wasdel = ap->wasdel; - args.resv =XFS_AG_RESV_NONE ; - args.datatype = ap->datatype; +if (args->fsbno !=NULLFSBLOCK ) +return 0 ; + +/* +* We are now critically low on space, so this is a last resort +* allocation attempt: no reserve, no locality, blocking, minimum +* length, full filesystem free space scan. We also indicate to future +* allocations in this transaction that we are critically low on space +* so they don't waste time on allocation modes that are unlikely to +* succeed. +*/ + args->fsbno =0 ; + args->type =XFS_ALLOCTYPE_FIRST_AG ; + args->total = ap->minlen; + error =xfs_alloc_vextent (args); +if (error) +return error; + ap->tp->t_flags |=XFS_TRANS_LOWMODE ; +return 0 ; +} + +static int +xfs_bmap_btalloc ( +struct xfs_bmalloca *ap) +{ +struct xfs_mount *mp = ap->ip->i_mount; +struct xfs_alloc_arg args = { + .tp = ap->tp, + .mp = mp, + .fsbno =NULLFSBLOCK , + .oinfo =XFS_RMAP_OINFO_SKIP_UPDATE , + .minleft = ap->minleft, + .wasdel = ap->wasdel, + .resv =XFS_AG_RESV_NONE , + .datatype = ap->datatype, + .alignment =1 , + .minalignslop =0 , + }; +xfs_fileoff_t orig_offset; +xfs_extlen_t orig_length; +int error; +int stripe_align; + +ASSERT (ap->length); + orig_offset = ap->offset; + orig_length = ap->length; + + stripe_align =xfs_bmap_compute_alignments (ap, &args); + +/* Trim the allocation back to the maximum an AG can fit. */ + args.maxlen =min (ap->length, mp->m_ag_max_usable); + + error =xfs_bmap_btalloc_best_length (ap, &args, stripe_align); +if (error) +return error;if (args.fsbno !=NULLFSBLOCK ) { -out_success:xfs_bmap_process_allocated_extent (ap, &args, orig_offset, orig_length); }else {
Signature · 1 line
2.39.0
PATCH 20/42 xfs: use xfs_alloc_vextent_first_ag() where appropriate
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Change obvious callers of single AG allocation to use xfs_alloc_vextent_first_ag(). This gets rid of XFS_ALLOCTYPE_FIRST_AG as the type used within xfs_alloc_vextent_first_ag() during iteration is _THIS_AG. Hence we can remove the setting of args->type from all the callers of _first_ag() and remove the alloctype.
While doing this, pass the allocation target fsb as a parameter rather than encoding it in args->fsbno. This starts the process of making args->fsbno an output only variable rather than input/output.
--- fs/xfs/libxfs/xfs_alloc.c | 35 +++++++++++++++++++---------------- fs/xfs/libxfs/xfs_alloc.h | 10 ++++++++-- fs/xfs/libxfs/xfs_bmap.c | 31 ++++++++++++++++--------------- 3 files changed, 43 insertions(+), 33 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +19 -16
@@ -3183,7 +3183,8 @@ xfs_alloc_read_agf(*/ static int xfs_alloc_vextent_check_args ( -struct xfs_alloc_arg *args) +struct xfs_alloc_arg *args, +xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp;xfs_agblock_t agsize;
@@ -3201,13 +3202,13 @@ xfs_alloc_vextent_check_args( args->maxlen = agsize;if (args->alignment ==0 ) args->alignment =1 ; -ASSERT (XFS_FSB_TO_AGNO (mp, args->fsbno) < mp->m_sb.sb_agcount); -ASSERT (XFS_FSB_TO_AGBNO (mp, args->fsbno) < agsize); +ASSERT (XFS_FSB_TO_AGNO (mp, target) < mp->m_sb.sb_agcount); +ASSERT (XFS_FSB_TO_AGBNO (mp, target) < agsize);ASSERT (args->minlen <= args->maxlen);ASSERT (args->minlen <= agsize);ASSERT (args->mod < args->prod); -if (XFS_FSB_TO_AGNO (mp, args->fsbno) >= mp->m_sb.sb_agcount || -XFS_FSB_TO_AGBNO (mp, args->fsbno) >= agsize || +if (XFS_FSB_TO_AGNO (mp, target) >= mp->m_sb.sb_agcount || +XFS_FSB_TO_AGBNO (mp, target) >= agsize || args->minlen > args->maxlen || args->minlen > agsize || args->mod >= args->prod) { args->fsbno =NULLFSBLOCK ;
@@ -3281,7 +3282,7 @@ xfs_alloc_vextent_this_ag(if (args->tp->t_highest_agno !=NULLAGNUMBER ) minimum_agno = args->tp->t_highest_agno; - error =xfs_alloc_vextent_check_args (args); + error =xfs_alloc_vextent_check_args (args, args->fsbno);if (error) {if (error == -ENOSPC )return 0 ;
@@ -3406,7 +3407,7 @@ xfs_alloc_vextent_start_ag(bool bump_rotor = false;int error; - error =xfs_alloc_vextent_check_args (args); + error =xfs_alloc_vextent_check_args (args, args->fsbno);if (error) {if (error == -ENOSPC )return 0 ;
@@ -3444,25 +3445,29 @@ xfs_alloc_vextent_start_ag(* filesystem attempting blocking allocation. This does not wrap or try a second * pass, so will not recurse into AGs lower than indicated by fsbno. */ -static int -xfs_alloc_vextent_first_ag ( +int +xfs_alloc_vextent_first_ag (struct xfs_alloc_arg *args, -xfs_agnumber_t minimum_agno) -{ +xfs_rfsblock_t target) + {struct xfs_mount *mp = args->mp; +xfs_agnumber_t minimum_agno =0 ;xfs_agnumber_t start_agno;int error; - error =xfs_alloc_vextent_check_args (args); +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + + error =xfs_alloc_vextent_check_args (args, target);if (error) {if (error == -ENOSPC )return 0 ;return error; } - start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); - + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); args->type =XFS_ALLOCTYPE_THIS_AG ; + args->fsbno = target; error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno,0 );xfs_alloc_vextent_set_fsbno (args, minimum_agno);
@@ -3495,8 +3500,6 @@ xfs_alloc_vextent(break ;case XFS_ALLOCTYPE_START_BNO :return xfs_alloc_vextent_start_ag (args, minimum_agno); -case XFS_ALLOCTYPE_FIRST_AG : -return xfs_alloc_vextent_first_ag (args, minimum_agno);default : error = -EFSCORRUPTED ;ASSERT (0 );
fs/xfs/libxfs/xfs_alloc.h +8 -2
@@ -19,7 +19,6 @@ unsigned int xfs_agfl_size(struct xfs_mount *mp);/* * Freespace allocation types. Argument to xfs_alloc_[v]extent. */ -#define XFS_ALLOCTYPE_FIRST_AG 0x02/* ... start at ag 0 */ #define XFS_ALLOCTYPE_THIS_AG 0x08/* anywhere in this a.g. */ #define XFS_ALLOCTYPE_START_BNO 0x10/* near this block else anywhere */ #define XFS_ALLOCTYPE_NEAR_BNO 0x20/* in this a.g. and near this block */
@@ -29,7 +28,6 @@ unsigned int xfs_agfl_size(struct xfs_mount *mp);typedef unsigned int xfs_alloctype_t ;#define XFS_ALLOC_TYPES \ - { XFS_ALLOCTYPE_FIRST_AG, "FIRST_AG" }, \ { XFS_ALLOCTYPE_THIS_AG, "THIS_AG" }, \ { XFS_ALLOCTYPE_START_BNO, "START_BNO" }, \ { XFS_ALLOCTYPE_NEAR_BNO, "NEAR_BNO" }, \
@@ -130,6 +128,14 @@ xfs_alloc_vextent(*/ int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* +* Iterate from the AG indicated from args->fsbno through to the end of the +* filesystem attempting blocking allocation. This is for use in last +* resort allocation attempts when everything else has failed. +*/ +int xfs_alloc_vextent_first_ag (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Free an extent. */
fs/xfs/libxfs/xfs_bmap.c +16 -15
@@ -3248,13 +3248,6 @@ xfs_bmap_btalloc_filestreams(int notinit =0 ;int error; -if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { - args->type =XFS_ALLOCTYPE_FIRST_AG ; - args->total = ap->minlen; - args->minlen = ap->minlen; -return 0 ; - } - args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total;
@@ -3462,9 +3455,7 @@ xfs_bmap_exact_minlen_extent_alloc(*/ ap->blkno =XFS_AGB_TO_FSB (mp,0 ,0 ); - args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ; - args.type =XFS_ALLOCTYPE_FIRST_AG ; args.minlen = args.maxlen = ap->minlen; args.total = ap->total;
@@ -3476,7 +3467,7 @@ xfs_bmap_exact_minlen_extent_alloc( args.resv =XFS_AG_RESV_NONE ; args.datatype = ap->datatype; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_first_ag (&args, ap->blkno);if (error)return error;
@@ -3623,10 +3614,21 @@ xfs_bmap_btalloc_best_length(* size to the largest space found. */ if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) +xfs_inode_is_filestream (ap->ip)) { +/* +* If there is very little free space before we start a +* filestreams allocation, we're almost guaranteed to fail to +* find an AG with enough contiguous free space to succeed, so +* just go straight to the low space algorithm. +*/ +if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { + args->minlen = ap->minlen; + goto critically_low_space; + } error =xfs_bmap_btalloc_filestreams (ap, args, &blen); -else + }else { error =xfs_bmap_btalloc_select_lengths (ap, args, &blen); + }if (error)return error;
@@ -3673,10 +3675,9 @@ xfs_bmap_btalloc_best_length(* so they don't waste time on allocation modes that are unlikely to * succeed. */ - args->fsbno =0 ; - args->type =XFS_ALLOCTYPE_FIRST_AG ; +critically_low_space: args->total = ap->minlen; - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_first_ag (args,0 );if (error)return error; ap->tp->t_flags |=XFS_TRANS_LOWMODE ;
Signature · 1 line
2.39.0
Re: [PATCH 20/42] xfs: use xfs_alloc_vextent_first_ag() where appropriate
Quoted 26 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Change obvious callers of single AG allocation to use
xfs_alloc_vextent_first_ag(). This gets rid ofXFS_ALLOCTYPE_FIRST_AGas the type used withinxfs_alloc_vextent_first_ag()during iteration is_THIS_AG. Hence we can remove the setting ofargs->typefrom all the callers of_first_ag()and remove the alloctype.While doing this, pass the allocation target fsb as a parameter rather than encoding it in
args->fsbno. This starts the process of makingargs->fsbnoan output only variable rather than input/output.Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 35 +++++++++++++++++++---------------- fs/xfs/libxfs/xfs_alloc.h | 10 ++++++++-- fs/xfs/libxfs/xfs_bmap.c | 31 ++++++++++++++++--------------- 3 files changed, 43 insertions(+), 33 deletions(-)fs/xfs/libxfs/xfs_alloc.c +0
-0
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3187
Quoted 6 lines
fs/xfs/libxfs/xfs_alloc.c +2
-1@@ -3183,7 +3183,8 @@ xfs_alloc_read_agf(*/ static int xfs_alloc_vextent_check_args ( -struct xfs_alloc_arg *args) +struct xfs_alloc_arg *args, +xfs_rfsblock_t target)
Isn't xfs_rfsblock_t supposed to be used to measure quantities of raw fs blocks, and not the segmented agno/agbno numbers that we encode in most places?
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_vextent_check_args( · line 3206
Quoted 11 lines
fs/xfs/libxfs/xfs_alloc.c +2
-2{struct xfs_mount *mp = args->mp;xfs_agblock_t agsize;@@ -3201,13 +3202,13 @@ xfs_alloc_vextent_check_args( args->maxlen = agsize;if (args->alignment ==0 ) args->alignment =1 ; -ASSERT (XFS_FSB_TO_AGNO (mp, args->fsbno) < mp->m_sb.sb_agcount); -ASSERT (XFS_FSB_TO_AGBNO (mp, args->fsbno) < agsize); +ASSERT (XFS_FSB_TO_AGNO (mp, target) < mp->m_sb.sb_agcount); +ASSERT (XFS_FSB_TO_AGBNO (mp, target) < agsize);
Yes, I think @target should be xfs_fsblock_t since we pass it to XFS_FSB_TO_AG{,B}NO here.
Quoted 31 lines
fs/xfs/libxfs/xfs_alloc.c +4
-4ASSERT (args->minlen <= args->maxlen);ASSERT (args->minlen <= agsize);ASSERT (args->mod < args->prod); -if (XFS_FSB_TO_AGNO (mp, args->fsbno) >= mp->m_sb.sb_agcount || -XFS_FSB_TO_AGBNO (mp, args->fsbno) >= agsize || +if (XFS_FSB_TO_AGNO (mp, target) >= mp->m_sb.sb_agcount || +XFS_FSB_TO_AGBNO (mp, target) >= agsize || args->minlen > args->maxlen || args->minlen > agsize || args->mod >= args->prod) { args->fsbno =NULLFSBLOCK ;@@ -3281,7 +3282,7 @@ xfs_alloc_vextent_this_ag(if (args->tp->t_highest_agno !=NULLAGNUMBER ) minimum_agno = args->tp->t_highest_agno; - error =xfs_alloc_vextent_check_args (args); + error =xfs_alloc_vextent_check_args (args, args->fsbno);if (error) {if (error == -ENOSPC )return 0 ;@@ -3406,7 +3407,7 @@ xfs_alloc_vextent_start_ag(bool bump_rotor = false;int error; - error =xfs_alloc_vextent_check_args (args); + error =xfs_alloc_vextent_check_args (args, args->fsbno);if (error) {if (error == -ENOSPC )return 0 ;@@ -3444,25 +3445,29 @@ xfs_alloc_vextent_start_ag(* filesystem attempting blocking allocation. This does not wrap or try a second * pass, so will not recurse into AGs lower than indicated by fsbno.
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_vextent_start_ag( · line 3452
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +4
-4*/ -static int -xfs_alloc_vextent_first_ag ( +int +xfs_alloc_vextent_first_ag (struct xfs_alloc_arg *args, -xfs_agnumber_t minimum_agno) -{ +xfs_rfsblock_t target) + {
Extra spaces here, and seemingly another variable that ought to be xfs_fsblock_t?
--D
Quoted 145 lines
fs/xfs/libxfs/xfs_alloc.c +7
-5struct xfs_mount *mp = args->mp; +xfs_agnumber_t minimum_agno =0 ;xfs_agnumber_t start_agno;int error; - error =xfs_alloc_vextent_check_args (args); +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + + error =xfs_alloc_vextent_check_args (args, target);if (error) {if (error == -ENOSPC )return 0 ;return error; } - start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); - + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); args->type =XFS_ALLOCTYPE_THIS_AG ; + args->fsbno = target; error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno,0 );xfs_alloc_vextent_set_fsbno (args, minimum_agno);@@ -3495,8 +3500,6 @@ xfs_alloc_vextent(break ;case XFS_ALLOCTYPE_START_BNO :return xfs_alloc_vextent_start_ag (args, minimum_agno); -case XFS_ALLOCTYPE_FIRST_AG : -return xfs_alloc_vextent_first_ag (args, minimum_agno);default : error = -EFSCORRUPTED ;ASSERT (0 );fs/xfs/libxfs/xfs_alloc.h +8
-2@@ -19,7 +19,6 @@ unsigned int xfs_agfl_size(struct xfs_mount *mp);/* * Freespace allocation types. Argument to xfs_alloc_[v]extent. */ -#define XFS_ALLOCTYPE_FIRST_AG 0x02/* ... start at ag 0 */ #define XFS_ALLOCTYPE_THIS_AG 0x08/* anywhere in this a.g. */ #define XFS_ALLOCTYPE_START_BNO 0x10/* near this block else anywhere */ #define XFS_ALLOCTYPE_NEAR_BNO 0x20/* in this a.g. and near this block */ @@ -29,7 +28,6 @@ unsigned int xfs_agfl_size(struct xfs_mount *mp);typedef unsigned int xfs_alloctype_t ;#define XFS_ALLOC_TYPES \ - { XFS_ALLOCTYPE_FIRST_AG, "FIRST_AG" }, \ { XFS_ALLOCTYPE_THIS_AG, "THIS_AG" }, \ { XFS_ALLOCTYPE_START_BNO, "START_BNO" }, \ { XFS_ALLOCTYPE_NEAR_BNO, "NEAR_BNO" }, \@@ -130,6 +128,14 @@ xfs_alloc_vextent(*/ int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* +* Iterate from the AG indicated from args->fsbno through to the end of the +* filesystem attempting blocking allocation. This is for use in last +* resort allocation attempts when everything else has failed. +*/ +int xfs_alloc_vextent_first_ag (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Free an extent. */ fs/xfs/libxfs/xfs_bmap.c +16
-15@@ -3248,13 +3248,6 @@ xfs_bmap_btalloc_filestreams(int notinit =0 ;int error; -if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { - args->type =XFS_ALLOCTYPE_FIRST_AG ; - args->total = ap->minlen; - args->minlen = ap->minlen; -return 0 ; - } - args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total;@@ -3462,9 +3455,7 @@ xfs_bmap_exact_minlen_extent_alloc(*/ ap->blkno =XFS_AGB_TO_FSB (mp,0 ,0 ); - args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ; - args.type =XFS_ALLOCTYPE_FIRST_AG ; args.minlen = args.maxlen = ap->minlen; args.total = ap->total;@@ -3476,7 +3467,7 @@ xfs_bmap_exact_minlen_extent_alloc( args.resv =XFS_AG_RESV_NONE ; args.datatype = ap->datatype; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_first_ag (&args, ap->blkno);if (error)return error;@@ -3623,10 +3614,21 @@ xfs_bmap_btalloc_best_length(* size to the largest space found. */ if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) +xfs_inode_is_filestream (ap->ip)) { +/* +* If there is very little free space before we start a +* filestreams allocation, we're almost guaranteed to fail to +* find an AG with enough contiguous free space to succeed, so +* just go straight to the low space algorithm. +*/ +if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { + args->minlen = ap->minlen; + goto critically_low_space; + } error =xfs_bmap_btalloc_filestreams (ap, args, &blen); -else + }else { error =xfs_bmap_btalloc_select_lengths (ap, args, &blen); + }if (error)return error;@@ -3673,10 +3675,9 @@ xfs_bmap_btalloc_best_length(* so they don't waste time on allocation modes that are unlikely to * succeed. */ - args->fsbno =0 ; - args->type =XFS_ALLOCTYPE_FIRST_AG ; +critically_low_space: args->total = ap->minlen; - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_first_ag (args,0 );if (error)return error; ap->tp->t_flags |=XFS_TRANS_LOWMODE ;Signature · 1 line
2.39.0
Re: [PATCH 20/42] xfs: use xfs_alloc_vextent_first_ag() where appropriate
Quoted 22 lines · Darrick J. Wong
Quoted 21 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Change obvious callers of single AG allocation to use
xfs_alloc_vextent_first_ag(). This gets rid ofXFS_ALLOCTYPE_FIRST_AGas the type used withinxfs_alloc_vextent_first_ag()during iteration is_THIS_AG. Hence we can remove the setting ofargs->typefrom all the callers of_first_ag()and remove the alloctype.While doing this, pass the allocation target fsb as a parameter rather than encoding it in
args->fsbno. This starts the process of makingargs->fsbnoan output only variable rather than input/output.Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 35 +++++++++++++++++++---------------- fs/xfs/libxfs/xfs_alloc.h | 10 ++++++++-- fs/xfs/libxfs/xfs_bmap.c | 31 ++++++++++++++++--------------- 3 files changed, 43 insertions(+), 33 deletions(-)
Quoted 15 lines
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_read_agf( · line 3187
Quoted 11 lines
fs/xfs/libxfs/xfs_alloc.c +2
-1@@ -3183,7 +3183,8 @@ xfs_alloc_read_agf(*/ static int xfs_alloc_vextent_check_args ( -struct xfs_alloc_arg *args) +struct xfs_alloc_arg *args, +xfs_rfsblock_t target)Isn't
xfs_rfsblock_tsupposed to be used to measure quantities of raw fs blocks, and not the segmented agno/agbno numbers that we encode in most places?
Yup, just a minor braino. I'll fix those.
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 21/42 xfs: use xfs_alloc_vextent_start_bno() where appropriate
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Change obvious callers of single AG allocation to use xfs_alloc_vextent_start_bno(). Callers no long need to specify XFS_ALLOCTYPE_START_BNO, and so the type can be driven inward and removed.
While doing this, also pass the allocation target fsb as a parameter rather than encoding it in args->fsbno.
--- fs/xfs/libxfs/xfs_alloc.c | 24 ++++++++++--------- fs/xfs/libxfs/xfs_alloc.h | 13 ++++++++-- fs/xfs/libxfs/xfs_bmap.c | 43 ++++++++++++++++++++-------------- fs/xfs/libxfs/xfs_bmap_btree.c | 9 ++----- 4 files changed, 51 insertions(+), 38 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +13 -11
@@ -3189,7 +3189,6 @@ xfs_alloc_vextent_check_args(struct xfs_mount *mp = args->mp;xfs_agblock_t agsize; - args->otype = args->type; args->agbno =NULLAGBLOCK ;/*
@@ -3345,7 +3344,7 @@ xfs_alloc_vextent_iterate_ags(trace_xfs_alloc_vextent_loopfailed (args);if (args->agno == start_agno && - args->otype ==XFS_ALLOCTYPE_START_BNO ) + args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) args->type =XFS_ALLOCTYPE_THIS_AG ;/*
@@ -3373,7 +3372,7 @@ xfs_alloc_vextent_iterate_ags( } flags =0 ; -if (args->otype ==XFS_ALLOCTYPE_START_BNO ) { +if (args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) { args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); args->type =XFS_ALLOCTYPE_NEAR_BNO ; }
@@ -3396,18 +3395,22 @@ xfs_alloc_vextent_iterate_ags(* otherwise will wrap back to the start AG and run a second blocking pass to * the end of the filesystem. */ -static int +int xfs_alloc_vextent_start_ag (struct xfs_alloc_arg *args, -xfs_agnumber_t minimum_agno) +xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp; +xfs_agnumber_t minimum_agno =0 ;xfs_agnumber_t start_agno;xfs_agnumber_t rotorstep = xfs_rotorstep;bool bump_rotor = false;int error; - error =xfs_alloc_vextent_check_args (args, args->fsbno); +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + + error =xfs_alloc_vextent_check_args (args, target);if (error) {if (error == -ENOSPC )return 0 ;
@@ -3416,14 +3419,15 @@ xfs_alloc_vextent_start_ag(if ((args->datatype &XFS_ALLOC_INITIAL_USER_DATA ) &&xfs_is_inode32 (mp)) { - args->fsbno =XFS_AGB_TO_FSB (mp, + target =XFS_AGB_TO_FSB (mp, ((mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount),0 ); bump_rotor =1 ; } - start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); + args->agbno =XFS_FSB_TO_AGBNO (mp, target); args->type =XFS_ALLOCTYPE_NEAR_BNO ; + args->fsbno = target; error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno,XFS_ALLOC_FLAG_TRYLOCK );
@@ -3498,8 +3502,6 @@ xfs_alloc_vextent( error =xfs_alloc_vextent_this_ag (args);xfs_perag_put (args->pag);break ; -case XFS_ALLOCTYPE_START_BNO : -return xfs_alloc_vextent_start_ag (args, minimum_agno);default : error = -EFSCORRUPTED ;ASSERT (0 );
fs/xfs/libxfs/xfs_alloc.h +11 -2
@@ -20,7 +20,6 @@ unsigned int xfs_agfl_size(struct xfs_mount *mp);* Freespace allocation types. Argument to xfs_alloc_[v]extent. */ #define XFS_ALLOCTYPE_THIS_AG 0x08/* anywhere in this a.g. */ -#define XFS_ALLOCTYPE_START_BNO 0x10/* near this block else anywhere */ #define XFS_ALLOCTYPE_NEAR_BNO 0x20/* in this a.g. and near this block */ #define XFS_ALLOCTYPE_THIS_BNO 0x40/* at exactly this block */
@@ -29,7 +28,6 @@ typedef unsigned int xfs_alloctype_t;#define XFS_ALLOC_TYPES \ { XFS_ALLOCTYPE_THIS_AG, "THIS_AG" }, \ - { XFS_ALLOCTYPE_START_BNO, "START_BNO" }, \ { XFS_ALLOCTYPE_NEAR_BNO, "NEAR_BNO" }, \ { XFS_ALLOCTYPE_THIS_BNO, "THIS_BNO" }
@@ -128,6 +126,17 @@ xfs_alloc_vextent(*/ int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* +* Best effort full filesystem allocation scan. +* +* Locality aware allocation will be attempted in the initial AG, but on failure +* non-localised attempts will be made. The AGs are constrained by previous +* allocations in the current transaction. Two passes will be made - the first +* non-blocking, the second blocking. +*/ +int xfs_alloc_vextent_start_ag (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Iterate from the AG indicated from args->fsbno through to the end of the * filesystem attempting blocking allocation. This is for use in last
fs/xfs/libxfs/xfs_bmap.c +25 -18
117 lines not on this page · raw message
fs/xfs/libxfs/xfs_bmap_btree.c +2 -7
@@ -214,9 +214,6 @@ xfs_bmbt_alloc_block(if (!args.wasdel && args.tp->t_blk_res ==0 )return -ENOSPC ; - args.fsbno =be64_to_cpu (start->l); - args.type =XFS_ALLOCTYPE_START_BNO ; -/* * If we are coming here from something like unwritten extent * conversion, there has been no data extent allocation already done, so
@@ -227,7 +224,7 @@ xfs_bmbt_alloc_block( args.minleft =xfs_bmapi_minleft (cur->bc_tp, cur->bc_ino.ip, cur->bc_ino.whichfork); - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_start_ag (&args,be64_to_cpu (start->l));if (error)return error;
@@ -237,10 +234,8 @@ xfs_bmbt_alloc_block(* a full btree split. Try again and if * successful activate the lowspace algorithm. */ - args.fsbno =0 ; args.minleft =0 ; - args.type =XFS_ALLOCTYPE_START_BNO ; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_start_ag (&args,0 );if (error)return error; cur->bc_tp->t_flags |=XFS_TRANS_LOWMODE ;
Signature · 1 line
2.39.0
Re: [PATCH 21/42] xfs: use xfs_alloc_vextent_start_bno() where appropriate
Quoted 49 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Change obvious callers of single AG allocation to use
xfs_alloc_vextent_start_bno(). Callers no long need to specifyXFS_ALLOCTYPE_START_BNO, and so the type can be driven inward and removed.While doing this, also pass the allocation target fsb as a parameter rather than encoding it in
args->fsbno.Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 24 ++++++++++--------- fs/xfs/libxfs/xfs_alloc.h | 13 ++++++++-- fs/xfs/libxfs/xfs_bmap.c | 43 ++++++++++++++++++++-------------- fs/xfs/libxfs/xfs_bmap_btree.c | 9 ++----- 4 files changed, 51 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_alloc.c +2
-3@@ -3189,7 +3189,6 @@ xfs_alloc_vextent_check_args(struct xfs_mount *mp = args->mp;xfs_agblock_t agsize; - args->otype = args->type; args->agbno =NULLAGBLOCK ;/* @@ -3345,7 +3344,7 @@ xfs_alloc_vextent_iterate_ags(trace_xfs_alloc_vextent_loopfailed (args);if (args->agno == start_agno && - args->otype ==XFS_ALLOCTYPE_START_BNO ) + args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) args->type =XFS_ALLOCTYPE_THIS_AG ;/* @@ -3373,7 +3372,7 @@ xfs_alloc_vextent_iterate_ags( } flags =0 ; -if (args->otype ==XFS_ALLOCTYPE_START_BNO ) { +if (args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) { args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); args->type =XFS_ALLOCTYPE_NEAR_BNO ; }
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_vextent_iterate_ags( · line 3401
Quoted 9 lines
fs/xfs/libxfs/xfs_alloc.c +2
-2@@ -3396,18 +3395,22 @@ xfs_alloc_vextent_iterate_ags(* otherwise will wrap back to the start AG and run a second blocking pass to * the end of the filesystem. */ -static int +int xfs_alloc_vextent_start_ag (struct xfs_alloc_arg *args, -xfs_agnumber_t minimum_agno) +xfs_rfsblock_t target)
Same xfs_fsblock_t vs. xfs_rfsblock_t comment as the last patch. The rest looks ok though.
--D
Quoted 250 lines
fs/xfs/libxfs/xfs_alloc.c +9
-6{struct xfs_mount *mp = args->mp; +xfs_agnumber_t minimum_agno =0 ;xfs_agnumber_t start_agno;xfs_agnumber_t rotorstep = xfs_rotorstep;bool bump_rotor = false;int error; - error =xfs_alloc_vextent_check_args (args, args->fsbno); +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + + error =xfs_alloc_vextent_check_args (args, target);if (error) {if (error == -ENOSPC )return 0 ;@@ -3416,14 +3419,15 @@ xfs_alloc_vextent_start_ag(if ((args->datatype &XFS_ALLOC_INITIAL_USER_DATA ) &&xfs_is_inode32 (mp)) { - args->fsbno =XFS_AGB_TO_FSB (mp, + target =XFS_AGB_TO_FSB (mp, ((mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount),0 ); bump_rotor =1 ; } - start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, args->fsbno)); - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); + args->agbno =XFS_FSB_TO_AGBNO (mp, target); args->type =XFS_ALLOCTYPE_NEAR_BNO ; + args->fsbno = target; error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno,XFS_ALLOC_FLAG_TRYLOCK );@@ -3498,8 +3502,6 @@ xfs_alloc_vextent( error =xfs_alloc_vextent_this_ag (args);xfs_perag_put (args->pag);break ; -case XFS_ALLOCTYPE_START_BNO : -return xfs_alloc_vextent_start_ag (args, minimum_agno);default : error = -EFSCORRUPTED ;ASSERT (0 );fs/xfs/libxfs/xfs_alloc.h +11
-2@@ -20,7 +20,6 @@ unsigned int xfs_agfl_size(struct xfs_mount *mp);* Freespace allocation types. Argument to xfs_alloc_[v]extent. */ #define XFS_ALLOCTYPE_THIS_AG 0x08/* anywhere in this a.g. */ -#define XFS_ALLOCTYPE_START_BNO 0x10/* near this block else anywhere */ #define XFS_ALLOCTYPE_NEAR_BNO 0x20/* in this a.g. and near this block */ #define XFS_ALLOCTYPE_THIS_BNO 0x40/* at exactly this block */ @@ -29,7 +28,6 @@ typedef unsigned int xfs_alloctype_t;#define XFS_ALLOC_TYPES \ { XFS_ALLOCTYPE_THIS_AG, "THIS_AG" }, \ - { XFS_ALLOCTYPE_START_BNO, "START_BNO" }, \ { XFS_ALLOCTYPE_NEAR_BNO, "NEAR_BNO" }, \ { XFS_ALLOCTYPE_THIS_BNO, "THIS_BNO" }@@ -128,6 +126,17 @@ xfs_alloc_vextent(*/ int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* +* Best effort full filesystem allocation scan. +* +* Locality aware allocation will be attempted in the initial AG, but on failure +* non-localised attempts will be made. The AGs are constrained by previous +* allocations in the current transaction. Two passes will be made - the first +* non-blocking, the second blocking. +*/ +int xfs_alloc_vextent_start_ag (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Iterate from the AG indicated from args->fsbno through to the end of the * filesystem attempting blocking allocation. This is for use in last fs/xfs/libxfs/xfs_bmap.c +25
-18@@ -646,12 +646,11 @@ xfs_bmap_extents_to_btree( args.mp = mp;xfs_rmap_ino_bmbt_owner (&args.oinfo, ip->i_ino, whichfork); - args.type =XFS_ALLOCTYPE_START_BNO ; - args.fsbno =XFS_INO_TO_FSB (mp, ip->i_ino); args.minlen = args.maxlen = args.prod =1 ; args.wasdel = wasdel; *logflagsp =0 ; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_start_ag (&args, +XFS_INO_TO_FSB (mp, ip->i_ino));if (error) goto out_root_realloc;@@ -792,15 +791,15 @@ xfs_bmap_local_to_extents( args.total = total; args.minlen = args.maxlen = args.prod =1 ;xfs_rmap_ino_owner (&args.oinfo, ip->i_ino, whichfork,0 ); +/* * Allocate a block. We know we need only one, since the * file currently fits in an inode. */ - args.fsbno =XFS_INO_TO_FSB (args.mp, ip->i_ino); - args.type =XFS_ALLOCTYPE_START_BNO ; args.total = total; args.minlen = args.maxlen = args.prod =1 ; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_start_ag (&args, +XFS_INO_TO_FSB (args.mp, ip->i_ino));if (error) goto done;@@ -3208,7 +3207,6 @@ xfs_bmap_btalloc_select_lengths(int notinit =0 ;int error =0 ; - args->type =XFS_ALLOCTYPE_START_BNO ;if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { args->total = ap->minlen; args->minlen = ap->minlen;@@ -3500,7 +3498,8 @@ xfs_bmap_btalloc_at_eof(struct xfs_bmalloca *ap, struct xfs_alloc_arg *args, xfs_extlen_t blen, - int stripe_align) + int stripe_align, + bool ag_only) { struct xfs_mount *mp = args->mp;xfs_alloctype_t atype;@@ -3565,7 +3564,10 @@ xfs_bmap_btalloc_at_eof( args->minalignslop =0 ; } - error =xfs_alloc_vextent (args); +if (ag_only) + error =xfs_alloc_vextent (args); +else + error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)return error;@@ -3591,13 +3593,17 @@ xfs_bmap_btalloc_best_length( {struct xfs_mount *mp = args->mp;xfs_extlen_t blen =0 ; +bool is_filestream = false;int error; +if ((ap->datatype &XFS_ALLOC_USERDATA ) && +xfs_inode_is_filestream (ap->ip)) + is_filestream = true; +/* * Determine the initial block number we will target for allocation. */ -if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) { +if (is_filestream) {xfs_agnumber_t agno =xfs_filestream_lookup_ag (ap->ip);if (agno ==NULLAGNUMBER ) agno =0 ;@@ -3613,8 +3619,7 @@ xfs_bmap_btalloc_best_length(* the request. If one isn't found, then adjust the minimum allocation * size to the largest space found. */ -if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) { +if (is_filestream) {/* * If there is very little free space before we start a * filestreams allocation, we're almost guaranteed to fail to @@ -3639,14 +3644,18 @@ xfs_bmap_btalloc_best_length(* trying. */ if (ap->aeof && !(ap->tp->t_flags &XFS_TRANS_LOWMODE )) { - error =xfs_bmap_btalloc_at_eof (ap, args, blen, stripe_align); + error =xfs_bmap_btalloc_at_eof (ap, args, blen, stripe_align, + is_filestream);if (error)return error;if (args->fsbno !=NULLFSBLOCK )return 0 ; } - error =xfs_alloc_vextent (args); +if (is_filestream) + error =xfs_alloc_vextent (args); +else + error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)return error;if (args->fsbno !=NULLFSBLOCK )@@ -3658,9 +3667,7 @@ xfs_bmap_btalloc_best_length(*/ if (args->minlen > ap->minlen) { args->minlen = ap->minlen; - args->type =XFS_ALLOCTYPE_START_BNO ; - args->fsbno = ap->blkno; - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)return error; }fs/xfs/libxfs/xfs_bmap_btree.c +2
-7@@ -214,9 +214,6 @@ xfs_bmbt_alloc_block(if (!args.wasdel && args.tp->t_blk_res ==0 )return -ENOSPC ; - args.fsbno =be64_to_cpu (start->l); - args.type =XFS_ALLOCTYPE_START_BNO ; -/* * If we are coming here from something like unwritten extent * conversion, there has been no data extent allocation already done, so @@ -227,7 +224,7 @@ xfs_bmbt_alloc_block( args.minleft =xfs_bmapi_minleft (cur->bc_tp, cur->bc_ino.ip, cur->bc_ino.whichfork); - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_start_ag (&args,be64_to_cpu (start->l));if (error)return error;@@ -237,10 +234,8 @@ xfs_bmbt_alloc_block(* a full btree split. Try again and if * successful activate the lowspace algorithm. */ - args.fsbno =0 ; args.minleft =0 ; - args.type =XFS_ALLOCTYPE_START_BNO ; - error =xfs_alloc_vextent (&args); + error =xfs_alloc_vextent_start_ag (&args,0 );if (error)return error; cur->bc_tp->t_flags |=XFS_TRANS_LOWMODE ;Signature · 1 line
2.39.0
PATCH 22/42 xfs: introduce xfs_alloc_vextent_near_bno()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
The remaining callers of xfs_alloc_vextent() are all doing NEAR_BNO allocations. We can replace that function with a new xfs_alloc_vextent_near_bno() function that does this explicitly.
We also multiplex NEAR_BNO allocations through xfs_alloc_vextent_this_ag via args->type. Replace all of these with direct calls to xfs_alloc_vextent_near_bno(), too.
--- fs/xfs/libxfs/xfs_alloc.c | 50 ++++++++++++++++++------------ fs/xfs/libxfs/xfs_alloc.h | 14 ++++----- fs/xfs/libxfs/xfs_bmap.c | 6 ++-- fs/xfs/libxfs/xfs_ialloc.c | 27 ++++++---------- fs/xfs/libxfs/xfs_ialloc_btree.c | 5 ++- fs/xfs/libxfs/xfs_refcount_btree.c | 7 ++--- 6 files changed, 55 insertions(+), 54 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +31 -19
@@ -3479,35 +3479,47 @@ int }/* -* Allocate an extent (variable-size). -* Depending on the allocation type, we either look in a single allocation -* group or loop over the allocation groups to find the result. +* Allocate an extent as close to the target as possible. If there are not +* viable candidates in the AG, then fail the allocation. */ int -xfs_alloc_vextent ( -struct xfs_alloc_arg *args) +xfs_alloc_vextent_near_bno ( +struct xfs_alloc_arg *args, +xfs_rfsblock_t target) { +struct xfs_mount *mp = args->mp; +bool need_pag = !args->pag;xfs_agnumber_t minimum_agno =0 ;int error;if (args->tp->t_highest_agno !=NULLAGNUMBER ) minimum_agno = args->tp->t_highest_agno; -switch (args->type) { -case XFS_ALLOCTYPE_THIS_AG : -case XFS_ALLOCTYPE_NEAR_BNO : -case XFS_ALLOCTYPE_THIS_BNO : - args->pag =xfs_perag_get (args->mp, -XFS_FSB_TO_AGNO (args->mp, args->fsbno)); - error =xfs_alloc_vextent_this_ag (args); -xfs_perag_put (args->pag); -break ; -default : - error = -EFSCORRUPTED ; -ASSERT (0 ); -break ; + error =xfs_alloc_vextent_check_args (args, target); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; } -return error; + + args->agno =XFS_FSB_TO_AGNO (mp, target); +if (minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); +return 0 ; + } + + args->agbno =XFS_FSB_TO_AGBNO (mp, target); + args->type =XFS_ALLOCTYPE_NEAR_BNO ; +if (need_pag) + args->pag =xfs_perag_get (args->mp, args->agno); + error =xfs_alloc_ag_vextent (args); +if (need_pag) +xfs_perag_put (args->pag); +if (error) +return error; + +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +return 0 ; }/* Ensure that the freelist is at full capacity. */
fs/xfs/libxfs/xfs_alloc.h +7 -7
@@ -113,19 +113,19 @@ xfs_alloc_log_agf(struct xfs_buf *bp,/* buffer for a.g. freelist header */ uint32_t fields);/* mask of fields to be logged (XFS_AGF_...) */ -/* -* Allocate an extent (variable-size). -*/ -int /* error */ -xfs_alloc_vextent ( -xfs_alloc_arg_t *args);/* allocation argument structure */ -/* * Allocate an extent in the specific AG defined by args->fsbno. If there is no * space in that AG, then the allocation will fail. */ int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* +* Allocate an extent as close to the target as possible. If there are not +* viable candidates in the AG, then fail the allocation. +*/ +int xfs_alloc_vextent_near_bno (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Best effort full filesystem allocation scan. *
fs/xfs/libxfs/xfs_bmap.c +2 -4
@@ -3246,7 +3246,6 @@ xfs_bmap_btalloc_filestreams(int notinit =0 ;int error; - args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total; start_agno =XFS_FSB_TO_AGNO (mp, ap->blkno);
@@ -3565,7 +3564,7 @@ xfs_bmap_btalloc_at_eof( }if (ag_only) - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_near_bno (args, ap->blkno);else error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)
@@ -3612,7 +3611,6 @@ xfs_bmap_btalloc_best_length( ap->blkno =XFS_INO_TO_FSB (mp, ap->ip->i_ino); }xfs_bmap_adjacent (ap); - args->fsbno = ap->blkno;/* * Search for an allocation group with a single extent large enough for
@@ -3653,7 +3651,7 @@ xfs_bmap_btalloc_best_length( }if (is_filestream) - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_near_bno (args, ap->blkno);else error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)
fs/xfs/libxfs/xfs_ialloc.c +10 -17
@@ -717,23 +717,17 @@ xfs_ialloc_ag_alloc( isaligned =1 ; }else args.alignment = igeo->cluster_align; -/* -* Need to figure out where to allocate the inode blocks. -* Ideally they should be spaced out through the a.g. -* For now, just allocate blocks up front. -*/ - args.agbno =be32_to_cpu (agi->agi_root); - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno);/* * Allocate a fixed-size extent of inodes. */ - args.type =XFS_ALLOCTYPE_NEAR_BNO ; args.prod =1 ;/* * Allow space for the inode btree to split. */ args.minleft = igeo->inobt_maxlevels; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, +be32_to_cpu (agi->agi_root)));if (error)return error; }
@@ -743,11 +737,11 @@ xfs_ialloc_ag_alloc(* alignment. */ if (isaligned && args.fsbno ==NULLFSBLOCK ) { - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.agbno =be32_to_cpu (agi->agi_root); - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno); args.alignment = igeo->cluster_align; -if ((error =xfs_alloc_vextent (&args))) + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, +be32_to_cpu (agi->agi_root))); +if (error)return error; }
@@ -759,9 +753,6 @@ xfs_ialloc_ag_alloc( igeo->ialloc_min_blks < igeo->ialloc_blks && args.fsbno == NULLFSBLOCK) { sparse_alloc: - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.agbno =be32_to_cpu (agi->agi_root); - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno); args.alignment = args.mp->m_sb.sb_spino_align; args.prod =1 ;
@@ -783,7 +774,9 @@ xfs_ialloc_ag_alloc( args.mp->m_sb.sb_inoalignmt) - igeo->ialloc_blks; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, +be32_to_cpu (agi->agi_root)));if (error)return error;
fs/xfs/libxfs/xfs_ialloc_btree.c +2 -3
@@ -105,14 +105,13 @@ __xfs_inobt_alloc_block( args.mp = cur->bc_mp; args.pag = cur->bc_ag.pag; args.oinfo =XFS_RMAP_OINFO_INOBT ; - args.fsbno =XFS_AGB_TO_FSB (args.mp, cur->bc_ag.pag->pag_agno, sbno); args.minlen =1 ; args.maxlen =1 ; args.prod =1 ; - args.type =XFS_ALLOCTYPE_NEAR_BNO ; args.resv = resv; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, args.pag->pag_agno, sbno));if (error)return error;
fs/xfs/libxfs/xfs_refcount_btree.c +3 -4
@@ -68,14 +68,13 @@ xfs_refcountbt_alloc_block( args.tp = cur->bc_tp; args.mp = cur->bc_mp; args.pag = cur->bc_ag.pag; - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.fsbno =XFS_AGB_TO_FSB (cur->bc_mp, cur->bc_ag.pag->pag_agno, -xfs_refc_block (args.mp)); args.oinfo =XFS_RMAP_OINFO_REFC ; args.minlen = args.maxlen = args.prod =1 ; args.resv =XFS_AG_RESV_METADATA ; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, args.pag->pag_agno, +xfs_refc_block (args.mp)));if (error) goto out_error; trace_xfs_refcountbt_alloc_block(cur->bc_mp, cur->bc_ag.pag->pag_agno,
Signature · 1 line
2.39.0
Re: [PATCH 22/42] xfs: introduce xfs_alloc_vextent_near_bno()
Quoted 30 lines · Dave Chinner
From: Dave Chinner <[email protected]>
The remaining callers of
xfs_alloc_vextent()are all doingNEAR_BNOallocations. We can replace that function with a newxfs_alloc_vextent_near_bno()function that does this explicitly.We also multiplex
NEAR_BNOallocations throughxfs_alloc_vextent_this_agviaargs->type. Replace all of these with direct calls toxfs_alloc_vextent_near_bno(), too.Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 50 ++++++++++++++++++------------ fs/xfs/libxfs/xfs_alloc.h | 14 ++++----- fs/xfs/libxfs/xfs_bmap.c | 6 ++-- fs/xfs/libxfs/xfs_ialloc.c | 27 ++++++---------- fs/xfs/libxfs/xfs_ialloc_btree.c | 5 ++- fs/xfs/libxfs/xfs_refcount_btree.c | 7 ++--- 6 files changed, 55 insertions(+), 54 deletions(-)fs/xfs/libxfs/xfs_alloc.c +0
-2@@ -3479,35 +3479,47 @@ int }/* -* Allocate an extent (variable-size). -* Depending on the allocation type, we either look in a single allocation
fs/xfs/libxfs/xfs_alloc.c int · line 3488
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +5
-3-* group or loop over the allocation groups to find the result. +* Allocate an extent as close to the target as possible. If there are not +* viable candidates in the AG, then fail the allocation. */ int -xfs_alloc_vextent ( -struct xfs_alloc_arg *args) +xfs_alloc_vextent_near_bno ( +struct xfs_alloc_arg *args, +xfs_rfsblock_t target)
xfs_rfsblock_t vs. xfs_fsblock_t here too...
--D
Quoted 234 lines
fs/xfs/libxfs/xfs_alloc.c +26
-14{ +struct xfs_mount *mp = args->mp; +bool need_pag = !args->pag;xfs_agnumber_t minimum_agno =0 ;int error;if (args->tp->t_highest_agno !=NULLAGNUMBER ) minimum_agno = args->tp->t_highest_agno; -switch (args->type) { -case XFS_ALLOCTYPE_THIS_AG : -case XFS_ALLOCTYPE_NEAR_BNO : -case XFS_ALLOCTYPE_THIS_BNO : - args->pag =xfs_perag_get (args->mp, -XFS_FSB_TO_AGNO (args->mp, args->fsbno)); - error =xfs_alloc_vextent_this_ag (args); -xfs_perag_put (args->pag); -break ; -default : - error = -EFSCORRUPTED ; -ASSERT (0 ); -break ; + error =xfs_alloc_vextent_check_args (args, target); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; } -return error; + + args->agno =XFS_FSB_TO_AGNO (mp, target); +if (minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); +return 0 ; + } + + args->agbno =XFS_FSB_TO_AGBNO (mp, target); + args->type =XFS_ALLOCTYPE_NEAR_BNO ; +if (need_pag) + args->pag =xfs_perag_get (args->mp, args->agno); + error =xfs_alloc_ag_vextent (args); +if (need_pag) +xfs_perag_put (args->pag); +if (error) +return error; + +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +return 0 ; }/* Ensure that the freelist is at full capacity. */ fs/xfs/libxfs/xfs_alloc.h +7
-7@@ -113,19 +113,19 @@ xfs_alloc_log_agf(struct xfs_buf *bp,/* buffer for a.g. freelist header */ uint32_t fields);/* mask of fields to be logged (XFS_AGF_...) */ -/* -* Allocate an extent (variable-size). -*/ -int /* error */ -xfs_alloc_vextent ( -xfs_alloc_arg_t *args);/* allocation argument structure */ -/* * Allocate an extent in the specific AG defined by args->fsbno. If there is no * space in that AG, then the allocation will fail. */ int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +/* +* Allocate an extent as close to the target as possible. If there are not +* viable candidates in the AG, then fail the allocation. +*/ +int xfs_alloc_vextent_near_bno (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Best effort full filesystem allocation scan. * fs/xfs/libxfs/xfs_bmap.c +2
-4@@ -3246,7 +3246,6 @@ xfs_bmap_btalloc_filestreams(int notinit =0 ;int error; - args->type =XFS_ALLOCTYPE_NEAR_BNO ; args->total = ap->total; start_agno =XFS_FSB_TO_AGNO (mp, ap->blkno);@@ -3565,7 +3564,7 @@ xfs_bmap_btalloc_at_eof( }if (ag_only) - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_near_bno (args, ap->blkno);else error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)@@ -3612,7 +3611,6 @@ xfs_bmap_btalloc_best_length( ap->blkno =XFS_INO_TO_FSB (mp, ap->ip->i_ino); }xfs_bmap_adjacent (ap); - args->fsbno = ap->blkno;/* * Search for an allocation group with a single extent large enough for @@ -3653,7 +3651,7 @@ xfs_bmap_btalloc_best_length( }if (is_filestream) - error =xfs_alloc_vextent (args); + error =xfs_alloc_vextent_near_bno (args, ap->blkno);else error =xfs_alloc_vextent_start_ag (args, ap->blkno);if (error)fs/xfs/libxfs/xfs_ialloc.c +10
-17@@ -717,23 +717,17 @@ xfs_ialloc_ag_alloc( isaligned =1 ; }else args.alignment = igeo->cluster_align; -/* -* Need to figure out where to allocate the inode blocks. -* Ideally they should be spaced out through the a.g. -* For now, just allocate blocks up front. -*/ - args.agbno =be32_to_cpu (agi->agi_root); - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno);/* * Allocate a fixed-size extent of inodes. */ - args.type =XFS_ALLOCTYPE_NEAR_BNO ; args.prod =1 ;/* * Allow space for the inode btree to split. */ args.minleft = igeo->inobt_maxlevels; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, +be32_to_cpu (agi->agi_root)));if (error)return error; }@@ -743,11 +737,11 @@ xfs_ialloc_ag_alloc(* alignment. */ if (isaligned && args.fsbno ==NULLFSBLOCK ) { - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.agbno =be32_to_cpu (agi->agi_root); - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno); args.alignment = igeo->cluster_align; -if ((error =xfs_alloc_vextent (&args))) + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, +be32_to_cpu (agi->agi_root))); +if (error)return error; }@@ -759,9 +753,6 @@ xfs_ialloc_ag_alloc( igeo->ialloc_min_blks < igeo->ialloc_blks && args.fsbno == NULLFSBLOCK) { sparse_alloc: - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.agbno =be32_to_cpu (agi->agi_root); - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno); args.alignment = args.mp->m_sb.sb_spino_align; args.prod =1 ;@@ -783,7 +774,9 @@ xfs_ialloc_ag_alloc( args.mp->m_sb.sb_inoalignmt) - igeo->ialloc_blks; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, +be32_to_cpu (agi->agi_root)));if (error)return error;fs/xfs/libxfs/xfs_ialloc_btree.c +2
-3@@ -105,14 +105,13 @@ __xfs_inobt_alloc_block( args.mp = cur->bc_mp; args.pag = cur->bc_ag.pag; args.oinfo =XFS_RMAP_OINFO_INOBT ; - args.fsbno =XFS_AGB_TO_FSB (args.mp, cur->bc_ag.pag->pag_agno, sbno); args.minlen =1 ; args.maxlen =1 ; args.prod =1 ; - args.type =XFS_ALLOCTYPE_NEAR_BNO ; args.resv = resv; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, args.pag->pag_agno, sbno));if (error)return error;fs/xfs/libxfs/xfs_refcount_btree.c +3
-4@@ -68,14 +68,13 @@ xfs_refcountbt_alloc_block( args.tp = cur->bc_tp; args.mp = cur->bc_mp; args.pag = cur->bc_ag.pag; - args.type =XFS_ALLOCTYPE_NEAR_BNO ; - args.fsbno =XFS_AGB_TO_FSB (cur->bc_mp, cur->bc_ag.pag->pag_agno, -xfs_refc_block (args.mp)); args.oinfo =XFS_RMAP_OINFO_REFC ; args.minlen = args.maxlen = args.prod =1 ; args.resv =XFS_AG_RESV_METADATA ; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_near_bno (&args, +XFS_AGB_TO_FSB (args.mp, args.pag->pag_agno, +xfs_refc_block (args.mp)));if (error) goto out_error; trace_xfs_refcountbt_alloc_block(cur->bc_mp, cur->bc_ag.pag->pag_agno,Signature · 1 line
2.39.0
PATCH 23/42 xfs: introduce xfs_alloc_vextent_exact_bno()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Two of the callers to xfs_alloc_vextent_this_ag() actually want exact block number allocation, not anywhere-in-ag allocation. Split this out from _this_ag() as a first class citizen so no external extent allocation code needs to care about args->type anymore.
--- fs/xfs/libxfs/xfs_ag.c | 6 ++-- fs/xfs/libxfs/xfs_alloc.c | 65 ++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_alloc.h | 13 ++++++-- fs/xfs/libxfs/xfs_bmap.c | 6 ++-- fs/xfs/libxfs/xfs_ialloc.c | 6 ++-- fs/xfs/scrub/repair.c | 4 +-- 6 files changed, 73 insertions(+), 27 deletions(-)
fs/xfs/libxfs/xfs_ag.c +2 -4
@@ -888,7 +888,6 @@ xfs_ag_shrink_space( .tp = *tpp, .mp = mp, .pag = pag, - .type = XFS_ALLOCTYPE_THIS_BNO, .minlen = delta, .maxlen = delta, .oinfo = XFS_RMAP_OINFO_SKIP_UPDATE,
@@ -920,8 +919,6 @@ xfs_ag_shrink_space(if (delta >= aglen)return -EINVAL ; - args.fsbno =XFS_AGB_TO_FSB (mp, pag->pag_agno, aglen - delta); -/* * Make sure that the last inode cluster cannot overlap with the new * end of the AG, even if it's sparse.
@@ -939,7 +936,8 @@ xfs_ag_shrink_space(return error;/* internal log shouldn't also show up in the free space btrees */ - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_exact_bno (&args, +XFS_AGB_TO_FSB (mp, pag->pag_agno, aglen - delta));if (!error && args.agbno ==NULLAGBLOCK ) error = -ENOSPC ;
fs/xfs/libxfs/xfs_alloc.c +55 -10
102 lines not on this page · raw message
fs/xfs/libxfs/xfs_alloc.h +10 -3
@@ -114,10 +114,10 @@ xfs_alloc_log_agf( uint32_t fields);/* mask of fields to be logged (XFS_AGF_...) *//* -* Allocate an extent in the specific AG defined by args->fsbno. If there is no -* space in that AG, then the allocation will fail. +* Allocate an extent anywhere in the specific AG given. If there is no +* space matching the requirements in that AG, then the allocation will fail. */ -int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args,xfs_agnumber_t agno);/* * Allocate an extent as close to the target as possible. If there are not
@@ -126,6 +126,13 @@ int xfs_alloc_vextent_this_ag(struct xfs_alloc_arg *args);int xfs_alloc_vextent_near_bno (struct xfs_alloc_arg *args,xfs_rfsblock_t target); +/* +* Allocate an extent exactly at the target given. If this is not possible +* then the allocation fails. +*/ +int xfs_alloc_vextent_exact_bno (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Best effort full filesystem allocation scan. *
fs/xfs/libxfs/xfs_bmap.c +2 -4
@@ -3514,7 +3514,6 @@ xfs_bmap_btalloc_at_eof(xfs_extlen_t nextminlen =0 ; atype = args->type; - args->type =XFS_ALLOCTYPE_THIS_BNO ; args->alignment =1 ;/*
@@ -3532,8 +3531,8 @@ xfs_bmap_btalloc_at_eof(else args->minalignslop =0 ; - args->pag =xfs_perag_get (mp,XFS_FSB_TO_AGNO (mp, args->fsbno)); - error =xfs_alloc_vextent_this_ag (args); + args->pag =xfs_perag_get (mp,XFS_FSB_TO_AGNO (mp, ap->blkno)); + error =xfs_alloc_vextent_exact_bno (args, ap->blkno);xfs_perag_put (args->pag);if (error)return error;
@@ -3546,7 +3545,6 @@ xfs_bmap_btalloc_at_eof(*/ args->pag =NULL ; args->type = atype; - args->fsbno = ap->blkno; args->alignment = stripe_align; args->minlen = nextminlen; args->minalignslop =0 ;
fs/xfs/libxfs/xfs_ialloc.c +3 -3
@@ -662,8 +662,6 @@ xfs_ialloc_ag_alloc( goto sparse_alloc;if (likely (newino !=NULLAGINO && (args.agbno <be32_to_cpu (agi->agi_length)))) { - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno); - args.type =XFS_ALLOCTYPE_THIS_BNO ; args.prod =1 ;/*
@@ -684,7 +682,9 @@ xfs_ialloc_ag_alloc(/* Allow space for the inode btree to split. */ args.minleft = igeo->inobt_maxlevels; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_exact_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, + args.agbno));if (error)return error;
fs/xfs/scrub/repair.c +1 -3
@@ -328,14 +328,12 @@ xrep_alloc_ag_block( args.mp = sc->mp; args.pag = sc->sa.pag; args.oinfo = *oinfo; - args.fsbno =XFS_AGB_TO_FSB (args.mp, sc->sa.pag->pag_agno,0 ); args.minlen =1 ; args.maxlen =1 ; args.prod =1 ; - args.type =XFS_ALLOCTYPE_THIS_AG ; args.resv = resv; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_this_ag (&args, sc->sa.pag->pag_agno);if (error)return error;if (args.fsbno ==NULLFSBLOCK )
Signature · 1 line
2.39.0
Re: [PATCH 23/42] xfs: introduce xfs_alloc_vextent_exact_bno()
Quoted 53 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Two of the callers to
xfs_alloc_vextent_this_ag()actually want exact block number allocation, not anywhere-in-ag allocation. Split this out from_this_ag()as a first class citizen so no external extent allocation code needs to care aboutargs->typeanymore.Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_ag.c | 6 ++-- fs/xfs/libxfs/xfs_alloc.c | 65 ++++++++++++++++++++++++++++++++------ fs/xfs/libxfs/xfs_alloc.h | 13 ++++++-- fs/xfs/libxfs/xfs_bmap.c | 6 ++-- fs/xfs/libxfs/xfs_ialloc.c | 6 ++-- fs/xfs/scrub/repair.c | 4 +-- 6 files changed, 73 insertions(+), 27 deletions(-)fs/xfs/libxfs/xfs_ag.c +2
-4@@ -888,7 +888,6 @@ xfs_ag_shrink_space( .tp = *tpp, .mp = mp, .pag = pag, - .type = XFS_ALLOCTYPE_THIS_BNO, .minlen = delta, .maxlen = delta, .oinfo = XFS_RMAP_OINFO_SKIP_UPDATE,@@ -920,8 +919,6 @@ xfs_ag_shrink_space(if (delta >= aglen)return -EINVAL ; - args.fsbno =XFS_AGB_TO_FSB (mp, pag->pag_agno, aglen - delta); -/* * Make sure that the last inode cluster cannot overlap with the new * end of the AG, even if it's sparse. @@ -939,7 +936,8 @@ xfs_ag_shrink_space(return error;/* internal log shouldn't also show up in the free space btrees */ - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_exact_bno (&args, +XFS_AGB_TO_FSB (mp, pag->pag_agno, aglen - delta));if (!error && args.agbno ==NULLAGBLOCK ) error = -ENOSPC ;fs/xfs/libxfs/xfs_alloc.c +0
-0
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_vextent_set_fsbno( · line 3280
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +3
-1@@ -3272,28 +3272,34 @@ xfs_alloc_vextent_set_fsbno(*/ int xfs_alloc_vextent_this_ag ( -struct xfs_alloc_arg *args) +struct xfs_alloc_arg *args, +xfs_agnumber_t agno) {struct xfs_mount *mp = args->mp;xfs_agnumber_t minimum_agno =0 ; +xfs_rfsblock_t target =XFS_AGB_TO_FSB (mp, agno,0 );
Same xfs_rfsblock_t vs. xfs_fsblock_t comment here too.
These conversions look like a good improvement though -- it's very helpful that we can now look at an xfs_alloc_vextent_* call and know exactly which behavior we're getting.
--D
Quoted 204 lines
fs/xfs/libxfs/xfs_alloc.c +52
-9int error;if (args->tp->t_highest_agno !=NULLAGNUMBER ) minimum_agno = args->tp->t_highest_agno; - error =xfs_alloc_vextent_check_args (args, args->fsbno); +if (minimum_agno > agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); + args->fsbno =NULLFSBLOCK ; +return 0 ; + } + + error =xfs_alloc_vextent_check_args (args, target);if (error) {if (error == -ENOSPC )return 0 ;return error; } - args->agno =XFS_FSB_TO_AGNO (mp, args->fsbno); -if (minimum_agno > args->agno) { -trace_xfs_alloc_vextent_skip_deadlock (args); - args->fsbno =NULLFSBLOCK ; -return 0 ; - } + args->agno = agno; + args->agbno =0 ; + args->fsbno = target; + args->type =XFS_ALLOCTYPE_THIS_AG ; error =xfs_alloc_ag_vextent (args);xfs_alloc_vextent_set_fsbno (args, minimum_agno);@@ -3450,7 +3456,7 @@ xfs_alloc_vextent_start_ag(* pass, so will not recurse into AGs lower than indicated by fsbno. */ int -xfs_alloc_vextent_first_ag ( +xfs_alloc_vextent_first_ag (struct xfs_alloc_arg *args,xfs_rfsblock_t target) {@@ -3472,12 +3478,51 @@ int start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); args->type =XFS_ALLOCTYPE_THIS_AG ; args->fsbno = target; - error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, + error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno,0 );xfs_alloc_vextent_set_fsbno (args, minimum_agno);return error; } +/* +* Allocate within a single AG only. +*/ +int +xfs_alloc_vextent_exact_bno ( +struct xfs_alloc_arg *args, +xfs_rfsblock_t target) +{ +struct xfs_mount *mp = args->mp; +xfs_agnumber_t minimum_agno =0 ; +int error; + +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + minimum_agno = args->tp->t_highest_agno; + + error =xfs_alloc_vextent_check_args (args, target); +if (error) { +if (error == -ENOSPC ) +return 0 ; +return error; + } + + args->agno =XFS_FSB_TO_AGNO (mp, target); +if (minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); +return 0 ; + } + + args->agbno =XFS_FSB_TO_AGBNO (mp, target); + args->fsbno = target; + args->type =XFS_ALLOCTYPE_THIS_BNO ; + error =xfs_alloc_ag_vextent (args); +if (error) +return error; + +xfs_alloc_vextent_set_fsbno (args, minimum_agno); +return 0 ; +} +/* * Allocate an extent as close to the target as possible. If there are not * viable candidates in the AG, then fail the allocation. fs/xfs/libxfs/xfs_alloc.h +10
-3@@ -114,10 +114,10 @@ xfs_alloc_log_agf( uint32_t fields);/* mask of fields to be logged (XFS_AGF_...) *//* -* Allocate an extent in the specific AG defined by args->fsbno. If there is no -* space in that AG, then the allocation will fail. +* Allocate an extent anywhere in the specific AG given. If there is no +* space matching the requirements in that AG, then the allocation will fail. */ -int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args); +int xfs_alloc_vextent_this_ag (struct xfs_alloc_arg *args,xfs_agnumber_t agno);/* * Allocate an extent as close to the target as possible. If there are not @@ -126,6 +126,13 @@ int xfs_alloc_vextent_this_ag(struct xfs_alloc_arg *args);int xfs_alloc_vextent_near_bno (struct xfs_alloc_arg *args,xfs_rfsblock_t target); +/* +* Allocate an extent exactly at the target given. If this is not possible +* then the allocation fails. +*/ +int xfs_alloc_vextent_exact_bno (struct xfs_alloc_arg *args, +xfs_rfsblock_t target); +/* * Best effort full filesystem allocation scan. * fs/xfs/libxfs/xfs_bmap.c +2
-4@@ -3514,7 +3514,6 @@ xfs_bmap_btalloc_at_eof(xfs_extlen_t nextminlen =0 ; atype = args->type; - args->type =XFS_ALLOCTYPE_THIS_BNO ; args->alignment =1 ;/* @@ -3532,8 +3531,8 @@ xfs_bmap_btalloc_at_eof(else args->minalignslop =0 ; - args->pag =xfs_perag_get (mp,XFS_FSB_TO_AGNO (mp, args->fsbno)); - error =xfs_alloc_vextent_this_ag (args); + args->pag =xfs_perag_get (mp,XFS_FSB_TO_AGNO (mp, ap->blkno)); + error =xfs_alloc_vextent_exact_bno (args, ap->blkno);xfs_perag_put (args->pag);if (error)return error;@@ -3546,7 +3545,6 @@ xfs_bmap_btalloc_at_eof(*/ args->pag =NULL ; args->type = atype; - args->fsbno = ap->blkno; args->alignment = stripe_align; args->minlen = nextminlen; args->minalignslop =0 ;fs/xfs/libxfs/xfs_ialloc.c +3
-3@@ -662,8 +662,6 @@ xfs_ialloc_ag_alloc( goto sparse_alloc;if (likely (newino !=NULLAGINO && (args.agbno <be32_to_cpu (agi->agi_length)))) { - args.fsbno =XFS_AGB_TO_FSB (args.mp, pag->pag_agno, args.agbno); - args.type =XFS_ALLOCTYPE_THIS_BNO ; args.prod =1 ;/* @@ -684,7 +682,9 @@ xfs_ialloc_ag_alloc(/* Allow space for the inode btree to split. */ args.minleft = igeo->inobt_maxlevels; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_exact_bno (&args, +XFS_AGB_TO_FSB (args.mp, pag->pag_agno, + args.agbno));if (error)return error;fs/xfs/scrub/repair.c +1
-3@@ -328,14 +328,12 @@ xrep_alloc_ag_block( args.mp = sc->mp; args.pag = sc->sa.pag; args.oinfo = *oinfo; - args.fsbno =XFS_AGB_TO_FSB (args.mp, sc->sa.pag->pag_agno,0 ); args.minlen =1 ; args.maxlen =1 ; args.prod =1 ; - args.type =XFS_ALLOCTYPE_THIS_AG ; args.resv = resv; - error =xfs_alloc_vextent_this_ag (&args); + error =xfs_alloc_vextent_this_ag (&args, sc->sa.pag->pag_agno);if (error)return error;if (args.fsbno ==NULLFSBLOCK )Signature · 1 line
2.39.0
PATCH 24/42 xfs: introduce xfs_alloc_vextent_prepare()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Now that we have wrapper functions for each type of allocation we can ask for, we can start unravelling xfs_alloc_ag_vextent(). That is essentially just a prepare stage, the allocation multiplexer and a post-allocation accounting step is the allocation proceeded.
The current xfs_alloc_vextent*() wrappers all have a prepare stage, the allocation operation and a post-allocation accounting step.
We can consolidate this by moving the AG alloc prep code into the wrapper functions, the accounting code in the wrapper accounting functions, and cut out the multiplexer layer entirely.
This patch consolidates the AG preparation stage.
--- fs/xfs/libxfs/xfs_alloc.c | 120 ++++++++++++++++++++++++-------------- 1 file changed, 76 insertions(+), 44 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +76 -44
@@ -1144,31 +1144,8 @@ static intxfs_alloc_ag_vextent ( struct xfs_alloc_arg *args) { -struct xfs_mount *mp = args->mp;int error =0 ; -ASSERT (args->minlen >0 ); -ASSERT (args->maxlen >0 ); -ASSERT (args->minlen <= args->maxlen); -ASSERT (args->mod < args->prod); -ASSERT (args->alignment >0 ); -ASSERT (args->resv !=XFS_AG_RESV_AGFL ); - - - error =xfs_alloc_fix_freelist (args,0 ); -if (error) { -trace_xfs_alloc_vextent_nofix (args); -return error; - } -if (!args->agbp) { -/* cannot allocate in this AG at all */ -trace_xfs_alloc_vextent_noagbp (args); - args->agbno =NULLAGBLOCK ; -return 0 ; - } - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); - args->wasfromfl =0 ; -/* * Branch to correct routine based on the type. */
@@ -3201,11 +3178,18 @@ xfs_alloc_vextent_check_args( args->maxlen = agsize;if (args->alignment ==0 ) args->alignment =1 ; + +ASSERT (args->minlen >0 ); +ASSERT (args->maxlen >0 ); +ASSERT (args->alignment >0 ); +ASSERT (args->resv !=XFS_AG_RESV_AGFL ); +ASSERT (XFS_FSB_TO_AGNO (mp, target) < mp->m_sb.sb_agcount);ASSERT (XFS_FSB_TO_AGBNO (mp, target) < agsize);ASSERT (args->minlen <= args->maxlen);ASSERT (args->minlen <= agsize);ASSERT (args->mod < args->prod); + if (XFS_FSB_TO_AGNO(mp, target) >= mp->m_sb.sb_agcount || XFS_FSB_TO_AGBNO(mp, target) >= agsize || args->minlen > args->maxlen || args->minlen > agsize ||
@@ -3217,6 +3201,41 @@ xfs_alloc_vextent_check_args(return 0 ; } +/* +* Prepare an AG for allocation. If the AG is not prepared to accept the +* allocation, return failure. +* +* XXX(dgc): The complexity of "need_pag" will go away as all caller paths are +* modified to hold their own perag references. +*/ +static int +xfs_alloc_vextent_prepare_ag ( +struct xfs_alloc_arg *args) +{ +bool need_pag = !args->pag; +int error; + +if (need_pag) + args->pag =xfs_perag_get (args->mp, args->agno); + + error =xfs_alloc_fix_freelist (args,0 ); +if (error) { +trace_xfs_alloc_vextent_nofix (args); +if (need_pag) +xfs_perag_put (args->pag); + args->agbno =NULLAGBLOCK ; +return error; + } +if (!args->agbp) { +/* cannot allocate in this AG at all */ +trace_xfs_alloc_vextent_noagbp (args); + args->agbno =NULLAGBLOCK ; +return 0 ; + } + args->wasfromfl =0 ; +return 0 ; +} +/* * Post-process allocation results to set the allocated block number correctly * for the caller.
@@ -3268,7 +3287,8 @@ xfs_alloc_vextent_set_fsbno( }/* -* Allocate within a single AG only. +* Allocate within a single AG only. Caller is expected to hold a +* perag reference in args->pag. */ int xfs_alloc_vextent_this_ag(
@@ -3301,7 +3321,10 @@ xfs_alloc_vextent_this_ag( args->fsbno = target; args->type =XFS_ALLOCTYPE_THIS_AG ; - error =xfs_alloc_ag_vextent (args); + error =xfs_alloc_vextent_prepare_ag (args); +if (!error && args->agbp) + error =xfs_alloc_ag_vextent (args); +xfs_alloc_vextent_set_fsbno (args, minimum_agno);return error; }
@@ -3339,13 +3362,19 @@ xfs_alloc_vextent_iterate_ags( args->agno = start_agno;for (;;) { args->pag =xfs_perag_get (mp, args->agno); - error =xfs_alloc_ag_vextent (args); -if (error) { - args->agbno =NULLAGBLOCK ; + args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); + error =xfs_alloc_vextent_prepare_ag (args); +if (error)break ; - } -if (args->agbp) + +if (args->agbp) { +/* +* Allocation is supposed to succeed now, so break out +* of the loop regardless of whether we succeed or not. +*/ + error =xfs_alloc_ag_vextent (args);break ; + }trace_xfs_alloc_vextent_loopfailed (args);
@@ -3378,10 +3407,8 @@ xfs_alloc_vextent_iterate_ags( } flags =0 ; -if (args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) { - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); +if (args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) args->type =XFS_ALLOCTYPE_NEAR_BNO ; - } }xfs_perag_put (args->pag); args->pag =NULL ;
@@ -3485,7 +3512,8 @@ xfs_alloc_vextent_first_ag( }/* -* Allocate within a single AG only. +* Allocate at the exact block target or fail. Caller is expected to hold a +* perag reference in args->pag. */ int xfs_alloc_vextent_exact_bno(
@@ -3515,9 +3543,10 @@ xfs_alloc_vextent_exact_bno( args->agbno =XFS_FSB_TO_AGBNO (mp, target); args->fsbno = target; args->type =XFS_ALLOCTYPE_THIS_BNO ; - error =xfs_alloc_ag_vextent (args); -if (error) -return error; + + error =xfs_alloc_vextent_prepare_ag (args); +if (!error && args->agbp) + error =xfs_alloc_ag_vextent (args);xfs_alloc_vextent_set_fsbno (args, minimum_agno);return 0 ;
@@ -3526,6 +3555,8 @@ xfs_alloc_vextent_exact_bno(/* * Allocate an extent as close to the target as possible. If there are not * viable candidates in the AG, then fail the allocation. +* +* Caller may or may not have a per-ag reference in args->pag. */ int xfs_alloc_vextent_near_bno(
@@ -3550,21 +3581,22 @@ xfs_alloc_vextent_near_bno( args->agno =XFS_FSB_TO_AGNO (mp, target);if (minimum_agno > args->agno) {trace_xfs_alloc_vextent_skip_deadlock (args); + args->fsbno =NULLFSBLOCK ;return 0 ; } args->agbno =XFS_FSB_TO_AGBNO (mp, target); args->type =XFS_ALLOCTYPE_NEAR_BNO ; -if (need_pag) - args->pag =xfs_perag_get (args->mp, args->agno); - error =xfs_alloc_ag_vextent (args); + + error =xfs_alloc_vextent_prepare_ag (args); +if (!error && args->agbp) + error =xfs_alloc_ag_vextent (args); + +xfs_alloc_vextent_set_fsbno (args, minimum_agno);if (need_pag)xfs_perag_put (args->pag); -if (error) -return error; -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -return 0 ; +return error; }/* Ensure that the freelist is at full capacity. */
Signature · 1 line
2.39.0
PATCH 25/42 xfs: move allocation accounting to xfs_alloc_vextent_set_fsbno()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Move it from xfs_alloc_ag_vextent() so we can get rid of that layer. Rename xfs_alloc_vextent_set_fsbno() to xfs_alloc_vextent_finish() to indicate that it's function is finishing off the allocation that we've run now that it contains much more functionality.
--- fs/xfs/libxfs/xfs_alloc.c | 122 ++++++++++++++++++++------------------ 1 file changed, 63 insertions(+), 59 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +63 -59
@@ -1163,36 +1163,6 @@ xfs_alloc_ag_vextent(ASSERT (0 );/* NOTREACHED */ } - -if (error || args->agbno ==NULLAGBLOCK ) -return error; - -ASSERT (args->len >= args->minlen); -ASSERT (args->len <= args->maxlen); -ASSERT (args->agbno % args->alignment ==0 ); - -/* if not file data, insert new block into the reverse map btree */ -if (!xfs_rmap_should_skip_owner_update (&args->oinfo)) { - error =xfs_rmap_alloc (args->tp, args->agbp, args->pag, - args->agbno, args->len, &args->oinfo); -if (error) -return error; - } - -if (!args->wasfromfl) { - error =xfs_alloc_update_counters (args->tp, args->agbp, - -((long )(args->len))); -if (error) -return error; - -ASSERT (!xfs_extent_busy_search (args->mp, args->pag, - args->agbno, args->len)); - } - -xfs_ag_resv_alloc_extent (args->pag, args->resv, args); - -XFS_STATS_INC (args->mp, xs_allocx); -XFS_STATS_ADD (args->mp, xs_allocb, args->len);return error; }
@@ -3237,18 +3207,21 @@ xfs_alloc_vextent_prepare_ag( }/* -* Post-process allocation results to set the allocated block number correctly -* for the caller. +* Post-process allocation results to account for the allocation if it succeed +* and set the allocated block number correctly for the caller. * -* XXX: xfs_alloc_vextent() should really be returning ENOSPC for ENOSPC, not +* XXX: we should really be returning ENOSPC for ENOSPC, not * hiding it behind a "successful" NULLFSBLOCK allocation. */ -static void -xfs_alloc_vextent_set_fsbno ( +static int +xfs_alloc_vextent_finish (struct xfs_alloc_arg *args, -xfs_agnumber_t minimum_agno) +xfs_agnumber_t minimum_agno, +int alloc_error, +bool drop_perag) {struct xfs_mount *mp = args->mp; +int error =0 ;/* * We can end up here with a locked AGF. If we failed, the caller is
@@ -3271,19 +3244,54 @@ xfs_alloc_vextent_set_fsbno( args->agno > minimum_agno)) args->tp->t_highest_agno = args->agno; -/* Allocation failed with ENOSPC if NULLAGBLOCK was returned. */ -if (args->agbno ==NULLAGBLOCK ) { +/* +* If the allocation failed with an error or we had an ENOSPC result, +* preserve the returned error whilst also marking the allocation result +* as "no extent allocated". This ensures that callers that fail to +* capture the error will still treat it as a failed allocation. +*/ +if (alloc_error || args->agbno ==NULLAGBLOCK ) { args->fsbno =NULLFSBLOCK ; -return ; + error = alloc_error; + goto out_drop_perag; } args->fsbno =XFS_AGB_TO_FSB (mp, args->agno, args->agbno); -#ifdef DEBUG +ASSERT (args->len >= args->minlen);ASSERT (args->len <= args->maxlen);ASSERT (args->agbno % args->alignment ==0 );XFS_AG_CHECK_DADDR (mp,XFS_FSB_TO_DADDR (mp, args->fsbno), args->len); -#endif + +/* if not file data, insert new block into the reverse map btree */ +if (!xfs_rmap_should_skip_owner_update (&args->oinfo)) { + error =xfs_rmap_alloc (args->tp, args->agbp, args->pag, + args->agbno, args->len, &args->oinfo); +if (error) + goto out_drop_perag; + } + +if (!args->wasfromfl) { + error =xfs_alloc_update_counters (args->tp, args->agbp, + -((long )(args->len))); +if (error) + goto out_drop_perag; + +ASSERT (!xfs_extent_busy_search (mp, args->pag, args->agbno, + args->len)); + } + +xfs_ag_resv_alloc_extent (args->pag, args->resv, args); + +XFS_STATS_INC (mp, xs_allocx); +XFS_STATS_ADD (mp, xs_allocb, args->len); + +out_drop_perag: +if (drop_perag) { +xfs_perag_put (args->pag); + args->pag =NULL ; + } +return error; }/*
@@ -3325,8 +3333,7 @@ xfs_alloc_vextent_this_ag(if (!error && args->agbp) error =xfs_alloc_ag_vextent (args); -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -return error; +return xfs_alloc_vextent_finish (args, minimum_agno, error, false); }/*
@@ -3413,10 +3420,10 @@ xfs_alloc_vextent_iterate_ags(xfs_perag_put (args->pag); args->pag =NULL ; } -if (args->pag) { -xfs_perag_put (args->pag); - args->pag =NULL ; - } +/* +* The perag is left referenced in args for the caller to clean +* up after they've finished the allocation. +*/ return error; }
@@ -3473,8 +3480,7 @@ xfs_alloc_vextent_start_ag( (mp->m_sb.sb_agcount * rotorstep); } -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -return error; +return xfs_alloc_vextent_finish (args, minimum_agno, error, true); }/*
@@ -3507,8 +3513,7 @@ xfs_alloc_vextent_first_ag( args->fsbno = target; error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno,0 ); -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -return error; +return xfs_alloc_vextent_finish (args, minimum_agno, error, true); }/*
@@ -3537,6 +3542,7 @@ xfs_alloc_vextent_exact_bno( args->agno =XFS_FSB_TO_AGNO (mp, target);if (minimum_agno > args->agno) {trace_xfs_alloc_vextent_skip_deadlock (args); + args->fsbno =NULLFSBLOCK ;return 0 ; }
@@ -3548,8 +3554,7 @@ xfs_alloc_vextent_exact_bno(if (!error && args->agbp) error =xfs_alloc_ag_vextent (args); -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -return 0 ; +return xfs_alloc_vextent_finish (args, minimum_agno, error, false); }/*
@@ -3564,8 +3569,8 @@ xfs_alloc_vextent_near_bno( xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp; -bool need_pag = !args->pag;xfs_agnumber_t minimum_agno =0 ; +bool needs_perag = args->pag ==NULL ;int error;if (args->tp->t_highest_agno !=NULLAGNUMBER )
@@ -3585,6 +3590,9 @@ xfs_alloc_vextent_near_bno(return 0 ; } +if (needs_perag) + args->pag =xfs_perag_get (mp, args->agno); + args->agbno =XFS_FSB_TO_AGBNO (mp, target); args->type =XFS_ALLOCTYPE_NEAR_BNO ;
@@ -3592,11 +3600,7 @@ xfs_alloc_vextent_near_bno(if (!error && args->agbp) error =xfs_alloc_ag_vextent (args); -xfs_alloc_vextent_set_fsbno (args, minimum_agno); -if (need_pag) -xfs_perag_put (args->pag); - -return error; +return xfs_alloc_vextent_finish (args, minimum_agno, error, needs_perag); }/* Ensure that the freelist is at full capacity. */
Signature · 1 line
2.39.0
PATCH 26/42 xfs: fold xfs_alloc_ag_vextent() into callers
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
We don't need the multiplexing xfs_alloc_ag_vextent() provided anymore - we can just call the exact/near/size variants directly. This allows us to remove args->type completely and stop using args->fsbno as an input to the allocator algorithms.
--- fs/xfs/libxfs/xfs_alloc.c | 100 ++++++++++---------------------------- fs/xfs/libxfs/xfs_alloc.h | 17 ------- fs/xfs/libxfs/xfs_bmap.c | 10 +--- fs/xfs/xfs_trace.h | 8 +-- 4 files changed, 29 insertions(+), 106 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +26 -74
@@ -36,10 +36,6 @@ struct workqueue_struct *xfs_alloc_wq;#define XFSA_FIXUP_BNO_OK 1#define XFSA_FIXUP_CNT_OK 2 -STATIC int xfs_alloc_ag_vextent_exact(xfs_alloc_arg_t *); -STATIC int xfs_alloc_ag_vextent_near(xfs_alloc_arg_t *); -STATIC int xfs_alloc_ag_vextent_size(xfs_alloc_arg_t *); -/* * Size of the AGFL. For CRC-enabled filesystes we steal a couple of slots in * the beginning of the block for a proper header with the location information
@@ -772,8 +768,6 @@ xfs_alloc_cur_setup(int error;int i; -ASSERT (args->alignment ==1 || args->type !=XFS_ALLOCTYPE_THIS_BNO ); - acur->cur_len = args->maxlen; acur->rec_bno =0 ; acur->rec_len =0 ;
@@ -887,7 +881,6 @@ xfs_alloc_cur_check(* We have an aligned record that satisfies minlen and beats or matches * the candidate extent size. Compare locality for near allocation mode. */ -ASSERT (args->type ==XFS_ALLOCTYPE_NEAR_BNO ); diff =xfs_alloc_compute_diff (args->agbno, args->len, args->alignment, args->datatype, bnoa, lena, &bnew);
@@ -1132,40 +1125,6 @@ xfs_alloc_ag_vextent_small(return error; } -/* -* Allocate a variable extent in the allocation group agno. -* Type and bno are used to determine where in the allocation group the -* extent will start. -* Extent's length (returned in *len) will be between minlen and maxlen, -* and of the form k * prod + mod unless there's nothing that large. -* Return the starting a.g. block, or NULLAGBLOCK if we can't do it. -*/ -static int -xfs_alloc_ag_vextent ( -struct xfs_alloc_arg *args) -{ -int error =0 ; - -/* -* Branch to correct routine based on the type. -*/ -switch (args->type) { -case XFS_ALLOCTYPE_THIS_AG : - error =xfs_alloc_ag_vextent_size (args); -break ; -case XFS_ALLOCTYPE_NEAR_BNO : - error =xfs_alloc_ag_vextent_near (args); -break ; -case XFS_ALLOCTYPE_THIS_BNO : - error =xfs_alloc_ag_vextent_exact (args); -break ; -default : -ASSERT (0 ); -/* NOTREACHED */ - } -return error; -} -/* * Allocate a variable extent at exactly agno/bno. * Extent's length (returned in *len) will be between minlen and maxlen,
@@ -1351,7 +1310,6 @@ xfs_alloc_ag_vextent_locality(bool fbinc;ASSERT (acur->len ==0 ); -ASSERT (args->type ==XFS_ALLOCTYPE_NEAR_BNO ); *stat =0 ;
@@ -3137,6 +3095,7 @@ xfs_alloc_vextent_check_args(xfs_agblock_t agsize; args->agbno =NULLAGBLOCK ; + args->fsbno =NULLFSBLOCK ;/* * Just fix this up, for the case where the last a.g. is shorter
@@ -3295,8 +3254,11 @@ xfs_alloc_vextent_finish( }/* -* Allocate within a single AG only. Caller is expected to hold a -* perag reference in args->pag. +* Allocate within a single AG only. This uses a best-fit length algorithm so if +* you need an exact sized allocation without locality constraints, this is the +* fastest way to do it. +* +* Caller is expected to hold a perag reference in args->pag. */ int xfs_alloc_vextent_this_ag(
@@ -3305,7 +3267,6 @@ xfs_alloc_vextent_this_ag( {struct xfs_mount *mp = args->mp;xfs_agnumber_t minimum_agno =0 ; -xfs_rfsblock_t target =XFS_AGB_TO_FSB (mp, agno,0 );int error;if (args->tp->t_highest_agno !=NULLAGNUMBER )
@@ -3317,7 +3278,7 @@ xfs_alloc_vextent_this_ag(return 0 ; } - error =xfs_alloc_vextent_check_args (args, target); + error =xfs_alloc_vextent_check_args (args,XFS_AGB_TO_FSB (mp, agno,0 ));if (error) {if (error == -ENOSPC )return 0 ;
@@ -3326,12 +3287,10 @@ xfs_alloc_vextent_this_ag( args->agno = agno; args->agbno =0 ; - args->fsbno = target; - args->type =XFS_ALLOCTYPE_THIS_AG ; error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp) - error =xfs_alloc_ag_vextent (args); + error =xfs_alloc_ag_vextent_size (args);return xfs_alloc_vextent_finish (args, minimum_agno, error, false); }
@@ -3355,6 +3314,7 @@ xfs_alloc_vextent_iterate_ags(struct xfs_alloc_arg *args, xfs_agnumber_t minimum_agno, xfs_agnumber_t start_agno, + xfs_agblock_t target_agbno, uint32_t flags) { struct xfs_mount *mp = args->mp;
@@ -3369,7 +3329,6 @@ xfs_alloc_vextent_iterate_ags( args->agno = start_agno;for (;;) { args->pag =xfs_perag_get (mp, args->agno); - args->agbno =XFS_FSB_TO_AGBNO (mp, args->fsbno); error =xfs_alloc_vextent_prepare_ag (args);if (error)break ;
@@ -3379,16 +3338,18 @@ xfs_alloc_vextent_iterate_ags(* Allocation is supposed to succeed now, so break out * of the loop regardless of whether we succeed or not. */ - error =xfs_alloc_ag_vextent (args); +if (args->agno == start_agno && target_agbno) { + args->agbno = target_agbno; + error =xfs_alloc_ag_vextent_near (args); + }else { + args->agbno =0 ; + error =xfs_alloc_ag_vextent_size (args); + }break ; }trace_xfs_alloc_vextent_loopfailed (args); -if (args->agno == start_agno && - args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) - args->type =XFS_ALLOCTYPE_THIS_AG ; -/* * If we are try-locking, we can't deadlock on AGF locks so we * can wrap all the way back to the first AG. Otherwise, wrap
@@ -3412,10 +3373,8 @@ xfs_alloc_vextent_iterate_ags(trace_xfs_alloc_vextent_allfailed (args);break ; } - + args->agbno = target_agbno; flags =0 ; -if (args->otype ==XFS_ALLOCTYPE_NEAR_BNO ) - args->type =XFS_ALLOCTYPE_NEAR_BNO ; }xfs_perag_put (args->pag); args->pag =NULL ;
@@ -3464,13 +3423,11 @@ xfs_alloc_vextent_start_ag( mp->m_sb.sb_agcount), 0); bump_rotor =1 ; } - start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); - args->agbno =XFS_FSB_TO_AGBNO (mp, target); - args->type =XFS_ALLOCTYPE_NEAR_BNO ; - args->fsbno = target; + start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno, -XFS_ALLOC_FLAG_TRYLOCK ); +XFS_FSB_TO_AGBNO (mp, target),XFS_ALLOC_FLAG_TRYLOCK ); +if (bump_rotor) {if (args->agno == start_agno) mp->m_agfrotor = (mp->m_agfrotor + 1) %
@@ -3484,9 +3441,9 @@ xfs_alloc_vextent_start_ag( }/* -* Iterate from the agno indicated from args->fsbno through to the end of the +* Iterate from the agno indicated via @target through to the end of the * filesystem attempting blocking allocation. This does not wrap or try a second -* pass, so will not recurse into AGs lower than indicated by fsbno. +* pass, so will not recurse into AGs lower than indicated by the target. */ int xfs_alloc_vextent_first_ag(
@@ -3509,10 +3466,8 @@ xfs_alloc_vextent_first_ag( } start_agno =max (minimum_agno,XFS_FSB_TO_AGNO (mp, target)); - args->type =XFS_ALLOCTYPE_THIS_AG ; - args->fsbno = target; - error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, - start_agno,0 ); + error =xfs_alloc_vextent_iterate_ags (args, minimum_agno, start_agno, +XFS_FSB_TO_AGBNO (mp, target),0 );return xfs_alloc_vextent_finish (args, minimum_agno, error, true); }
@@ -3547,12 +3502,10 @@ xfs_alloc_vextent_exact_bno( } args->agbno =XFS_FSB_TO_AGBNO (mp, target); - args->fsbno = target; - args->type =XFS_ALLOCTYPE_THIS_BNO ; error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp) - error =xfs_alloc_ag_vextent (args); + error =xfs_alloc_ag_vextent_exact (args);return xfs_alloc_vextent_finish (args, minimum_agno, error, false); }
@@ -3594,11 +3547,10 @@ xfs_alloc_vextent_near_bno( args->pag =xfs_perag_get (mp, args->agno); args->agbno =XFS_FSB_TO_AGBNO (mp, target); - args->type =XFS_ALLOCTYPE_NEAR_BNO ; error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp) - error =xfs_alloc_ag_vextent (args); + error =xfs_alloc_ag_vextent_near (args);return xfs_alloc_vextent_finish (args, minimum_agno, error, needs_perag); }
fs/xfs/libxfs/xfs_alloc.h +0 -17
@@ -16,21 +16,6 @@ extern struct workqueue_struct *xfs_alloc_wq;unsigned int xfs_agfl_size (struct xfs_mount *mp); -/* -* Freespace allocation types. Argument to xfs_alloc_[v]extent. -*/ -#define XFS_ALLOCTYPE_THIS_AG 0x08/* anywhere in this a.g. */ -#define XFS_ALLOCTYPE_NEAR_BNO 0x20/* in this a.g. and near this block */ -#define XFS_ALLOCTYPE_THIS_BNO 0x40/* at exactly this block */ - -/* this should become an enum again when the tracing code is fixed */ -typedef unsigned int xfs_alloctype_t ; - -#define XFS_ALLOC_TYPES \ - { XFS_ALLOCTYPE_THIS_AG, "THIS_AG" }, \ - { XFS_ALLOCTYPE_NEAR_BNO, "NEAR_BNO" }, \ - { XFS_ALLOCTYPE_THIS_BNO, "THIS_BNO" } -/* * Flags for xfs_alloc_fix_freelist. */
@@ -64,8 +49,6 @@ typedef struct xfs_alloc_arg {xfs_agblock_t min_agbno;/* set an agbno range for NEAR allocs */ xfs_agblock_t max_agbno;/* ... */ xfs_extlen_t len;/* output: actual size of extent */ -xfs_alloctype_t type;/* allocation type XFS_ALLOCTYPE_... */ -xfs_alloctype_t otype;/* original allocation type */ int datatype;/* mask defining data type treatment */ char wasdel;/* set if allocation was prev delayed */ char wasfromfl;/* set if allocation is from freelist */
fs/xfs/libxfs/xfs_bmap.c +2 -8
@@ -3501,7 +3501,6 @@ xfs_bmap_btalloc_at_eof( bool ag_only) {struct xfs_mount *mp = args->mp; -xfs_alloctype_t atype;int error;/*
@@ -3513,14 +3512,12 @@ xfs_bmap_btalloc_at_eof(if (ap->offset) {xfs_extlen_t nextminlen =0 ; - atype = args->type; - args->alignment =1 ; -/* * Compute the minlen+alignment for the next case. Set slop so * that the value of minlen+alignment+slop doesn't go up between * the calls. */ + args->alignment =1 ;if (blen > stripe_align && blen <= args->maxlen) nextminlen = blen - stripe_align;else
@@ -3544,17 +3541,15 @@ xfs_bmap_btalloc_at_eof(* according to the original allocation specification. */ args->pag =NULL ; - args->type = atype; args->alignment = stripe_align; args->minlen = nextminlen; args->minalignslop =0 ; }else { - args->alignment = stripe_align; - atype = args->type;/* * Adjust minlen to try and preserve alignment if we * can't guarantee an aligned maxlen extent. */ + args->alignment = stripe_align;if (blen > args->alignment && blen <= args->maxlen + args->alignment) args->minlen = blen - args->alignment;
@@ -3576,7 +3571,6 @@ xfs_bmap_btalloc_at_eof(* original non-aligned state so the caller can proceed on allocation * failure as if this function was never called. */ - args->type = atype; args->fsbno = ap->blkno; args->alignment =1 ;return 0 ;
fs/xfs/xfs_trace.h +1 -7
@@ -1799,8 +1799,6 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __field(xfs_extlen_t, alignment) __field(xfs_extlen_t, minalignslop) __field(xfs_extlen_t, len) - __field(short, type) - __field(short, otype) __field(char, wasdel) __field(char, wasfromfl)__field (int, resv)
@@ -1820,8 +1818,6 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __entry->alignment = args->alignment; __entry->minalignslop = args->minalignslop; __entry->len = args->len; - __entry->type = args->type; - __entry->otype = args->otype; __entry->wasdel = args->wasdel; __entry->wasfromfl = args->wasfromfl; __entry->resv = args->resv;
@@ -1830,7 +1826,7 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, ), TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u " "prod %u minleft %u total %u alignment %u minalignslop %u " - "len %u type %s otype %s wasdel %d wasfromfl %d resv %d " + "len %u wasdel %d wasfromfl %d resv %d " "datatype 0x%x highest_agno 0x%x", MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno,
@@ -1844,8 +1840,6 @@ DECLARE_EVENT_CLASS(xfs_alloc_class, __entry->alignment, __entry->minalignslop, __entry->len, -__print_symbolic (__entry->type,XFS_ALLOC_TYPES ), -__print_symbolic (__entry->otype,XFS_ALLOC_TYPES ), __entry->wasdel, __entry->wasfromfl, __entry->resv,
Signature · 1 line
2.39.0
PATCH 27/42 xfs: move the minimum agno checks into xfs_alloc_vextent_check_args
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
All of the allocation functions now extract the minimum allowed AG from the transaction and then use it in some way. The allocation functions that are restricted to a single AG all check if the AG requested can be allocated from and return an error if so. These all set args->agno appropriately.
All the allocation functions that iterate AGs use it to calculate the scan start AG. args->agno is not set until the iterator starts walking AGs.
Hence we can easily set up a conditional check against the minimum AG allowed in xfs_alloc_vextent_check_args() based on whether args->agno contains NULLAGNUMBER or not and move all the repeated setup code to xfs_alloc_vextent_check_args(), further simplifying the allocation functions.
--- fs/xfs/libxfs/xfs_alloc.c | 88 +++++++++++++++------------------------ 1 file changed, 33 insertions(+), 55 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +33 -55
@@ -3089,14 +3089,18 @@ xfs_alloc_read_agf(static int xfs_alloc_vextent_check_args (struct xfs_alloc_arg *args, -xfs_rfsblock_t target) +xfs_rfsblock_t target, +xfs_agnumber_t *minimum_agno) {struct xfs_mount *mp = args->mp;xfs_agblock_t agsize; - args->agbno =NULLAGBLOCK ; args->fsbno =NULLFSBLOCK ; + *minimum_agno =0 ; +if (args->tp->t_highest_agno !=NULLAGNUMBER ) + *minimum_agno = args->tp->t_highest_agno; +/* * Just fix this up, for the case where the last a.g. is shorter * (or there's only one a.g.) and the caller couldn't easily figure
@@ -3123,11 +3127,16 @@ xfs_alloc_vextent_check_args( XFS_FSB_TO_AGBNO(mp, target) >= agsize || args->minlen > args->maxlen || args->minlen > agsize || args->mod >= args->prod) { - args->fsbno = NULLFSBLOCK;trace_xfs_alloc_vextent_badargs (args);return -ENOSPC ; } + +if (args->agno !=NULLAGNUMBER && *minimum_agno > args->agno) { +trace_xfs_alloc_vextent_skip_deadlock (args); +return -ENOSPC ; + }return 0 ; + }/*
@@ -3266,28 +3275,19 @@ xfs_alloc_vextent_this_ag( xfs_agnumber_t agno) {struct xfs_mount *mp = args->mp; -xfs_agnumber_t minimum_agno =0 ; +xfs_agnumber_t minimum_agno;int error; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; - -if (minimum_agno > agno) { -trace_xfs_alloc_vextent_skip_deadlock (args); - args->fsbno =NULLFSBLOCK ; -return 0 ; - } - - error =xfs_alloc_vextent_check_args (args,XFS_AGB_TO_FSB (mp, agno,0 )); + args->agno = agno; + args->agbno =0 ; + error =xfs_alloc_vextent_check_args (args,XFS_AGB_TO_FSB (mp, agno,0 ), + &minimum_agno);if (error) {if (error == -ENOSPC )return 0 ;return error; } - args->agno = agno; - args->agbno =0 ; - error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp) error =xfs_alloc_ag_vextent_size (args);
@@ -3400,16 +3400,15 @@ xfs_alloc_vextent_start_ag( xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp; -xfs_agnumber_t minimum_agno =0 ; +xfs_agnumber_t minimum_agno;xfs_agnumber_t start_agno;xfs_agnumber_t rotorstep = xfs_rotorstep;bool bump_rotor = false;int error; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; - - error =xfs_alloc_vextent_check_args (args, target); + args->agno =NULLAGNUMBER ; + args->agbno =NULLAGBLOCK ; + error =xfs_alloc_vextent_check_args (args, target, &minimum_agno);if (error) {if (error == -ENOSPC )return 0 ;
@@ -3451,14 +3450,13 @@ xfs_alloc_vextent_first_ag( xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp; -xfs_agnumber_t minimum_agno =0 ; +xfs_agnumber_t minimum_agno;xfs_agnumber_t start_agno;int error; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; - - error =xfs_alloc_vextent_check_args (args, target); + args->agno =NULLAGNUMBER ; + args->agbno =NULLAGBLOCK ; + error =xfs_alloc_vextent_check_args (args, target, &minimum_agno);if (error) {if (error == -ENOSPC )return 0 ;
@@ -3481,28 +3479,18 @@ xfs_alloc_vextent_exact_bno( xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp; -xfs_agnumber_t minimum_agno =0 ; +xfs_agnumber_t minimum_agno;int error; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; - - error =xfs_alloc_vextent_check_args (args, target); + args->agno =XFS_FSB_TO_AGNO (mp, target); + args->agbno =XFS_FSB_TO_AGBNO (mp, target); + error =xfs_alloc_vextent_check_args (args, target, &minimum_agno);if (error) {if (error == -ENOSPC )return 0 ;return error; } - args->agno =XFS_FSB_TO_AGNO (mp, target); -if (minimum_agno > args->agno) { -trace_xfs_alloc_vextent_skip_deadlock (args); - args->fsbno =NULLFSBLOCK ; -return 0 ; - } - - args->agbno =XFS_FSB_TO_AGBNO (mp, target); - error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp) error =xfs_alloc_ag_vextent_exact (args);
@@ -3522,32 +3510,22 @@ xfs_alloc_vextent_near_bno( xfs_rfsblock_t target) {struct xfs_mount *mp = args->mp; -xfs_agnumber_t minimum_agno =0 ; +xfs_agnumber_t minimum_agno;bool needs_perag = args->pag ==NULL ;int error; -if (args->tp->t_highest_agno !=NULLAGNUMBER ) - minimum_agno = args->tp->t_highest_agno; - - error =xfs_alloc_vextent_check_args (args, target); + args->agno =XFS_FSB_TO_AGNO (mp, target); + args->agbno =XFS_FSB_TO_AGBNO (mp, target); + error =xfs_alloc_vextent_check_args (args, target, &minimum_agno);if (error) {if (error == -ENOSPC )return 0 ;return error; } - args->agno =XFS_FSB_TO_AGNO (mp, target); -if (minimum_agno > args->agno) { -trace_xfs_alloc_vextent_skip_deadlock (args); - args->fsbno =NULLFSBLOCK ; -return 0 ; - } -if (needs_perag) args->pag =xfs_perag_get (mp, args->agno); - args->agbno =XFS_FSB_TO_AGBNO (mp, target); - error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp) error =xfs_alloc_ag_vextent_near (args);
Signature · 1 line
2.39.0
PATCH 28/42 xfs: convert xfs_alloc_vextent_iterate_ags() to use perag walker
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Now that the AG iteration code in the core allocation code has been cleaned up, we can easily convert it to use a for_each_perag..() variant to use active references and skip AGs that it can't get active references on.
--- fs/xfs/libxfs/xfs_ag.h | 22 ++++++--- fs/xfs/libxfs/xfs_alloc.c | 98 ++++++++++++++++++--------------------- 2 files changed, 60 insertions(+), 60 deletions(-)
fs/xfs/libxfs/xfs_ag.h +15 -7
@@ -253,6 +253,7 @@ xfs_perag_next_wrap(struct xfs_perag *pag, xfs_agnumber_t *agno, xfs_agnumber_t stop_agno, + xfs_agnumber_t restart_agno, xfs_agnumber_t wrap_agno) { struct xfs_mount *mp = pag->pag_mount;
@@ -260,10 +261,11 @@ xfs_perag_next_wrap( *agno = pag->pag_agno +1 ;xfs_perag_rele (pag);while (*agno != stop_agno) { -if (*agno >= wrap_agno) - *agno =0 ; -if (*agno == stop_agno) -break ; +if (*agno >= wrap_agno) { +if (restart_agno >= stop_agno) +break ; + *agno = restart_agno; + } pag =xfs_perag_grab (mp, *agno);if (pag)
@@ -274,14 +276,20 @@ xfs_perag_next_wrap( }/* -* Iterate all AGs from start_agno through wrap_agno, then 0 through +* Iterate all AGs from start_agno through wrap_agno, then restart_agno through * (start_agno - 1). */ -#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag) \ +#define for_each_perag_wrap_range (mp, start_agno, restart_agno, wrap_agno, agno, pag) \ for ((agno) = (start_agno), (pag) = xfs_perag_grab((mp), (agno)); \ (pag) != NULL; \ (pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \ - (wrap_agno))) + (restart_agno), (wrap_agno))) +/* +* Iterate all AGs from start_agno through wrap_agno, then 0 through +* (start_agno - 1). +*/ +#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag) \ + for_each_perag_wrap_range((mp), (start_agno), 0, (wrap_agno), (agno), (pag))/* * Iterate all AGs from start_agno through to the end of the filesystem, then 0
fs/xfs/libxfs/xfs_alloc.c +45 -53
144 lines not on this page · raw message
Signature · 1 line
2.39.0
Re: [PATCH 28/42] xfs: convert xfs_alloc_vextent_iterate_ags() to use perag walker
Quoted 104 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Now that the AG iteration code in the core allocation code has been cleaned up, we can easily convert it to use a for_each_perag..() variant to use active references and skip AGs that it can't get active references on.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_ag.h | 22 ++++++--- fs/xfs/libxfs/xfs_alloc.c | 98 ++++++++++++++++++--------------------- 2 files changed, 60 insertions(+), 60 deletions(-)fs/xfs/libxfs/xfs_ag.h +15
-7@@ -253,6 +253,7 @@ xfs_perag_next_wrap(struct xfs_perag *pag, xfs_agnumber_t *agno, xfs_agnumber_t stop_agno, + xfs_agnumber_t restart_agno, xfs_agnumber_t wrap_agno) { struct xfs_mount *mp = pag->pag_mount;@@ -260,10 +261,11 @@ xfs_perag_next_wrap( *agno = pag->pag_agno +1 ;xfs_perag_rele (pag);while (*agno != stop_agno) { -if (*agno >= wrap_agno) - *agno =0 ; -if (*agno == stop_agno) -break ; +if (*agno >= wrap_agno) { +if (restart_agno >= stop_agno) +break ; + *agno = restart_agno; + } pag =xfs_perag_grab (mp, *agno);if (pag)@@ -274,14 +276,20 @@ xfs_perag_next_wrap( }/* -* Iterate all AGs from start_agno through wrap_agno, then 0 through +* Iterate all AGs from start_agno through wrap_agno, then restart_agno through * (start_agno - 1). */ -#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag) \ +#define for_each_perag_wrap_range (mp, start_agno, restart_agno, wrap_agno, agno, pag) \ for ((agno) = (start_agno), (pag) = xfs_perag_grab((mp), (agno)); \ (pag) != NULL; \ (pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \ - (wrap_agno))) + (restart_agno), (wrap_agno))) +/* +* Iterate all AGs from start_agno through wrap_agno, then 0 through +* (start_agno - 1). +*/ +#define for_each_perag_wrap_at (mp, start_agno, wrap_agno, agno, pag) \ + for_each_perag_wrap_range((mp), (start_agno), 0, (wrap_agno), (agno), (pag))/* * Iterate all AGs from start_agno through to the end of the filesystem, then 0 fs/xfs/libxfs/xfs_alloc.c +8
-2@@ -3156,6 +3156,7 @@ xfs_alloc_vextent_prepare_ag(if (need_pag) args->pag =xfs_perag_get (args->mp, args->agno); + args->agbp =NULL ; error =xfs_alloc_fix_freelist (args,0 );if (error) {trace_xfs_alloc_vextent_nofix (args);@@ -3255,8 +3256,8 @@ xfs_alloc_vextent_finish(XFS_STATS_ADD (mp, xs_allocb, args->len); out_drop_perag: -if (drop_perag) { -xfs_perag_put (args->pag); +if (drop_perag && args->pag) { +xfs_perag_rele (args->pag); args->pag =NULL ; }return error;@@ -3304,6 +3305,10 @@ xfs_alloc_vextent_this_ag(* we attempt to allocation in as there is no locality optimisation possible for * those allocations. * +* On return, args->pag may be left referenced if we finish before the "all +* failed" return point. The allocation finish still needs the perag, and +* so the caller will release it once they've finished the allocation. +* * When we wrap the AG iteration at the end of the filesystem, we have to be * careful not to wrap into AGs below ones we already have locked in the * transaction if we are doing a blocking iteration. This will result in an @@ -3318,72 +3323,59 @@ xfs_alloc_vextent_iterate_ags( uint32_t flags) {struct xfs_mount *mp = args->mp; +xfs_agnumber_t agno;
fs/xfs/libxfs/xfs_alloc.c xfs_alloc_vextent_iterate_ags( · line 3335
Quoted 10 lines
fs/xfs/libxfs/xfs_alloc.c +7
-1int error =0 ; -ASSERT (start_agno >= minimum_agno); +restart: +for_each_perag_wrap_range (mp, start_agno, minimum_agno, + mp->m_sb.sb_agcount, agno, args->pag) { + args->agno = agno; +trace_printk ("sag %u minag %u agno %u pag %u, agbno %u, agcnt %u" , + start_agno, minimum_agno, agno, args->pag->pag_agno, + target_agbno, mp->m_sb.sb_agcount);
Please remove the debugging statement or (if it's useful) convert this to a static tracepoint.
--D
Quoted 107 lines
fs/xfs/libxfs/xfs_alloc.c +30
-50-/* -* Loop over allocation groups twice; first time with -* trylock set, second time without. -*/ - args->agno = start_agno; -for (;;) { - args->pag =xfs_perag_get (mp, args->agno); error =xfs_alloc_vextent_prepare_ag (args);if (error)break ; - -if (args->agbp) { -/* -* Allocation is supposed to succeed now, so break out -* of the loop regardless of whether we succeed or not. -*/ -if (args->agno == start_agno && target_agbno) { - args->agbno = target_agbno; - error =xfs_alloc_ag_vextent_near (args); - }else { - args->agbno =0 ; - error =xfs_alloc_ag_vextent_size (args); - } -break ; +if (!args->agbp) { +trace_xfs_alloc_vextent_loopfailed (args); +continue ; } -trace_xfs_alloc_vextent_loopfailed (args); -/* -* If we are try-locking, we can't deadlock on AGF locks so we -* can wrap all the way back to the first AG. Otherwise, wrap -* back to the start AG so we can't deadlock and let the end of -* scan handler decide what to do next. +* Allocation is supposed to succeed now, so break out of the +* loop regardless of whether we succeed or not. */ -if (++(args->agno) == mp->m_sb.sb_agcount) { -if (flags &XFS_ALLOC_FLAG_TRYLOCK ) - args->agno =0 ; -else - args->agno = minimum_agno; - } - -/* -* Reached the starting a.g., must either be done -* or switch to non-trylock mode. -*/ -if (args->agno == start_agno) { -if (flags ==0 ) { - args->agbno =NULLAGBLOCK ; -trace_xfs_alloc_vextent_allfailed (args); -break ; - } +if (args->agno == start_agno && target_agbno) { args->agbno = target_agbno; - flags =0 ; + error =xfs_alloc_ag_vextent_near (args); + }else { + args->agbno =0 ; + error =xfs_alloc_ag_vextent_size (args); } -xfs_perag_put (args->pag); +break ; + } +if (error) { +xfs_perag_rele (args->pag); args->pag =NULL ; +return error; } +if (args->agbp) +return 0 ; +/* -* The perag is left referenced in args for the caller to clean -* up after they've finished the allocation. +* We didn't find an AG we can alloation from. If we were given +* constraining flags by the caller, drop them and retry the allocation +* without any constraints being set. */ -return error; +if (flags) { + flags =0 ; + goto restart; + } + +ASSERT (args->pag ==NULL ); +trace_xfs_alloc_vextent_allfailed (args); +return 0 ; }/* @@ -3524,7 +3516,7 @@ xfs_alloc_vextent_near_bno( }if (needs_perag) - args->pag =xfs_perag_get (mp, args->agno); + args->pag =xfs_perag_grab (mp, args->agno); error =xfs_alloc_vextent_prepare_ag (args);if (!error && args->agbp)Signature · 1 line
2.39.0
PATCH 29/42 xfs: convert trim to use for_each_perag_range
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
To convert it to using active perag references and hence make it shrink safe.
--- fs/xfs/xfs_discard.c | 50 ++++++++++++++++++++------------------------ 1 file changed, 23 insertions(+), 27 deletions(-)
fs/xfs/xfs_discard.c +23 -27
@@ -21,23 +21,20 @@ STATIC intxfs_trim_extents ( -struct xfs_mount *mp, -xfs_agnumber_t agno, +struct xfs_perag *pag,xfs_daddr_t start,xfs_daddr_t end,xfs_daddr_t minlen,uint64_t *blocks_trimmed) { +struct xfs_mount *mp = pag->pag_mount;struct block_device *bdev = mp->m_ddev_targp->bt_bdev;struct xfs_btree_cur *cur;struct xfs_buf *agbp;struct xfs_agf *agf; -struct xfs_perag *pag;int error;int i; - pag =xfs_perag_get (mp, agno); -/* * Force out the log. This means any transactions that might have freed * space before we take the AGF buffer lock are now on disk, and the
@@ -47,7 +44,7 @@ xfs_trim_extents( error =xfs_alloc_read_agf (pag,NULL ,0 , &agbp);if (error) - goto out_put_perag; +return error; agf = agbp->b_addr; cur =xfs_allocbt_init_cursor (mp,NULL , agbp, pag,XFS_BTNUM_CNT );
@@ -71,10 +68,10 @@ xfs_trim_extents( error =xfs_alloc_get_rec (cur, &fbno, &flen, &i);if (error) - goto out_del_cursor; +break ;if (XFS_IS_CORRUPT (mp, i !=1 )) { error = -EFSCORRUPTED ; - goto out_del_cursor; +break ; }ASSERT (flen <=be32_to_cpu (agf->agf_longest));
@@ -83,15 +80,15 @@ xfs_trim_extents(* the format the range/len variables are supplied in by * userspace. */ - dbno =XFS_AGB_TO_DADDR (mp, agno, fbno); + dbno =XFS_AGB_TO_DADDR (mp, pag->pag_agno, fbno); dlen =XFS_FSB_TO_BB (mp, flen);/* * Too small? Give up. */ if (dlen < minlen) { -trace_xfs_discard_toosmall (mp, agno, fbno, flen); - goto out_del_cursor; +trace_xfs_discard_toosmall (mp, pag->pag_agno, fbno, flen); +break ; }/*
@@ -100,7 +97,7 @@ xfs_trim_extents(* down partially overlapping ranges for now. */ if (dbno + dlen < start || dbno > end) { -trace_xfs_discard_exclude (mp, agno, fbno, flen); +trace_xfs_discard_exclude (mp, pag->pag_agno, fbno, flen); goto next_extent; }
@@ -109,32 +106,30 @@ xfs_trim_extents(* discard and try again the next time. */ if (xfs_extent_busy_search (mp, pag, fbno, flen)) { -trace_xfs_discard_busy (mp, agno, fbno, flen); +trace_xfs_discard_busy (mp, pag->pag_agno, fbno, flen); goto next_extent; } -trace_xfs_discard_extent (mp, agno, fbno, flen); +trace_xfs_discard_extent (mp, pag->pag_agno, fbno, flen); error =blkdev_issue_discard (bdev, dbno, dlen,GFP_NOFS );if (error) - goto out_del_cursor; +break ; *blocks_trimmed += flen; next_extent: error =xfs_btree_decrement (cur,0 , &i);if (error) - goto out_del_cursor; +break ;if (fatal_signal_pending (current)) { error = -ERESTARTSYS ; - goto out_del_cursor; +break ; } } out_del_cursor:xfs_btree_del_cursor (cur, error);xfs_buf_relse (agbp); -out_put_perag: -xfs_perag_put (pag);return error; }
@@ -152,11 +147,12 @@ xfs_ioc_trim(struct xfs_mount *mp, struct fstrim_range __user *urange) { + struct xfs_perag *pag;unsigned int granularity =bdev_discard_granularity (mp->m_ddev_targp->bt_bdev);struct fstrim_range range;xfs_daddr_t start, end, minlen; -xfs_agnumber_t start_agno, end_agno, agno; +xfs_agnumber_t agno;uint64_t blocks_trimmed =0 ;int error, last_error =0 ;
@@ -193,18 +189,18 @@ xfs_ioc_trim( end = start +BTOBBT (range.len) -1 ;if (end >XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks) -1 ) - end =XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks)-1 ; - - start_agno =xfs_daddr_to_agno (mp, start); - end_agno =xfs_daddr_to_agno (mp, end); + end =XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks) -1 ; -for (agno = start_agno; agno <= end_agno; agno++) { - error =xfs_trim_extents (mp, agno, start, end, minlen, + agno =xfs_daddr_to_agno (mp, start); +for_each_perag_range (mp, agno,xfs_daddr_to_agno (mp, end), pag) { + error =xfs_trim_extents (pag, start, end, minlen, &blocks_trimmed);if (error) { last_error = error; -if (error == -ERESTARTSYS ) +if (error == -ERESTARTSYS ) { +xfs_perag_rele (pag);break ; + } } }
Signature · 1 line
2.39.0
Re: [PATCH 29/42] xfs: convert trim to use for_each_perag_range
Quoted 29 lines · Dave Chinner
From: Dave Chinner <[email protected]>
To convert it to using active perag references and hence make it shrink safe.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/xfs_discard.c | 50 ++++++++++++++++++++------------------------ 1 file changed, 23 insertions(+), 27 deletions(-)fs/xfs/xfs_discard.c +2
-2@@ -21,23 +21,20 @@ STATIC intxfs_trim_extents ( -struct xfs_mount *mp, -xfs_agnumber_t agno, +struct xfs_perag *pag,xfs_daddr_t start,xfs_daddr_t end,xfs_daddr_t minlen,uint64_t *blocks_trimmed) { +struct xfs_mount *mp = pag->pag_mount;struct block_device *bdev = mp->m_ddev_targp->bt_bdev;struct xfs_btree_cur *cur;
fs/xfs/xfs_discard.c line 39
Quoted 10 lines
fs/xfs/xfs_discard.c +0
-3struct xfs_buf *agbp;struct xfs_agf *agf; -struct xfs_perag *pag;int error;int i; - pag =xfs_perag_get (mp, agno); -/* * Force out the log. This means any transactions that might have freed
This is a tangent, but one thing I've wondered is if it's really necessary to force the log for *every* AG that we want to trim? Even if we've just come from trimming the previous AG?
Looks good otherwise,
--D
Quoted 132 lines
fs/xfs/xfs_discard.c +21
-22* space before we take the AGF buffer lock are now on disk, and the @@ -47,7 +44,7 @@ xfs_trim_extents( error =xfs_alloc_read_agf (pag,NULL ,0 , &agbp);if (error) - goto out_put_perag; +return error; agf = agbp->b_addr; cur =xfs_allocbt_init_cursor (mp,NULL , agbp, pag,XFS_BTNUM_CNT );@@ -71,10 +68,10 @@ xfs_trim_extents( error =xfs_alloc_get_rec (cur, &fbno, &flen, &i);if (error) - goto out_del_cursor; +break ;if (XFS_IS_CORRUPT (mp, i !=1 )) { error = -EFSCORRUPTED ; - goto out_del_cursor; +break ; }ASSERT (flen <=be32_to_cpu (agf->agf_longest));@@ -83,15 +80,15 @@ xfs_trim_extents(* the format the range/len variables are supplied in by * userspace. */ - dbno =XFS_AGB_TO_DADDR (mp, agno, fbno); + dbno =XFS_AGB_TO_DADDR (mp, pag->pag_agno, fbno); dlen =XFS_FSB_TO_BB (mp, flen);/* * Too small? Give up. */ if (dlen < minlen) { -trace_xfs_discard_toosmall (mp, agno, fbno, flen); - goto out_del_cursor; +trace_xfs_discard_toosmall (mp, pag->pag_agno, fbno, flen); +break ; }/* @@ -100,7 +97,7 @@ xfs_trim_extents(* down partially overlapping ranges for now. */ if (dbno + dlen < start || dbno > end) { -trace_xfs_discard_exclude (mp, agno, fbno, flen); +trace_xfs_discard_exclude (mp, pag->pag_agno, fbno, flen); goto next_extent; }@@ -109,32 +106,30 @@ xfs_trim_extents(* discard and try again the next time. */ if (xfs_extent_busy_search (mp, pag, fbno, flen)) { -trace_xfs_discard_busy (mp, agno, fbno, flen); +trace_xfs_discard_busy (mp, pag->pag_agno, fbno, flen); goto next_extent; } -trace_xfs_discard_extent (mp, agno, fbno, flen); +trace_xfs_discard_extent (mp, pag->pag_agno, fbno, flen); error =blkdev_issue_discard (bdev, dbno, dlen,GFP_NOFS );if (error) - goto out_del_cursor; +break ; *blocks_trimmed += flen; next_extent: error =xfs_btree_decrement (cur,0 , &i);if (error) - goto out_del_cursor; +break ;if (fatal_signal_pending (current)) { error = -ERESTARTSYS ; - goto out_del_cursor; +break ; } } out_del_cursor:xfs_btree_del_cursor (cur, error);xfs_buf_relse (agbp); -out_put_perag: -xfs_perag_put (pag);return error; }@@ -152,11 +147,12 @@ xfs_ioc_trim(struct xfs_mount *mp, struct fstrim_range __user *urange) { + struct xfs_perag *pag;unsigned int granularity =bdev_discard_granularity (mp->m_ddev_targp->bt_bdev);struct fstrim_range range;xfs_daddr_t start, end, minlen; -xfs_agnumber_t start_agno, end_agno, agno; +xfs_agnumber_t agno;uint64_t blocks_trimmed =0 ;int error, last_error =0 ;@@ -193,18 +189,18 @@ xfs_ioc_trim( end = start +BTOBBT (range.len) -1 ;if (end >XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks) -1 ) - end =XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks)-1 ; - - start_agno =xfs_daddr_to_agno (mp, start); - end_agno =xfs_daddr_to_agno (mp, end); + end =XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks) -1 ; -for (agno = start_agno; agno <= end_agno; agno++) { - error =xfs_trim_extents (mp, agno, start, end, minlen, + agno =xfs_daddr_to_agno (mp, start); +for_each_perag_range (mp, agno,xfs_daddr_to_agno (mp, end), pag) { + error =xfs_trim_extents (pag, start, end, minlen, &blocks_trimmed);if (error) { last_error = error; -if (error == -ERESTARTSYS ) +if (error == -ERESTARTSYS ) { +xfs_perag_rele (pag);break ; + } } }Signature · 1 line
2.39.0
Re: [PATCH 29/42] xfs: convert trim to use for_each_perag_range
Quoted 36 lines · Darrick J. Wong
Quoted 35 lines · Dave Chinner
From: Dave Chinner <[email protected]>
To convert it to using active perag references and hence make it shrink safe.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/xfs_discard.c | 50 ++++++++++++++++++++------------------------ 1 file changed, 23 insertions(+), 27 deletions(-)fs/xfs/xfs_discard.c +2
-3@@ -21,23 +21,20 @@ STATIC intxfs_trim_extents ( -struct xfs_mount *mp, -xfs_agnumber_t agno, +struct xfs_perag *pag,xfs_daddr_t start,xfs_daddr_t end,xfs_daddr_t minlen,uint64_t *blocks_trimmed) { +struct xfs_mount *mp = pag->pag_mount;struct block_device *bdev = mp->m_ddev_targp->bt_bdev;struct xfs_btree_cur *cur;struct xfs_buf *agbp;struct xfs_agf *agf; -struct xfs_perag *pag;int error;int i;
Quoted 8 lines
fs/xfs/xfs_discard.c line 39
Quoted 4 lines
fs/xfs/xfs_discard.c +0
-2- pag =xfs_perag_get (mp, agno); -/* * Force out the log. This means any transactions that might have freed This is a tangent, but one thing I've wondered is if it's really necessary to force the log for *every* AG that we want to trim? Even if we've just come from trimming the previous AG?
I suspect the thought behind this is that TRIM operations can be really slow, so there can be a big build-up of new busy extents as a large fragmented AG is trimmed.
I don't think it really matters at this point - if you are running a multi-AG trim range, a few extra log forces is the least of your performance worries. If someone reports it as a perf problem, let's look at it then....
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
PATCH 30/42 xfs: factor out filestreams from xfs_bmap_btalloc_nullfb
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
There's many if (filestreams) {} else {} branches in this function. Split it out into a filestreams specific function so that we can then work directly on cleaning up the filestreams code without impacting the rest of the allocation algorithms.
--- fs/xfs/libxfs/xfs_bmap.c | 167 ++++++++++++++++++++++----------------- 1 file changed, 96 insertions(+), 71 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +96 -71
@@ -3234,8 +3234,8 @@ xfs_bmap_btalloc_select_lengths(return 0 ; } -STATIC int -xfs_bmap_btalloc_filestreams ( +static int +xfs_bmap_btalloc_filestreams_select_lengths (struct xfs_bmalloca *ap,struct xfs_alloc_arg *args,xfs_extlen_t *blen)
@@ -3576,54 +3576,109 @@ xfs_bmap_btalloc_at_eof(return 0 ; } +/* +* We have failed multiple allocation attempts so now are in a low space +* allocation situation. Try a locality first full filesystem minimum length +* allocation whilst still maintaining necessary total block reservation +* requirements. +* +* If that fails, we are now critically low on space, so perform a last resort +* allocation attempt: no reserve, no locality, blocking, minimum length, full +* filesystem free space scan. We also indicate to future allocations in this +* transaction that we are critically low on space so they don't waste time on +* allocation modes that are unlikely to succeed. +*/ static int -xfs_bmap_btalloc_best_length ( +xfs_bmap_btalloc_low_space ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args) +{ +int error; + +if (args->minlen > ap->minlen) { + args->minlen = ap->minlen; + error =xfs_alloc_vextent_start_ag (args, ap->blkno); +if (error || args->fsbno !=NULLFSBLOCK ) +return error; + } + +/* Last ditch attempt before failure is declared. */ + args->total = ap->minlen; + error =xfs_alloc_vextent_first_ag (args,0 ); +if (error) +return error; + ap->tp->t_flags |=XFS_TRANS_LOWMODE ; +return 0 ; +} + +static int +xfs_bmap_btalloc_filestreams (struct xfs_bmalloca *ap,struct xfs_alloc_arg *args,int stripe_align) { -struct xfs_mount *mp = args->mp; +xfs_agnumber_t agno =xfs_filestream_lookup_ag (ap->ip);xfs_extlen_t blen =0 ; -bool is_filestream = false;int error; -if ((ap->datatype &XFS_ALLOC_USERDATA ) && -xfs_inode_is_filestream (ap->ip)) - is_filestream = true; +/* Determine the initial block number we will target for allocation. */ +if (agno ==NULLAGNUMBER ) + agno =0 ; + ap->blkno =XFS_AGB_TO_FSB (args->mp, agno,0 ); +xfs_bmap_adjacent (ap);/* -* Determine the initial block number we will target for allocation. +* If there is very little free space before we start a +* filestreams allocation, we're almost guaranteed to fail to +* find an AG with enough contiguous free space to succeed, so +* just go straight to the low space algorithm. */ -if (is_filestream) { -xfs_agnumber_t agno =xfs_filestream_lookup_ag (ap->ip); -if (agno ==NULLAGNUMBER ) - agno =0 ; - ap->blkno =XFS_AGB_TO_FSB (mp, agno,0 ); - }else { - ap->blkno =XFS_INO_TO_FSB (mp, ap->ip->i_ino); +if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { + args->minlen = ap->minlen; +return xfs_bmap_btalloc_low_space (ap, args); } -xfs_bmap_adjacent (ap);/* * Search for an allocation group with a single extent large enough for * the request. If one isn't found, then adjust the minimum allocation * size to the largest space found. */ -if (is_filestream) { -/* -* If there is very little free space before we start a -* filestreams allocation, we're almost guaranteed to fail to -* find an AG with enough contiguous free space to succeed, so -* just go straight to the low space algorithm. -*/ -if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) { - args->minlen = ap->minlen; - goto critically_low_space; - } - error =xfs_bmap_btalloc_filestreams (ap, args, &blen); - }else { - error =xfs_bmap_btalloc_select_lengths (ap, args, &blen); + error =xfs_bmap_btalloc_filestreams_select_lengths (ap, args, &blen); +if (error) +return error; + +if (ap->aeof) { + error =xfs_bmap_btalloc_at_eof (ap, args, blen, stripe_align, + true); +if (error || args->fsbno !=NULLFSBLOCK ) +return error; } + + error =xfs_alloc_vextent_near_bno (args, ap->blkno); +if (error || args->fsbno !=NULLFSBLOCK ) +return error; + +return xfs_bmap_btalloc_low_space (ap, args); +} + +static int +xfs_bmap_btalloc_best_length ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args, +int stripe_align) +{ +xfs_extlen_t blen =0 ; +int error; + + ap->blkno =XFS_INO_TO_FSB (args->mp, ap->ip->i_ino); +xfs_bmap_adjacent (ap); + +/* +* Search for an allocation group with a single extent large enough for +* the request. If one isn't found, then adjust the minimum allocation +* size to the largest space found. +*/ + error =xfs_bmap_btalloc_select_lengths (ap, args, &blen);if (error)return error;
@@ -3635,50 +3690,16 @@ xfs_bmap_btalloc_best_length(*/ if (ap->aeof && !(ap->tp->t_flags &XFS_TRANS_LOWMODE )) { error =xfs_bmap_btalloc_at_eof (ap, args, blen, stripe_align, - is_filestream); -if (error) + false); +if (error || args->fsbno !=NULLFSBLOCK )return error; -if (args->fsbno !=NULLFSBLOCK ) -return 0 ; } -if (is_filestream) - error =xfs_alloc_vextent_near_bno (args, ap->blkno); -else - error =xfs_alloc_vextent_start_ag (args, ap->blkno); -if (error) + error =xfs_alloc_vextent_start_ag (args, ap->blkno); +if (error || args->fsbno !=NULLFSBLOCK )return error; -if (args->fsbno !=NULLFSBLOCK ) -return 0 ; - -/* -* Try a locality first full filesystem minimum length allocation whilst -* still maintaining necessary total block reservation requirements. -*/ -if (args->minlen > ap->minlen) { - args->minlen = ap->minlen; - error =xfs_alloc_vextent_start_ag (args, ap->blkno); -if (error) -return error; - } -if (args->fsbno !=NULLFSBLOCK ) -return 0 ; -/* -* We are now critically low on space, so this is a last resort -* allocation attempt: no reserve, no locality, blocking, minimum -* length, full filesystem free space scan. We also indicate to future -* allocations in this transaction that we are critically low on space -* so they don't waste time on allocation modes that are unlikely to -* succeed. -*/ -critically_low_space: - args->total = ap->minlen; - error =xfs_alloc_vextent_first_ag (args,0 ); -if (error) -return error; - ap->tp->t_flags |=XFS_TRANS_LOWMODE ; -return 0 ; +return xfs_bmap_btalloc_low_space (ap, args); } static int
@@ -3712,7 +3733,11 @@ xfs_bmap_btalloc(/* Trim the allocation back to the maximum an AG can fit. */ args.maxlen =min (ap->length, mp->m_ag_max_usable); - error =xfs_bmap_btalloc_best_length (ap, &args, stripe_align); +if ((ap->datatype &XFS_ALLOC_USERDATA ) && +xfs_inode_is_filestream (ap->ip)) + error =xfs_bmap_btalloc_filestreams (ap, &args, stripe_align); +else + error =xfs_bmap_btalloc_best_length (ap, &args, stripe_align);if (error)return error;
Signature · 1 line
2.39.0
PATCH 31/42 xfs: get rid of notinit from xfs_bmap_longest_free_extent
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
It is only set if reading the AGF gets a EAGAIN error. Just return the EAGAIN error and handle that error in the callers.
This means we can remove the not_init parameter from xfs_bmap_select_minlen(), too, because the use of not_init there is pessimistic. If we can't read the agf, it won't increase blen.
The only time we actually care whether we checked all the AGFs for contiguous free space is when the best length is less than the minimum allocation length. If not_init is set, then we ignore blen and set the minimum alloc length to the absolute minimum, not the best length we know already is present.
However, if blen is less than the minimum we're going to ignore it anyway, regardless of whether we scanned all the AGFs or not. Hence not_init can go away, because we only use if blen is good from the scanned AGs otherwise we ignore it altogether and use minlen.
--- fs/xfs/libxfs/xfs_bmap.c | 84 +++++++++++++++++----------------------- 1 file changed, 36 insertions(+), 48 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +36 -48
@@ -3139,8 +3139,7 @@ static intxfs_bmap_longest_free_extent ( struct xfs_perag *pag, struct xfs_trans *tp, - xfs_extlen_t *blen, - int *notinit) + xfs_extlen_t *blen) { xfs_extlen_t longest;int error =0 ;
@@ -3148,14 +3147,8 @@ xfs_bmap_longest_free_extent(if (!xfs_perag_initialised_agf (pag)) { error =xfs_alloc_read_agf (pag, tp,XFS_ALLOC_FLAG_TRYLOCK ,NULL ); -if (error) { -/* Couldn't lock the AGF, so skip this AG. */ -if (error == -EAGAIN ) { - *notinit =1 ; - error =0 ; - } +if (error)return error; - } } longest = xfs_alloc_longest_free_extent(pag,
@@ -3167,32 +3160,28 @@ xfs_bmap_longest_free_extent(return 0 ; } -static void +static xfs_extlen_t xfs_bmap_select_minlen (struct xfs_bmalloca *ap,struct xfs_alloc_arg *args, -xfs_extlen_t *blen, -int notinit) +xfs_extlen_t blen) { -if (notinit || *blen < ap->minlen) { -/* -* Since we did a BUF_TRYLOCK above, it is possible that -* there is space for this request. -*/ - args->minlen = ap->minlen; - }else if (*blen < args->maxlen) { -/* -* If the best seen length is less than the request length, -* use the best as the minimum. -*/ - args->minlen = *blen; - }else { -/* -* Otherwise we've seen an extent as big as maxlen, use that -* as the minimum. -*/ - args->minlen = args->maxlen; - } + +/* +* Since we used XFS_ALLOC_FLAG_TRYLOCK in _longest_free_extent(), it is +* possible that there is enough contiguous free space for this request. +*/ +if (blen < ap->minlen) +return ap->minlen; + +/* +* If the best seen length is less than the request length, +* use the best as the minimum, otherwise we've got the maxlen we +* were asked for. +*/ +if (blen < args->maxlen) +return blen; +return args->maxlen; } static int
@@ -3204,7 +3193,6 @@ xfs_bmap_btalloc_select_lengths(struct xfs_mount *mp = args->mp;struct xfs_perag *pag;xfs_agnumber_t agno, startag; -int notinit =0 ;int error =0 ;if (ap->tp->t_flags &XFS_TRANS_LOWMODE ) {
@@ -3220,9 +3208,8 @@ xfs_bmap_btalloc_select_lengths( *blen =0 ;for_each_perag_wrap (mp, startag, agno, pag) { - error =xfs_bmap_longest_free_extent (pag, args->tp, blen, - ¬init); -if (error) + error =xfs_bmap_longest_free_extent (pag, args->tp, blen); +if (error && error != -EAGAIN )break ;if (*blen >= args->maxlen)break ;
@@ -3230,7 +3217,7 @@ xfs_bmap_btalloc_select_lengths(if (pag)xfs_perag_rele (pag); -xfs_bmap_select_minlen (ap, args, blen, notinit); + args->minlen =xfs_bmap_select_minlen (ap, args, *blen);return 0 ; }
@@ -3243,7 +3230,6 @@ xfs_bmap_btalloc_filestreams_select_lengths(struct xfs_mount *mp = ap->ip->i_mount;struct xfs_perag *pag;xfs_agnumber_t start_agno; -int notinit =0 ;int error; args->total = ap->total;
@@ -3254,11 +3240,13 @@ xfs_bmap_btalloc_filestreams_select_lengths( pag =xfs_perag_grab (mp, start_agno);if (pag) { - error =xfs_bmap_longest_free_extent (pag, args->tp, blen, - ¬init); + error =xfs_bmap_longest_free_extent (pag, args->tp, blen);xfs_perag_rele (pag); -if (error) -return error; +if (error) { +if (error != -EAGAIN ) +return error; + *blen =0 ; + } }if (*blen < args->maxlen) {
@@ -3274,18 +3262,18 @@ xfs_bmap_btalloc_filestreams_select_lengths(if (!pag) goto out_select; - error =xfs_bmap_longest_free_extent (pag, args->tp, - blen, ¬init); + error =xfs_bmap_longest_free_extent (pag, args->tp, blen);xfs_perag_rele (pag); -if (error) -return error; - +if (error) { +if (error != -EAGAIN ) +return error; + *blen =0 ; + } start_agno = agno; - } out_select: -xfs_bmap_select_minlen (ap, args, blen, notinit); + args->minlen =xfs_bmap_select_minlen (ap, args, *blen);/* * Set the failure fallback case to look in the selected AG as stream
Signature · 1 line
2.39.0