xfs: queue inactivation immediately when quota is nearing enforcement

Now that we have made the inactivation of unlinked inodes a background
task to increase the throughput of file deletions, we need to be a
little more careful about how long of a delay we can tolerate.

Specifically, if the dquots attached to the inode being inactivated are
nearing any kind of enforcement boundary, we want to queue that
inactivation work immediately so that users don't get EDQUOT/ENOSPC
errors even after they deleted a bunch of files to stay within quota.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index f642884a6834855f52025833eecbc1c9288a9289..6b5e3cf40c8b7e91f2eb88f9c7f9544e8c70be53 100644 (file)
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -54,6 +54,16 @@ struct xfs_dquot_res {
        xfs_qwarncnt_t          warnings;
 };
 
+static inline bool
+xfs_dquot_res_over_limits(
+       const struct xfs_dquot_res      *qres)
+{
+       if ((qres->softlimit && qres->softlimit < qres->reserved) ||
+           (qres->hardlimit && qres->hardlimit < qres->reserved))
+               return true;
+       return false;
+}
+
 /*
  * The incore dquot structure
  */

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 8b2ac969c60c9389c7be031b08b94b0462c415fd..0bea604f320a3d71236d8d41f3c916b8a27e4a80 100644 (file)
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1921,6 +1921,7 @@ xfs_inodegc_start(
  *
  *  - We've accumulated more than one inode cluster buffer's worth of inodes.
  *  - There is less than 5% free space left.
+ *  - Any of the quotas for this inode are near an enforcement limit.
  */
 static inline bool
 xfs_inodegc_want_queue_work(
@@ -1937,6 +1938,15 @@ xfs_inodegc_want_queue_work(
                                XFS_FDBLOCKS_BATCH) < 0)
                return true;
 
+       if (xfs_inode_near_dquot_enforcement(ip, XFS_DQTYPE_USER))
+               return true;
+
+       if (xfs_inode_near_dquot_enforcement(ip, XFS_DQTYPE_GROUP))
+               return true;
+
+       if (xfs_inode_near_dquot_enforcement(ip, XFS_DQTYPE_PROJ))
+               return true;
+
        return false;
 }
 

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 351d99bc52e5f8d961961061e5a877b06e270664..2bef4735d03031002c2b30b61c804b0573d72c00 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1882,3 +1882,37 @@ xfs_qm_vop_create_dqattach(
        }
 }
 
+/* Decide if this inode's dquot is near an enforcement boundary. */
+bool
+xfs_inode_near_dquot_enforcement(
+       struct xfs_inode        *ip,
+       xfs_dqtype_t            type)
+{
+       struct xfs_dquot        *dqp;
+       int64_t                 freesp;
+
+       /* We only care for quotas that are enabled and enforced. */
+       dqp = xfs_inode_dquot(ip, type);
+       if (!dqp || !xfs_dquot_is_enforced(dqp))
+               return false;
+
+       if (xfs_dquot_res_over_limits(&dqp->q_ino) ||
+           xfs_dquot_res_over_limits(&dqp->q_rtb))
+               return true;
+
+       /* For space on the data device, check the various thresholds. */
+       if (!dqp->q_prealloc_hi_wmark)
+               return false;
+
+       if (dqp->q_blk.reserved < dqp->q_prealloc_lo_wmark)
+               return false;
+
+       if (dqp->q_blk.reserved >= dqp->q_prealloc_hi_wmark)
+               return true;
+
+       freesp = dqp->q_prealloc_hi_wmark - dqp->q_blk.reserved;
+       if (freesp < dqp->q_low_space[XFS_QLOWSP_5_PCNT])
+               return true;
+
+       return false;
+}

diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index d00d0130254521a3549f8af8084f2f9011708c14..dcc785fdd34532673c6c6ca9c899b77bbb5cebfd 100644 (file)
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -113,6 +113,7 @@ xfs_quota_reserve_blkres(struct xfs_inode *ip, int64_t blocks)
 {
        return xfs_trans_reserve_quota_nblks(NULL, ip, blocks, 0, false);
 }
+bool xfs_inode_near_dquot_enforcement(struct xfs_inode *ip, xfs_dqtype_t type);
 #else
 static inline int
 xfs_qm_vop_dqalloc(struct xfs_inode *ip, kuid_t kuid, kgid_t kgid,
@@ -168,6 +169,7 @@ xfs_trans_reserve_quota_icreate(struct xfs_trans *tp, struct xfs_dquot *udqp,
 #define xfs_qm_mount_quotas(mp)
 #define xfs_qm_unmount(mp)
 #define xfs_qm_unmount_quotas(mp)
+#define xfs_inode_near_dquot_enforcement(ip, type)                     (false)
 #endif /* CONFIG_XFS_QUOTA */
 
 static inline int