| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (c) 2000-2002 Silicon Graphics, Inc. |
| * All Rights Reserved. |
| */ |
| #include "xfs.h" |
| #include "xfs_fs.h" |
| #include "xfs_shared.h" |
| #include "xfs_format.h" |
| #include "xfs_log_format.h" |
| #include "xfs_trans_resv.h" |
| #include "xfs_mount.h" |
| #include "xfs_inode.h" |
| #include "xfs_trans.h" |
| #include "xfs_trans_priv.h" |
| #include "xfs_quota.h" |
| #include "xfs_qm.h" |
| |
| STATIC void xfs_trans_alloc_dqinfo(xfs_trans_t *); |
| |
| /* |
| * Add the locked dquot to the transaction. |
| * The dquot must be locked, and it cannot be associated with any |
| * transaction. |
| */ |
| void |
| xfs_trans_dqjoin( |
| struct xfs_trans *tp, |
| struct xfs_dquot *dqp) |
| { |
| ASSERT(XFS_DQ_IS_LOCKED(dqp)); |
| ASSERT(dqp->q_logitem.qli_dquot == dqp); |
| |
| /* |
| * Get a log_item_desc to point at the new item. |
| */ |
| xfs_trans_add_item(tp, &dqp->q_logitem.qli_item); |
| } |
| |
| /* |
| * This is called to mark the dquot as needing |
| * to be logged when the transaction is committed. The dquot must |
| * already be associated with the given transaction. |
| * Note that it marks the entire transaction as dirty. In the ordinary |
| * case, this gets called via xfs_trans_commit, after the transaction |
| * is already dirty. However, there's nothing stop this from getting |
| * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY |
| * flag. |
| */ |
| void |
| xfs_trans_log_dquot( |
| struct xfs_trans *tp, |
| struct xfs_dquot *dqp) |
| { |
| ASSERT(XFS_DQ_IS_LOCKED(dqp)); |
| |
| tp->t_flags |= XFS_TRANS_DIRTY; |
| set_bit(XFS_LI_DIRTY, &dqp->q_logitem.qli_item.li_flags); |
| } |
| |
| /* |
| * Carry forward whatever is left of the quota blk reservation to |
| * the spanky new transaction |
| */ |
| void |
| xfs_trans_dup_dqinfo( |
| struct xfs_trans *otp, |
| struct xfs_trans *ntp) |
| { |
| struct xfs_dqtrx *oq, *nq; |
| int i, j; |
| struct xfs_dqtrx *oqa, *nqa; |
| uint64_t blk_res_used; |
| |
| if (!otp->t_dqinfo) |
| return; |
| |
| xfs_trans_alloc_dqinfo(ntp); |
| |
| /* |
| * Because the quota blk reservation is carried forward, |
| * it is also necessary to carry forward the DQ_DIRTY flag. |
| */ |
| if (otp->t_flags & XFS_TRANS_DQ_DIRTY) |
| ntp->t_flags |= XFS_TRANS_DQ_DIRTY; |
| |
| for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) { |
| oqa = otp->t_dqinfo->dqs[j]; |
| nqa = ntp->t_dqinfo->dqs[j]; |
| for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { |
| blk_res_used = 0; |
| |
| if (oqa[i].qt_dquot == NULL) |
| break; |
| oq = &oqa[i]; |
| nq = &nqa[i]; |
| |
| if (oq->qt_blk_res && oq->qt_bcount_delta > 0) |
| blk_res_used = oq->qt_bcount_delta; |
| |
| nq->qt_dquot = oq->qt_dquot; |
| nq->qt_bcount_delta = nq->qt_icount_delta = 0; |
| nq->qt_rtbcount_delta = 0; |
| |
| /* |
| * Transfer whatever is left of the reservations. |
| */ |
| nq->qt_blk_res = oq->qt_blk_res - blk_res_used; |
| oq->qt_blk_res = blk_res_used; |
| |
| nq->qt_rtblk_res = oq->qt_rtblk_res - |
| oq->qt_rtblk_res_used; |
| oq->qt_rtblk_res = oq->qt_rtblk_res_used; |
| |
| nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used; |
| oq->qt_ino_res = oq->qt_ino_res_used; |
| |
| } |
| } |
| } |
| |
| /* |
| * Wrap around mod_dquot to account for both user and group quotas. |
| */ |
| void |
| xfs_trans_mod_dquot_byino( |
| xfs_trans_t *tp, |
| xfs_inode_t *ip, |
| uint field, |
| int64_t delta) |
| { |
| xfs_mount_t *mp = tp->t_mountp; |
| |
| if (!XFS_IS_QUOTA_RUNNING(mp) || |
| !XFS_IS_QUOTA_ON(mp) || |
| xfs_is_quota_inode(&mp->m_sb, ip->i_ino)) |
| return; |
| |
| if (tp->t_dqinfo == NULL) |
| xfs_trans_alloc_dqinfo(tp); |
| |
| if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot) |
| (void) xfs_trans_mod_dquot(tp, ip->i_udquot, field, delta); |
| if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot) |
| (void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta); |
| if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot) |
| (void) xfs_trans_mod_dquot(tp, ip->i_pdquot, field, delta); |
| } |
| |
| STATIC struct xfs_dqtrx * |
| xfs_trans_get_dqtrx( |
| struct xfs_trans *tp, |
| struct xfs_dquot *dqp) |
| { |
| int i; |
| struct xfs_dqtrx *qa; |
| |
| if (XFS_QM_ISUDQ(dqp)) |
| qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR]; |
| else if (XFS_QM_ISGDQ(dqp)) |
| qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP]; |
| else if (XFS_QM_ISPDQ(dqp)) |
| qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ]; |
| else |
| return NULL; |
| |
| for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { |
| if (qa[i].qt_dquot == NULL || |
| qa[i].qt_dquot == dqp) |
| return &qa[i]; |
| } |
| |
| return NULL; |
| } |
| |
| /* |
| * Make the changes in the transaction structure. |
| * The moral equivalent to xfs_trans_mod_sb(). |
| * We don't touch any fields in the dquot, so we don't care |
| * if it's locked or not (most of the time it won't be). |
| */ |
| void |
| xfs_trans_mod_dquot( |
| struct xfs_trans *tp, |
| struct xfs_dquot *dqp, |
| uint field, |
| int64_t delta) |
| { |
| struct xfs_dqtrx *qtrx; |
| |
| ASSERT(tp); |
| ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp)); |
| qtrx = NULL; |
| |
| if (tp->t_dqinfo == NULL) |
| xfs_trans_alloc_dqinfo(tp); |
| /* |
| * Find either the first free slot or the slot that belongs |
| * to this dquot. |
| */ |
| qtrx = xfs_trans_get_dqtrx(tp, dqp); |
| ASSERT(qtrx); |
| if (qtrx->qt_dquot == NULL) |
| qtrx->qt_dquot = dqp; |
| |
| switch (field) { |
| |
| /* |
| * regular disk blk reservation |
| */ |
| case XFS_TRANS_DQ_RES_BLKS: |
| qtrx->qt_blk_res += delta; |
| break; |
| |
| /* |
| * inode reservation |
| */ |
| case XFS_TRANS_DQ_RES_INOS: |
| qtrx->qt_ino_res += delta; |
| break; |
| |
| /* |
| * disk blocks used. |
| */ |
| case XFS_TRANS_DQ_BCOUNT: |
| qtrx->qt_bcount_delta += delta; |
| break; |
| |
| case XFS_TRANS_DQ_DELBCOUNT: |
| qtrx->qt_delbcnt_delta += delta; |
| break; |
| |
| /* |
| * Inode Count |
| */ |
| case XFS_TRANS_DQ_ICOUNT: |
| if (qtrx->qt_ino_res && delta > 0) { |
| qtrx->qt_ino_res_used += delta; |
| ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used); |
| } |
| qtrx->qt_icount_delta += delta; |
| break; |
| |
| /* |
| * rtblk reservation |
| */ |
| case XFS_TRANS_DQ_RES_RTBLKS: |
| qtrx->qt_rtblk_res += delta; |
| break; |
| |
| /* |
| * rtblk count |
| */ |
| case XFS_TRANS_DQ_RTBCOUNT: |
| if (qtrx->qt_rtblk_res && delta > 0) { |
| qtrx->qt_rtblk_res_used += delta; |
| ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used); |
| } |
| qtrx->qt_rtbcount_delta += delta; |
| break; |
| |
| case XFS_TRANS_DQ_DELRTBCOUNT: |
| qtrx->qt_delrtb_delta += delta; |
| break; |
| |
| default: |
| ASSERT(0); |
| } |
| tp->t_flags |= XFS_TRANS_DQ_DIRTY; |
| } |
| |
| |
| /* |
| * Given an array of dqtrx structures, lock all the dquots associated and join |
| * them to the transaction, provided they have been modified. We know that the |
| * highest number of dquots of one type - usr, grp and prj - involved in a |
| * transaction is 3 so we don't need to make this very generic. |
| */ |
| STATIC void |
| xfs_trans_dqlockedjoin( |
| struct xfs_trans *tp, |
| struct xfs_dqtrx *q) |
| { |
| ASSERT(q[0].qt_dquot != NULL); |
| if (q[1].qt_dquot == NULL) { |
| xfs_dqlock(q[0].qt_dquot); |
| xfs_trans_dqjoin(tp, q[0].qt_dquot); |
| } else { |
| ASSERT(XFS_QM_TRANS_MAXDQS == 2); |
| xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot); |
| xfs_trans_dqjoin(tp, q[0].qt_dquot); |
| xfs_trans_dqjoin(tp, q[1].qt_dquot); |
| } |
| } |
| |
| |
| /* |
| * Called by xfs_trans_commit() and similar in spirit to |
| * xfs_trans_apply_sb_deltas(). |
| * Go thru all the dquots belonging to this transaction and modify the |
| * INCORE dquot to reflect the actual usages. |
| * Unreserve just the reservations done by this transaction. |
| * dquot is still left locked at exit. |
| */ |
| void |
| xfs_trans_apply_dquot_deltas( |
| struct xfs_trans *tp) |
| { |
| int i, j; |
| struct xfs_dquot *dqp; |
| struct xfs_dqtrx *qtrx, *qa; |
| struct xfs_disk_dquot *d; |
| int64_t totalbdelta; |
| int64_t totalrtbdelta; |
| |
| if (!(tp->t_flags & XFS_TRANS_DQ_DIRTY)) |
| return; |
| |
| ASSERT(tp->t_dqinfo); |
| for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) { |
| qa = tp->t_dqinfo->dqs[j]; |
| if (qa[0].qt_dquot == NULL) |
| continue; |
| |
| /* |
| * Lock all of the dquots and join them to the transaction. |
| */ |
| xfs_trans_dqlockedjoin(tp, qa); |
| |
| for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { |
| qtrx = &qa[i]; |
| /* |
| * The array of dquots is filled |
| * sequentially, not sparsely. |
| */ |
| if ((dqp = qtrx->qt_dquot) == NULL) |
| break; |
| |
| ASSERT(XFS_DQ_IS_LOCKED(dqp)); |
| |
| /* |
| * adjust the actual number of blocks used |
| */ |
| d = &dqp->q_core; |
| |
| /* |
| * The issue here is - sometimes we don't make a blkquota |
| * reservation intentionally to be fair to users |
| * (when the amount is small). On the other hand, |
| * delayed allocs do make reservations, but that's |
| * outside of a transaction, so we have no |
| * idea how much was really reserved. |
| * So, here we've accumulated delayed allocation blks and |
| * non-delay blks. The assumption is that the |
| * delayed ones are always reserved (outside of a |
| * transaction), and the others may or may not have |
| * quota reservations. |
| */ |
| totalbdelta = qtrx->qt_bcount_delta + |
| qtrx->qt_delbcnt_delta; |
| totalrtbdelta = qtrx->qt_rtbcount_delta + |
| qtrx->qt_delrtb_delta; |
| #ifdef DEBUG |
| if (totalbdelta < 0) |
| ASSERT(be64_to_cpu(d->d_bcount) >= |
| -totalbdelta); |
| |
| if (totalrtbdelta < 0) |
| ASSERT(be64_to_cpu(d->d_rtbcount) >= |
| -totalrtbdelta); |
| |
| if (qtrx->qt_icount_delta < 0) |
| ASSERT(be64_to_cpu(d->d_icount) >= |
| -qtrx->qt_icount_delta); |
| #endif |
| if (totalbdelta) |
| be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta); |
| |
| if (qtrx->qt_icount_delta) |
| be64_add_cpu(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta); |
| |
| if (totalrtbdelta) |
| be64_add_cpu(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta); |
| |
| /* |
| * Get any default limits in use. |
| * Start/reset the timer(s) if needed. |
| */ |
| if (d->d_id) { |
| xfs_qm_adjust_dqlimits(tp->t_mountp, dqp); |
| xfs_qm_adjust_dqtimers(tp->t_mountp, d); |
| } |
| |
| dqp->dq_flags |= XFS_DQ_DIRTY; |
| /* |
| * add this to the list of items to get logged |
| */ |
| xfs_trans_log_dquot(tp, dqp); |
| /* |
| * Take off what's left of the original reservation. |
| * In case of delayed allocations, there's no |
| * reservation that a transaction structure knows of. |
| */ |
| if (qtrx->qt_blk_res != 0) { |
| uint64_t blk_res_used = 0; |
| |
| if (qtrx->qt_bcount_delta > 0) |
| blk_res_used = qtrx->qt_bcount_delta; |
| |
| if (qtrx->qt_blk_res != blk_res_used) { |
| if (qtrx->qt_blk_res > blk_res_used) |
| dqp->q_res_bcount -= (xfs_qcnt_t) |
| (qtrx->qt_blk_res - |
| blk_res_used); |
| else |
| dqp->q_res_bcount -= (xfs_qcnt_t) |
| (blk_res_used - |
| qtrx->qt_blk_res); |
| } |
| } else { |
| /* |
| * These blks were never reserved, either inside |
| * a transaction or outside one (in a delayed |
| * allocation). Also, this isn't always a |
| * negative number since we sometimes |
| * deliberately skip quota reservations. |
| */ |
| if (qtrx->qt_bcount_delta) { |
| dqp->q_res_bcount += |
| (xfs_qcnt_t)qtrx->qt_bcount_delta; |
| } |
| } |
| /* |
| * Adjust the RT reservation. |
| */ |
| if (qtrx->qt_rtblk_res != 0) { |
| if (qtrx->qt_rtblk_res != qtrx->qt_rtblk_res_used) { |
| if (qtrx->qt_rtblk_res > |
| qtrx->qt_rtblk_res_used) |
| dqp->q_res_rtbcount -= (xfs_qcnt_t) |
| (qtrx->qt_rtblk_res - |
| qtrx->qt_rtblk_res_used); |
| else |
| dqp->q_res_rtbcount -= (xfs_qcnt_t) |
| (qtrx->qt_rtblk_res_used - |
| qtrx->qt_rtblk_res); |
| } |
| } else { |
| if (qtrx->qt_rtbcount_delta) |
| dqp->q_res_rtbcount += |
| (xfs_qcnt_t)qtrx->qt_rtbcount_delta; |
| } |
| |
| /* |
| * Adjust the inode reservation. |
| */ |
| if (qtrx->qt_ino_res != 0) { |
| ASSERT(qtrx->qt_ino_res >= |
| qtrx->qt_ino_res_used); |
| if (qtrx->qt_ino_res > qtrx->qt_ino_res_used) |
| dqp->q_res_icount -= (xfs_qcnt_t) |
| (qtrx->qt_ino_res - |
| qtrx->qt_ino_res_used); |
| } else { |
| if (qtrx->qt_icount_delta) |
| dqp->q_res_icount += |
| (xfs_qcnt_t)qtrx->qt_icount_delta; |
| } |
| |
| ASSERT(dqp->q_res_bcount >= |
| be64_to_cpu(dqp->q_core.d_bcount)); |
| ASSERT(dqp->q_res_icount >= |
| be64_to_cpu(dqp->q_core.d_icount)); |
| ASSERT(dqp->q_res_rtbcount >= |
| be64_to_cpu(dqp->q_core.d_rtbcount)); |
| } |
| } |
| } |
| |
| /* |
| * Release the reservations, and adjust the dquots accordingly. |
| * This is called only when the transaction is being aborted. If by |
| * any chance we have done dquot modifications incore (ie. deltas) already, |
| * we simply throw those away, since that's the expected behavior |
| * when a transaction is curtailed without a commit. |
| */ |
| void |
| xfs_trans_unreserve_and_mod_dquots( |
| struct xfs_trans *tp) |
| { |
| int i, j; |
| struct xfs_dquot *dqp; |
| struct xfs_dqtrx *qtrx, *qa; |
| bool locked; |
| |
| if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY)) |
| return; |
| |
| for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) { |
| qa = tp->t_dqinfo->dqs[j]; |
| |
| for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { |
| qtrx = &qa[i]; |
| /* |
| * We assume that the array of dquots is filled |
| * sequentially, not sparsely. |
| */ |
| if ((dqp = qtrx->qt_dquot) == NULL) |
| break; |
| /* |
| * Unreserve the original reservation. We don't care |
| * about the number of blocks used field, or deltas. |
| * Also we don't bother to zero the fields. |
| */ |
| locked = false; |
| if (qtrx->qt_blk_res) { |
| xfs_dqlock(dqp); |
| locked = true; |
| dqp->q_res_bcount -= |
| (xfs_qcnt_t)qtrx->qt_blk_res; |
| } |
| if (qtrx->qt_ino_res) { |
| if (!locked) { |
| xfs_dqlock(dqp); |
| locked = true; |
| } |
| dqp->q_res_icount -= |
| (xfs_qcnt_t)qtrx->qt_ino_res; |
| } |
| |
| if (qtrx->qt_rtblk_res) { |
| if (!locked) { |
| xfs_dqlock(dqp); |
| locked = true; |
| } |
| dqp->q_res_rtbcount -= |
| (xfs_qcnt_t)qtrx->qt_rtblk_res; |
| } |
| if (locked) |
| xfs_dqunlock(dqp); |
| |
| } |
| } |
| } |
| |
| STATIC void |
| xfs_quota_warn( |
| struct xfs_mount *mp, |
| struct xfs_dquot *dqp, |
| int type) |
| { |
| enum quota_type qtype; |
| |
| if (dqp->dq_flags & XFS_DQ_PROJ) |
| qtype = PRJQUOTA; |
| else if (dqp->dq_flags & XFS_DQ_USER) |
| qtype = USRQUOTA; |
| else |
| qtype = GRPQUOTA; |
| |
| quota_send_warning(make_kqid(&init_user_ns, qtype, |
| be32_to_cpu(dqp->q_core.d_id)), |
| mp->m_super->s_dev, type); |
| } |
| |
| /* |
| * This reserves disk blocks and inodes against a dquot. |
| * Flags indicate if the dquot is to be locked here and also |
| * if the blk reservation is for RT or regular blocks. |
| * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check. |
| */ |
| STATIC int |
| xfs_trans_dqresv( |
| struct xfs_trans *tp, |
| struct xfs_mount *mp, |
| struct xfs_dquot *dqp, |
| int64_t nblks, |
| long ninos, |
| uint flags) |
| { |
| xfs_qcnt_t hardlimit; |
| xfs_qcnt_t softlimit; |
| time_t timer; |
| xfs_qwarncnt_t warns; |
| xfs_qwarncnt_t warnlimit; |
| xfs_qcnt_t total_count; |
| xfs_qcnt_t *resbcountp; |
| struct xfs_quotainfo *q = mp->m_quotainfo; |
| struct xfs_def_quota *defq; |
| |
| |
| xfs_dqlock(dqp); |
| |
| defq = xfs_get_defquota(dqp, q); |
| |
| if (flags & XFS_TRANS_DQ_RES_BLKS) { |
| hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit); |
| if (!hardlimit) |
| hardlimit = defq->bhardlimit; |
| softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit); |
| if (!softlimit) |
| softlimit = defq->bsoftlimit; |
| timer = be32_to_cpu(dqp->q_core.d_btimer); |
| warns = be16_to_cpu(dqp->q_core.d_bwarns); |
| warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit; |
| resbcountp = &dqp->q_res_bcount; |
| } else { |
| ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS); |
| hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit); |
| if (!hardlimit) |
| hardlimit = defq->rtbhardlimit; |
| softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit); |
| if (!softlimit) |
| softlimit = defq->rtbsoftlimit; |
| timer = be32_to_cpu(dqp->q_core.d_rtbtimer); |
| warns = be16_to_cpu(dqp->q_core.d_rtbwarns); |
| warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit; |
| resbcountp = &dqp->q_res_rtbcount; |
| } |
| |
| if ((flags & XFS_QMOPT_FORCE_RES) == 0 && |
| dqp->q_core.d_id && |
| ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) || |
| (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) || |
| (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) { |
| if (nblks > 0) { |
| /* |
| * dquot is locked already. See if we'd go over the |
| * hardlimit or exceed the timelimit if we allocate |
| * nblks. |
| */ |
| total_count = *resbcountp + nblks; |
| if (hardlimit && total_count > hardlimit) { |
| xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN); |
| goto error_return; |
| } |
| if (softlimit && total_count > softlimit) { |
| if ((timer != 0 && get_seconds() > timer) || |
| (warns != 0 && warns >= warnlimit)) { |
| xfs_quota_warn(mp, dqp, |
| QUOTA_NL_BSOFTLONGWARN); |
| goto error_return; |
| } |
| |
| xfs_quota_warn(mp, dqp, QUOTA_NL_BSOFTWARN); |
| } |
| } |
| if (ninos > 0) { |
| total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos; |
| timer = be32_to_cpu(dqp->q_core.d_itimer); |
| warns = be16_to_cpu(dqp->q_core.d_iwarns); |
| warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit; |
| hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit); |
| if (!hardlimit) |
| hardlimit = defq->ihardlimit; |
| softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit); |
| if (!softlimit) |
| softlimit = defq->isoftlimit; |
| |
| if (hardlimit && total_count > hardlimit) { |
| xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN); |
| goto error_return; |
| } |
| if (softlimit && total_count > softlimit) { |
| if ((timer != 0 && get_seconds() > timer) || |
| (warns != 0 && warns >= warnlimit)) { |
| xfs_quota_warn(mp, dqp, |
| QUOTA_NL_ISOFTLONGWARN); |
| goto error_return; |
| } |
| xfs_quota_warn(mp, dqp, QUOTA_NL_ISOFTWARN); |
| } |
| } |
| } |
| |
| /* |
| * Change the reservation, but not the actual usage. |
| * Note that q_res_bcount = q_core.d_bcount + resv |
| */ |
| (*resbcountp) += (xfs_qcnt_t)nblks; |
| if (ninos != 0) |
| dqp->q_res_icount += (xfs_qcnt_t)ninos; |
| |
| /* |
| * note the reservation amt in the trans struct too, |
| * so that the transaction knows how much was reserved by |
| * it against this particular dquot. |
| * We don't do this when we are reserving for a delayed allocation, |
| * because we don't have the luxury of a transaction envelope then. |
| */ |
| if (tp) { |
| ASSERT(tp->t_dqinfo); |
| ASSERT(flags & XFS_QMOPT_RESBLK_MASK); |
| if (nblks != 0) |
| xfs_trans_mod_dquot(tp, dqp, |
| flags & XFS_QMOPT_RESBLK_MASK, |
| nblks); |
| if (ninos != 0) |
| xfs_trans_mod_dquot(tp, dqp, |
| XFS_TRANS_DQ_RES_INOS, |
| ninos); |
| } |
| ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount)); |
| ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount)); |
| ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount)); |
| |
| xfs_dqunlock(dqp); |
| return 0; |
| |
| error_return: |
| xfs_dqunlock(dqp); |
| if (flags & XFS_QMOPT_ENOSPC) |
| return -ENOSPC; |
| return -EDQUOT; |
| } |
| |
| |
| /* |
| * Given dquot(s), make disk block and/or inode reservations against them. |
| * The fact that this does the reservation against user, group and |
| * project quotas is important, because this follows a all-or-nothing |
| * approach. |
| * |
| * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown. |
| * XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT. Used by pquota. |
| * XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks |
| * XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks |
| * dquots are unlocked on return, if they were not locked by caller. |
| */ |
| int |
| xfs_trans_reserve_quota_bydquots( |
| struct xfs_trans *tp, |
| struct xfs_mount *mp, |
| struct xfs_dquot *udqp, |
| struct xfs_dquot *gdqp, |
| struct xfs_dquot *pdqp, |
| int64_t nblks, |
| long ninos, |
| uint flags) |
| { |
| int error; |
| |
| if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) |
| return 0; |
| |
| if (tp && tp->t_dqinfo == NULL) |
| xfs_trans_alloc_dqinfo(tp); |
| |
| ASSERT(flags & XFS_QMOPT_RESBLK_MASK); |
| |
| if (udqp) { |
| error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos, |
| (flags & ~XFS_QMOPT_ENOSPC)); |
| if (error) |
| return error; |
| } |
| |
| if (gdqp) { |
| error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags); |
| if (error) |
| goto unwind_usr; |
| } |
| |
| if (pdqp) { |
| error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags); |
| if (error) |
| goto unwind_grp; |
| } |
| |
| /* |
| * Didn't change anything critical, so, no need to log |
| */ |
| return 0; |
| |
| unwind_grp: |
| flags |= XFS_QMOPT_FORCE_RES; |
| if (gdqp) |
| xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags); |
| unwind_usr: |
| flags |= XFS_QMOPT_FORCE_RES; |
| if (udqp) |
| xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags); |
| return error; |
| } |
| |
| |
| /* |
| * Lock the dquot and change the reservation if we can. |
| * This doesn't change the actual usage, just the reservation. |
| * The inode sent in is locked. |
| */ |
| int |
| xfs_trans_reserve_quota_nblks( |
| struct xfs_trans *tp, |
| struct xfs_inode *ip, |
| int64_t nblks, |
| long ninos, |
| uint flags) |
| { |
| struct xfs_mount *mp = ip->i_mount; |
| |
| if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) |
| return 0; |
| if (XFS_IS_PQUOTA_ON(mp)) |
| flags |= XFS_QMOPT_ENOSPC; |
| |
| ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino)); |
| |
| ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); |
| ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) == |
| XFS_TRANS_DQ_RES_RTBLKS || |
| (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) == |
| XFS_TRANS_DQ_RES_BLKS); |
| |
| /* |
| * Reserve nblks against these dquots, with trans as the mediator. |
| */ |
| return xfs_trans_reserve_quota_bydquots(tp, mp, |
| ip->i_udquot, ip->i_gdquot, |
| ip->i_pdquot, |
| nblks, ninos, flags); |
| } |
| |
| /* |
| * This routine is called to allocate a quotaoff log item. |
| */ |
| struct xfs_qoff_logitem * |
| xfs_trans_get_qoff_item( |
| struct xfs_trans *tp, |
| struct xfs_qoff_logitem *startqoff, |
| uint flags) |
| { |
| struct xfs_qoff_logitem *q; |
| |
| ASSERT(tp != NULL); |
| |
| q = xfs_qm_qoff_logitem_init(tp->t_mountp, startqoff, flags); |
| ASSERT(q != NULL); |
| |
| /* |
| * Get a log_item_desc to point at the new item. |
| */ |
| xfs_trans_add_item(tp, &q->qql_item); |
| return q; |
| } |
| |
| |
| /* |
| * This is called to mark the quotaoff logitem as needing |
| * to be logged when the transaction is committed. The logitem must |
| * already be associated with the given transaction. |
| */ |
| void |
| xfs_trans_log_quotaoff_item( |
| struct xfs_trans *tp, |
| struct xfs_qoff_logitem *qlp) |
| { |
| tp->t_flags |= XFS_TRANS_DIRTY; |
| set_bit(XFS_LI_DIRTY, &qlp->qql_item.li_flags); |
| } |
| |
| STATIC void |
| xfs_trans_alloc_dqinfo( |
| xfs_trans_t *tp) |
| { |
| tp->t_dqinfo = kmem_zone_zalloc(xfs_qm_dqtrxzone, 0); |
| } |
| |
| void |
| xfs_trans_free_dqinfo( |
| xfs_trans_t *tp) |
| { |
| if (!tp->t_dqinfo) |
| return; |
| kmem_cache_free(xfs_qm_dqtrxzone, tp->t_dqinfo); |
| tp->t_dqinfo = NULL; |
| } |