UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

xfs: pass alloc flags through to xfs_extent_busy_flush() 

To avoid blocking in xfs_extent_busy_flush() when freeing extents
and the only busy extents are held by the current transaction, we
need to pass the XFS_ALLOC_FLAG_FREEING flag context all the way
into xfs_extent_busy_flush().

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Chandan Babu R <chandan.babu@oracle.com>
This commit is contained in:
Dave Chinner 2023-06-28 11:04:32 -07:00 committed by Darrick J. Wong
parent b742d7b4f0
commit 6a2a9d776c
4 changed files with 56 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
fs/xfs/libxfs/xfs_alloc.c
View File

@ -1536,7 +1536,8 @@ xfs_alloc_ag_vextent_lastblock(
*/ */
STATIC int STATIC int
xfs_alloc_ag_vextent_near( xfs_alloc_ag_vextent_near(
struct xfs_alloc_arg *args) struct xfs_alloc_arg *args,
uint32_t alloc_flags)
{ {
struct xfs_alloc_cur acur = {}; struct xfs_alloc_cur acur = {};
int error; /* error code */ int error; /* error code */
@ -1612,7 +1613,7 @@ restart:
if (acur.busy) { if (acur.busy) {
trace_xfs_alloc_near_busy(args); trace_xfs_alloc_near_busy(args);
xfs_extent_busy_flush(args->mp, args->pag, xfs_extent_busy_flush(args->mp, args->pag,
acur.busy_gen); acur.busy_gen, alloc_flags);
goto restart; goto restart;
} }
trace_xfs_alloc_size_neither(args); trace_xfs_alloc_size_neither(args);
@ -1635,21 +1636,22 @@ out:
* and of the form k * prod + mod unless there's nothing that large. * 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. * Return the starting a.g. block, or NULLAGBLOCK if we can't do it.
*/ */
STATIC int /* error */ static int
xfs_alloc_ag_vextent_size( xfs_alloc_ag_vextent_size(
xfs_alloc_arg_t *args) /* allocation argument structure */ struct xfs_alloc_arg *args,
uint32_t alloc_flags)
{ {
struct xfs_agf *agf = args->agbp->b_addr; struct xfs_agf *agf = args->agbp->b_addr;
struct xfs_btree_cur *bno_cur; /* cursor for bno btree */ struct xfs_btree_cur *bno_cur;
struct xfs_btree_cur *cnt_cur; /* cursor for cnt btree */ struct xfs_btree_cur *cnt_cur;
int error; /* error result */
xfs_agblock_t fbno; /* start of found freespace */ xfs_agblock_t fbno; /* start of found freespace */
xfs_extlen_t flen; /* length of found freespace */ xfs_extlen_t flen; /* length of found freespace */
int i; /* temp status variable */
xfs_agblock_t rbno; /* returned block number */ xfs_agblock_t rbno; /* returned block number */
xfs_extlen_t rlen; /* length of returned extent */ xfs_extlen_t rlen; /* length of returned extent */
bool busy; bool busy;
unsigned busy_gen; unsigned busy_gen;
int error;
int i;
restart: restart:
/* /*
@ -1717,8 +1719,8 @@ restart:
xfs_btree_del_cursor(cnt_cur, xfs_btree_del_cursor(cnt_cur,
XFS_BTREE_NOERROR); XFS_BTREE_NOERROR);
trace_xfs_alloc_size_busy(args); trace_xfs_alloc_size_busy(args);
xfs_extent_busy_flush(args->mp, xfs_extent_busy_flush(args->mp, args->pag,
args->pag, busy_gen); busy_gen, alloc_flags);
goto restart; goto restart;
} }
} }
@ -1802,7 +1804,8 @@ restart:
if (busy) { if (busy) {
xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR); xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
trace_xfs_alloc_size_busy(args); trace_xfs_alloc_size_busy(args);
xfs_extent_busy_flush(args->mp, args->pag, busy_gen); xfs_extent_busy_flush(args->mp, args->pag, busy_gen,
alloc_flags);
goto restart; goto restart;
} }
goto out_nominleft; goto out_nominleft;
@ -2572,7 +2575,7 @@ out:
int /* error */ int /* error */
xfs_alloc_fix_freelist( xfs_alloc_fix_freelist(
struct xfs_alloc_arg *args, /* allocation argument structure */ struct xfs_alloc_arg *args, /* allocation argument structure */
int flags) /* XFS_ALLOC_FLAG_... */ uint32_t alloc_flags)
{ {
struct xfs_mount *mp = args->mp; struct xfs_mount *mp = args->mp;
struct xfs_perag *pag = args->pag; struct xfs_perag *pag = args->pag;
@ -2588,7 +2591,7 @@ xfs_alloc_fix_freelist(
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
if (!xfs_perag_initialised_agf(pag)) { if (!xfs_perag_initialised_agf(pag)) {
error = xfs_alloc_read_agf(pag, tp, flags, &agbp); error = xfs_alloc_read_agf(pag, tp, alloc_flags, &agbp);
if (error) { if (error) {
/* Couldn't lock the AGF so skip this AG. */ /* Couldn't lock the AGF so skip this AG. */
if (error == -EAGAIN) if (error == -EAGAIN)
@ -2604,13 +2607,13 @@ xfs_alloc_fix_freelist(
*/ */
if (xfs_perag_prefers_metadata(pag) && if (xfs_perag_prefers_metadata(pag) &&
(args->datatype & XFS_ALLOC_USERDATA) && (args->datatype & XFS_ALLOC_USERDATA) &&
(flags & XFS_ALLOC_FLAG_TRYLOCK)) { (alloc_flags & XFS_ALLOC_FLAG_TRYLOCK)) {
ASSERT(!(flags & XFS_ALLOC_FLAG_FREEING)); ASSERT(!(alloc_flags & XFS_ALLOC_FLAG_FREEING));
goto out_agbp_relse; goto out_agbp_relse;
} }
need = xfs_alloc_min_freelist(mp, pag); need = xfs_alloc_min_freelist(mp, pag);
if (!xfs_alloc_space_available(args, need, flags | if (!xfs_alloc_space_available(args, need, alloc_flags |
XFS_ALLOC_FLAG_CHECK)) XFS_ALLOC_FLAG_CHECK))
goto out_agbp_relse; goto out_agbp_relse;
@ -2619,7 +2622,7 @@ xfs_alloc_fix_freelist(
* Can fail if we're not blocking on locks, and it's held. * Can fail if we're not blocking on locks, and it's held.
*/ */
if (!agbp) { if (!agbp) {
error = xfs_alloc_read_agf(pag, tp, flags, &agbp); error = xfs_alloc_read_agf(pag, tp, alloc_flags, &agbp);
if (error) { if (error) {
/* Couldn't lock the AGF so skip this AG. */ /* Couldn't lock the AGF so skip this AG. */
if (error == -EAGAIN) if (error == -EAGAIN)
@ -2634,7 +2637,7 @@ xfs_alloc_fix_freelist(
/* If there isn't enough total space or single-extent, reject it. */ /* If there isn't enough total space or single-extent, reject it. */
need = xfs_alloc_min_freelist(mp, pag); need = xfs_alloc_min_freelist(mp, pag);
if (!xfs_alloc_space_available(args, need, flags)) if (!xfs_alloc_space_available(args, need, alloc_flags))
goto out_agbp_relse; goto out_agbp_relse;
#ifdef DEBUG #ifdef DEBUG
@ -2672,11 +2675,12 @@ xfs_alloc_fix_freelist(
*/ */
memset(&targs, 0, sizeof(targs)); memset(&targs, 0, sizeof(targs));
/* struct copy below */ /* struct copy below */
if (flags & XFS_ALLOC_FLAG_NORMAP) if (alloc_flags & XFS_ALLOC_FLAG_NORMAP)
targs.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE; targs.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
else else
targs.oinfo = XFS_RMAP_OINFO_AG; targs.oinfo = XFS_RMAP_OINFO_AG;
while (!(flags & XFS_ALLOC_FLAG_NOSHRINK) && pag->pagf_flcount > need) { while (!(alloc_flags & XFS_ALLOC_FLAG_NOSHRINK) &&
pag->pagf_flcount > need) {
error = xfs_alloc_get_freelist(pag, tp, agbp, &bno, 0); error = xfs_alloc_get_freelist(pag, tp, agbp, &bno, 0);
if (error) if (error)
goto out_agbp_relse; goto out_agbp_relse;
@ -2704,7 +2708,7 @@ xfs_alloc_fix_freelist(
targs.resv = XFS_AG_RESV_AGFL; targs.resv = XFS_AG_RESV_AGFL;
/* Allocate as many blocks as possible at once. */ /* Allocate as many blocks as possible at once. */
error = xfs_alloc_ag_vextent_size(&targs); error = xfs_alloc_ag_vextent_size(&targs, alloc_flags);
if (error) if (error)
goto out_agflbp_relse; goto out_agflbp_relse;
@ -2714,7 +2718,7 @@ xfs_alloc_fix_freelist(
* on a completely full ag. * on a completely full ag.
*/ */
if (targs.agbno == NULLAGBLOCK) { if (targs.agbno == NULLAGBLOCK) {
if (flags & XFS_ALLOC_FLAG_FREEING) if (alloc_flags & XFS_ALLOC_FLAG_FREEING)
break; break;
goto out_agflbp_relse; goto out_agflbp_relse;
} }
@ -3230,7 +3234,7 @@ xfs_alloc_vextent_check_args(
static int static int
xfs_alloc_vextent_prepare_ag( xfs_alloc_vextent_prepare_ag(
struct xfs_alloc_arg *args, struct xfs_alloc_arg *args,
uint32_t flags) uint32_t alloc_flags)
{ {
bool need_pag = !args->pag; bool need_pag = !args->pag;
int error; int error;
@ -3239,7 +3243,7 @@ xfs_alloc_vextent_prepare_ag(
args->pag = xfs_perag_get(args->mp, args->agno); args->pag = xfs_perag_get(args->mp, args->agno);
args->agbp = NULL; args->agbp = NULL;
error = xfs_alloc_fix_freelist(args, flags); error = xfs_alloc_fix_freelist(args, alloc_flags);
if (error) { if (error) {
trace_xfs_alloc_vextent_nofix(args); trace_xfs_alloc_vextent_nofix(args);
if (need_pag) if (need_pag)
@ -3361,6 +3365,7 @@ xfs_alloc_vextent_this_ag(
{ {
struct xfs_mount *mp = args->mp; struct xfs_mount *mp = args->mp;
xfs_agnumber_t minimum_agno; xfs_agnumber_t minimum_agno;
uint32_t alloc_flags = 0;
int error; int error;
ASSERT(args->pag != NULL); ASSERT(args->pag != NULL);
@ -3379,9 +3384,9 @@ xfs_alloc_vextent_this_ag(
return error; return error;
} }
error = xfs_alloc_vextent_prepare_ag(args, 0); error = xfs_alloc_vextent_prepare_ag(args, alloc_flags);
if (!error && args->agbp) if (!error && args->agbp)
error = xfs_alloc_ag_vextent_size(args); error = xfs_alloc_ag_vextent_size(args, alloc_flags);
return xfs_alloc_vextent_finish(args, minimum_agno, error, false); return xfs_alloc_vextent_finish(args, minimum_agno, error, false);
} }
@ -3410,20 +3415,20 @@ xfs_alloc_vextent_iterate_ags(
xfs_agnumber_t minimum_agno, xfs_agnumber_t minimum_agno,
xfs_agnumber_t start_agno, xfs_agnumber_t start_agno,
xfs_agblock_t target_agbno, xfs_agblock_t target_agbno,
uint32_t flags) uint32_t alloc_flags)
{ {
struct xfs_mount *mp = args->mp; struct xfs_mount *mp = args->mp;
xfs_agnumber_t restart_agno = minimum_agno; xfs_agnumber_t restart_agno = minimum_agno;
xfs_agnumber_t agno; xfs_agnumber_t agno;
int error = 0; int error = 0;
if (flags & XFS_ALLOC_FLAG_TRYLOCK) if (alloc_flags & XFS_ALLOC_FLAG_TRYLOCK)
restart_agno = 0; restart_agno = 0;
restart: restart:
for_each_perag_wrap_range(mp, start_agno, restart_agno, for_each_perag_wrap_range(mp, start_agno, restart_agno,
mp->m_sb.sb_agcount, agno, args->pag) { mp->m_sb.sb_agcount, agno, args->pag) {
args->agno = agno; args->agno = agno;
error = xfs_alloc_vextent_prepare_ag(args, flags); error = xfs_alloc_vextent_prepare_ag(args, alloc_flags);
if (error) if (error)
break; break;
if (!args->agbp) { if (!args->agbp) {
@ -3437,10 +3442,10 @@ restart:
*/ */
if (args->agno == start_agno && target_agbno) { if (args->agno == start_agno && target_agbno) {
args->agbno = target_agbno; args->agbno = target_agbno;
error = xfs_alloc_ag_vextent_near(args); error = xfs_alloc_ag_vextent_near(args, alloc_flags);
} else { } else {
args->agbno = 0; args->agbno = 0;
error = xfs_alloc_ag_vextent_size(args); error = xfs_alloc_ag_vextent_size(args, alloc_flags);
} }
break; break;
} }
@ -3457,8 +3462,8 @@ restart:
* constraining flags by the caller, drop them and retry the allocation * constraining flags by the caller, drop them and retry the allocation
* without any constraints being set. * without any constraints being set.
*/ */
if (flags) { if (alloc_flags & XFS_ALLOC_FLAG_TRYLOCK) {
flags = 0; alloc_flags &= ~XFS_ALLOC_FLAG_TRYLOCK;
restart_agno = minimum_agno; restart_agno = minimum_agno;
goto restart; goto restart;
} }
@ -3486,6 +3491,7 @@ xfs_alloc_vextent_start_ag(
xfs_agnumber_t start_agno; xfs_agnumber_t start_agno;
xfs_agnumber_t rotorstep = xfs_rotorstep; xfs_agnumber_t rotorstep = xfs_rotorstep;
bool bump_rotor = false; bool bump_rotor = false;
uint32_t alloc_flags = XFS_ALLOC_FLAG_TRYLOCK;
int error; int error;
ASSERT(args->pag == NULL); ASSERT(args->pag == NULL);
@ -3512,7 +3518,7 @@ xfs_alloc_vextent_start_ag(
start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target)); start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target));
error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno, error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno,
XFS_FSB_TO_AGBNO(mp, target), XFS_ALLOC_FLAG_TRYLOCK); XFS_FSB_TO_AGBNO(mp, target), alloc_flags);
if (bump_rotor) { if (bump_rotor) {
if (args->agno == start_agno) if (args->agno == start_agno)
@ -3539,6 +3545,7 @@ xfs_alloc_vextent_first_ag(
struct xfs_mount *mp = args->mp; struct xfs_mount *mp = args->mp;
xfs_agnumber_t minimum_agno; xfs_agnumber_t minimum_agno;
xfs_agnumber_t start_agno; xfs_agnumber_t start_agno;
uint32_t alloc_flags = XFS_ALLOC_FLAG_TRYLOCK;
int error; int error;
ASSERT(args->pag == NULL); ASSERT(args->pag == NULL);
@ -3557,7 +3564,7 @@ xfs_alloc_vextent_first_ag(
start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target)); start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target));
error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno, error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno,
XFS_FSB_TO_AGBNO(mp, target), 0); XFS_FSB_TO_AGBNO(mp, target), alloc_flags);
return xfs_alloc_vextent_finish(args, minimum_agno, error, true); return xfs_alloc_vextent_finish(args, minimum_agno, error, true);
} }
@ -3610,6 +3617,7 @@ xfs_alloc_vextent_near_bno(
struct xfs_mount *mp = args->mp; struct xfs_mount *mp = args->mp;
xfs_agnumber_t minimum_agno; xfs_agnumber_t minimum_agno;
bool needs_perag = args->pag == NULL; bool needs_perag = args->pag == NULL;
uint32_t alloc_flags = 0;
int error; int error;
if (!needs_perag) if (!needs_perag)
@ -3630,9 +3638,9 @@ xfs_alloc_vextent_near_bno(
if (needs_perag) if (needs_perag)
args->pag = xfs_perag_grab(mp, args->agno); args->pag = xfs_perag_grab(mp, args->agno);
error = xfs_alloc_vextent_prepare_ag(args, 0); error = xfs_alloc_vextent_prepare_ag(args, alloc_flags);
if (!error && args->agbp) if (!error && args->agbp)
error = xfs_alloc_ag_vextent_near(args); error = xfs_alloc_ag_vextent_near(args, alloc_flags);
return xfs_alloc_vextent_finish(args, minimum_agno, error, needs_perag); return xfs_alloc_vextent_finish(args, minimum_agno, error, needs_perag);
} }

2
fs/xfs/libxfs/xfs_alloc.h
View File

@ -195,7 +195,7 @@ int xfs_alloc_read_agfl(struct xfs_perag *pag, struct xfs_trans *tp,
struct xfs_buf **bpp); struct xfs_buf **bpp);
int xfs_free_agfl_block(struct xfs_trans *, xfs_agnumber_t, xfs_agblock_t, int xfs_free_agfl_block(struct xfs_trans *, xfs_agnumber_t, xfs_agblock_t,
struct xfs_buf *, struct xfs_owner_info *); struct xfs_buf *, struct xfs_owner_info *);
int xfs_alloc_fix_freelist(struct xfs_alloc_arg *args, int flags); int xfs_alloc_fix_freelist(struct xfs_alloc_arg *args, uint32_t alloc_flags);
int xfs_free_extent_fix_freelist(struct xfs_trans *tp, struct xfs_perag *pag, int xfs_free_extent_fix_freelist(struct xfs_trans *tp, struct xfs_perag *pag,
struct xfs_buf **agbp); struct xfs_buf **agbp);

3
fs/xfs/xfs_extent_busy.c
View File

@ -571,7 +571,8 @@ void
xfs_extent_busy_flush( xfs_extent_busy_flush(
struct xfs_mount *mp, struct xfs_mount *mp,
struct xfs_perag *pag, struct xfs_perag *pag,
unsigned busy_gen) unsigned busy_gen,
uint32_t alloc_flags)
{ {
DEFINE_WAIT (wait); DEFINE_WAIT (wait);
int error; int error;

2
fs/xfs/xfs_extent_busy.h
View File

@ -53,7 +53,7 @@ xfs_extent_busy_trim(struct xfs_alloc_arg *args, xfs_agblock_t *bno,
void void
xfs_extent_busy_flush(struct xfs_mount *mp, struct xfs_perag *pag, xfs_extent_busy_flush(struct xfs_mount *mp, struct xfs_perag *pag,
unsigned busy_gen); unsigned busy_gen, uint32_t alloc_flags);
void void
xfs_extent_busy_wait_all(struct xfs_mount *mp); xfs_extent_busy_wait_all(struct xfs_mount *mp);