Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 33ba6129 authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: connect refcount adjust functions to upper layers 



Plumb in the upper level interface to schedule and finish deferred
refcount operations via the deferred ops mechanism.

Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
parent 31727258

fs/xfs/libxfs/xfs_defer.h

+1 −0
Original line number Diff line number Diff line
@@ -51,6 +51,7 @@ struct xfs_defer_pending { 
 * find all the space it needs.

 */

enum xfs_defer_ops_type {

	XFS_DEFER_OPS_TYPE_REFCOUNT,

	XFS_DEFER_OPS_TYPE_RMAP,

	XFS_DEFER_OPS_TYPE_FREE,

	XFS_DEFER_OPS_TYPE_MAX,

fs/xfs/libxfs/xfs_refcount.c

+174 −0
Original line number Diff line number Diff line
@@ -989,3 +989,177 @@ xfs_refcount_adjust( 
			error, _RET_IP_);

	return error;

}



/* Clean up after calling xfs_refcount_finish_one. */

void

xfs_refcount_finish_one_cleanup(

	struct xfs_trans	*tp,

	struct xfs_btree_cur	*rcur,

	int			error)

{

	struct xfs_buf		*agbp;



	if (rcur == NULL)

		return;

	agbp = rcur->bc_private.a.agbp;

	xfs_btree_del_cursor(rcur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);

	if (error)

		xfs_trans_brelse(tp, agbp);

}



/*

 * Process one of the deferred refcount operations.  We pass back the

 * btree cursor to maintain our lock on the btree between calls.

 * This saves time and eliminates a buffer deadlock between the

 * superblock and the AGF because we'll always grab them in the same

 * order.

 */

int

xfs_refcount_finish_one(

	struct xfs_trans		*tp,

	struct xfs_defer_ops		*dfops,

	enum xfs_refcount_intent_type	type,

	xfs_fsblock_t			startblock,

	xfs_extlen_t			blockcount,

	xfs_fsblock_t			*new_fsb,

	xfs_extlen_t			*new_len,

	struct xfs_btree_cur		**pcur)

{

	struct xfs_mount		*mp = tp->t_mountp;

	struct xfs_btree_cur		*rcur;

	struct xfs_buf			*agbp = NULL;

	int				error = 0;

	xfs_agnumber_t			agno;

	xfs_agblock_t			bno;

	xfs_agblock_t			new_agbno;

	unsigned long			nr_ops = 0;

	int				shape_changes = 0;



	agno = XFS_FSB_TO_AGNO(mp, startblock);

	ASSERT(agno != NULLAGNUMBER);

	bno = XFS_FSB_TO_AGBNO(mp, startblock);



	trace_xfs_refcount_deferred(mp, XFS_FSB_TO_AGNO(mp, startblock),

			type, XFS_FSB_TO_AGBNO(mp, startblock),

			blockcount);



	if (XFS_TEST_ERROR(false, mp,

			XFS_ERRTAG_REFCOUNT_FINISH_ONE,

			XFS_RANDOM_REFCOUNT_FINISH_ONE))

		return -EIO;



	/*

	 * If we haven't gotten a cursor or the cursor AG doesn't match

	 * the startblock, get one now.

	 */

	rcur = *pcur;

	if (rcur != NULL && rcur->bc_private.a.agno != agno) {

		nr_ops = rcur->bc_private.a.priv.refc.nr_ops;

		shape_changes = rcur->bc_private.a.priv.refc.shape_changes;

		xfs_refcount_finish_one_cleanup(tp, rcur, 0);

		rcur = NULL;

		*pcur = NULL;

	}

	if (rcur == NULL) {

		error = xfs_alloc_read_agf(tp->t_mountp, tp, agno,

				XFS_ALLOC_FLAG_FREEING, &agbp);

		if (error)

			return error;

		if (!agbp)

			return -EFSCORRUPTED;



		rcur = xfs_refcountbt_init_cursor(mp, tp, agbp, agno, dfops);

		if (!rcur) {

			error = -ENOMEM;

			goto out_cur;

		}

		rcur->bc_private.a.priv.refc.nr_ops = nr_ops;

		rcur->bc_private.a.priv.refc.shape_changes = shape_changes;

	}

	*pcur = rcur;



	switch (type) {

	case XFS_REFCOUNT_INCREASE:

		error = xfs_refcount_adjust(rcur, bno, blockcount, &new_agbno,

			new_len, XFS_REFCOUNT_ADJUST_INCREASE, dfops, NULL);

		*new_fsb = XFS_AGB_TO_FSB(mp, agno, new_agbno);

		break;

	case XFS_REFCOUNT_DECREASE:

		error = xfs_refcount_adjust(rcur, bno, blockcount, &new_agbno,

			new_len, XFS_REFCOUNT_ADJUST_DECREASE, dfops, NULL);

		*new_fsb = XFS_AGB_TO_FSB(mp, agno, new_agbno);

		break;

	default:

		ASSERT(0);

		error = -EFSCORRUPTED;

	}

	if (!error && *new_len > 0)

		trace_xfs_refcount_finish_one_leftover(mp, agno, type,

				bno, blockcount, new_agbno, *new_len);

	return error;



out_cur:

	xfs_trans_brelse(tp, agbp);



	return error;

}



/*

 * Record a refcount intent for later processing.

 */

static int

__xfs_refcount_add(

	struct xfs_mount		*mp,

	struct xfs_defer_ops		*dfops,

	enum xfs_refcount_intent_type	type,

	xfs_fsblock_t			startblock,

	xfs_extlen_t			blockcount)

{

	struct xfs_refcount_intent	*ri;



	trace_xfs_refcount_defer(mp, XFS_FSB_TO_AGNO(mp, startblock),

			type, XFS_FSB_TO_AGBNO(mp, startblock),

			blockcount);



	ri = kmem_alloc(sizeof(struct xfs_refcount_intent),

			KM_SLEEP | KM_NOFS);

	INIT_LIST_HEAD(&ri->ri_list);

	ri->ri_type = type;

	ri->ri_startblock = startblock;

	ri->ri_blockcount = blockcount;



	xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_REFCOUNT, &ri->ri_list);

	return 0;

}



/*

 * Increase the reference count of the blocks backing a file's extent.

 */

int

xfs_refcount_increase_extent(

	struct xfs_mount		*mp,

	struct xfs_defer_ops		*dfops,

	struct xfs_bmbt_irec		*PREV)

{

	if (!xfs_sb_version_hasreflink(&mp->m_sb))

		return 0;



	return __xfs_refcount_add(mp, dfops, XFS_REFCOUNT_INCREASE,

			PREV->br_startblock, PREV->br_blockcount);

}



/*

 * Decrease the reference count of the blocks backing a file's extent.

 */

int

xfs_refcount_decrease_extent(

	struct xfs_mount		*mp,

	struct xfs_defer_ops		*dfops,

	struct xfs_bmbt_irec		*PREV)

{

	if (!xfs_sb_version_hasreflink(&mp->m_sb))

		return 0;



	return __xfs_refcount_add(mp, dfops, XFS_REFCOUNT_DECREASE,

			PREV->br_startblock, PREV->br_blockcount);

}

fs/xfs/libxfs/xfs_refcount.h

+13 −0
Original line number Diff line number Diff line
@@ -41,4 +41,17 @@ struct xfs_refcount_intent { 
	xfs_extlen_t				ri_blockcount;

};



extern int xfs_refcount_increase_extent(struct xfs_mount *mp,

		struct xfs_defer_ops *dfops, struct xfs_bmbt_irec *irec);

extern int xfs_refcount_decrease_extent(struct xfs_mount *mp,

		struct xfs_defer_ops *dfops, struct xfs_bmbt_irec *irec);



extern void xfs_refcount_finish_one_cleanup(struct xfs_trans *tp,

		struct xfs_btree_cur *rcur, int error);

extern int xfs_refcount_finish_one(struct xfs_trans *tp,

		struct xfs_defer_ops *dfops, enum xfs_refcount_intent_type type,

		xfs_fsblock_t startblock, xfs_extlen_t blockcount,

		xfs_fsblock_t *new_fsb, xfs_extlen_t *new_len,

		struct xfs_btree_cur **pcur);



#endif	/* __XFS_REFCOUNT_H__ */

fs/xfs/xfs_error.h

+3 −1
Original line number Diff line number Diff line
@@ -93,7 +93,8 @@ extern void xfs_verifier_error(struct xfs_buf *bp); 
#define XFS_ERRTAG_FREE_EXTENT				22

#define XFS_ERRTAG_RMAP_FINISH_ONE			23

#define XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE		24

#define XFS_ERRTAG_MAX					25

#define XFS_ERRTAG_REFCOUNT_FINISH_ONE			25

#define XFS_ERRTAG_MAX					26



/*

 * Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -123,6 +124,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp); 
#define XFS_RANDOM_FREE_EXTENT				1

#define XFS_RANDOM_RMAP_FINISH_ONE			1

#define XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE		1

#define XFS_RANDOM_REFCOUNT_FINISH_ONE			1



#ifdef DEBUG

extern int xfs_error_test_active;

fs/xfs/xfs_refcount_item.c

+85 −1
Original line number Diff line number Diff line
@@ -396,9 +396,20 @@ xfs_cui_recover( 
{

	int				i;

	int				error = 0;

	unsigned int			refc_type;

	struct xfs_phys_extent		*refc;

	xfs_fsblock_t			startblock_fsb;

	bool				op_ok;

	struct xfs_cud_log_item		*cudp;

	struct xfs_trans		*tp;

	struct xfs_btree_cur		*rcur = NULL;

	enum xfs_refcount_intent_type	type;

	xfs_fsblock_t			firstfsb;

	xfs_fsblock_t			new_fsb;

	xfs_extlen_t			new_len;

	struct xfs_bmbt_irec		irec;

	struct xfs_defer_ops		dfops;

	bool				requeue_only = false;



	ASSERT(!test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags));
@@ -437,7 +448,80 @@ xfs_cui_recover( 
		}

	}



	/*

	 * Under normal operation, refcount updates are deferred, so we

	 * wouldn't be adding them directly to a transaction.  All

	 * refcount updates manage reservation usage internally and

	 * dynamically by deferring work that won't fit in the

	 * transaction.  Normally, any work that needs to be deferred

	 * gets attached to the same defer_ops that scheduled the

	 * refcount update.  However, we're in log recovery here, so we

	 * we create our own defer_ops and use that to finish up any

	 * work that doesn't fit.

	 */

	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);

	if (error)

		return error;

	cudp = xfs_trans_get_cud(tp, cuip);



	xfs_defer_init(&dfops, &firstfsb);

	for (i = 0; i < cuip->cui_format.cui_nextents; i++) {

		refc = &cuip->cui_format.cui_extents[i];

		refc_type = refc->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK;

		switch (refc_type) {

		case XFS_REFCOUNT_INCREASE:

		case XFS_REFCOUNT_DECREASE:

		case XFS_REFCOUNT_ALLOC_COW:

		case XFS_REFCOUNT_FREE_COW:

			type = refc_type;

			break;

		default:

			error = -EFSCORRUPTED;

			goto abort_error;

		}

		if (requeue_only) {

			new_fsb = refc->pe_startblock;

			new_len = refc->pe_len;

		} else

			error = xfs_trans_log_finish_refcount_update(tp, cudp,

				&dfops, type, refc->pe_startblock, refc->pe_len,

				&new_fsb, &new_len, &rcur);

		if (error)

			goto abort_error;



		/* Requeue what we didn't finish. */

		if (new_len > 0) {

			irec.br_startblock = new_fsb;

			irec.br_blockcount = new_len;

			switch (type) {

			case XFS_REFCOUNT_INCREASE:

				error = xfs_refcount_increase_extent(

						tp->t_mountp, &dfops, &irec);

				break;

			case XFS_REFCOUNT_DECREASE:

				error = xfs_refcount_decrease_extent(

						tp->t_mountp, &dfops, &irec);

				break;

			default:

				ASSERT(0);

			}

			if (error)

				goto abort_error;

			requeue_only = true;

		}

	}



	xfs_refcount_finish_one_cleanup(tp, rcur, error);

	error = xfs_defer_finish(&tp, &dfops, NULL);

	if (error)

		goto abort_error;

	set_bit(XFS_CUI_RECOVERED, &cuip->cui_flags);

	xfs_cui_release(cuip);

	error = xfs_trans_commit(tp);

	return error;



abort_error:

	xfs_refcount_finish_one_cleanup(tp, rcur, error);

	xfs_defer_cancel(&dfops);

	xfs_trans_cancel(tp);

	return error;

}