1/*
  2 * Copyright (c) 2000-2002 Silicon Graphics, Inc.
  3 * All Rights Reserved.
  4 *
  5 * This program is free software; you can redistribute it and/or
  6 * modify it under the terms of the GNU General Public License as
  7 * published by the Free Software Foundation.
  8 *
  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.
 13 *
 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
 17 */
 18#include "xfs.h"
 19#include "xfs_fs.h"
 20#include "xfs_shared.h"
 21#include "xfs_format.h"
 22#include "xfs_log_format.h"
 23#include "xfs_trans_resv.h"
 24#include "xfs_mount.h"
 25#include "xfs_inode.h"
 26#include "xfs_error.h"
 27#include "xfs_trans.h"
 28#include "xfs_trans_priv.h"
 29#include "xfs_quota.h"
 30#include "xfs_qm.h"
 31
 32STATIC void	xfs_trans_alloc_dqinfo(xfs_trans_t *);
 33
 34/*
 35 * Add the locked dquot to the transaction.
 36 * The dquot must be locked, and it cannot be associated with any
 37 * transaction.
 38 */
 39void
 40xfs_trans_dqjoin(
 41	xfs_trans_t	*tp,
 42	xfs_dquot_t	*dqp)
 43{
 44	ASSERT(dqp->q_transp != tp);
 45	ASSERT(XFS_DQ_IS_LOCKED(dqp));
 46	ASSERT(dqp->q_logitem.qli_dquot == dqp);
 47
 48	/*
 49	 * Get a log_item_desc to point at the new item.
 50	 */
 51	xfs_trans_add_item(tp, &dqp->q_logitem.qli_item);
 52
 53	/*
 54	 * Initialize d_transp so we can later determine if this dquot is
 55	 * associated with this transaction.
 56	 */
 57	dqp->q_transp = tp;
 58}
 59
 60
 61/*
 62 * This is called to mark the dquot as needing
 63 * to be logged when the transaction is committed.  The dquot must
 64 * already be associated with the given transaction.
 65 * Note that it marks the entire transaction as dirty. In the ordinary
 66 * case, this gets called via xfs_trans_commit, after the transaction
 67 * is already dirty. However, there's nothing stop this from getting
 68 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
 69 * flag.
 70 */
 71void
 72xfs_trans_log_dquot(
 73	xfs_trans_t	*tp,
 74	xfs_dquot_t	*dqp)
 75{
 76	ASSERT(dqp->q_transp == tp);
 77	ASSERT(XFS_DQ_IS_LOCKED(dqp));
 78
 79	tp->t_flags |= XFS_TRANS_DIRTY;
 80	dqp->q_logitem.qli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
 81}
 82
 83/*
 84 * Carry forward whatever is left of the quota blk reservation to
 85 * the spanky new transaction
 86 */
 87void
 88xfs_trans_dup_dqinfo(
 89	xfs_trans_t	*otp,
 90	xfs_trans_t	*ntp)
 91{
 92	xfs_dqtrx_t	*oq, *nq;
 93	int		i, j;
 94	xfs_dqtrx_t	*oqa, *nqa;
 95	ulong		blk_res_used;
 96
 97	if (!otp->t_dqinfo)
 98		return;
 99
100	xfs_trans_alloc_dqinfo(ntp);
101
102	/*
103	 * Because the quota blk reservation is carried forward,
104	 * it is also necessary to carry forward the DQ_DIRTY flag.
105	 */
106	if (otp->t_flags & XFS_TRANS_DQ_DIRTY)
107		ntp->t_flags |= XFS_TRANS_DQ_DIRTY;
108
109	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
110		oqa = otp->t_dqinfo->dqs[j];
111		nqa = ntp->t_dqinfo->dqs[j];
112		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
113			blk_res_used = 0;
114
115			if (oqa[i].qt_dquot == NULL)
116				break;
117			oq = &oqa[i];
118			nq = &nqa[i];
119
120			if (oq->qt_blk_res && oq->qt_bcount_delta > 0)
121				blk_res_used = oq->qt_bcount_delta;
122
123			nq->qt_dquot = oq->qt_dquot;
124			nq->qt_bcount_delta = nq->qt_icount_delta = 0;
125			nq->qt_rtbcount_delta = 0;
126
127			/*
128			 * Transfer whatever is left of the reservations.
129			 */
130			nq->qt_blk_res = oq->qt_blk_res - blk_res_used;
131			oq->qt_blk_res = blk_res_used;
132
133			nq->qt_rtblk_res = oq->qt_rtblk_res -
134				oq->qt_rtblk_res_used;
135			oq->qt_rtblk_res = oq->qt_rtblk_res_used;
136
137			nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used;
138			oq->qt_ino_res = oq->qt_ino_res_used;
139
140		}
141	}
142}
143
144/*
145 * Wrap around mod_dquot to account for both user and group quotas.
146 */
147void
148xfs_trans_mod_dquot_byino(
149	xfs_trans_t	*tp,
150	xfs_inode_t	*ip,
151	uint		field,
152	long		delta)
153{
154	xfs_mount_t	*mp = tp->t_mountp;
155
156	if (!XFS_IS_QUOTA_RUNNING(mp) ||
157	    !XFS_IS_QUOTA_ON(mp) ||
158	    xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
159		return;
160
161	if (tp->t_dqinfo == NULL)
162		xfs_trans_alloc_dqinfo(tp);
163
164	if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot)
165		(void) xfs_trans_mod_dquot(tp, ip->i_udquot, field, delta);
166	if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot)
167		(void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta);
168	if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot)
169		(void) xfs_trans_mod_dquot(tp, ip->i_pdquot, field, delta);
170}
171
172STATIC struct xfs_dqtrx *
173xfs_trans_get_dqtrx(
174	struct xfs_trans	*tp,
175	struct xfs_dquot	*dqp)
176{
177	int			i;
178	struct xfs_dqtrx	*qa;
179
180	if (XFS_QM_ISUDQ(dqp))
181		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR];
182	else if (XFS_QM_ISGDQ(dqp))
183		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP];
184	else if (XFS_QM_ISPDQ(dqp))
185		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ];
186	else
187		return NULL;
188
189	for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
190		if (qa[i].qt_dquot == NULL ||
191		    qa[i].qt_dquot == dqp)
192			return &qa[i];
193	}
194
195	return NULL;
196}
197
198/*
199 * Make the changes in the transaction structure.
200 * The moral equivalent to xfs_trans_mod_sb().
201 * We don't touch any fields in the dquot, so we don't care
202 * if it's locked or not (most of the time it won't be).
203 */
204void
205xfs_trans_mod_dquot(
206	xfs_trans_t	*tp,
207	xfs_dquot_t	*dqp,
208	uint		field,
209	long		delta)
210{
211	xfs_dqtrx_t	*qtrx;
212
213	ASSERT(tp);
214	ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
215	qtrx = NULL;
216
217	if (tp->t_dqinfo == NULL)
218		xfs_trans_alloc_dqinfo(tp);
219	/*
220	 * Find either the first free slot or the slot that belongs
221	 * to this dquot.
222	 */
223	qtrx = xfs_trans_get_dqtrx(tp, dqp);
224	ASSERT(qtrx);
225	if (qtrx->qt_dquot == NULL)
226		qtrx->qt_dquot = dqp;
227
228	switch (field) {
229
230		/*
231		 * regular disk blk reservation
232		 */
233	      case XFS_TRANS_DQ_RES_BLKS:
234		qtrx->qt_blk_res += (ulong)delta;
235		break;
236
237		/*
238		 * inode reservation
239		 */
240	      case XFS_TRANS_DQ_RES_INOS:
241		qtrx->qt_ino_res += (ulong)delta;
242		break;
243
244		/*
245		 * disk blocks used.
246		 */
247	      case XFS_TRANS_DQ_BCOUNT:
248		qtrx->qt_bcount_delta += delta;
249		break;
250
251	      case XFS_TRANS_DQ_DELBCOUNT:
252		qtrx->qt_delbcnt_delta += delta;
253		break;
254
255		/*
256		 * Inode Count
257		 */
258	      case XFS_TRANS_DQ_ICOUNT:
259		if (qtrx->qt_ino_res && delta > 0) {
260			qtrx->qt_ino_res_used += (ulong)delta;
261			ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
262		}
263		qtrx->qt_icount_delta += delta;
264		break;
265
266		/*
267		 * rtblk reservation
268		 */
269	      case XFS_TRANS_DQ_RES_RTBLKS:
270		qtrx->qt_rtblk_res += (ulong)delta;
271		break;
272
273		/*
274		 * rtblk count
275		 */
276	      case XFS_TRANS_DQ_RTBCOUNT:
277		if (qtrx->qt_rtblk_res && delta > 0) {
278			qtrx->qt_rtblk_res_used += (ulong)delta;
279			ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used);
280		}
281		qtrx->qt_rtbcount_delta += delta;
282		break;
283
284	      case XFS_TRANS_DQ_DELRTBCOUNT:
285		qtrx->qt_delrtb_delta += delta;
286		break;
287
288	      default:
289		ASSERT(0);
290	}
291	tp->t_flags |= XFS_TRANS_DQ_DIRTY;
292}
293
294
295/*
296 * Given an array of dqtrx structures, lock all the dquots associated and join
297 * them to the transaction, provided they have been modified.  We know that the
298 * highest number of dquots of one type - usr, grp and prj - involved in a
299 * transaction is 3 so we don't need to make this very generic.
300 */
301STATIC void
302xfs_trans_dqlockedjoin(
303	xfs_trans_t	*tp,
304	xfs_dqtrx_t	*q)
305{
306	ASSERT(q[0].qt_dquot != NULL);
307	if (q[1].qt_dquot == NULL) {
308		xfs_dqlock(q[0].qt_dquot);
309		xfs_trans_dqjoin(tp, q[0].qt_dquot);
310	} else {
311		ASSERT(XFS_QM_TRANS_MAXDQS == 2);
312		xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot);
313		xfs_trans_dqjoin(tp, q[0].qt_dquot);
314		xfs_trans_dqjoin(tp, q[1].qt_dquot);
315	}
316}
317
318
319/*
320 * Called by xfs_trans_commit() and similar in spirit to
321 * xfs_trans_apply_sb_deltas().
322 * Go thru all the dquots belonging to this transaction and modify the
323 * INCORE dquot to reflect the actual usages.
324 * Unreserve just the reservations done by this transaction.
325 * dquot is still left locked at exit.
326 */
327void
328xfs_trans_apply_dquot_deltas(
329	struct xfs_trans	*tp)
330{
331	int			i, j;
332	struct xfs_dquot	*dqp;
333	struct xfs_dqtrx	*qtrx, *qa;
334	struct xfs_disk_dquot	*d;
335	long			totalbdelta;
336	long			totalrtbdelta;
337
338	if (!(tp->t_flags & XFS_TRANS_DQ_DIRTY))
339		return;
340
341	ASSERT(tp->t_dqinfo);
342	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
343		qa = tp->t_dqinfo->dqs[j];
344		if (qa[0].qt_dquot == NULL)
345			continue;
346
347		/*
348		 * Lock all of the dquots and join them to the transaction.
349		 */
350		xfs_trans_dqlockedjoin(tp, qa);
351
352		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
353			qtrx = &qa[i];
354			/*
355			 * The array of dquots is filled
356			 * sequentially, not sparsely.
357			 */
358			if ((dqp = qtrx->qt_dquot) == NULL)
359				break;
360
361			ASSERT(XFS_DQ_IS_LOCKED(dqp));
362			ASSERT(dqp->q_transp == tp);
363
364			/*
365			 * adjust the actual number of blocks used
366			 */
367			d = &dqp->q_core;
368
369			/*
370			 * The issue here is - sometimes we don't make a blkquota
371			 * reservation intentionally to be fair to users
372			 * (when the amount is small). On the other hand,
373			 * delayed allocs do make reservations, but that's
374			 * outside of a transaction, so we have no
375			 * idea how much was really reserved.
376			 * So, here we've accumulated delayed allocation blks and
377			 * non-delay blks. The assumption is that the
378			 * delayed ones are always reserved (outside of a
379			 * transaction), and the others may or may not have
380			 * quota reservations.
381			 */
382			totalbdelta = qtrx->qt_bcount_delta +
383				qtrx->qt_delbcnt_delta;
384			totalrtbdelta = qtrx->qt_rtbcount_delta +
385				qtrx->qt_delrtb_delta;
386#ifdef DEBUG
387			if (totalbdelta < 0)
388				ASSERT(be64_to_cpu(d->d_bcount) >=
389				       -totalbdelta);
390
391			if (totalrtbdelta < 0)
392				ASSERT(be64_to_cpu(d->d_rtbcount) >=
393				       -totalrtbdelta);
394
395			if (qtrx->qt_icount_delta < 0)
396				ASSERT(be64_to_cpu(d->d_icount) >=
397				       -qtrx->qt_icount_delta);
398#endif
399			if (totalbdelta)
400				be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
401
402			if (qtrx->qt_icount_delta)
403				be64_add_cpu(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta);
404
405			if (totalrtbdelta)
406				be64_add_cpu(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta);
407
408			/*
409			 * Get any default limits in use.
410			 * Start/reset the timer(s) if needed.
411			 */
412			if (d->d_id) {
413				xfs_qm_adjust_dqlimits(tp->t_mountp, dqp);
414				xfs_qm_adjust_dqtimers(tp->t_mountp, d);
415			}
416
417			dqp->dq_flags |= XFS_DQ_DIRTY;
418			/*
419			 * add this to the list of items to get logged
420			 */
421			xfs_trans_log_dquot(tp, dqp);
422			/*
423			 * Take off what's left of the original reservation.
424			 * In case of delayed allocations, there's no
425			 * reservation that a transaction structure knows of.
426			 */
427			if (qtrx->qt_blk_res != 0) {
428				ulong blk_res_used = 0;
429
430				if (qtrx->qt_bcount_delta > 0)
431					blk_res_used = qtrx->qt_bcount_delta;
432
433				if (qtrx->qt_blk_res != blk_res_used) {
434					if (qtrx->qt_blk_res > blk_res_used)
435						dqp->q_res_bcount -= (xfs_qcnt_t)
436							(qtrx->qt_blk_res -
437							 blk_res_used);
438					else
439						dqp->q_res_bcount -= (xfs_qcnt_t)
440							(blk_res_used -
441							 qtrx->qt_blk_res);
442				}
443			} else {
444				/*
445				 * These blks were never reserved, either inside
446				 * a transaction or outside one (in a delayed
447				 * allocation). Also, this isn't always a
448				 * negative number since we sometimes
449				 * deliberately skip quota reservations.
450				 */
451				if (qtrx->qt_bcount_delta) {
452					dqp->q_res_bcount +=
453					      (xfs_qcnt_t)qtrx->qt_bcount_delta;
454				}
455			}
456			/*
457			 * Adjust the RT reservation.
458			 */
459			if (qtrx->qt_rtblk_res != 0) {
460				if (qtrx->qt_rtblk_res != qtrx->qt_rtblk_res_used) {
461					if (qtrx->qt_rtblk_res >
462					    qtrx->qt_rtblk_res_used)
463					       dqp->q_res_rtbcount -= (xfs_qcnt_t)
464						       (qtrx->qt_rtblk_res -
465							qtrx->qt_rtblk_res_used);
466					else
467					       dqp->q_res_rtbcount -= (xfs_qcnt_t)
468						       (qtrx->qt_rtblk_res_used -
469							qtrx->qt_rtblk_res);
470				}
471			} else {
472				if (qtrx->qt_rtbcount_delta)
473					dqp->q_res_rtbcount +=
474					    (xfs_qcnt_t)qtrx->qt_rtbcount_delta;
475			}
476
477			/*
478			 * Adjust the inode reservation.
479			 */
480			if (qtrx->qt_ino_res != 0) {
481				ASSERT(qtrx->qt_ino_res >=
482				       qtrx->qt_ino_res_used);
483				if (qtrx->qt_ino_res > qtrx->qt_ino_res_used)
484					dqp->q_res_icount -= (xfs_qcnt_t)
485						(qtrx->qt_ino_res -
486						 qtrx->qt_ino_res_used);
487			} else {
488				if (qtrx->qt_icount_delta)
489					dqp->q_res_icount +=
490					    (xfs_qcnt_t)qtrx->qt_icount_delta;
491			}
492
493			ASSERT(dqp->q_res_bcount >=
494				be64_to_cpu(dqp->q_core.d_bcount));
495			ASSERT(dqp->q_res_icount >=
496				be64_to_cpu(dqp->q_core.d_icount));
497			ASSERT(dqp->q_res_rtbcount >=
498				be64_to_cpu(dqp->q_core.d_rtbcount));
499		}
500	}
501}
502
503/*
504 * Release the reservations, and adjust the dquots accordingly.
505 * This is called only when the transaction is being aborted. If by
506 * any chance we have done dquot modifications incore (ie. deltas) already,
507 * we simply throw those away, since that's the expected behavior
508 * when a transaction is curtailed without a commit.
509 */
510void
511xfs_trans_unreserve_and_mod_dquots(
512	xfs_trans_t		*tp)
513{
514	int			i, j;
515	xfs_dquot_t		*dqp;
516	xfs_dqtrx_t		*qtrx, *qa;
517	bool                    locked;
518
519	if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY))
520		return;
521
522	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
523		qa = tp->t_dqinfo->dqs[j];
524
525		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
526			qtrx = &qa[i];
527			/*
528			 * We assume that the array of dquots is filled
529			 * sequentially, not sparsely.
530			 */
531			if ((dqp = qtrx->qt_dquot) == NULL)
532				break;
533			/*
534			 * Unreserve the original reservation. We don't care
535			 * about the number of blocks used field, or deltas.
536			 * Also we don't bother to zero the fields.
537			 */
538			locked = false;
539			if (qtrx->qt_blk_res) {
540				xfs_dqlock(dqp);
541				locked = true;
542				dqp->q_res_bcount -=
543					(xfs_qcnt_t)qtrx->qt_blk_res;
544			}
545			if (qtrx->qt_ino_res) {
546				if (!locked) {
547					xfs_dqlock(dqp);
548					locked = true;
549				}
550				dqp->q_res_icount -=
551					(xfs_qcnt_t)qtrx->qt_ino_res;
552			}
553
554			if (qtrx->qt_rtblk_res) {
555				if (!locked) {
556					xfs_dqlock(dqp);
557					locked = true;
558				}
559				dqp->q_res_rtbcount -=
560					(xfs_qcnt_t)qtrx->qt_rtblk_res;
561			}
562			if (locked)
563				xfs_dqunlock(dqp);
564
565		}
566	}
567}
568
569STATIC void
570xfs_quota_warn(
571	struct xfs_mount	*mp,
572	struct xfs_dquot	*dqp,
573	int			type)
574{
575	enum quota_type qtype;
576
577	if (dqp->dq_flags & XFS_DQ_PROJ)
578		qtype = PRJQUOTA;
579	else if (dqp->dq_flags & XFS_DQ_USER)
580		qtype = USRQUOTA;
581	else
582		qtype = GRPQUOTA;
583
584	quota_send_warning(make_kqid(&init_user_ns, qtype,
585				     be32_to_cpu(dqp->q_core.d_id)),
586			   mp->m_super->s_dev, type);
587}
588
589/*
590 * This reserves disk blocks and inodes against a dquot.
591 * Flags indicate if the dquot is to be locked here and also
592 * if the blk reservation is for RT or regular blocks.
593 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
594 */
595STATIC int
596xfs_trans_dqresv(
597	xfs_trans_t	*tp,
598	xfs_mount_t	*mp,
599	xfs_dquot_t	*dqp,
600	long		nblks,
601	long		ninos,
602	uint		flags)
603{
604	xfs_qcnt_t	hardlimit;
605	xfs_qcnt_t	softlimit;
606	time_t		timer;
607	xfs_qwarncnt_t	warns;
608	xfs_qwarncnt_t	warnlimit;
609	xfs_qcnt_t	total_count;
610	xfs_qcnt_t	*resbcountp;
611	xfs_quotainfo_t	*q = mp->m_quotainfo;
612	struct xfs_def_quota	*defq;
613
614
615	xfs_dqlock(dqp);
616
617	defq = xfs_get_defquota(dqp, q);
618
619	if (flags & XFS_TRANS_DQ_RES_BLKS) {
620		hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
621		if (!hardlimit)
622			hardlimit = defq->bhardlimit;
623		softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);
624		if (!softlimit)
625			softlimit = defq->bsoftlimit;
626		timer = be32_to_cpu(dqp->q_core.d_btimer);
627		warns = be16_to_cpu(dqp->q_core.d_bwarns);
628		warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit;
629		resbcountp = &dqp->q_res_bcount;
630	} else {
631		ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
632		hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
633		if (!hardlimit)
634			hardlimit = defq->rtbhardlimit;
635		softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);
636		if (!softlimit)
637			softlimit = defq->rtbsoftlimit;
638		timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
639		warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
640		warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit;
641		resbcountp = &dqp->q_res_rtbcount;
642	}
643
644	if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
645	    dqp->q_core.d_id &&
646	    ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
647	     (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) ||
648	     (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) {
649		if (nblks > 0) {
650			/*
651			 * dquot is locked already. See if we'd go over the
652			 * hardlimit or exceed the timelimit if we allocate
653			 * nblks.
654			 */
655			total_count = *resbcountp + nblks;
656			if (hardlimit && total_count > hardlimit) {
657				xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN);
658				goto error_return;
659			}
660			if (softlimit && total_count > softlimit) {
661				if ((timer != 0 && get_seconds() > timer) ||
662				    (warns != 0 && warns >= warnlimit)) {
663					xfs_quota_warn(mp, dqp,
664						       QUOTA_NL_BSOFTLONGWARN);
665					goto error_return;
666				}
667
668				xfs_quota_warn(mp, dqp, QUOTA_NL_BSOFTWARN);
669			}
670		}
671		if (ninos > 0) {
672			total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos;
673			timer = be32_to_cpu(dqp->q_core.d_itimer);
674			warns = be16_to_cpu(dqp->q_core.d_iwarns);
675			warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit;
676			hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
677			if (!hardlimit)
678				hardlimit = defq->ihardlimit;
679			softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
680			if (!softlimit)
681				softlimit = defq->isoftlimit;
682
683			if (hardlimit && total_count > hardlimit) {
684				xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
685				goto error_return;
686			}
687			if (softlimit && total_count > softlimit) {
688				if  ((timer != 0 && get_seconds() > timer) ||
689				     (warns != 0 && warns >= warnlimit)) {
690					xfs_quota_warn(mp, dqp,
691						       QUOTA_NL_ISOFTLONGWARN);
692					goto error_return;
693				}
694				xfs_quota_warn(mp, dqp, QUOTA_NL_ISOFTWARN);
695			}
696		}
697	}
698
699	/*
700	 * Change the reservation, but not the actual usage.
701	 * Note that q_res_bcount = q_core.d_bcount + resv
702	 */
703	(*resbcountp) += (xfs_qcnt_t)nblks;
704	if (ninos != 0)
705		dqp->q_res_icount += (xfs_qcnt_t)ninos;
706
707	/*
708	 * note the reservation amt in the trans struct too,
709	 * so that the transaction knows how much was reserved by
710	 * it against this particular dquot.
711	 * We don't do this when we are reserving for a delayed allocation,
712	 * because we don't have the luxury of a transaction envelope then.
713	 */
714	if (tp) {
715		ASSERT(tp->t_dqinfo);
716		ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
717		if (nblks != 0)
718			xfs_trans_mod_dquot(tp, dqp,
719					    flags & XFS_QMOPT_RESBLK_MASK,
720					    nblks);
721		if (ninos != 0)
722			xfs_trans_mod_dquot(tp, dqp,
723					    XFS_TRANS_DQ_RES_INOS,
724					    ninos);
725	}
726	ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount));
727	ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount));
728	ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount));
729
730	xfs_dqunlock(dqp);
731	return 0;
732
733error_return:
734	xfs_dqunlock(dqp);
735	if (flags & XFS_QMOPT_ENOSPC)
736		return -ENOSPC;
737	return -EDQUOT;
738}
739
740
741/*
742 * Given dquot(s), make disk block and/or inode reservations against them.
743 * The fact that this does the reservation against user, group and
744 * project quotas is important, because this follows a all-or-nothing
745 * approach.
746 *
747 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
748 *	   XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT.  Used by pquota.
749 *	   XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
750 *	   XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
751 * dquots are unlocked on return, if they were not locked by caller.
752 */
753int
754xfs_trans_reserve_quota_bydquots(
755	struct xfs_trans	*tp,
756	struct xfs_mount	*mp,
757	struct xfs_dquot	*udqp,
758	struct xfs_dquot	*gdqp,
759	struct xfs_dquot	*pdqp,
760	long			nblks,
761	long			ninos,
762	uint			flags)
763{
764	int		error;
765
766	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
767		return 0;
768
769	if (tp && tp->t_dqinfo == NULL)
770		xfs_trans_alloc_dqinfo(tp);
771
772	ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
773
774	if (udqp) {
775		error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos,
776					(flags & ~XFS_QMOPT_ENOSPC));
777		if (error)
778			return error;
779	}
780
781	if (gdqp) {
782		error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
783		if (error)
784			goto unwind_usr;
785	}
786
787	if (pdqp) {
788		error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags);
789		if (error)
790			goto unwind_grp;
791	}
792
793	/*
794	 * Didn't change anything critical, so, no need to log
795	 */
796	return 0;
797
798unwind_grp:
799	flags |= XFS_QMOPT_FORCE_RES;
800	if (gdqp)
801		xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags);
802unwind_usr:
803	flags |= XFS_QMOPT_FORCE_RES;
804	if (udqp)
805		xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
806	return error;
807}
808
809
810/*
811 * Lock the dquot and change the reservation if we can.
812 * This doesn't change the actual usage, just the reservation.
813 * The inode sent in is locked.
814 */
815int
816xfs_trans_reserve_quota_nblks(
817	struct xfs_trans	*tp,
818	struct xfs_inode	*ip,
819	long			nblks,
820	long			ninos,
821	uint			flags)
822{
823	struct xfs_mount	*mp = ip->i_mount;
824
825	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
826		return 0;
827	if (XFS_IS_PQUOTA_ON(mp))
828		flags |= XFS_QMOPT_ENOSPC;
829
830	ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
831
832	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
833	ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
834				XFS_TRANS_DQ_RES_RTBLKS ||
835	       (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
836				XFS_TRANS_DQ_RES_BLKS);
837
838	/*
839	 * Reserve nblks against these dquots, with trans as the mediator.
840	 */
841	return xfs_trans_reserve_quota_bydquots(tp, mp,
842						ip->i_udquot, ip->i_gdquot,
843						ip->i_pdquot,
844						nblks, ninos, flags);
845}
846
847/*
848 * This routine is called to allocate a quotaoff log item.
849 */
850xfs_qoff_logitem_t *
851xfs_trans_get_qoff_item(
852	xfs_trans_t		*tp,
853	xfs_qoff_logitem_t	*startqoff,
854	uint			flags)
855{
856	xfs_qoff_logitem_t	*q;
857
858	ASSERT(tp != NULL);
859
860	q = xfs_qm_qoff_logitem_init(tp->t_mountp, startqoff, flags);
861	ASSERT(q != NULL);
862
863	/*
864	 * Get a log_item_desc to point at the new item.
865	 */
866	xfs_trans_add_item(tp, &q->qql_item);
867	return q;
868}
869
870
871/*
872 * This is called to mark the quotaoff logitem as needing
873 * to be logged when the transaction is committed.  The logitem must
874 * already be associated with the given transaction.
875 */
876void
877xfs_trans_log_quotaoff_item(
878	xfs_trans_t		*tp,
879	xfs_qoff_logitem_t	*qlp)
880{
881	tp->t_flags |= XFS_TRANS_DIRTY;
882	qlp->qql_item.li_desc->lid_flags |= XFS_LID_DIRTY;
883}
884
885STATIC void
886xfs_trans_alloc_dqinfo(
887	xfs_trans_t	*tp)
888{
889	tp->t_dqinfo = kmem_zone_zalloc(xfs_qm_dqtrxzone, KM_SLEEP);
890}
891
892void
893xfs_trans_free_dqinfo(
894	xfs_trans_t	*tp)
895{
896	if (!tp->t_dqinfo)
897		return;
898	kmem_zone_free(xfs_qm_dqtrxzone, tp->t_dqinfo);
899	tp->t_dqinfo = NULL;
900}