Commit 230e8fe8 authored by Dave Chinner's avatar Dave Chinner
Browse files

xfs: fold xfs_alloc_ag_vextent() into callers 



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.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
parent e4d17426

fs/xfs/libxfs/xfs_alloc.c

+26 −74
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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,