]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/xfs/xfs_trans_dquot.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2002 Silicon Graphics, Inc.
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_trans.h"
15 #include "xfs_trans_priv.h"
16 #include "xfs_quota.h"
18 #include "xfs_trace.h"
19 #include "xfs_error.h"
21 STATIC
void xfs_trans_alloc_dqinfo(xfs_trans_t
*);
24 * Add the locked dquot to the transaction.
25 * The dquot must be locked, and it cannot be associated with any
31 struct xfs_dquot
*dqp
)
33 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
34 ASSERT(dqp
->q_logitem
.qli_dquot
== dqp
);
37 * Get a log_item_desc to point at the new item.
39 xfs_trans_add_item(tp
, &dqp
->q_logitem
.qli_item
);
43 * This is called to mark the dquot as needing
44 * to be logged when the transaction is committed. The dquot must
45 * already be associated with the given transaction.
46 * Note that it marks the entire transaction as dirty. In the ordinary
47 * case, this gets called via xfs_trans_commit, after the transaction
48 * is already dirty. However, there's nothing stop this from getting
49 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
55 struct xfs_dquot
*dqp
)
57 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
59 /* Upgrade the dquot to bigtime format if possible. */
61 xfs_has_bigtime(tp
->t_mountp
) &&
62 !(dqp
->q_type
& XFS_DQTYPE_BIGTIME
))
63 dqp
->q_type
|= XFS_DQTYPE_BIGTIME
;
65 tp
->t_flags
|= XFS_TRANS_DIRTY
;
66 set_bit(XFS_LI_DIRTY
, &dqp
->q_logitem
.qli_item
.li_flags
);
70 * Carry forward whatever is left of the quota blk reservation to
71 * the spanky new transaction
75 struct xfs_trans
*otp
,
76 struct xfs_trans
*ntp
)
78 struct xfs_dqtrx
*oq
, *nq
;
80 struct xfs_dqtrx
*oqa
, *nqa
;
81 uint64_t blk_res_used
;
86 xfs_trans_alloc_dqinfo(ntp
);
88 for (j
= 0; j
< XFS_QM_TRANS_DQTYPES
; j
++) {
89 oqa
= otp
->t_dqinfo
->dqs
[j
];
90 nqa
= ntp
->t_dqinfo
->dqs
[j
];
91 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
94 if (oqa
[i
].qt_dquot
== NULL
)
99 if (oq
->qt_blk_res
&& oq
->qt_bcount_delta
> 0)
100 blk_res_used
= oq
->qt_bcount_delta
;
102 nq
->qt_dquot
= oq
->qt_dquot
;
103 nq
->qt_bcount_delta
= nq
->qt_icount_delta
= 0;
104 nq
->qt_rtbcount_delta
= 0;
107 * Transfer whatever is left of the reservations.
109 nq
->qt_blk_res
= oq
->qt_blk_res
- blk_res_used
;
110 oq
->qt_blk_res
= blk_res_used
;
112 nq
->qt_rtblk_res
= oq
->qt_rtblk_res
-
113 oq
->qt_rtblk_res_used
;
114 oq
->qt_rtblk_res
= oq
->qt_rtblk_res_used
;
116 nq
->qt_ino_res
= oq
->qt_ino_res
- oq
->qt_ino_res_used
;
117 oq
->qt_ino_res
= oq
->qt_ino_res_used
;
124 * Wrap around mod_dquot to account for both user and group quotas.
127 xfs_trans_mod_dquot_byino(
133 xfs_mount_t
*mp
= tp
->t_mountp
;
135 if (!XFS_IS_QUOTA_ON(mp
) ||
136 xfs_is_quota_inode(&mp
->m_sb
, ip
->i_ino
))
139 if (XFS_IS_UQUOTA_ON(mp
) && ip
->i_udquot
)
140 (void) xfs_trans_mod_dquot(tp
, ip
->i_udquot
, field
, delta
);
141 if (XFS_IS_GQUOTA_ON(mp
) && ip
->i_gdquot
)
142 (void) xfs_trans_mod_dquot(tp
, ip
->i_gdquot
, field
, delta
);
143 if (XFS_IS_PQUOTA_ON(mp
) && ip
->i_pdquot
)
144 (void) xfs_trans_mod_dquot(tp
, ip
->i_pdquot
, field
, delta
);
147 STATIC
struct xfs_dqtrx
*
149 struct xfs_trans
*tp
,
150 struct xfs_dquot
*dqp
)
153 struct xfs_dqtrx
*qa
;
155 switch (xfs_dquot_type(dqp
)) {
156 case XFS_DQTYPE_USER
:
157 qa
= tp
->t_dqinfo
->dqs
[XFS_QM_TRANS_USR
];
159 case XFS_DQTYPE_GROUP
:
160 qa
= tp
->t_dqinfo
->dqs
[XFS_QM_TRANS_GRP
];
162 case XFS_DQTYPE_PROJ
:
163 qa
= tp
->t_dqinfo
->dqs
[XFS_QM_TRANS_PRJ
];
169 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
170 if (qa
[i
].qt_dquot
== NULL
||
171 qa
[i
].qt_dquot
== dqp
)
179 * Make the changes in the transaction structure.
180 * The moral equivalent to xfs_trans_mod_sb().
181 * We don't touch any fields in the dquot, so we don't care
182 * if it's locked or not (most of the time it won't be).
186 struct xfs_trans
*tp
,
187 struct xfs_dquot
*dqp
,
191 struct xfs_dqtrx
*qtrx
;
194 ASSERT(XFS_IS_QUOTA_ON(tp
->t_mountp
));
200 if (tp
->t_dqinfo
== NULL
)
201 xfs_trans_alloc_dqinfo(tp
);
203 * Find either the first free slot or the slot that belongs
206 qtrx
= xfs_trans_get_dqtrx(tp
, dqp
);
208 if (qtrx
->qt_dquot
== NULL
)
209 qtrx
->qt_dquot
= dqp
;
211 trace_xfs_trans_mod_dquot_before(qtrx
);
212 trace_xfs_trans_mod_dquot(tp
, dqp
, field
, delta
);
215 /* regular disk blk reservation */
216 case XFS_TRANS_DQ_RES_BLKS
:
217 qtrx
->qt_blk_res
+= delta
;
220 /* inode reservation */
221 case XFS_TRANS_DQ_RES_INOS
:
222 qtrx
->qt_ino_res
+= delta
;
225 /* disk blocks used. */
226 case XFS_TRANS_DQ_BCOUNT
:
227 qtrx
->qt_bcount_delta
+= delta
;
230 case XFS_TRANS_DQ_DELBCOUNT
:
231 qtrx
->qt_delbcnt_delta
+= delta
;
235 case XFS_TRANS_DQ_ICOUNT
:
236 if (qtrx
->qt_ino_res
&& delta
> 0) {
237 qtrx
->qt_ino_res_used
+= delta
;
238 ASSERT(qtrx
->qt_ino_res
>= qtrx
->qt_ino_res_used
);
240 qtrx
->qt_icount_delta
+= delta
;
243 /* rtblk reservation */
244 case XFS_TRANS_DQ_RES_RTBLKS
:
245 qtrx
->qt_rtblk_res
+= delta
;
249 case XFS_TRANS_DQ_RTBCOUNT
:
250 if (qtrx
->qt_rtblk_res
&& delta
> 0) {
251 qtrx
->qt_rtblk_res_used
+= delta
;
252 ASSERT(qtrx
->qt_rtblk_res
>= qtrx
->qt_rtblk_res_used
);
254 qtrx
->qt_rtbcount_delta
+= delta
;
257 case XFS_TRANS_DQ_DELRTBCOUNT
:
258 qtrx
->qt_delrtb_delta
+= delta
;
265 trace_xfs_trans_mod_dquot_after(qtrx
);
270 * Given an array of dqtrx structures, lock all the dquots associated and join
271 * them to the transaction, provided they have been modified. We know that the
272 * highest number of dquots of one type - usr, grp and prj - involved in a
273 * transaction is 3 so we don't need to make this very generic.
276 xfs_trans_dqlockedjoin(
277 struct xfs_trans
*tp
,
280 ASSERT(q
[0].qt_dquot
!= NULL
);
281 if (q
[1].qt_dquot
== NULL
) {
282 xfs_dqlock(q
[0].qt_dquot
);
283 xfs_trans_dqjoin(tp
, q
[0].qt_dquot
);
285 ASSERT(XFS_QM_TRANS_MAXDQS
== 2);
286 xfs_dqlock2(q
[0].qt_dquot
, q
[1].qt_dquot
);
287 xfs_trans_dqjoin(tp
, q
[0].qt_dquot
);
288 xfs_trans_dqjoin(tp
, q
[1].qt_dquot
);
292 /* Apply dqtrx changes to the quota reservation counters. */
294 xfs_apply_quota_reservation_deltas(
295 struct xfs_dquot_res
*res
,
302 * Subtle math here: If reserved > res_used (the normal case),
303 * we're simply subtracting the unused transaction quota
304 * reservation from the dquot reservation.
306 * If, however, res_used > reserved, then we have allocated
307 * more quota blocks than were reserved for the transaction.
308 * We must add that excess to the dquot reservation since it
309 * tracks (usage + resv) and by definition we didn't reserve
312 res
->reserved
-= abs(reserved
- res_used
);
313 } else if (count_delta
!= 0) {
315 * These blks were never reserved, either inside a transaction
316 * or outside one (in a delayed allocation). Also, this isn't
317 * always a negative number since we sometimes deliberately
318 * skip quota reservations.
320 res
->reserved
+= count_delta
;
325 * Called by xfs_trans_commit() and similar in spirit to
326 * xfs_trans_apply_sb_deltas().
327 * Go thru all the dquots belonging to this transaction and modify the
328 * INCORE dquot to reflect the actual usages.
329 * Unreserve just the reservations done by this transaction.
330 * dquot is still left locked at exit.
333 xfs_trans_apply_dquot_deltas(
334 struct xfs_trans
*tp
)
337 struct xfs_dquot
*dqp
;
338 struct xfs_dqtrx
*qtrx
, *qa
;
340 int64_t totalrtbdelta
;
345 ASSERT(tp
->t_dqinfo
);
346 for (j
= 0; j
< XFS_QM_TRANS_DQTYPES
; j
++) {
347 qa
= tp
->t_dqinfo
->dqs
[j
];
348 if (qa
[0].qt_dquot
== NULL
)
352 * Lock all of the dquots and join them to the transaction.
354 xfs_trans_dqlockedjoin(tp
, qa
);
356 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
357 uint64_t blk_res_used
;
361 * The array of dquots is filled
362 * sequentially, not sparsely.
364 if ((dqp
= qtrx
->qt_dquot
) == NULL
)
367 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
370 * adjust the actual number of blocks used
374 * The issue here is - sometimes we don't make a blkquota
375 * reservation intentionally to be fair to users
376 * (when the amount is small). On the other hand,
377 * delayed allocs do make reservations, but that's
378 * outside of a transaction, so we have no
379 * idea how much was really reserved.
380 * So, here we've accumulated delayed allocation blks and
381 * non-delay blks. The assumption is that the
382 * delayed ones are always reserved (outside of a
383 * transaction), and the others may or may not have
384 * quota reservations.
386 totalbdelta
= qtrx
->qt_bcount_delta
+
387 qtrx
->qt_delbcnt_delta
;
388 totalrtbdelta
= qtrx
->qt_rtbcount_delta
+
389 qtrx
->qt_delrtb_delta
;
391 if (totalbdelta
!= 0 || totalrtbdelta
!= 0 ||
392 qtrx
->qt_icount_delta
!= 0) {
393 trace_xfs_trans_apply_dquot_deltas_before(dqp
);
394 trace_xfs_trans_apply_dquot_deltas(qtrx
);
399 ASSERT(dqp
->q_blk
.count
>= -totalbdelta
);
401 if (totalrtbdelta
< 0)
402 ASSERT(dqp
->q_rtb
.count
>= -totalrtbdelta
);
404 if (qtrx
->qt_icount_delta
< 0)
405 ASSERT(dqp
->q_ino
.count
>= -qtrx
->qt_icount_delta
);
408 dqp
->q_blk
.count
+= totalbdelta
;
410 if (qtrx
->qt_icount_delta
)
411 dqp
->q_ino
.count
+= qtrx
->qt_icount_delta
;
414 dqp
->q_rtb
.count
+= totalrtbdelta
;
416 if (totalbdelta
!= 0 || totalrtbdelta
!= 0 ||
417 qtrx
->qt_icount_delta
!= 0)
418 trace_xfs_trans_apply_dquot_deltas_after(dqp
);
421 * Get any default limits in use.
422 * Start/reset the timer(s) if needed.
425 xfs_qm_adjust_dqlimits(dqp
);
426 xfs_qm_adjust_dqtimers(dqp
);
429 dqp
->q_flags
|= XFS_DQFLAG_DIRTY
;
431 * add this to the list of items to get logged
433 xfs_trans_log_dquot(tp
, dqp
);
435 * Take off what's left of the original reservation.
436 * In case of delayed allocations, there's no
437 * reservation that a transaction structure knows of.
439 blk_res_used
= max_t(int64_t, 0, qtrx
->qt_bcount_delta
);
440 xfs_apply_quota_reservation_deltas(&dqp
->q_blk
,
441 qtrx
->qt_blk_res
, blk_res_used
,
442 qtrx
->qt_bcount_delta
);
445 * Adjust the RT reservation.
447 xfs_apply_quota_reservation_deltas(&dqp
->q_rtb
,
449 qtrx
->qt_rtblk_res_used
,
450 qtrx
->qt_rtbcount_delta
);
453 * Adjust the inode reservation.
455 ASSERT(qtrx
->qt_ino_res
>= qtrx
->qt_ino_res_used
);
456 xfs_apply_quota_reservation_deltas(&dqp
->q_ino
,
458 qtrx
->qt_ino_res_used
,
459 qtrx
->qt_icount_delta
);
461 ASSERT(dqp
->q_blk
.reserved
>= dqp
->q_blk
.count
);
462 ASSERT(dqp
->q_ino
.reserved
>= dqp
->q_ino
.count
);
463 ASSERT(dqp
->q_rtb
.reserved
>= dqp
->q_rtb
.count
);
469 * Release the reservations, and adjust the dquots accordingly.
470 * This is called only when the transaction is being aborted. If by
471 * any chance we have done dquot modifications incore (ie. deltas) already,
472 * we simply throw those away, since that's the expected behavior
473 * when a transaction is curtailed without a commit.
476 xfs_trans_unreserve_and_mod_dquots(
477 struct xfs_trans
*tp
)
480 struct xfs_dquot
*dqp
;
481 struct xfs_dqtrx
*qtrx
, *qa
;
487 for (j
= 0; j
< XFS_QM_TRANS_DQTYPES
; j
++) {
488 qa
= tp
->t_dqinfo
->dqs
[j
];
490 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
493 * We assume that the array of dquots is filled
494 * sequentially, not sparsely.
496 if ((dqp
= qtrx
->qt_dquot
) == NULL
)
499 * Unreserve the original reservation. We don't care
500 * about the number of blocks used field, or deltas.
501 * Also we don't bother to zero the fields.
504 if (qtrx
->qt_blk_res
) {
507 dqp
->q_blk
.reserved
-=
508 (xfs_qcnt_t
)qtrx
->qt_blk_res
;
510 if (qtrx
->qt_ino_res
) {
515 dqp
->q_ino
.reserved
-=
516 (xfs_qcnt_t
)qtrx
->qt_ino_res
;
519 if (qtrx
->qt_rtblk_res
) {
524 dqp
->q_rtb
.reserved
-=
525 (xfs_qcnt_t
)qtrx
->qt_rtblk_res
;
536 struct xfs_mount
*mp
,
537 struct xfs_dquot
*dqp
,
540 enum quota_type qtype
;
542 switch (xfs_dquot_type(dqp
)) {
543 case XFS_DQTYPE_PROJ
:
546 case XFS_DQTYPE_USER
:
549 case XFS_DQTYPE_GROUP
:
556 quota_send_warning(make_kqid(&init_user_ns
, qtype
, dqp
->q_id
),
557 mp
->m_super
->s_dev
, type
);
561 * Decide if we can make an additional reservation against a quota resource.
562 * Returns an inode QUOTA_NL_ warning code and whether or not it's fatal.
564 * Note that we assume that the numeric difference between the inode and block
565 * warning codes will always be 3 since it's userspace ABI now, and will never
566 * decrease the quota reservation, so the *BELOW messages are irrelevant.
570 struct xfs_dquot_res
*res
,
571 struct xfs_quota_limits
*qlim
,
575 xfs_qcnt_t hardlimit
= res
->hardlimit
;
576 xfs_qcnt_t softlimit
= res
->softlimit
;
577 xfs_qcnt_t total_count
= res
->reserved
+ delta
;
579 BUILD_BUG_ON(QUOTA_NL_BHARDWARN
!= QUOTA_NL_IHARDWARN
+ 3);
580 BUILD_BUG_ON(QUOTA_NL_BSOFTLONGWARN
!= QUOTA_NL_ISOFTLONGWARN
+ 3);
581 BUILD_BUG_ON(QUOTA_NL_BSOFTWARN
!= QUOTA_NL_ISOFTWARN
+ 3);
585 return QUOTA_NL_NOWARN
;
588 hardlimit
= qlim
->hard
;
590 softlimit
= qlim
->soft
;
592 if (hardlimit
&& total_count
> hardlimit
) {
594 return QUOTA_NL_IHARDWARN
;
597 if (softlimit
&& total_count
> softlimit
) {
598 time64_t now
= ktime_get_real_seconds();
600 if ((res
->timer
!= 0 && now
> res
->timer
) ||
601 (res
->warnings
!= 0 && res
->warnings
>= qlim
->warn
)) {
603 return QUOTA_NL_ISOFTLONGWARN
;
607 return QUOTA_NL_ISOFTWARN
;
610 return QUOTA_NL_NOWARN
;
614 * This reserves disk blocks and inodes against a dquot.
615 * Flags indicate if the dquot is to be locked here and also
616 * if the blk reservation is for RT or regular blocks.
617 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
621 struct xfs_trans
*tp
,
622 struct xfs_mount
*mp
,
623 struct xfs_dquot
*dqp
,
628 struct xfs_quotainfo
*q
= mp
->m_quotainfo
;
629 struct xfs_def_quota
*defq
;
630 struct xfs_dquot_res
*blkres
;
631 struct xfs_quota_limits
*qlim
;
635 defq
= xfs_get_defquota(q
, xfs_dquot_type(dqp
));
637 if (flags
& XFS_TRANS_DQ_RES_BLKS
) {
638 blkres
= &dqp
->q_blk
;
641 blkres
= &dqp
->q_rtb
;
645 if ((flags
& XFS_QMOPT_FORCE_RES
) == 0 && dqp
->q_id
&&
646 xfs_dquot_is_enforced(dqp
)) {
651 * dquot is locked already. See if we'd go over the hardlimit
652 * or exceed the timelimit if we'd reserve resources.
654 quota_nl
= xfs_dqresv_check(blkres
, qlim
, nblks
, &fatal
);
655 if (quota_nl
!= QUOTA_NL_NOWARN
) {
657 * Quota block warning codes are 3 more than the inode
658 * codes, which we check above.
660 xfs_quota_warn(mp
, dqp
, quota_nl
+ 3);
665 quota_nl
= xfs_dqresv_check(&dqp
->q_ino
, &defq
->ino
, ninos
,
667 if (quota_nl
!= QUOTA_NL_NOWARN
) {
668 xfs_quota_warn(mp
, dqp
, quota_nl
);
675 * Change the reservation, but not the actual usage.
676 * Note that q_blk.reserved = q_blk.count + resv
678 blkres
->reserved
+= (xfs_qcnt_t
)nblks
;
679 dqp
->q_ino
.reserved
+= (xfs_qcnt_t
)ninos
;
682 * note the reservation amt in the trans struct too,
683 * so that the transaction knows how much was reserved by
684 * it against this particular dquot.
685 * We don't do this when we are reserving for a delayed allocation,
686 * because we don't have the luxury of a transaction envelope then.
689 ASSERT(flags
& XFS_QMOPT_RESBLK_MASK
);
690 xfs_trans_mod_dquot(tp
, dqp
, flags
& XFS_QMOPT_RESBLK_MASK
,
692 xfs_trans_mod_dquot(tp
, dqp
, XFS_TRANS_DQ_RES_INOS
, ninos
);
695 if (XFS_IS_CORRUPT(mp
, dqp
->q_blk
.reserved
< dqp
->q_blk
.count
) ||
696 XFS_IS_CORRUPT(mp
, dqp
->q_rtb
.reserved
< dqp
->q_rtb
.count
) ||
697 XFS_IS_CORRUPT(mp
, dqp
->q_ino
.reserved
< dqp
->q_ino
.count
))
705 if (xfs_dquot_type(dqp
) == XFS_DQTYPE_PROJ
)
710 xfs_force_shutdown(mp
, SHUTDOWN_CORRUPT_INCORE
);
711 return -EFSCORRUPTED
;
716 * Given dquot(s), make disk block and/or inode reservations against them.
717 * The fact that this does the reservation against user, group and
718 * project quotas is important, because this follows a all-or-nothing
721 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
722 * XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT. Used by pquota.
723 * XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
724 * XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
725 * dquots are unlocked on return, if they were not locked by caller.
728 xfs_trans_reserve_quota_bydquots(
729 struct xfs_trans
*tp
,
730 struct xfs_mount
*mp
,
731 struct xfs_dquot
*udqp
,
732 struct xfs_dquot
*gdqp
,
733 struct xfs_dquot
*pdqp
,
740 if (!XFS_IS_QUOTA_ON(mp
))
743 ASSERT(flags
& XFS_QMOPT_RESBLK_MASK
);
746 error
= xfs_trans_dqresv(tp
, mp
, udqp
, nblks
, ninos
, flags
);
752 error
= xfs_trans_dqresv(tp
, mp
, gdqp
, nblks
, ninos
, flags
);
758 error
= xfs_trans_dqresv(tp
, mp
, pdqp
, nblks
, ninos
, flags
);
764 * Didn't change anything critical, so, no need to log
769 flags
|= XFS_QMOPT_FORCE_RES
;
771 xfs_trans_dqresv(tp
, mp
, gdqp
, -nblks
, -ninos
, flags
);
773 flags
|= XFS_QMOPT_FORCE_RES
;
775 xfs_trans_dqresv(tp
, mp
, udqp
, -nblks
, -ninos
, flags
);
781 * Lock the dquot and change the reservation if we can.
782 * This doesn't change the actual usage, just the reservation.
783 * The inode sent in is locked.
786 xfs_trans_reserve_quota_nblks(
787 struct xfs_trans
*tp
,
788 struct xfs_inode
*ip
,
793 struct xfs_mount
*mp
= ip
->i_mount
;
794 unsigned int qflags
= 0;
797 if (!XFS_IS_QUOTA_ON(mp
))
800 ASSERT(!xfs_is_quota_inode(&mp
->m_sb
, ip
->i_ino
));
801 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
804 qflags
|= XFS_QMOPT_FORCE_RES
;
806 /* Reserve data device quota against the inode's dquots. */
807 error
= xfs_trans_reserve_quota_bydquots(tp
, mp
, ip
->i_udquot
,
808 ip
->i_gdquot
, ip
->i_pdquot
, dblocks
, 0,
809 XFS_QMOPT_RES_REGBLKS
| qflags
);
813 /* Do the same but for realtime blocks. */
814 error
= xfs_trans_reserve_quota_bydquots(tp
, mp
, ip
->i_udquot
,
815 ip
->i_gdquot
, ip
->i_pdquot
, rblocks
, 0,
816 XFS_QMOPT_RES_RTBLKS
| qflags
);
818 xfs_trans_reserve_quota_bydquots(tp
, mp
, ip
->i_udquot
,
819 ip
->i_gdquot
, ip
->i_pdquot
, -dblocks
, 0,
820 XFS_QMOPT_RES_REGBLKS
);
827 /* Change the quota reservations for an inode creation activity. */
829 xfs_trans_reserve_quota_icreate(
830 struct xfs_trans
*tp
,
831 struct xfs_dquot
*udqp
,
832 struct xfs_dquot
*gdqp
,
833 struct xfs_dquot
*pdqp
,
836 struct xfs_mount
*mp
= tp
->t_mountp
;
838 if (!XFS_IS_QUOTA_ON(mp
))
841 return xfs_trans_reserve_quota_bydquots(tp
, mp
, udqp
, gdqp
, pdqp
,
842 dblocks
, 1, XFS_QMOPT_RES_REGBLKS
);
846 xfs_trans_alloc_dqinfo(
849 tp
->t_dqinfo
= kmem_cache_zalloc(xfs_qm_dqtrxzone
,
850 GFP_KERNEL
| __GFP_NOFAIL
);
854 xfs_trans_free_dqinfo(
859 kmem_cache_free(xfs_qm_dqtrxzone
, tp
->t_dqinfo
);