system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-10-02 01:10:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

xfs: convert xfs_alloc_vextent_iterate_ags() to use perag walker

Browse source 
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 <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
This commit is contained in:
Dave Chinner 2023-02-13 09:14:54 +11:00
parent 8b81356825
commit 3432ef6111
2 changed files with 59 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
fs/xfs/libxfs/xfs_ag.h
View file

@ -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)
@ -273,15 +275,21 @@ xfs_perag_next_wrap(
return NULL;
}
/*
* Iterate all AGs from start_agno through wrap_agno, then restart_agno through
* (start_agno - 1).
*/
#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), \
(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 ((agno) = (start_agno), (pag) = xfs_perag_grab((mp), (agno)); \
(pag) != NULL; \
(pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \
(wrap_agno)))
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

98
fs/xfs/libxfs/xfs_alloc.c
View file

@ -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,55 @@ xfs_alloc_vextent_iterate_ags(
uint32_t flags)
{
struct xfs_mount *mp = args->mp;
xfs_agnumber_t agno;
int error = 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);
restart:
for_each_perag_wrap_range(mp, start_agno, minimum_agno,
mp->m_sb.sb_agcount, agno, args->pag) {
args->agno = 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;
}
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.
*/
if (++(args->agno) == mp->m_sb.sb_agcount) {
if (flags & XFS_ALLOC_FLAG_TRYLOCK)
args->agno = 0;
else
args->agno = minimum_agno;
if (!args->agbp) {
trace_xfs_alloc_vextent_loopfailed(args);
continue;
}
/*
* Reached the starting a.g., must either be done
* or switch to non-trylock mode.
* Allocation is supposed to succeed now, so break out of the
* loop regardless of whether we succeed or not.
*/
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);
args->pag = NULL;
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 +3512,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)