Commit f8f2835a authored by Brian Foster's avatar Brian Foster Committed by Darrick J. Wong
Browse files

xfs: defer agfl block frees when dfops is available 



The AGFL fixup code executes before every block allocation/free and
rectifies the AGFL based on the current, dynamic allocation
requirements of the fs. The AGFL must hold a minimum number of
blocks to satisfy a worst case split of the free space btrees caused
by the impending allocation operation. The AGFL is also updated to
maintain the implicit requirement for a minimum number of free slots
to satisfy a worst case join of the free space btrees.

Since the AGFL caches individual blocks, AGFL reduction typically
involves multiple, single block frees. We've had reports of
transaction overrun problems during certain workloads that boil down
to AGFL reduction freeing multiple blocks and consuming more space
in the log than was reserved for the transaction.

Since the objective of freeing AGFL blocks is to ensure free AGFL
free slots are available for the upcoming allocation, one way to
address this problem is to release surplus blocks from the AGFL
immediately but defer the free of those blocks (similar to how
file-mapped blocks are unmapped from the file in one transaction and
freed via a deferred operation) until the transaction is rolled.
This turns AGFL reduction into an operation with predictable log
reservation consumption.

Add the capability to defer AGFL block frees when a deferred ops
list is available to the AGFL fixup code. Add a dfops pointer to the
transaction to carry dfops through various contexts to the allocator
context. Deferring AGFL frees is  conditional behavior based on
whether the transaction pointer is populated. The long term
objective is to reuse the transaction pointer to clean up all
unrelated callchains that pass dfops on the stack along with a
transaction and in doing so, consistently defer AGFL blocks from the
allocator.

A bit of customization is required to handle deferred completion
processing because AGFL blocks are accounted against a per-ag
reservation pool and AGFL blocks are not inserted into the extent
busy list when freed (they are inserted when used and released back
to the AGFL). Reuse the majority of the existing deferred extent
free infrastructure and customize it appropriately to handle AGFL
blocks.

Note that this patch only adds infrastructure. It does not change
behavior because no callers have been updated to pass ->t_agfl_dfops
into the allocation code.

Signed-off-by: default avatarBrian Foster <bfoster@redhat.com>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent 4223f659

fs/xfs/libxfs/xfs_alloc.c

+47 −4
Original line number Diff line number Diff line
@@ -39,6 +39,9 @@ 
#include "xfs_buf_item.h"

#include "xfs_log.h"

#include "xfs_ag_resv.h"

#include "xfs_bmap.h"



extern kmem_zone_t	*xfs_bmap_free_item_zone;



struct workqueue_struct *xfs_alloc_wq;
@@ -2171,6 +2174,40 @@ xfs_agfl_reset( 
	pag->pagf_agflreset = false;

}



/*

 * Defer an AGFL block free. This is effectively equivalent to

 * xfs_bmap_add_free() with some special handling particular to AGFL blocks.

 *

 * Deferring AGFL frees helps prevent log reservation overruns due to too many

 * allocation operations in a transaction. AGFL frees are prone to this problem

 * because for one they are always freed one at a time. Further, an immediate

 * AGFL block free can cause a btree join and require another block free before

 * the real allocation can proceed. Deferring the free disconnects freeing up

 * the AGFL slot from freeing the block.

 */

STATIC void

xfs_defer_agfl_block(

	struct xfs_mount		*mp,

	struct xfs_defer_ops		*dfops,

	xfs_agnumber_t			agno,

	xfs_fsblock_t			agbno,

	struct xfs_owner_info		*oinfo)

{

	struct xfs_extent_free_item	*new;		/* new element */



	ASSERT(xfs_bmap_free_item_zone != NULL);

	ASSERT(oinfo != NULL);



	new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);

	new->xefi_startblock = XFS_AGB_TO_FSB(mp, agno, agbno);

	new->xefi_blockcount = 1;

	new->xefi_oinfo = *oinfo;



	trace_xfs_agfl_free_defer(mp, agno, 0, agbno, 1);



	xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_AGFL_FREE, &new->xefi_list);

}



/*

 * Decide whether to use this allocation group for this allocation.

 * If so, fix up the btree freelist's size.
@@ -2275,11 +2312,17 @@ xfs_alloc_fix_freelist( 
		if (error)

			goto out_agbp_relse;



		/* defer agfl frees if dfops is provided */

		if (tp->t_agfl_dfops) {

			xfs_defer_agfl_block(mp, tp->t_agfl_dfops, args->agno,

					     bno, &targs.oinfo);

		} else {

			error = xfs_free_agfl_block(tp, args->agno, bno, agbp,

						    &targs.oinfo);

			if (error)

				goto out_agbp_relse;

		}

	}



	targs.tp = tp;

	targs.mp = mp;

fs/xfs/libxfs/xfs_defer.h

+1 −0
Original line number Diff line number Diff line
@@ -55,6 +55,7 @@ enum xfs_defer_ops_type { 
	XFS_DEFER_OPS_TYPE_REFCOUNT,

	XFS_DEFER_OPS_TYPE_RMAP,

	XFS_DEFER_OPS_TYPE_FREE,

	XFS_DEFER_OPS_TYPE_AGFL_FREE,

	XFS_DEFER_OPS_TYPE_MAX,

};

fs/xfs/xfs_trace.h

+2 −0
Original line number Diff line number Diff line
@@ -2436,6 +2436,8 @@ DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort); 
#define DEFINE_BMAP_FREE_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT

DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_defer);

DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_deferred);

DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_agfl_free_defer);

DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_agfl_free_deferred);



/* rmap tracepoints */

DECLARE_EVENT_CLASS(xfs_rmap_class,

fs/xfs/xfs_trans.c

+8 −3
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#include "xfs_log.h"

#include "xfs_trace.h"

#include "xfs_error.h"

#include "xfs_defer.h"



kmem_zone_t	*xfs_trans_zone;

kmem_zone_t	*xfs_log_item_desc_zone;
@@ -94,11 +95,11 @@ xfs_trans_free( 
 * blocks.  Locks and log items, however, are no inherited.  They must

 * be added to the new transaction explicitly.

 */

STATIC xfs_trans_t *

STATIC struct xfs_trans *

xfs_trans_dup(

	xfs_trans_t	*tp)

	struct xfs_trans	*tp)

{

	xfs_trans_t	*ntp;

	struct xfs_trans	*ntp;



	ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
@@ -127,6 +128,7 @@ xfs_trans_dup( 
	ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;

	tp->t_rtx_res = tp->t_rtx_res_used;

	ntp->t_pflags = tp->t_pflags;

	ntp->t_agfl_dfops = tp->t_agfl_dfops;



	xfs_trans_dup_dqinfo(tp, ntp);
@@ -936,6 +938,9 @@ __xfs_trans_commit( 
	int			error = 0;

	int			sync = tp->t_flags & XFS_TRANS_SYNC;



	ASSERT(!tp->t_agfl_dfops ||

	       !xfs_defer_has_unfinished_work(tp->t_agfl_dfops) || regrant);



	/*

	 * If there is nothing to be logged by the transaction,

	 * then unlock all of the items associated with the

fs/xfs/xfs_trans.h

+1 −0
Original line number Diff line number Diff line
@@ -111,6 +111,7 @@ typedef struct xfs_trans { 
	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 */

	struct xfs_defer_ops	*t_agfl_dfops;	/* optional agfl fixup dfops */

	unsigned int		t_flags;	/* misc flags */

	int64_t			t_icount_delta;	/* superblock icount change */

	int64_t			t_ifree_delta;	/* superblock ifree change */

CRA Git | Maintained and supported by SUSTech CRA and CCSE