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

Commit 7bfa31d8 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Alex Elder
Browse files

xfs: give xfs_item_ops methods the correct prototypes 



Stop the function pointer casting madness and give all the xfs_item_ops the
correct prototypes.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
parent 9412e318

fs/xfs/quota/xfs_dquot_item.c

+119 −149
Original line number Diff line number Diff line
@@ -37,18 +37,22 @@ 
#include "xfs_trans_priv.h"

#include "xfs_qm.h"



static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip)

{

	return container_of(lip, struct xfs_dq_logitem, qli_item);

}



/*

 * returns the number of iovecs needed to log the given dquot item.

 */

/* ARGSUSED */

STATIC uint

xfs_qm_dquot_logitem_size(

	xfs_dq_logitem_t	*logitem)

	struct xfs_log_item	*lip)

{

	/*

	 * we need only two iovecs, one for the format, one for the real thing

	 */

	return (2);

	return 2;

}



/*
@@ -56,22 +60,21 @@ xfs_qm_dquot_logitem_size( 
 */

STATIC void

xfs_qm_dquot_logitem_format(

	xfs_dq_logitem_t	*logitem,

	xfs_log_iovec_t		*logvec)

	struct xfs_log_item	*lip,

	struct xfs_log_iovec	*logvec)

{

	ASSERT(logitem);

	ASSERT(logitem->qli_dquot);

	struct xfs_dq_logitem	*qlip = DQUOT_ITEM(lip);



	logvec->i_addr = (xfs_caddr_t)&logitem->qli_format;

	logvec->i_addr = (xfs_caddr_t)&qlip->qli_format;

	logvec->i_len  = sizeof(xfs_dq_logformat_t);

	logvec->i_type = XLOG_REG_TYPE_QFORMAT;

	logvec++;

	logvec->i_addr = (xfs_caddr_t)&logitem->qli_dquot->q_core;

	logvec->i_addr = (xfs_caddr_t)&qlip->qli_dquot->q_core;

	logvec->i_len  = sizeof(xfs_disk_dquot_t);

	logvec->i_type = XLOG_REG_TYPE_DQUOT;



	ASSERT(2 == logitem->qli_item.li_desc->lid_size);

	logitem->qli_format.qlf_size = 2;

	ASSERT(2 == lip->li_desc->lid_size);

	qlip->qli_format.qlf_size = 2;



}
@@ -80,9 +83,9 @@ xfs_qm_dquot_logitem_format( 
 */

STATIC void

xfs_qm_dquot_logitem_pin(

	xfs_dq_logitem_t *logitem)

	struct xfs_log_item	*lip)

{

	xfs_dquot_t *dqp = logitem->qli_dquot;

	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;



	ASSERT(XFS_DQ_IS_LOCKED(dqp));

	atomic_inc(&dqp->q_pincount);
@@ -94,13 +97,12 @@ xfs_qm_dquot_logitem_pin( 
 * dquot must have been previously pinned with a call to

 * xfs_qm_dquot_logitem_pin().

 */

/* ARGSUSED */

STATIC void

xfs_qm_dquot_logitem_unpin(

	xfs_dq_logitem_t	*logitem,

	struct xfs_log_item	*lip,

	int			remove)

{

	xfs_dquot_t *dqp = logitem->qli_dquot;

	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;



	ASSERT(atomic_read(&dqp->q_pincount) > 0);

	if (atomic_dec_and_test(&dqp->q_pincount))
@@ -115,13 +117,11 @@ xfs_qm_dquot_logitem_unpin( 
 */

STATIC void

xfs_qm_dquot_logitem_push(

	xfs_dq_logitem_t	*logitem)

	struct xfs_log_item	*lip)

{

	xfs_dquot_t	*dqp;

	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;

	int			error;



	dqp = logitem->qli_dquot;



	ASSERT(XFS_DQ_IS_LOCKED(dqp));

	ASSERT(!completion_done(&dqp->q_flush));
@@ -142,27 +142,25 @@ xfs_qm_dquot_logitem_push( 
	xfs_dqunlock(dqp);

}



/*ARGSUSED*/

STATIC xfs_lsn_t

xfs_qm_dquot_logitem_committed(

	xfs_dq_logitem_t	*l,

	struct xfs_log_item	*lip,

	xfs_lsn_t		lsn)

{

	/*

	 * We always re-log the entire dquot when it becomes dirty,

	 * so, the latest copy _is_ the only one that matters.

	 */

	return (lsn);

	return lsn;

}





/*

 * This is called to wait for the given dquot to be unpinned.

 * Most of these pin/unpin routines are plagiarized from inode code.

 */

void

xfs_qm_dqunpin_wait(

	xfs_dquot_t	*dqp)

	struct xfs_dquot	*dqp)

{

	ASSERT(XFS_DQ_IS_LOCKED(dqp));

	if (atomic_read(&dqp->q_pincount) == 0)
@@ -188,13 +186,12 @@ xfs_qm_dqunpin_wait( 
 */

STATIC void

xfs_qm_dquot_logitem_pushbuf(

	xfs_dq_logitem_t    *qip)

	struct xfs_log_item	*lip)

{

	xfs_dquot_t	*dqp;

	xfs_mount_t	*mp;

	xfs_buf_t	*bp;

	struct xfs_dq_logitem	*qlip = DQUOT_ITEM(lip);

	struct xfs_dquot	*dqp = qlip->qli_dquot;

	struct xfs_buf		*bp;



	dqp = qip->qli_dquot;

	ASSERT(XFS_DQ_IS_LOCKED(dqp));



	/*
@@ -203,21 +200,19 @@ xfs_qm_dquot_logitem_pushbuf( 
	 * So, just get out.

	 */

	if (completion_done(&dqp->q_flush) ||

	    ((qip->qli_item.li_flags & XFS_LI_IN_AIL) == 0)) {

	    !(lip->li_flags & XFS_LI_IN_AIL)) {

		xfs_dqunlock(dqp);

		return;

	}

	mp = dqp->q_mount;

	bp = xfs_incore(mp->m_ddev_targp, qip->qli_format.qlf_blkno,

			mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK);



	bp = xfs_incore(dqp->q_mount->m_ddev_targp, qlip->qli_format.qlf_blkno,

			dqp->q_mount->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK);

	xfs_dqunlock(dqp);

	if (!bp)

		return;

	if (XFS_BUF_ISDELAYWRITE(bp))

		xfs_buf_delwri_promote(bp);

	xfs_buf_relse(bp);

	return;



}



/*
@@ -232,11 +227,10 @@ xfs_qm_dquot_logitem_pushbuf( 
 */

STATIC uint

xfs_qm_dquot_logitem_trylock(

	xfs_dq_logitem_t	*qip)

	struct xfs_log_item	*lip)

{

	xfs_dquot_t		*dqp;

	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;



	dqp = qip->qli_dquot;

	if (atomic_read(&dqp->q_pincount) > 0)

		return XFS_ITEM_PINNED;
@@ -251,11 +245,10 @@ xfs_qm_dquot_logitem_trylock( 
		return XFS_ITEM_PUSHBUF;

	}



	ASSERT(qip->qli_item.li_flags & XFS_LI_IN_AIL);

	ASSERT(lip->li_flags & XFS_LI_IN_AIL);

	return XFS_ITEM_SUCCESS;

}





/*

 * Unlock the dquot associated with the log item.

 * Clear the fields of the dquot and dquot log item that
@@ -264,12 +257,10 @@ xfs_qm_dquot_logitem_trylock( 
 */

STATIC void

xfs_qm_dquot_logitem_unlock(

	xfs_dq_logitem_t    *ql)

	struct xfs_log_item	*lip)

{

	xfs_dquot_t	*dqp;

	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;



	ASSERT(ql != NULL);

	dqp = ql->qli_dquot;

	ASSERT(XFS_DQ_IS_LOCKED(dqp));



	/*
@@ -286,41 +277,32 @@ xfs_qm_dquot_logitem_unlock( 
	xfs_dqunlock(dqp);

}





/*

 * this needs to stamp an lsn into the dquot, I think.

 * rpc's that look at user dquot's would then have to

 * push on the dependency recorded in the dquot

 */

/* ARGSUSED */

STATIC void

xfs_qm_dquot_logitem_committing(

	xfs_dq_logitem_t	*l,

	struct xfs_log_item	*lip,

	xfs_lsn_t		lsn)

{

	return;

}





/*

 * This is the ops vector for dquots

 */

static struct xfs_item_ops xfs_dquot_item_ops = {

	.iop_size	= (uint(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_size,

	.iop_format	= (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))

					xfs_qm_dquot_logitem_format,

	.iop_pin	= (void(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_pin,

	.iop_unpin	= (void(*)(xfs_log_item_t*, int))xfs_qm_dquot_logitem_unpin,

	.iop_trylock	= (uint(*)(xfs_log_item_t*))

					xfs_qm_dquot_logitem_trylock,

	.iop_unlock	= (void(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_unlock,

	.iop_committed	= (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_qm_dquot_logitem_committed,

	.iop_push	= (void(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_push,

	.iop_pushbuf	= (void(*)(xfs_log_item_t*))

					xfs_qm_dquot_logitem_pushbuf,

	.iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_qm_dquot_logitem_committing

	.iop_size	= xfs_qm_dquot_logitem_size,

	.iop_format	= xfs_qm_dquot_logitem_format,

	.iop_pin	= xfs_qm_dquot_logitem_pin,

	.iop_unpin	= xfs_qm_dquot_logitem_unpin,

	.iop_trylock	= xfs_qm_dquot_logitem_trylock,

	.iop_unlock	= xfs_qm_dquot_logitem_unlock,

	.iop_committed	= xfs_qm_dquot_logitem_committed,

	.iop_push	= xfs_qm_dquot_logitem_push,

	.iop_pushbuf	= xfs_qm_dquot_logitem_pushbuf,

	.iop_committing = xfs_qm_dquot_logitem_committing

};



/*
@@ -332,8 +314,7 @@ void 
xfs_qm_dquot_logitem_init(

	struct xfs_dquot	*dqp)

{

	xfs_dq_logitem_t  *lp;

	lp = &dqp->q_logitem;

	struct xfs_dq_logitem	*lp = &dqp->q_logitem;



	xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT,

					&xfs_dquot_item_ops);
@@ -354,16 +335,22 @@ xfs_qm_dquot_logitem_init( 


/*------------------  QUOTAOFF LOG ITEMS  -------------------*/



static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip)

{

	return container_of(lip, struct xfs_qoff_logitem, qql_item);

}





/*

 * This returns the number of iovecs needed to log the given quotaoff item.

 * We only need 1 iovec for an quotaoff item.  It just logs the

 * quotaoff_log_format structure.

 */

/*ARGSUSED*/

STATIC uint

xfs_qm_qoff_logitem_size(xfs_qoff_logitem_t *qf)

xfs_qm_qoff_logitem_size(

	struct xfs_log_item	*lip)

{

	return (1);

	return 1;

}



/*
@@ -374,46 +361,46 @@ xfs_qm_qoff_logitem_size(xfs_qoff_logitem_t *qf) 
 * slots in the quotaoff item have been filled.

 */

STATIC void

xfs_qm_qoff_logitem_format(xfs_qoff_logitem_t	*qf,

			   xfs_log_iovec_t	*log_vector)

xfs_qm_qoff_logitem_format(

	struct xfs_log_item	*lip,

	struct xfs_log_iovec	*log_vector)

{

	ASSERT(qf->qql_format.qf_type == XFS_LI_QUOTAOFF);

	struct xfs_qoff_logitem	*qflip = QOFF_ITEM(lip);



	ASSERT(qflip->qql_format.qf_type == XFS_LI_QUOTAOFF);



	log_vector->i_addr = (xfs_caddr_t)&(qf->qql_format);

	log_vector->i_addr = (xfs_caddr_t)&(qflip->qql_format);

	log_vector->i_len = sizeof(xfs_qoff_logitem_t);

	log_vector->i_type = XLOG_REG_TYPE_QUOTAOFF;

	qf->qql_format.qf_size = 1;

	qflip->qql_format.qf_size = 1;

}





/*

 * Pinning has no meaning for an quotaoff item, so just return.

 */

/*ARGSUSED*/

STATIC void

xfs_qm_qoff_logitem_pin(xfs_qoff_logitem_t *qf)

xfs_qm_qoff_logitem_pin(

	struct xfs_log_item	*lip)

{

	return;

}





/*

 * Since pinning has no meaning for an quotaoff item, unpinning does

 * not either.

 */

/*ARGSUSED*/

STATIC void

xfs_qm_qoff_logitem_unpin(xfs_qoff_logitem_t *qf, int remove)

xfs_qm_qoff_logitem_unpin(

	struct xfs_log_item	*lip,

	int			remove)

{

	return;

}



/*

 * Quotaoff items have no locking, so just return success.

 */

/*ARGSUSED*/

STATIC uint

xfs_qm_qoff_logitem_trylock(xfs_qoff_logitem_t *qf)

xfs_qm_qoff_logitem_trylock(

	struct xfs_log_item	*lip)

{

	return XFS_ITEM_LOCKED;

}
@@ -422,53 +409,51 @@ xfs_qm_qoff_logitem_trylock(xfs_qoff_logitem_t *qf) 
 * Quotaoff items have no locking or pushing, so return failure

 * so that the caller doesn't bother with us.

 */

/*ARGSUSED*/

STATIC void

xfs_qm_qoff_logitem_unlock(xfs_qoff_logitem_t *qf)

xfs_qm_qoff_logitem_unlock(

	struct xfs_log_item	*lip)

{

	return;

}



/*

 * The quotaoff-start-item is logged only once and cannot be moved in the log,

 * so simply return the lsn at which it's been logged.

 */

/*ARGSUSED*/

STATIC xfs_lsn_t

xfs_qm_qoff_logitem_committed(xfs_qoff_logitem_t *qf, xfs_lsn_t lsn)

xfs_qm_qoff_logitem_committed(

	struct xfs_log_item	*lip,

	xfs_lsn_t		lsn)

{

	return (lsn);

	return lsn;

}



/*

 * There isn't much you can do to push on an quotaoff item.  It is simply

 * stuck waiting for the log to be flushed to disk.

 */

/*ARGSUSED*/

STATIC void

xfs_qm_qoff_logitem_push(xfs_qoff_logitem_t *qf)

xfs_qm_qoff_logitem_push(

	struct xfs_log_item	*lip)

{

	return;

}





/*ARGSUSED*/

STATIC xfs_lsn_t

xfs_qm_qoffend_logitem_committed(

	xfs_qoff_logitem_t *qfe,

	struct xfs_log_item	*lip,

	xfs_lsn_t		lsn)

{

	xfs_qoff_logitem_t	*qfs;

	struct xfs_ail		*ailp;

	struct xfs_qoff_logitem	*qfe = QOFF_ITEM(lip);

	struct xfs_qoff_logitem	*qfs = qfe->qql_start_lip;

	struct xfs_ail		*ailp = qfs->qql_item.li_ailp;



	qfs = qfe->qql_start_lip;

	ailp = qfs->qql_item.li_ailp;

	spin_lock(&ailp->xa_lock);

	/*

	 * Delete the qoff-start logitem from the AIL.

	 * xfs_trans_ail_delete() drops the AIL lock.

	 */

	spin_lock(&ailp->xa_lock);

	xfs_trans_ail_delete(ailp, (xfs_log_item_t *)qfs);



	kmem_free(qfs);

	kmem_free(qfe);

	return (xfs_lsn_t)-1;
@@ -488,67 +473,52 @@ xfs_qm_qoffend_logitem_committed( 
 * (truly makes the quotaoff irrevocable).  If we do something else,

 * then maybe we don't need two.

 */

/* ARGSUSED */

STATIC void

xfs_qm_qoff_logitem_committing(xfs_qoff_logitem_t *qip, xfs_lsn_t commit_lsn)

{

	return;

}



/* ARGSUSED */

STATIC void

xfs_qm_qoffend_logitem_committing(xfs_qoff_logitem_t *qip, xfs_lsn_t commit_lsn)

xfs_qm_qoff_logitem_committing(

	struct xfs_log_item	*lip,

	xfs_lsn_t		commit_lsn)

{

	return;

}



static struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {

	.iop_size	= (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_size,

	.iop_format	= (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))

					xfs_qm_qoff_logitem_format,

	.iop_pin	= (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_pin,

	.iop_unpin	= (void(*)(xfs_log_item_t*, int))xfs_qm_qoff_logitem_unpin,

	.iop_trylock	= (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_trylock,

	.iop_unlock	= (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_unlock,

	.iop_committed	= (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_qm_qoffend_logitem_committed,

	.iop_push	= (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_push,

	.iop_pushbuf	= NULL,

	.iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_qm_qoffend_logitem_committing

	.iop_size	= xfs_qm_qoff_logitem_size,

	.iop_format	= xfs_qm_qoff_logitem_format,

	.iop_pin	= xfs_qm_qoff_logitem_pin,

	.iop_unpin	= xfs_qm_qoff_logitem_unpin,

	.iop_trylock	= xfs_qm_qoff_logitem_trylock,

	.iop_unlock	= xfs_qm_qoff_logitem_unlock,

	.iop_committed	= xfs_qm_qoffend_logitem_committed,

	.iop_push	= xfs_qm_qoff_logitem_push,

	.iop_committing = xfs_qm_qoff_logitem_committing

};



/*

 * This is the ops vector shared by all quotaoff-start log items.

 */

static struct xfs_item_ops xfs_qm_qoff_logitem_ops = {

	.iop_size	= (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_size,

	.iop_format	= (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))

					xfs_qm_qoff_logitem_format,

	.iop_pin	= (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_pin,

	.iop_unpin	= (void(*)(xfs_log_item_t*, int))xfs_qm_qoff_logitem_unpin,

	.iop_trylock	= (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_trylock,

	.iop_unlock	= (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_unlock,

	.iop_committed	= (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_qm_qoff_logitem_committed,

	.iop_push	= (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_push,

	.iop_pushbuf	= NULL,

	.iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_qm_qoff_logitem_committing

	.iop_size	= xfs_qm_qoff_logitem_size,

	.iop_format	= xfs_qm_qoff_logitem_format,

	.iop_pin	= xfs_qm_qoff_logitem_pin,

	.iop_unpin	= xfs_qm_qoff_logitem_unpin,

	.iop_trylock	= xfs_qm_qoff_logitem_trylock,

	.iop_unlock	= xfs_qm_qoff_logitem_unlock,

	.iop_committed	= xfs_qm_qoff_logitem_committed,

	.iop_push	= xfs_qm_qoff_logitem_push,

	.iop_committing = xfs_qm_qoff_logitem_committing

};



/*

 * Allocate and initialize an quotaoff item of the correct quota type(s).

 */

xfs_qoff_logitem_t *

struct xfs_qoff_logitem *

xfs_qm_qoff_logitem_init(

	struct xfs_mount	*mp,

	xfs_qoff_logitem_t *start,

	struct xfs_qoff_logitem	*start,

	uint			flags)

{

	xfs_qoff_logitem_t	*qf;

	struct xfs_qoff_logitem	*qf;



	qf = (xfs_qoff_logitem_t*) kmem_zalloc(sizeof(xfs_qoff_logitem_t), KM_SLEEP);

	qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), KM_SLEEP);



	xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ?

			&xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops);
@@ -556,5 +526,5 @@ xfs_qm_qoff_logitem_init( 
	qf->qql_format.qf_type = XFS_LI_QUOTAOFF;

	qf->qql_format.qf_flags = flags;

	qf->qql_start_lip = start;

	return (qf);

	return qf;

}

fs/xfs/xfs_buf_item.c

+66 −63
Original line number Diff line number Diff line
@@ -33,6 +33,12 @@ 


kmem_zone_t	*xfs_buf_item_zone;



static inline struct xfs_buf_log_item *BUF_ITEM(struct xfs_log_item *lip)

{

	return container_of(lip, struct xfs_buf_log_item, bli_item);

}





#ifdef XFS_TRANS_DEBUG

/*

 * This function uses an alternate strategy for tracking the bytes
@@ -150,12 +156,13 @@ STATIC void xfs_buf_do_callbacks(xfs_buf_t *bp, xfs_log_item_t *lip); 
 */

STATIC uint

xfs_buf_item_size(

	xfs_buf_log_item_t	*bip)

	struct xfs_log_item	*lip)

{

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf		*bp = bip->bli_buf;

	uint			nvecs;

	int			next_bit;

	int			last_bit;

	xfs_buf_t	*bp;



	ASSERT(atomic_read(&bip->bli_refcount) > 0);

	if (bip->bli_flags & XFS_BLI_STALE) {
@@ -169,7 +176,6 @@ xfs_buf_item_size( 
		return 1;

	}



	bp = bip->bli_buf;

	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);

	nvecs = 1;

	last_bit = xfs_next_bit(bip->bli_format.blf_data_map,
@@ -218,13 +224,13 @@ xfs_buf_item_size( 
 */

STATIC void

xfs_buf_item_format(

	xfs_buf_log_item_t	*bip,

	xfs_log_iovec_t		*log_vector)

	struct xfs_log_item	*lip,

	struct xfs_log_iovec	*vecp)

{

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf	*bp = bip->bli_buf;

	uint		base_size;

	uint		nvecs;

	xfs_log_iovec_t	*vecp;

	xfs_buf_t	*bp;

	int		first_bit;

	int		last_bit;

	int		next_bit;
@@ -234,8 +240,6 @@ xfs_buf_item_format( 
	ASSERT(atomic_read(&bip->bli_refcount) > 0);

	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||

	       (bip->bli_flags & XFS_BLI_STALE));

	bp = bip->bli_buf;

	vecp = log_vector;



	/*

	 * The size of the base structure is the size of the
@@ -262,7 +266,7 @@ xfs_buf_item_format( 
	 */

	if (bip->bli_flags & XFS_BLI_INODE_BUF) {

		if (!((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&

		      xfs_log_item_in_current_chkpt(&bip->bli_item)))

		      xfs_log_item_in_current_chkpt(lip)))

			bip->bli_format.blf_flags |= XFS_BLF_INODE_BUF;

		bip->bli_flags &= ~XFS_BLI_INODE_BUF;

	}
@@ -365,21 +369,20 @@ xfs_buf_item_format( 


STATIC void

xfs_buf_item_pin(

	xfs_buf_log_item_t	*bip)

	struct xfs_log_item	*lip)

{

	xfs_buf_t	*bp;

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);



	bp = bip->bli_buf;

	ASSERT(XFS_BUF_ISBUSY(bp));

	ASSERT(XFS_BUF_ISBUSY(bip->bli_buf));

	ASSERT(atomic_read(&bip->bli_refcount) > 0);

	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||

	       (bip->bli_flags & XFS_BLI_STALE));



	atomic_inc(&bip->bli_refcount);

	trace_xfs_buf_item_pin(bip);

	xfs_bpin(bp);

	xfs_bpin(bip->bli_buf);

}





/*

 * This is called to unpin the buffer associated with the buf log

 * item which was previously pinned with a call to xfs_buf_item_pin().
@@ -396,13 +399,14 @@ xfs_buf_item_pin( 
 */

STATIC void

xfs_buf_item_unpin(

	xfs_buf_log_item_t	*bip,

	struct xfs_log_item	*lip,

	int			remove)

{

	struct xfs_ail	*ailp;

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	xfs_buf_t	*bp = bip->bli_buf;

	int		freed;

	struct xfs_ail	*ailp = lip->li_ailp;

	int		stale = bip->bli_flags & XFS_BLI_STALE;

	int		freed;



	ASSERT(XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *) == bip);

	ASSERT(atomic_read(&bip->bli_refcount) > 0);
@@ -410,8 +414,8 @@ xfs_buf_item_unpin( 
	trace_xfs_buf_item_unpin(bip);



	freed = atomic_dec_and_test(&bip->bli_refcount);

	ailp = bip->bli_item.li_ailp;

	xfs_bunpin(bp);



	if (freed && stale) {

		ASSERT(bip->bli_flags & XFS_BLI_STALE);

		ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
@@ -429,7 +433,7 @@ xfs_buf_item_unpin( 
			 * in xfs_trans_uncommit() will ry to reference the

			 * buffer which we no longer have a hold on.

			 */

			xfs_trans_del_item(&bip->bli_item);

			xfs_trans_del_item(lip);



			/*

			 * Since the transaction no longer refers to the buffer,
@@ -468,11 +472,11 @@ xfs_buf_item_unpin( 
 */

STATIC uint

xfs_buf_item_trylock(

	xfs_buf_log_item_t	*bip)

	struct xfs_log_item	*lip)

{

	xfs_buf_t	*bp;

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf		*bp = bip->bli_buf;



	bp = bip->bli_buf;

	if (XFS_BUF_ISPINNED(bp))

		return XFS_ITEM_PINNED;

	if (!XFS_BUF_CPSEMA(bp))
@@ -509,14 +513,13 @@ xfs_buf_item_trylock( 
 */

STATIC void

xfs_buf_item_unlock(

	xfs_buf_log_item_t	*bip)

	struct xfs_log_item	*lip)

{

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf		*bp = bip->bli_buf;

	int			aborted;

	xfs_buf_t	*bp;

	uint			hold;



	bp = bip->bli_buf;



	/* Clear the buffer's association with this transaction. */

	XFS_BUF_SET_FSPRIVATE2(bp, NULL);
@@ -526,7 +529,7 @@ xfs_buf_item_unlock( 
	 * (cancelled) buffers at unpin time, but we'll never go through the

	 * pin/unpin cycle if we abort inside commit.

	 */

	aborted = (bip->bli_item.li_flags & XFS_LI_ABORTED) != 0;

	aborted = (lip->li_flags & XFS_LI_ABORTED) != 0;



	/*

	 * Before possibly freeing the buf item, determine if we should
@@ -587,16 +590,16 @@ xfs_buf_item_unlock( 
 */

STATIC xfs_lsn_t

xfs_buf_item_committed(

	xfs_buf_log_item_t	*bip,

	struct xfs_log_item	*lip,

	xfs_lsn_t		lsn)

{

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);



	trace_xfs_buf_item_committed(bip);



	if ((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&

	    (bip->bli_item.li_lsn != 0)) {

		return bip->bli_item.li_lsn;

	}

	return (lsn);

	if ((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) && lip->li_lsn != 0)

		return lip->li_lsn;

	return lsn;

}



/*
@@ -606,15 +609,16 @@ xfs_buf_item_committed( 
 */

STATIC void

xfs_buf_item_push(

	xfs_buf_log_item_t	*bip)

	struct xfs_log_item	*lip)

{

	xfs_buf_t	*bp;

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf		*bp = bip->bli_buf;



	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));

	ASSERT(!XFS_BUF_ISDELAYWRITE(bp));



	trace_xfs_buf_item_push(bip);



	bp = bip->bli_buf;

	ASSERT(!XFS_BUF_ISDELAYWRITE(bp));

	xfs_buf_relse(bp);

}
@@ -626,22 +630,24 @@ xfs_buf_item_push( 
 */

STATIC void

xfs_buf_item_pushbuf(

	xfs_buf_log_item_t	*bip)

	struct xfs_log_item	*lip)

{

	xfs_buf_t	*bp;

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf		*bp = bip->bli_buf;



	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));

	ASSERT(XFS_BUF_ISDELAYWRITE(bp));



	trace_xfs_buf_item_pushbuf(bip);



	bp = bip->bli_buf;

	ASSERT(XFS_BUF_ISDELAYWRITE(bp));

	xfs_buf_delwri_promote(bp);

	xfs_buf_relse(bp);

}



/* ARGSUSED */

STATIC void

xfs_buf_item_committing(xfs_buf_log_item_t *bip, xfs_lsn_t commit_lsn)

xfs_buf_item_committing(

	struct xfs_log_item	*lip,

	xfs_lsn_t		commit_lsn)

{

}
@@ -649,19 +655,16 @@ xfs_buf_item_committing(xfs_buf_log_item_t *bip, xfs_lsn_t commit_lsn) 
 * This is the ops vector shared by all buf log items.

 */

static struct xfs_item_ops xfs_buf_item_ops = {

	.iop_size	= (uint(*)(xfs_log_item_t*))xfs_buf_item_size,

	.iop_format	= (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))

					xfs_buf_item_format,

	.iop_pin	= (void(*)(xfs_log_item_t*))xfs_buf_item_pin,

	.iop_unpin	= (void(*)(xfs_log_item_t*, int))xfs_buf_item_unpin,

	.iop_trylock	= (uint(*)(xfs_log_item_t*))xfs_buf_item_trylock,

	.iop_unlock	= (void(*)(xfs_log_item_t*))xfs_buf_item_unlock,

	.iop_committed	= (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_buf_item_committed,

	.iop_push	= (void(*)(xfs_log_item_t*))xfs_buf_item_push,

	.iop_pushbuf	= (void(*)(xfs_log_item_t*))xfs_buf_item_pushbuf,

	.iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))

					xfs_buf_item_committing

	.iop_size	= xfs_buf_item_size,

	.iop_format	= xfs_buf_item_format,

	.iop_pin	= xfs_buf_item_pin,

	.iop_unpin	= xfs_buf_item_unpin,

	.iop_trylock	= xfs_buf_item_trylock,

	.iop_unlock	= xfs_buf_item_unlock,

	.iop_committed	= xfs_buf_item_committed,

	.iop_push	= xfs_buf_item_push,

	.iop_pushbuf	= xfs_buf_item_pushbuf,

	.iop_committing = xfs_buf_item_committing

};

fs/xfs/xfs_extfree_item.c

+110 −116

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/xfs_inode_item.c

+65 −76

File changed.

Preview size limit exceeded, changes collapsed.