Commit c02a2525 authored by Dave Chinner's avatar Dave Chinner Committed by openeuler-sync-bot
Browse files

xfs: pass alloc flags through to xfs_extent_busy_flush() 

mainline inclusion
from mainline-v6.4-rc6
commit 6a2a9d77
category: bugfix
bugzilla: 188883, https://gitee.com/openeuler/kernel/issues/I76JSK
CVE: NA

Reference: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6a2a9d776c4ae24a797e25eed2b9f7f33f756296



--------------------------------

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: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Reviewed-by: default avatarChandan Babu R <chandan.babu@oracle.com>

Conflicts: fs/xfs/libxfs/xfs_alloc.c
      fs/xfs/libxfs/xfs_alloc.h
Signed-off-by: default avatarLong Li <leo.lilong@huawei.com>
(cherry picked from commit 0650e61d)
parent dcb27ade

fs/xfs/libxfs/xfs_alloc.c

+48 −42
Original line number Diff line number Diff line
@@ -37,8 +37,8 @@ struct workqueue_struct *xfs_alloc_wq; 
#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 *);

STATIC int xfs_alloc_ag_vextent_near(xfs_alloc_arg_t *, uint32_t);

STATIC int xfs_alloc_ag_vextent_size(xfs_alloc_arg_t *, uint32_t);



/*

 * Size of the AGFL.  For CRC-enabled filesystes we steal a couple of slots in
@@ -1127,7 +1127,8 @@ xfs_alloc_ag_vextent_small( 
 */

STATIC int			/* error */

xfs_alloc_ag_vextent(

	xfs_alloc_arg_t	*args)	/* argument structure for allocation */

	xfs_alloc_arg_t	*args,	/* argument structure for allocation */

	uint32_t	alloc_flags)

{

	int		error=0;
@@ -1143,10 +1144,10 @@ xfs_alloc_ag_vextent( 
	args->wasfromfl = 0;

	switch (args->type) {

	case XFS_ALLOCTYPE_THIS_AG:

		error = xfs_alloc_ag_vextent_size(args);

		error = xfs_alloc_ag_vextent_size(args, alloc_flags);

		break;

	case XFS_ALLOCTYPE_NEAR_BNO:

		error = xfs_alloc_ag_vextent_near(args);

		error = xfs_alloc_ag_vextent_near(args, alloc_flags);

		break;

	case XFS_ALLOCTYPE_THIS_BNO:

		error = xfs_alloc_ag_vextent_exact(args);
@@ -1554,7 +1555,8 @@ xfs_alloc_ag_vextent_lastblock( 
 */

STATIC int

xfs_alloc_ag_vextent_near(

	struct xfs_alloc_arg	*args)

	struct xfs_alloc_arg	*args,

	uint32_t		alloc_flags)

{

	struct xfs_alloc_cur	acur = {};

	int			error;		/* error code */
@@ -1630,7 +1632,7 @@ xfs_alloc_ag_vextent_near( 
		if (acur.busy) {

			trace_xfs_alloc_near_busy(args);

			xfs_extent_busy_flush(args->mp, args->pag,

					      acur.busy_gen);

					      acur.busy_gen, alloc_flags);

			goto restart;

		}

		trace_xfs_alloc_size_neither(args);
@@ -1653,21 +1655,22 @@ xfs_alloc_ag_vextent_near( 
 * 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_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;

	xfs_btree_cur_t	*bno_cur;	/* cursor for bno btree */

	xfs_btree_cur_t	*cnt_cur;	/* cursor for cnt btree */

	int		error;		/* error result */

	struct xfs_btree_cur	*bno_cur;

	struct xfs_btree_cur	*cnt_cur;

	xfs_agblock_t		fbno;		/* start of found freespace */

	xfs_extlen_t		flen;		/* length of found freespace */

	int		i;		/* temp status variable */

	xfs_agblock_t		rbno;		/* returned block number */

	xfs_extlen_t		rlen;		/* length of returned extent */

	bool			busy;

	unsigned		busy_gen;

	int			error;

	int			i;



restart:

	/*
@@ -1736,8 +1739,8 @@ xfs_alloc_ag_vextent_size( 
				xfs_btree_del_cursor(cnt_cur,

						     XFS_BTREE_NOERROR);

				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;

			}

		}
@@ -1821,7 +1824,8 @@ xfs_alloc_ag_vextent_size( 
		if (busy) {

			xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);

			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 out_nominleft;
@@ -2545,7 +2549,7 @@ __xfs_free_extent_later( 
int			/* error */

xfs_alloc_fix_freelist(

	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_perag	*pag = args->pag;
@@ -2561,7 +2565,7 @@ xfs_alloc_fix_freelist( 
	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);



	if (!pag->pagf_init) {

		error = xfs_alloc_read_agf(mp, tp, args->agno, flags, &agbp);

		error = xfs_alloc_read_agf(mp, tp, args->agno, alloc_flags, &agbp);

		if (error) {

			/* Couldn't lock the AGF so skip this AG. */

			if (error == -EAGAIN)
@@ -2576,8 +2580,8 @@ xfs_alloc_fix_freelist( 
	 * point

	 */

	if (pag->pagf_metadata && (args->datatype & XFS_ALLOC_USERDATA) &&

	    (flags & XFS_ALLOC_FLAG_TRYLOCK)) {

		ASSERT(!(flags & XFS_ALLOC_FLAG_FREEING));

	    (alloc_flags & XFS_ALLOC_FLAG_TRYLOCK)) {

		ASSERT(!(alloc_flags & XFS_ALLOC_FLAG_FREEING));

		goto out_agbp_relse;

	}
@@ -2587,7 +2591,7 @@ xfs_alloc_fix_freelist( 
	 * transaction if needed.

	 */

	need = xfs_alloc_min_freelist(mp, pag) * (1 + args->postallocs);

	if (!xfs_alloc_space_available(args, need, flags |

	if (!xfs_alloc_space_available(args, need, alloc_flags |

			XFS_ALLOC_FLAG_CHECK))

		goto out_agbp_relse;
@@ -2596,7 +2600,7 @@ xfs_alloc_fix_freelist( 
	 * Can fail if we're not blocking on locks, and it's held.

	 */

	if (!agbp) {

		error = xfs_alloc_read_agf(mp, tp, args->agno, flags, &agbp);

		error = xfs_alloc_read_agf(mp, tp, args->agno, alloc_flags, &agbp);

		if (error) {

			/* Couldn't lock the AGF so skip this AG. */

			if (error == -EAGAIN)
@@ -2611,7 +2615,7 @@ xfs_alloc_fix_freelist( 


	/* If there isn't enough total space or single-extent, reject it. */

	need = xfs_alloc_min_freelist(mp, pag) * (1 + args->postallocs);

	if (!xfs_alloc_space_available(args, need, flags))

	if (!xfs_alloc_space_available(args, need, alloc_flags))

		goto out_agbp_relse;



	/*
@@ -2640,11 +2644,12 @@ xfs_alloc_fix_freelist( 
	 */

	memset(&targs, 0, sizeof(targs));

	/* struct copy below */

	if (flags & XFS_ALLOC_FLAG_NORMAP)

	if (alloc_flags & XFS_ALLOC_FLAG_NORMAP)

		targs.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;

	else

		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(tp, agbp, &bno, 0);

		if (error)

			goto out_agbp_relse;
@@ -2673,7 +2678,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(&targs, alloc_flags);

		if (error)

			goto out_agflbp_relse;
@@ -2683,7 +2688,7 @@ xfs_alloc_fix_freelist( 
		 * on a completely full ag.

		 */

		if (targs.agbno == NULLAGBLOCK) {

			if (flags & XFS_ALLOC_FLAG_FREEING)

			if (alloc_flags & XFS_ALLOC_FLAG_FREEING)

				break;

			goto out_agflbp_relse;

		}
@@ -3130,7 +3135,7 @@ xfs_alloc_vextent( 
{

	xfs_agblock_t		agsize;	/* allocation group size */

	int			error;

	int			flags;	/* XFS_ALLOC_FLAG_... locking flags */

	uint32_t		alloc_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 */
@@ -3183,7 +3188,7 @@ xfs_alloc_vextent( 
			break;

		}

		args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);

		if ((error = xfs_alloc_ag_vextent(args)))

		if ((error = xfs_alloc_ag_vextent(args, 0)))

			goto error0;

		break;

	case XFS_ALLOCTYPE_START_BNO:
@@ -3212,13 +3217,13 @@ xfs_alloc_vextent( 
			args->agno = XFS_FSB_TO_AGNO(mp, args->fsbno);

			args->type = XFS_ALLOCTYPE_THIS_AG;

			sagno = 0;

			flags = 0;

			alloc_flags = 0;

		} else {

			/*

			 * Start with the given allocation group.

			 */

			args->agno = sagno = XFS_FSB_TO_AGNO(mp, args->fsbno);

			flags = XFS_ALLOC_FLAG_TRYLOCK;

			alloc_flags = XFS_ALLOC_FLAG_TRYLOCK;

		}

		/*

		 * Loop over allocation groups twice; first time with
@@ -3226,7 +3231,7 @@ xfs_alloc_vextent( 
		 */

		for (;;) {

			args->pag = xfs_perag_get(mp, args->agno);

			error = xfs_alloc_fix_freelist(args, flags);

			error = xfs_alloc_fix_freelist(args, alloc_flags);

			if (error) {

				trace_xfs_alloc_vextent_nofix(args);

				goto error0;
@@ -3235,7 +3240,8 @@ xfs_alloc_vextent( 
			 * If we get a buffer back then the allocation will fly.

			 */

			if (args->agbp) {

				if ((error = xfs_alloc_ag_vextent(args)))

				if ((error = xfs_alloc_ag_vextent(args,

						alloc_flags)))

					goto error0;

				break;

			}
@@ -3266,13 +3272,13 @@ xfs_alloc_vextent( 
			 * or switch to non-trylock mode.

			 */

			if (args->agno == sagno) {

				if (flags == 0) {

				if (alloc_flags == 0) {

					args->agbno = NULLAGBLOCK;

					trace_xfs_alloc_vextent_allfailed(args);

					break;

				}



				flags = 0;

				alloc_flags = 0;

				if (type == XFS_ALLOCTYPE_START_BNO) {

					args->agbno = XFS_FSB_TO_AGBNO(mp,

						args->fsbno);

fs/xfs/libxfs/xfs_alloc.h

+1 −1
Original line number Diff line number Diff line
@@ -211,7 +211,7 @@ int xfs_alloc_read_agfl(struct xfs_mount *mp, struct xfs_trans *tp, 
			xfs_agnumber_t agno, struct xfs_buf **bpp);

int xfs_free_agfl_block(struct xfs_trans *, xfs_agnumber_t, xfs_agblock_t,

			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, xfs_agnumber_t agno,

		struct xfs_buf **agbp);

fs/xfs/xfs_extent_busy.c

+2 −1
Original line number Diff line number Diff line
@@ -583,7 +583,8 @@ void 
xfs_extent_busy_flush(

	struct xfs_mount	*mp,

	struct xfs_perag	*pag,

	unsigned		busy_gen)

	unsigned		busy_gen,

	uint32_t		alloc_flags)

{

	DEFINE_WAIT		(wait);

	int			error;

fs/xfs/xfs_extent_busy.h

+1 −1
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ xfs_extent_busy_trim(struct xfs_alloc_arg *args, xfs_agblock_t *bno, 


void

xfs_extent_busy_flush(struct xfs_mount *mp, struct xfs_perag *pag,

	unsigned busy_gen);

	unsigned busy_gen, uint32_t alloc_flags);



void

xfs_extent_busy_wait_all(struct xfs_mount *mp);