[mirror_ubuntu-zesty-kernel.git] / fs / xfs / xfs_dquot_item.c

/*
 * Copyright (c) 2000-2003 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_quota.h"
#include "xfs_error.h"
#include "xfs_trans.h"
#include "xfs_buf_item.h"
#include "xfs_trans_priv.h"
#include "xfs_qm.h"
#include "xfs_log.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.
 */
STATIC void
xfs_qm_dquot_logitem_size(
	struct xfs_log_item	*lip,
	int			*nvecs,
	int			*nbytes)
{
	*nvecs += 2;
	*nbytes += sizeof(struct xfs_dq_logformat) +
		   sizeof(struct xfs_disk_dquot);
}

/*
 * fills in the vector of log iovecs for the given dquot log item.
 */
STATIC void
xfs_qm_dquot_logitem_format(
	struct xfs_log_item	*lip,
	struct xfs_log_vec	*lv)
{
	struct xfs_dq_logitem	*qlip = DQUOT_ITEM(lip);
	struct xfs_log_iovec	*vecp = NULL;
	struct xfs_dq_logformat	*qlf;

	qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QFORMAT);
	qlf->qlf_type = XFS_LI_DQUOT;
	qlf->qlf_size = 2;
	qlf->qlf_id = be32_to_cpu(qlip->qli_dquot->q_core.d_id);
	qlf->qlf_blkno = qlip->qli_dquot->q_blkno;
	qlf->qlf_len = 1;
	qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset;
	xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat));

	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT,
			&qlip->qli_dquot->q_core,
			sizeof(struct xfs_disk_dquot));
}

/*
 * Increment the pin count of the given dquot.
 */
STATIC void
xfs_qm_dquot_logitem_pin(
	struct xfs_log_item	*lip)
{
	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;

	ASSERT(XFS_DQ_IS_LOCKED(dqp));
	atomic_inc(&dqp->q_pincount);
}

/*
 * Decrement the pin count of the given dquot, and wake up
 * anyone in xfs_dqwait_unpin() if the count goes to 0.	 The
 * dquot must have been previously pinned with a call to
 * xfs_qm_dquot_logitem_pin().
 */
STATIC void
xfs_qm_dquot_logitem_unpin(
	struct xfs_log_item	*lip,
	int			remove)
{
	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;

	ASSERT(atomic_read(&dqp->q_pincount) > 0);
	if (atomic_dec_and_test(&dqp->q_pincount))
		wake_up(&dqp->q_pinwait);
}

STATIC xfs_lsn_t
xfs_qm_dquot_logitem_committed(
	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;
}

/*
 * 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(
	struct xfs_dquot	*dqp)
{
	ASSERT(XFS_DQ_IS_LOCKED(dqp));
	if (atomic_read(&dqp->q_pincount) == 0)
		return;

	/*
	 * Give the log a push so we don't wait here too long.
	 */
	xfs_log_force(dqp->q_mount, 0);
	wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0));
}

STATIC uint
xfs_qm_dquot_logitem_push(
	struct xfs_log_item	*lip,
	struct list_head	*buffer_list) __releases(&lip->li_ailp->xa_lock)
					      __acquires(&lip->li_ailp->xa_lock)
{
	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;
	struct xfs_buf		*bp = NULL;
	uint			rval = XFS_ITEM_SUCCESS;
	int			error;

	if (atomic_read(&dqp->q_pincount) > 0)
		return XFS_ITEM_PINNED;

	if (!xfs_dqlock_nowait(dqp))
		return XFS_ITEM_LOCKED;

	/*
	 * Re-check the pincount now that we stabilized the value by
	 * taking the quota lock.
	 */
	if (atomic_read(&dqp->q_pincount) > 0) {
		rval = XFS_ITEM_PINNED;
		goto out_unlock;
	}

	/*
	 * Someone else is already flushing the dquot.  Nothing we can do
	 * here but wait for the flush to finish and remove the item from
	 * the AIL.
	 */
	if (!xfs_dqflock_nowait(dqp)) {
		rval = XFS_ITEM_FLUSHING;
		goto out_unlock;
	}

	spin_unlock(&lip->li_ailp->xa_lock);

	error = xfs_qm_dqflush(dqp, &bp);
	if (error) {
		xfs_warn(dqp->q_mount, "%s: push error %d on dqp %p",
			__func__, error, dqp);
	} else {
		if (!xfs_buf_delwri_queue(bp, buffer_list))
			rval = XFS_ITEM_FLUSHING;
		xfs_buf_relse(bp);
	}

	spin_lock(&lip->li_ailp->xa_lock);
out_unlock:
	xfs_dqunlock(dqp);
	return rval;
}

/*
 * Unlock the dquot associated with the log item.
 * Clear the fields of the dquot and dquot log item that
 * are specific to the current transaction.  If the
 * hold flags is set, do not unlock the dquot.
 */
STATIC void
xfs_qm_dquot_logitem_unlock(
	struct xfs_log_item	*lip)
{
	struct xfs_dquot	*dqp = DQUOT_ITEM(lip)->qli_dquot;

	ASSERT(XFS_DQ_IS_LOCKED(dqp));

	/*
	 * Clear the transaction pointer in the dquot
	 */
	dqp->q_transp = NULL;

	/*
	 * dquots are never 'held' from getting unlocked at the end of
	 * a transaction.  Their locking and unlocking is hidden inside the
	 * transaction layer, within trans_commit. Hence, no LI_HOLD flag
	 * for the logitem.
	 */
	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
 */
STATIC void
xfs_qm_dquot_logitem_committing(
	struct xfs_log_item	*lip,
	xfs_lsn_t		lsn)
{
}

/*
 * This is the ops vector for dquots
 */
static const struct xfs_item_ops xfs_dquot_item_ops = {
	.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_unlock	= xfs_qm_dquot_logitem_unlock,
	.iop_committed	= xfs_qm_dquot_logitem_committed,
	.iop_push	= xfs_qm_dquot_logitem_push,
	.iop_committing = xfs_qm_dquot_logitem_committing
};

/*
 * Initialize the dquot log item for a newly allocated dquot.
 * The dquot isn't locked at this point, but it isn't on any of the lists
 * either, so we don't care.
 */
void
xfs_qm_dquot_logitem_init(
	struct xfs_dquot	*dqp)
{
	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);
	lp->qli_dquot = dqp;
}

/*------------------  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.
 */
STATIC void
xfs_qm_qoff_logitem_size(
	struct xfs_log_item	*lip,
	int			*nvecs,
	int			*nbytes)
{
	*nvecs += 1;
	*nbytes += sizeof(struct xfs_qoff_logitem);
}

STATIC void
xfs_qm_qoff_logitem_format(
	struct xfs_log_item	*lip,
	struct xfs_log_vec	*lv)
{
	struct xfs_qoff_logitem	*qflip = QOFF_ITEM(lip);
	struct xfs_log_iovec	*vecp = NULL;
	struct xfs_qoff_logformat *qlf;

	qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QUOTAOFF);
	qlf->qf_type = XFS_LI_QUOTAOFF;
	qlf->qf_size = 1;
	qlf->qf_flags = qflip->qql_flags;
	xlog_finish_iovec(lv, vecp, sizeof(struct xfs_qoff_logitem));
}

/*
 * Pinning has no meaning for an quotaoff item, so just return.
 */
STATIC void
xfs_qm_qoff_logitem_pin(
	struct xfs_log_item	*lip)
{
}

/*
 * Since pinning has no meaning for an quotaoff item, unpinning does
 * not either.
 */
STATIC void
xfs_qm_qoff_logitem_unpin(
	struct xfs_log_item	*lip,
	int			remove)
{
}

/*
 * There isn't much you can do to push a quotaoff item.  It is simply
 * stuck waiting for the log to be flushed to disk.
 */
STATIC uint
xfs_qm_qoff_logitem_push(
	struct xfs_log_item	*lip,
	struct list_head	*buffer_list)
{
	return XFS_ITEM_LOCKED;
}

/*
 * Quotaoff items have no locking or pushing, so return failure
 * so that the caller doesn't bother with us.
 */
STATIC void
xfs_qm_qoff_logitem_unlock(
	struct xfs_log_item	*lip)
{
}

/*
 * 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.
 */
STATIC xfs_lsn_t
xfs_qm_qoff_logitem_committed(
	struct xfs_log_item	*lip,
	xfs_lsn_t		lsn)
{
	return lsn;
}

STATIC xfs_lsn_t
xfs_qm_qoffend_logitem_committed(
	struct xfs_log_item	*lip,
	xfs_lsn_t		lsn)
{
	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;

	/*
	 * 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, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR);

	kmem_free(qfs);
	kmem_free(qfe);
	return (xfs_lsn_t)-1;
}

/*
 * XXX rcc - don't know quite what to do with this.  I think we can
 * just ignore it.  The only time that isn't the case is if we allow
 * the client to somehow see that quotas have been turned off in which
 * we can't allow that to get back until the quotaoff hits the disk.
 * So how would that happen?  Also, do we need different routines for
 * quotaoff start and quotaoff end?  I suspect the answer is yes but
 * to be sure, I need to look at the recovery code and see how quota off
 * recovery is handled (do we roll forward or back or do something else).
 * If we roll forwards or backwards, then we need two separate routines,
 * one that does nothing and one that stamps in the lsn that matters
 * (truly makes the quotaoff irrevocable).  If we do something else,
 * then maybe we don't need two.
 */
STATIC void
xfs_qm_qoff_logitem_committing(
	struct xfs_log_item	*lip,
	xfs_lsn_t		commit_lsn)
{
}

static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
	.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_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 const struct xfs_item_ops xfs_qm_qoff_logitem_ops = {
	.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_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).
 */
struct xfs_qoff_logitem *
xfs_qm_qoff_logitem_init(
	struct xfs_mount	*mp,
	struct xfs_qoff_logitem	*start,
	uint			flags)
{
	struct xfs_qoff_logitem	*qf;

	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);
	qf->qql_item.li_mountp = mp;
	qf->qql_start_lip = start;
	qf->qql_flags = flags;
	return qf;
}
Commit	Line	Data
1da177e4	1	/*
4ce3121f NS	2	* Copyright (c) 2000-2003 Silicon Graphics, Inc.
4ce3121f NS	3	* All Rights Reserved.
1da177e4	4	*
4ce3121f NS	5	* This program is free software; you can redistribute it and/or
4ce3121f NS	6	* modify it under the terms of the GNU General Public License as
1da177e4 LT	7	* published by the Free Software Foundation.
1da177e4 LT	8	*
4ce3121f NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
1da177e4	13	*
4ce3121f NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4	17	*/
1da177e4 LT	18	#include "xfs.h"
1da177e4 LT	19	#include "xfs_fs.h"
6ca1c906	20	#include "xfs_format.h"
239880ef DC	21	#include "xfs_log_format.h"
239880ef DC	22	#include "xfs_trans_resv.h"
1da177e4 LT	23	#include "xfs_sb.h"
1da177e4 LT	24	#include "xfs_ag.h"
1da177e4	25	#include "xfs_mount.h"
1da177e4	26	#include "xfs_inode.h"
a4fbe6ab	27	#include "xfs_quota.h"
1da177e4	28	#include "xfs_error.h"
239880ef	29	#include "xfs_trans.h"
1da177e4 LT	30	#include "xfs_buf_item.h"
1da177e4 LT	31	#include "xfs_trans_priv.h"
1da177e4	32	#include "xfs_qm.h"
239880ef	33	#include "xfs_log.h"
1da177e4	34
7bfa31d8 CH	35	static inline struct xfs_dq_logitem DQUOT_ITEM(struct xfs_log_item lip)
	36	{
	37	return container_of(lip, struct xfs_dq_logitem, qli_item);
	38	}
	39
1da177e4 LT	40	/*
	41	* returns the number of iovecs needed to log the given dquot item.
	42	*/
166d1368	43	STATIC void
1da177e4	44	xfs_qm_dquot_logitem_size(
166d1368 DC	45	struct xfs_log_item *lip,
	46	int *nvecs,
	47	int *nbytes)
1da177e4	48	{
166d1368 DC	49	*nvecs += 2;
	50	*nbytes += sizeof(struct xfs_dq_logformat) +
	51	sizeof(struct xfs_disk_dquot);
1da177e4 LT	52	}
	53
	54	/*
	55	* fills in the vector of log iovecs for the given dquot log item.
	56	*/
	57	STATIC void
	58	xfs_qm_dquot_logitem_format(
7bfa31d8	59	struct xfs_log_item *lip,
bde7cff6	60	struct xfs_log_vec *lv)
1da177e4	61	{
7bfa31d8	62	struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip);
bde7cff6	63	struct xfs_log_iovec *vecp = NULL;
ce8e9629	64	struct xfs_dq_logformat *qlf;
1da177e4	65
ce8e9629 CH	66	qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QFORMAT);
	67	qlf->qlf_type = XFS_LI_DQUOT;
	68	qlf->qlf_size = 2;
	69	qlf->qlf_id = be32_to_cpu(qlip->qli_dquot->q_core.d_id);
	70	qlf->qlf_blkno = qlip->qli_dquot->q_blkno;
	71	qlf->qlf_len = 1;
	72	qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset;
	73	xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat));
bde7cff6	74
bde7cff6	75	xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT,
1234351c CH	76	&qlip->qli_dquot->q_core,
1234351c CH	77	sizeof(struct xfs_disk_dquot));
1da177e4 LT	78	}
	79
	80	/*
	81	* Increment the pin count of the given dquot.
1da177e4 LT	82	*/
	83	STATIC void
	84	xfs_qm_dquot_logitem_pin(
7bfa31d8	85	struct xfs_log_item *lip)
1da177e4	86	{
7bfa31d8	87	struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot;
1da177e4	88
1da177e4	89	ASSERT(XFS_DQ_IS_LOCKED(dqp));
d1de8021	90	atomic_inc(&dqp->q_pincount);
1da177e4 LT	91	}
	92
	93	/*
	94	* Decrement the pin count of the given dquot, and wake up
	95	* anyone in xfs_dqwait_unpin() if the count goes to 0. The
bc3048e3 PL	96	* dquot must have been previously pinned with a call to
bc3048e3 PL	97	* xfs_qm_dquot_logitem_pin().
1da177e4	98	*/
1da177e4 LT	99	STATIC void
1da177e4 LT	100	xfs_qm_dquot_logitem_unpin(
7bfa31d8	101	struct xfs_log_item *lip,
9412e318	102	int remove)
1da177e4	103	{
7bfa31d8	104	struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot;
1da177e4	105
bc3048e3 PL	106	ASSERT(atomic_read(&dqp->q_pincount) > 0);
	107	if (atomic_dec_and_test(&dqp->q_pincount))
	108	wake_up(&dqp->q_pinwait);
1da177e4 LT	109	}
1da177e4 LT	110
1da177e4 LT	111	STATIC xfs_lsn_t
1da177e4 LT	112	xfs_qm_dquot_logitem_committed(
7bfa31d8	113	struct xfs_log_item *lip,
1da177e4 LT	114	xfs_lsn_t lsn)
	115	{
	116	/*
	117	* We always re-log the entire dquot when it becomes dirty,
	118	* so, the latest copy _is_ the only one that matters.
	119	*/
7bfa31d8	120	return lsn;
1da177e4 LT	121	}
1da177e4 LT	122
1da177e4 LT	123	/*
	124	* This is called to wait for the given dquot to be unpinned.
	125	* Most of these pin/unpin routines are plagiarized from inode code.
	126	*/
	127	void
	128	xfs_qm_dqunpin_wait(
7bfa31d8	129	struct xfs_dquot *dqp)
1da177e4	130	{
1da177e4	131	ASSERT(XFS_DQ_IS_LOCKED(dqp));
bc3048e3	132	if (atomic_read(&dqp->q_pincount) == 0)
1da177e4	133	return;
1da177e4 LT	134
	135	/*
	136	* Give the log a push so we don't wait here too long.
	137	*/
a14a348b	138	xfs_log_force(dqp->q_mount, 0);
bc3048e3	139	wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0));
1da177e4 LT	140	}
1da177e4 LT	141
1da177e4	142	STATIC uint
43ff2122 CH	143	xfs_qm_dquot_logitem_push(
43ff2122 CH	144	struct xfs_log_item *lip,
a30b0367 DC	145	struct list_head *buffer_list) __releases(&lip->li_ailp->xa_lock)
a30b0367 DC	146	__acquires(&lip->li_ailp->xa_lock)
1da177e4	147	{
7bfa31d8	148	struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot;
43ff2122 CH	149	struct xfs_buf *bp = NULL;
	150	uint rval = XFS_ITEM_SUCCESS;
	151	int error;
1da177e4	152
bc3048e3	153	if (atomic_read(&dqp->q_pincount) > 0)
d808f617	154	return XFS_ITEM_PINNED;
1da177e4	155
800b484e	156	if (!xfs_dqlock_nowait(dqp))
d808f617	157	return XFS_ITEM_LOCKED;
1da177e4	158
fe7257fd CH	159	/*
	160	* Re-check the pincount now that we stabilized the value by
	161	* taking the quota lock.
	162	*/
	163	if (atomic_read(&dqp->q_pincount) > 0) {
43ff2122 CH	164	rval = XFS_ITEM_PINNED;
43ff2122 CH	165	goto out_unlock;
fe7257fd CH	166	}
fe7257fd CH	167
43ff2122 CH	168	/*
	169	* Someone else is already flushing the dquot. Nothing we can do
	170	* here but wait for the flush to finish and remove the item from
	171	* the AIL.
	172	*/
e1f49cf2	173	if (!xfs_dqflock_nowait(dqp)) {
43ff2122 CH	174	rval = XFS_ITEM_FLUSHING;
	175	goto out_unlock;
	176	}
	177
	178	spin_unlock(&lip->li_ailp->xa_lock);
	179
	180	error = xfs_qm_dqflush(dqp, &bp);
	181	if (error) {
	182	xfs_warn(dqp->q_mount, "%s: push error %d on dqp %p",
	183	__func__, error, dqp);
	184	} else {
	185	if (!xfs_buf_delwri_queue(bp, buffer_list))
	186	rval = XFS_ITEM_FLUSHING;
	187	xfs_buf_relse(bp);
1da177e4 LT	188	}
1da177e4 LT	189
43ff2122 CH	190	spin_lock(&lip->li_ailp->xa_lock);
	191	out_unlock:
	192	xfs_dqunlock(dqp);
	193	return rval;
1da177e4 LT	194	}
1da177e4 LT	195
1da177e4 LT	196	/*
	197	* Unlock the dquot associated with the log item.
	198	* Clear the fields of the dquot and dquot log item that
	199	* are specific to the current transaction. If the
	200	* hold flags is set, do not unlock the dquot.
	201	*/
	202	STATIC void
	203	xfs_qm_dquot_logitem_unlock(
7bfa31d8	204	struct xfs_log_item *lip)
1da177e4	205	{
7bfa31d8	206	struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot;
1da177e4	207
1da177e4 LT	208	ASSERT(XFS_DQ_IS_LOCKED(dqp));
	209
	210	/*
	211	* Clear the transaction pointer in the dquot
	212	*/
	213	dqp->q_transp = NULL;
	214
	215	/*
	216	* dquots are never 'held' from getting unlocked at the end of
	217	* a transaction. Their locking and unlocking is hidden inside the
	218	* transaction layer, within trans_commit. Hence, no LI_HOLD flag
	219	* for the logitem.
	220	*/
	221	xfs_dqunlock(dqp);
	222	}
	223
1da177e4 LT	224	/*
	225	* this needs to stamp an lsn into the dquot, I think.
	226	* rpc's that look at user dquot's would then have to
	227	* push on the dependency recorded in the dquot
	228	*/
1da177e4 LT	229	STATIC void
1da177e4 LT	230	xfs_qm_dquot_logitem_committing(
7bfa31d8	231	struct xfs_log_item *lip,
1da177e4 LT	232	xfs_lsn_t lsn)
1da177e4 LT	233	{
1da177e4 LT	234	}
1da177e4 LT	235
1da177e4 LT	236	/*
	237	* This is the ops vector for dquots
	238	*/
272e42b2	239	static const struct xfs_item_ops xfs_dquot_item_ops = {
7bfa31d8 CH	240	.iop_size = xfs_qm_dquot_logitem_size,
	241	.iop_format = xfs_qm_dquot_logitem_format,
	242	.iop_pin = xfs_qm_dquot_logitem_pin,
	243	.iop_unpin = xfs_qm_dquot_logitem_unpin,
7bfa31d8 CH	244	.iop_unlock = xfs_qm_dquot_logitem_unlock,
	245	.iop_committed = xfs_qm_dquot_logitem_committed,
	246	.iop_push = xfs_qm_dquot_logitem_push,
7bfa31d8	247	.iop_committing = xfs_qm_dquot_logitem_committing
1da177e4 LT	248	};
	249
	250	/*
	251	* Initialize the dquot log item for a newly allocated dquot.
	252	* The dquot isn't locked at this point, but it isn't on any of the lists
	253	* either, so we don't care.
	254	*/
	255	void
	256	xfs_qm_dquot_logitem_init(
7bfa31d8	257	struct xfs_dquot *dqp)
1da177e4	258	{
7bfa31d8	259	struct xfs_dq_logitem *lp = &dqp->q_logitem;
1da177e4	260
43f5efc5 DC	261	xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT,
43f5efc5 DC	262	&xfs_dquot_item_ops);
1da177e4	263	lp->qli_dquot = dqp;
1da177e4 LT	264	}
	265
	266	/------------------ QUOTAOFF LOG ITEMS -------------------/
	267
7bfa31d8 CH	268	static inline struct xfs_qoff_logitem QOFF_ITEM(struct xfs_log_item lip)
	269	{
	270	return container_of(lip, struct xfs_qoff_logitem, qql_item);
	271	}
	272
	273
1da177e4 LT	274	/*
	275	* This returns the number of iovecs needed to log the given quotaoff item.
	276	* We only need 1 iovec for an quotaoff item. It just logs the
	277	* quotaoff_log_format structure.
	278	*/
166d1368	279	STATIC void
7bfa31d8	280	xfs_qm_qoff_logitem_size(
166d1368 DC	281	struct xfs_log_item *lip,
	282	int *nvecs,
	283	int *nbytes)
1da177e4	284	{
166d1368 DC	285	*nvecs += 1;
166d1368 DC	286	*nbytes += sizeof(struct xfs_qoff_logitem);
1da177e4 LT	287	}
1da177e4 LT	288
1da177e4	289	STATIC void
7bfa31d8 CH	290	xfs_qm_qoff_logitem_format(
7bfa31d8 CH	291	struct xfs_log_item *lip,
bde7cff6	292	struct xfs_log_vec *lv)
1da177e4	293	{
7bfa31d8	294	struct xfs_qoff_logitem *qflip = QOFF_ITEM(lip);
bde7cff6	295	struct xfs_log_iovec *vecp = NULL;
ffda4e83	296	struct xfs_qoff_logformat *qlf;
1da177e4	297
ffda4e83 CH	298	qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QUOTAOFF);
	299	qlf->qf_type = XFS_LI_QUOTAOFF;
	300	qlf->qf_size = 1;
	301	qlf->qf_flags = qflip->qql_flags;
	302	xlog_finish_iovec(lv, vecp, sizeof(struct xfs_qoff_logitem));
1da177e4 LT	303	}
1da177e4 LT	304
1da177e4 LT	305	/*
	306	* Pinning has no meaning for an quotaoff item, so just return.
	307	*/
1da177e4	308	STATIC void
7bfa31d8 CH	309	xfs_qm_qoff_logitem_pin(
7bfa31d8 CH	310	struct xfs_log_item *lip)
1da177e4	311	{
1da177e4 LT	312	}
1da177e4 LT	313
1da177e4 LT	314	/*
	315	* Since pinning has no meaning for an quotaoff item, unpinning does
	316	* not either.
	317	*/
1da177e4	318	STATIC void
7bfa31d8 CH	319	xfs_qm_qoff_logitem_unpin(
	320	struct xfs_log_item *lip,
	321	int remove)
1da177e4	322	{
1da177e4 LT	323	}
	324
	325	/*
43ff2122 CH	326	* There isn't much you can do to push a quotaoff item. It is simply
43ff2122 CH	327	* stuck waiting for the log to be flushed to disk.
1da177e4	328	*/
1da177e4	329	STATIC uint
43ff2122 CH	330	xfs_qm_qoff_logitem_push(
	331	struct xfs_log_item *lip,
	332	struct list_head *buffer_list)
1da177e4 LT	333	{
	334	return XFS_ITEM_LOCKED;
	335	}
	336
	337	/*
	338	* Quotaoff items have no locking or pushing, so return failure
	339	* so that the caller doesn't bother with us.
	340	*/
1da177e4	341	STATIC void
7bfa31d8 CH	342	xfs_qm_qoff_logitem_unlock(
7bfa31d8 CH	343	struct xfs_log_item *lip)
1da177e4	344	{
1da177e4 LT	345	}
	346
	347	/*
	348	* The quotaoff-start-item is logged only once and cannot be moved in the log,
	349	* so simply return the lsn at which it's been logged.
	350	*/
1da177e4	351	STATIC xfs_lsn_t
7bfa31d8 CH	352	xfs_qm_qoff_logitem_committed(
	353	struct xfs_log_item *lip,
	354	xfs_lsn_t lsn)
1da177e4	355	{
7bfa31d8	356	return lsn;
1da177e4 LT	357	}
1da177e4 LT	358
1da177e4 LT	359	STATIC xfs_lsn_t
1da177e4 LT	360	xfs_qm_qoffend_logitem_committed(
7bfa31d8 CH	361	struct xfs_log_item *lip,
7bfa31d8 CH	362	xfs_lsn_t lsn)
1da177e4	363	{
7bfa31d8 CH	364	struct xfs_qoff_logitem *qfe = QOFF_ITEM(lip);
	365	struct xfs_qoff_logitem *qfs = qfe->qql_start_lip;
	366	struct xfs_ail *ailp = qfs->qql_item.li_ailp;
1da177e4	367
1da177e4 LT	368	/*
1da177e4 LT	369	* Delete the qoff-start logitem from the AIL.
783a2f65	370	* xfs_trans_ail_delete() drops the AIL lock.
1da177e4	371	*/
7bfa31d8	372	spin_lock(&ailp->xa_lock);
04913fdd	373	xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR);
7bfa31d8	374
f0e2d93c DV	375	kmem_free(qfs);
f0e2d93c DV	376	kmem_free(qfe);
1da177e4 LT	377	return (xfs_lsn_t)-1;
	378	}
	379
	380	/*
	381	* XXX rcc - don't know quite what to do with this. I think we can
	382	* just ignore it. The only time that isn't the case is if we allow
	383	* the client to somehow see that quotas have been turned off in which
	384	* we can't allow that to get back until the quotaoff hits the disk.
	385	* So how would that happen? Also, do we need different routines for
	386	* quotaoff start and quotaoff end? I suspect the answer is yes but
	387	* to be sure, I need to look at the recovery code and see how quota off
	388	* recovery is handled (do we roll forward or back or do something else).
	389	* If we roll forwards or backwards, then we need two separate routines,
	390	* one that does nothing and one that stamps in the lsn that matters
	391	* (truly makes the quotaoff irrevocable). If we do something else,
	392	* then maybe we don't need two.
	393	*/
1da177e4	394	STATIC void
7bfa31d8 CH	395	xfs_qm_qoff_logitem_committing(
	396	struct xfs_log_item *lip,
	397	xfs_lsn_t commit_lsn)
1da177e4	398	{
1da177e4 LT	399	}
1da177e4 LT	400
272e42b2	401	static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
7bfa31d8 CH	402	.iop_size = xfs_qm_qoff_logitem_size,
	403	.iop_format = xfs_qm_qoff_logitem_format,
	404	.iop_pin = xfs_qm_qoff_logitem_pin,
	405	.iop_unpin = xfs_qm_qoff_logitem_unpin,
7bfa31d8 CH	406	.iop_unlock = xfs_qm_qoff_logitem_unlock,
	407	.iop_committed = xfs_qm_qoffend_logitem_committed,
	408	.iop_push = xfs_qm_qoff_logitem_push,
	409	.iop_committing = xfs_qm_qoff_logitem_committing
1da177e4 LT	410	};
	411
	412	/*
	413	* This is the ops vector shared by all quotaoff-start log items.
	414	*/
272e42b2	415	static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = {
7bfa31d8 CH	416	.iop_size = xfs_qm_qoff_logitem_size,
	417	.iop_format = xfs_qm_qoff_logitem_format,
	418	.iop_pin = xfs_qm_qoff_logitem_pin,
	419	.iop_unpin = xfs_qm_qoff_logitem_unpin,
7bfa31d8 CH	420	.iop_unlock = xfs_qm_qoff_logitem_unlock,
	421	.iop_committed = xfs_qm_qoff_logitem_committed,
	422	.iop_push = xfs_qm_qoff_logitem_push,
	423	.iop_committing = xfs_qm_qoff_logitem_committing
1da177e4 LT	424	};
	425
	426	/*
	427	* Allocate and initialize an quotaoff item of the correct quota type(s).
	428	*/
7bfa31d8	429	struct xfs_qoff_logitem *
1da177e4	430	xfs_qm_qoff_logitem_init(
7bfa31d8 CH	431	struct xfs_mount *mp,
	432	struct xfs_qoff_logitem *start,
	433	uint flags)
1da177e4	434	{
7bfa31d8	435	struct xfs_qoff_logitem *qf;
1da177e4	436
7bfa31d8	437	qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), KM_SLEEP);
1da177e4	438
43f5efc5 DC	439	xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ?
43f5efc5 DC	440	&xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops);
1da177e4	441	qf->qql_item.li_mountp = mp;
1da177e4	442	qf->qql_start_lip = start;
ffda4e83	443	qf->qql_flags = flags;
7bfa31d8	444	return qf;
1da177e4	445	}