2 * Copyright (c) 2000-2002 Silicon Graphics, Inc.
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.
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.
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
23 #include "xfs_trans.h"
27 #include "xfs_alloc.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_quota.h"
30 #include "xfs_mount.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_alloc_btree.h"
33 #include "xfs_ialloc_btree.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_dir2_sf.h"
36 #include "xfs_dinode.h"
37 #include "xfs_inode.h"
38 #include "xfs_ialloc.h"
39 #include "xfs_itable.h"
40 #include "xfs_btree.h"
42 #include "xfs_rtalloc.h"
43 #include "xfs_error.h"
47 #include "xfs_buf_item.h"
48 #include "xfs_trans_priv.h"
51 STATIC
void xfs_trans_alloc_dqinfo(xfs_trans_t
*);
54 * Add the locked dquot to the transaction.
55 * The dquot must be locked, and it cannot be associated with any
65 ASSERT(! XFS_DQ_IS_ADDEDTO_TRX(tp
, dqp
));
66 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
67 ASSERT(XFS_DQ_IS_LOGITEM_INITD(dqp
));
71 * Get a log_item_desc to point at the new item.
73 (void) xfs_trans_add_item(tp
, (xfs_log_item_t
*)(lp
));
76 * Initialize i_transp so we can later determine if this dquot is
77 * associated with this transaction.
84 * This is called to mark the dquot as needing
85 * to be logged when the transaction is committed. The dquot must
86 * already be associated with the given transaction.
87 * Note that it marks the entire transaction as dirty. In the ordinary
88 * case, this gets called via xfs_trans_commit, after the transaction
89 * is already dirty. However, there's nothing stop this from getting
90 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
98 xfs_log_item_desc_t
*lidp
;
100 ASSERT(XFS_DQ_IS_ADDEDTO_TRX(tp
, dqp
));
101 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
103 lidp
= xfs_trans_find_item(tp
, (xfs_log_item_t
*)(&dqp
->q_logitem
));
104 ASSERT(lidp
!= NULL
);
106 tp
->t_flags
|= XFS_TRANS_DIRTY
;
107 lidp
->lid_flags
|= XFS_LID_DIRTY
;
111 * Carry forward whatever is left of the quota blk reservation to
112 * the spanky new transaction
115 xfs_trans_dup_dqinfo(
119 xfs_dqtrx_t
*oq
, *nq
;
121 xfs_dqtrx_t
*oqa
, *nqa
;
126 xfs_trans_alloc_dqinfo(ntp
);
127 oqa
= otp
->t_dqinfo
->dqa_usrdquots
;
128 nqa
= ntp
->t_dqinfo
->dqa_usrdquots
;
131 * Because the quota blk reservation is carried forward,
132 * it is also necessary to carry forward the DQ_DIRTY flag.
134 if(otp
->t_flags
& XFS_TRANS_DQ_DIRTY
)
135 ntp
->t_flags
|= XFS_TRANS_DQ_DIRTY
;
137 for (j
= 0; j
< 2; j
++) {
138 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
139 if (oqa
[i
].qt_dquot
== NULL
)
144 nq
->qt_dquot
= oq
->qt_dquot
;
145 nq
->qt_bcount_delta
= nq
->qt_icount_delta
= 0;
146 nq
->qt_rtbcount_delta
= 0;
149 * Transfer whatever is left of the reservations.
151 nq
->qt_blk_res
= oq
->qt_blk_res
- oq
->qt_blk_res_used
;
152 oq
->qt_blk_res
= oq
->qt_blk_res_used
;
154 nq
->qt_rtblk_res
= oq
->qt_rtblk_res
-
155 oq
->qt_rtblk_res_used
;
156 oq
->qt_rtblk_res
= oq
->qt_rtblk_res_used
;
158 nq
->qt_ino_res
= oq
->qt_ino_res
- oq
->qt_ino_res_used
;
159 oq
->qt_ino_res
= oq
->qt_ino_res_used
;
162 oqa
= otp
->t_dqinfo
->dqa_grpdquots
;
163 nqa
= ntp
->t_dqinfo
->dqa_grpdquots
;
168 * Wrap around mod_dquot to account for both user and group quotas.
171 xfs_trans_mod_dquot_byino(
177 xfs_mount_t
*mp
= tp
->t_mountp
;
179 if (!XFS_IS_QUOTA_RUNNING(mp
) ||
180 !XFS_IS_QUOTA_ON(mp
) ||
181 ip
->i_ino
== mp
->m_sb
.sb_uquotino
||
182 ip
->i_ino
== mp
->m_sb
.sb_gquotino
)
185 if (tp
->t_dqinfo
== NULL
)
186 xfs_trans_alloc_dqinfo(tp
);
188 if (XFS_IS_UQUOTA_ON(mp
) && ip
->i_udquot
)
189 (void) xfs_trans_mod_dquot(tp
, ip
->i_udquot
, field
, delta
);
190 if (XFS_IS_OQUOTA_ON(mp
) && ip
->i_gdquot
)
191 (void) xfs_trans_mod_dquot(tp
, ip
->i_gdquot
, field
, delta
);
202 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
203 qa
= XFS_QM_DQP_TO_DQACCT(tp
, dqp
);
205 if (qa
[i
].qt_dquot
== NULL
||
206 qa
[i
].qt_dquot
== dqp
) {
215 * Make the changes in the transaction structure.
216 * The moral equivalent to xfs_trans_mod_sb().
217 * We don't touch any fields in the dquot, so we don't care
218 * if it's locked or not (most of the time it won't be).
230 ASSERT(XFS_IS_QUOTA_RUNNING(tp
->t_mountp
));
233 if (tp
->t_dqinfo
== NULL
)
234 xfs_trans_alloc_dqinfo(tp
);
236 * Find either the first free slot or the slot that belongs
239 qtrx
= xfs_trans_get_dqtrx(tp
, dqp
);
241 if (qtrx
->qt_dquot
== NULL
)
242 qtrx
->qt_dquot
= dqp
;
247 * regular disk blk reservation
249 case XFS_TRANS_DQ_RES_BLKS
:
250 qtrx
->qt_blk_res
+= (ulong
)delta
;
256 case XFS_TRANS_DQ_RES_INOS
:
257 qtrx
->qt_ino_res
+= (ulong
)delta
;
263 case XFS_TRANS_DQ_BCOUNT
:
264 if (qtrx
->qt_blk_res
&& delta
> 0) {
265 qtrx
->qt_blk_res_used
+= (ulong
)delta
;
266 ASSERT(qtrx
->qt_blk_res
>= qtrx
->qt_blk_res_used
);
268 qtrx
->qt_bcount_delta
+= delta
;
271 case XFS_TRANS_DQ_DELBCOUNT
:
272 qtrx
->qt_delbcnt_delta
+= delta
;
278 case XFS_TRANS_DQ_ICOUNT
:
279 if (qtrx
->qt_ino_res
&& delta
> 0) {
280 qtrx
->qt_ino_res_used
+= (ulong
)delta
;
281 ASSERT(qtrx
->qt_ino_res
>= qtrx
->qt_ino_res_used
);
283 qtrx
->qt_icount_delta
+= delta
;
289 case XFS_TRANS_DQ_RES_RTBLKS
:
290 qtrx
->qt_rtblk_res
+= (ulong
)delta
;
296 case XFS_TRANS_DQ_RTBCOUNT
:
297 if (qtrx
->qt_rtblk_res
&& delta
> 0) {
298 qtrx
->qt_rtblk_res_used
+= (ulong
)delta
;
299 ASSERT(qtrx
->qt_rtblk_res
>= qtrx
->qt_rtblk_res_used
);
301 qtrx
->qt_rtbcount_delta
+= delta
;
304 case XFS_TRANS_DQ_DELRTBCOUNT
:
305 qtrx
->qt_delrtb_delta
+= delta
;
311 tp
->t_flags
|= XFS_TRANS_DQ_DIRTY
;
316 * Given an array of dqtrx structures, lock all the dquots associated
317 * and join them to the transaction, provided they have been modified.
318 * We know that the highest number of dquots (of one type - usr OR grp),
319 * involved in a transaction is 2 and that both usr and grp combined - 3.
320 * So, we don't attempt to make this very generic.
323 xfs_trans_dqlockedjoin(
327 ASSERT(q
[0].qt_dquot
!= NULL
);
328 if (q
[1].qt_dquot
== NULL
) {
329 xfs_dqlock(q
[0].qt_dquot
);
330 xfs_trans_dqjoin(tp
, q
[0].qt_dquot
);
332 ASSERT(XFS_QM_TRANS_MAXDQS
== 2);
333 xfs_dqlock2(q
[0].qt_dquot
, q
[1].qt_dquot
);
334 xfs_trans_dqjoin(tp
, q
[0].qt_dquot
);
335 xfs_trans_dqjoin(tp
, q
[1].qt_dquot
);
341 * Called by xfs_trans_commit() and similar in spirit to
342 * xfs_trans_apply_sb_deltas().
343 * Go thru all the dquots belonging to this transaction and modify the
344 * INCORE dquot to reflect the actual usages.
345 * Unreserve just the reservations done by this transaction.
346 * dquot is still left locked at exit.
349 xfs_trans_apply_dquot_deltas(
354 xfs_dqtrx_t
*qtrx
, *qa
;
359 if (!(tp
->t_flags
& XFS_TRANS_DQ_DIRTY
))
362 ASSERT(tp
->t_dqinfo
);
363 qa
= tp
->t_dqinfo
->dqa_usrdquots
;
364 for (j
= 0; j
< 2; j
++) {
365 if (qa
[0].qt_dquot
== NULL
) {
366 qa
= tp
->t_dqinfo
->dqa_grpdquots
;
371 * Lock all of the dquots and join them to the transaction.
373 xfs_trans_dqlockedjoin(tp
, qa
);
375 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
378 * The array of dquots is filled
379 * sequentially, not sparsely.
381 if ((dqp
= qtrx
->qt_dquot
) == NULL
)
384 ASSERT(XFS_DQ_IS_LOCKED(dqp
));
385 ASSERT(XFS_DQ_IS_ADDEDTO_TRX(tp
, dqp
));
388 * adjust the actual number of blocks used
393 * The issue here is - sometimes we don't make a blkquota
394 * reservation intentionally to be fair to users
395 * (when the amount is small). On the other hand,
396 * delayed allocs do make reservations, but that's
397 * outside of a transaction, so we have no
398 * idea how much was really reserved.
399 * So, here we've accumulated delayed allocation blks and
400 * non-delay blks. The assumption is that the
401 * delayed ones are always reserved (outside of a
402 * transaction), and the others may or may not have
403 * quota reservations.
405 totalbdelta
= qtrx
->qt_bcount_delta
+
406 qtrx
->qt_delbcnt_delta
;
407 totalrtbdelta
= qtrx
->qt_rtbcount_delta
+
408 qtrx
->qt_delrtb_delta
;
411 ASSERT(be64_to_cpu(d
->d_bcount
) >=
412 (xfs_qcnt_t
) -totalbdelta
);
414 if (totalrtbdelta
< 0)
415 ASSERT(be64_to_cpu(d
->d_rtbcount
) >=
416 (xfs_qcnt_t
) -totalrtbdelta
);
418 if (qtrx
->qt_icount_delta
< 0)
419 ASSERT(be64_to_cpu(d
->d_icount
) >=
420 (xfs_qcnt_t
) -qtrx
->qt_icount_delta
);
423 be64_add_cpu(&d
->d_bcount
, (xfs_qcnt_t
)totalbdelta
);
425 if (qtrx
->qt_icount_delta
)
426 be64_add_cpu(&d
->d_icount
, (xfs_qcnt_t
)qtrx
->qt_icount_delta
);
429 be64_add_cpu(&d
->d_rtbcount
, (xfs_qcnt_t
)totalrtbdelta
);
432 * Get any default limits in use.
433 * Start/reset the timer(s) if needed.
436 xfs_qm_adjust_dqlimits(tp
->t_mountp
, d
);
437 xfs_qm_adjust_dqtimers(tp
->t_mountp
, d
);
440 dqp
->dq_flags
|= XFS_DQ_DIRTY
;
442 * add this to the list of items to get logged
444 xfs_trans_log_dquot(tp
, dqp
);
446 * Take off what's left of the original reservation.
447 * In case of delayed allocations, there's no
448 * reservation that a transaction structure knows of.
450 if (qtrx
->qt_blk_res
!= 0) {
451 if (qtrx
->qt_blk_res
!= qtrx
->qt_blk_res_used
) {
452 if (qtrx
->qt_blk_res
>
453 qtrx
->qt_blk_res_used
)
454 dqp
->q_res_bcount
-= (xfs_qcnt_t
)
456 qtrx
->qt_blk_res_used
);
458 dqp
->q_res_bcount
-= (xfs_qcnt_t
)
459 (qtrx
->qt_blk_res_used
-
464 * These blks were never reserved, either inside
465 * a transaction or outside one (in a delayed
466 * allocation). Also, this isn't always a
467 * negative number since we sometimes
468 * deliberately skip quota reservations.
470 if (qtrx
->qt_bcount_delta
) {
472 (xfs_qcnt_t
)qtrx
->qt_bcount_delta
;
476 * Adjust the RT reservation.
478 if (qtrx
->qt_rtblk_res
!= 0) {
479 if (qtrx
->qt_rtblk_res
!= qtrx
->qt_rtblk_res_used
) {
480 if (qtrx
->qt_rtblk_res
>
481 qtrx
->qt_rtblk_res_used
)
482 dqp
->q_res_rtbcount
-= (xfs_qcnt_t
)
483 (qtrx
->qt_rtblk_res
-
484 qtrx
->qt_rtblk_res_used
);
486 dqp
->q_res_rtbcount
-= (xfs_qcnt_t
)
487 (qtrx
->qt_rtblk_res_used
-
491 if (qtrx
->qt_rtbcount_delta
)
492 dqp
->q_res_rtbcount
+=
493 (xfs_qcnt_t
)qtrx
->qt_rtbcount_delta
;
497 * Adjust the inode reservation.
499 if (qtrx
->qt_ino_res
!= 0) {
500 ASSERT(qtrx
->qt_ino_res
>=
501 qtrx
->qt_ino_res_used
);
502 if (qtrx
->qt_ino_res
> qtrx
->qt_ino_res_used
)
503 dqp
->q_res_icount
-= (xfs_qcnt_t
)
505 qtrx
->qt_ino_res_used
);
507 if (qtrx
->qt_icount_delta
)
509 (xfs_qcnt_t
)qtrx
->qt_icount_delta
;
512 ASSERT(dqp
->q_res_bcount
>=
513 be64_to_cpu(dqp
->q_core
.d_bcount
));
514 ASSERT(dqp
->q_res_icount
>=
515 be64_to_cpu(dqp
->q_core
.d_icount
));
516 ASSERT(dqp
->q_res_rtbcount
>=
517 be64_to_cpu(dqp
->q_core
.d_rtbcount
));
520 * Do the group quotas next
522 qa
= tp
->t_dqinfo
->dqa_grpdquots
;
527 * Release the reservations, and adjust the dquots accordingly.
528 * This is called only when the transaction is being aborted. If by
529 * any chance we have done dquot modifications incore (ie. deltas) already,
530 * we simply throw those away, since that's the expected behavior
531 * when a transaction is curtailed without a commit.
534 xfs_trans_unreserve_and_mod_dquots(
539 xfs_dqtrx_t
*qtrx
, *qa
;
542 if (!tp
->t_dqinfo
|| !(tp
->t_flags
& XFS_TRANS_DQ_DIRTY
))
545 qa
= tp
->t_dqinfo
->dqa_usrdquots
;
547 for (j
= 0; j
< 2; j
++) {
548 for (i
= 0; i
< XFS_QM_TRANS_MAXDQS
; i
++) {
551 * We assume that the array of dquots is filled
552 * sequentially, not sparsely.
554 if ((dqp
= qtrx
->qt_dquot
) == NULL
)
557 * Unreserve the original reservation. We don't care
558 * about the number of blocks used field, or deltas.
559 * Also we don't bother to zero the fields.
562 if (qtrx
->qt_blk_res
) {
566 (xfs_qcnt_t
)qtrx
->qt_blk_res
;
568 if (qtrx
->qt_ino_res
) {
574 (xfs_qcnt_t
)qtrx
->qt_ino_res
;
577 if (qtrx
->qt_rtblk_res
) {
582 dqp
->q_res_rtbcount
-=
583 (xfs_qcnt_t
)qtrx
->qt_rtblk_res
;
589 qa
= tp
->t_dqinfo
->dqa_grpdquots
;
594 xfs_quota_error(uint flags
)
596 if (flags
& XFS_QMOPT_ENOSPC
)
602 * This reserves disk blocks and inodes against a dquot.
603 * Flags indicate if the dquot is to be locked here and also
604 * if the blk reservation is for RT or regular blocks.
605 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
617 xfs_qcnt_t hardlimit
;
618 xfs_qcnt_t softlimit
;
620 xfs_qwarncnt_t warns
;
621 xfs_qwarncnt_t warnlimit
;
623 xfs_qcnt_t
*resbcountp
;
624 xfs_quotainfo_t
*q
= mp
->m_quotainfo
;
629 if (flags
& XFS_TRANS_DQ_RES_BLKS
) {
630 hardlimit
= be64_to_cpu(dqp
->q_core
.d_blk_hardlimit
);
632 hardlimit
= q
->qi_bhardlimit
;
633 softlimit
= be64_to_cpu(dqp
->q_core
.d_blk_softlimit
);
635 softlimit
= q
->qi_bsoftlimit
;
636 timer
= be32_to_cpu(dqp
->q_core
.d_btimer
);
637 warns
= be16_to_cpu(dqp
->q_core
.d_bwarns
);
638 warnlimit
= XFS_QI_BWARNLIMIT(dqp
->q_mount
);
639 resbcountp
= &dqp
->q_res_bcount
;
641 ASSERT(flags
& XFS_TRANS_DQ_RES_RTBLKS
);
642 hardlimit
= be64_to_cpu(dqp
->q_core
.d_rtb_hardlimit
);
644 hardlimit
= q
->qi_rtbhardlimit
;
645 softlimit
= be64_to_cpu(dqp
->q_core
.d_rtb_softlimit
);
647 softlimit
= q
->qi_rtbsoftlimit
;
648 timer
= be32_to_cpu(dqp
->q_core
.d_rtbtimer
);
649 warns
= be16_to_cpu(dqp
->q_core
.d_rtbwarns
);
650 warnlimit
= XFS_QI_RTBWARNLIMIT(dqp
->q_mount
);
651 resbcountp
= &dqp
->q_res_rtbcount
;
655 if ((flags
& XFS_QMOPT_FORCE_RES
) == 0 &&
657 ((XFS_IS_UQUOTA_ENFORCED(dqp
->q_mount
) && XFS_QM_ISUDQ(dqp
)) ||
658 (XFS_IS_OQUOTA_ENFORCED(dqp
->q_mount
) &&
659 (XFS_QM_ISPDQ(dqp
) || XFS_QM_ISGDQ(dqp
))))) {
661 cmn_err(CE_DEBUG
, "BLK Res: nblks=%ld + resbcount=%Ld"
662 " > hardlimit=%Ld?", nblks
, *resbcountp
, hardlimit
);
666 * dquot is locked already. See if we'd go over the
667 * hardlimit or exceed the timelimit if we allocate
670 if (hardlimit
> 0ULL &&
671 (hardlimit
<= nblks
+ *resbcountp
)) {
672 error
= xfs_quota_error(flags
);
676 if (softlimit
> 0ULL &&
677 (softlimit
<= nblks
+ *resbcountp
)) {
678 if ((timer
!= 0 && get_seconds() > timer
) ||
679 (warns
!= 0 && warns
>= warnlimit
)) {
680 error
= xfs_quota_error(flags
);
686 count
= be64_to_cpu(dqp
->q_core
.d_icount
);
687 timer
= be32_to_cpu(dqp
->q_core
.d_itimer
);
688 warns
= be16_to_cpu(dqp
->q_core
.d_iwarns
);
689 warnlimit
= XFS_QI_IWARNLIMIT(dqp
->q_mount
);
690 hardlimit
= be64_to_cpu(dqp
->q_core
.d_ino_hardlimit
);
692 hardlimit
= q
->qi_ihardlimit
;
693 softlimit
= be64_to_cpu(dqp
->q_core
.d_ino_softlimit
);
695 softlimit
= q
->qi_isoftlimit
;
696 if (hardlimit
> 0ULL && count
>= hardlimit
) {
697 error
= xfs_quota_error(flags
);
699 } else if (softlimit
> 0ULL && count
>= softlimit
) {
700 if ((timer
!= 0 && get_seconds() > timer
) ||
701 (warns
!= 0 && warns
>= warnlimit
)) {
702 error
= xfs_quota_error(flags
);
710 * Change the reservation, but not the actual usage.
711 * Note that q_res_bcount = q_core.d_bcount + resv
713 (*resbcountp
) += (xfs_qcnt_t
)nblks
;
715 dqp
->q_res_icount
+= (xfs_qcnt_t
)ninos
;
718 * note the reservation amt in the trans struct too,
719 * so that the transaction knows how much was reserved by
720 * it against this particular dquot.
721 * We don't do this when we are reserving for a delayed allocation,
722 * because we don't have the luxury of a transaction envelope then.
725 ASSERT(tp
->t_dqinfo
);
726 ASSERT(flags
& XFS_QMOPT_RESBLK_MASK
);
728 xfs_trans_mod_dquot(tp
, dqp
,
729 flags
& XFS_QMOPT_RESBLK_MASK
,
732 xfs_trans_mod_dquot(tp
, dqp
,
733 XFS_TRANS_DQ_RES_INOS
,
736 ASSERT(dqp
->q_res_bcount
>= be64_to_cpu(dqp
->q_core
.d_bcount
));
737 ASSERT(dqp
->q_res_rtbcount
>= be64_to_cpu(dqp
->q_core
.d_rtbcount
));
738 ASSERT(dqp
->q_res_icount
>= be64_to_cpu(dqp
->q_core
.d_icount
));
747 * Given dquot(s), make disk block and/or inode reservations against them.
748 * The fact that this does the reservation against both the usr and
749 * grp/prj quotas is important, because this follows a both-or-nothing
752 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
753 * XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT. Used by pquota.
754 * XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
755 * XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
756 * dquots are unlocked on return, if they were not locked by caller.
759 xfs_trans_reserve_quota_bydquots(
768 int resvd
= 0, error
;
770 if (!XFS_IS_QUOTA_RUNNING(mp
) || !XFS_IS_QUOTA_ON(mp
))
773 if (tp
&& tp
->t_dqinfo
== NULL
)
774 xfs_trans_alloc_dqinfo(tp
);
776 ASSERT(flags
& XFS_QMOPT_RESBLK_MASK
);
779 error
= xfs_trans_dqresv(tp
, mp
, udqp
, nblks
, ninos
,
780 (flags
& ~XFS_QMOPT_ENOSPC
));
787 error
= xfs_trans_dqresv(tp
, mp
, gdqp
, nblks
, ninos
, flags
);
790 * can't do it, so backout previous reservation
793 flags
|= XFS_QMOPT_FORCE_RES
;
794 xfs_trans_dqresv(tp
, mp
, udqp
,
795 -nblks
, -ninos
, flags
);
802 * Didn't change anything critical, so, no need to log
809 * Lock the dquot and change the reservation if we can.
810 * This doesn't change the actual usage, just the reservation.
811 * The inode sent in is locked.
814 xfs_trans_reserve_quota_nblks(
815 struct xfs_trans
*tp
,
816 struct xfs_inode
*ip
,
821 struct xfs_mount
*mp
= ip
->i_mount
;
823 if (!XFS_IS_QUOTA_RUNNING(mp
) || !XFS_IS_QUOTA_ON(mp
))
825 if (XFS_IS_PQUOTA_ON(mp
))
826 flags
|= XFS_QMOPT_ENOSPC
;
828 ASSERT(ip
->i_ino
!= mp
->m_sb
.sb_uquotino
);
829 ASSERT(ip
->i_ino
!= mp
->m_sb
.sb_gquotino
);
831 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
832 ASSERT((flags
& ~(XFS_QMOPT_FORCE_RES
| XFS_QMOPT_ENOSPC
)) ==
833 XFS_TRANS_DQ_RES_RTBLKS
||
834 (flags
& ~(XFS_QMOPT_FORCE_RES
| XFS_QMOPT_ENOSPC
)) ==
835 XFS_TRANS_DQ_RES_BLKS
);
838 * Reserve nblks against these dquots, with trans as the mediator.
840 return xfs_trans_reserve_quota_bydquots(tp
, mp
,
841 ip
->i_udquot
, ip
->i_gdquot
,
842 nblks
, ninos
, flags
);
846 * This routine is called to allocate a quotaoff log item.
849 xfs_trans_get_qoff_item(
851 xfs_qoff_logitem_t
*startqoff
,
854 xfs_qoff_logitem_t
*q
;
858 q
= xfs_qm_qoff_logitem_init(tp
->t_mountp
, startqoff
, flags
);
862 * Get a log_item_desc to point at the new item.
864 (void) xfs_trans_add_item(tp
, (xfs_log_item_t
*)q
);
871 * This is called to mark the quotaoff logitem as needing
872 * to be logged when the transaction is committed. The logitem must
873 * already be associated with the given transaction.
876 xfs_trans_log_quotaoff_item(
878 xfs_qoff_logitem_t
*qlp
)
880 xfs_log_item_desc_t
*lidp
;
882 lidp
= xfs_trans_find_item(tp
, (xfs_log_item_t
*)qlp
);
883 ASSERT(lidp
!= NULL
);
885 tp
->t_flags
|= XFS_TRANS_DIRTY
;
886 lidp
->lid_flags
|= XFS_LID_DIRTY
;
890 xfs_trans_alloc_dqinfo(
893 tp
->t_dqinfo
= kmem_zone_zalloc(xfs_Gqm
->qm_dqtrxzone
, KM_SLEEP
);
897 xfs_trans_free_dqinfo(
902 kmem_zone_free(xfs_Gqm
->qm_dqtrxzone
, tp
->t_dqinfo
);
This page took 0.058837 seconds and 5 git commands to generate.