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