xfs: Split default quota limits by quota type

Default quotas are globally set due historical reasons. IRIX only
supported user and project quotas, and default quota was only
applied to user quotas.

In Linux, when a default quota is set, all different quota types
inherits the same default value.

An user with a quota limit larger than the default quota value, will
still be limited to the default value because the group quotas also
inherits the default quotas. Unless the group which the user belongs
to have a custom quota limit set.

This patch aims to split the default quota value by quota type.
Allowing each quota type having different default values.

Default time limits are still set globally. XFS does not set a
per-user/group timer, but a single global timer. For changing this
behavior, some changes should be made in user-space tools another
bugs being fixed.

Signed-off-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>

1 files changed, 43 insertions, 12 deletions

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 532ab79d38fe..be125e1758c1 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -560,6 +560,37 @@ xfs_qm_shrink_count(
         return list_lru_shrink_count(&qi->qi_lru, sc);
 }
 
+STATIC void
+xfs_qm_set_defquota(
+        xfs_mount_t     *mp,
+        uint            type,
+        xfs_quotainfo_t *qinf)
+{
+        xfs_dquot_t             *dqp;
+        struct xfs_def_quota    *defq;
+        int                     error;
+
+        error = xfs_qm_dqread(mp, 0, type, XFS_QMOPT_DOWARN, &dqp);
+
+        if (!error) {
+                xfs_disk_dquot_t        *ddqp = &dqp->q_core;
+
+                defq = xfs_get_defquota(dqp, qinf);
+
+                /*
+                 * Timers and warnings have been already set, let's just set the
+                 * default limits for this quota type
+                 */
+                defq->bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
+                defq->bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
+                defq->ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
+                defq->isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
+                defq->rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
+                defq->rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
+                xfs_qm_dqdestroy(dqp);
+        }
+}
+
 /*
  * This initializes all the quota information that's kept in the
  * mount structure
@@ -606,19 +637,19 @@ xfs_qm_init_quotainfo(
          * We try to get the limits from the superuser's limits fields.
          * This is quite hacky, but it is standard quota practice.
          *
-         * We look at the USR dquot with id == 0 first, but if user quotas
-         * are not enabled we goto the GRP dquot with id == 0.
-         * We don't really care to keep separate default limits for user
-         * and group quotas, at least not at this point.
-         *
          * Since we may not have done a quotacheck by this point, just read
          * the dquot without attaching it to any hashtables or lists.
+         *
+         * Timers and warnings are globally set by the first timer found in
+         * user/group/proj quota types, otherwise a default value is used.
+         * This should be split into different fields per quota type.
          */
         error = xfs_qm_dqread(mp, 0,
                         XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
                          (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
                           XFS_DQ_PROJ),
                         XFS_QMOPT_DOWARN, &dqp);
+
         if (!error) {
                 xfs_disk_dquot_t        *ddqp = &dqp->q_core;
 
@@ -639,13 +670,6 @@ xfs_qm_init_quotainfo(
                         be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
                 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
                         be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
-                qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
-                qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
-                qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
-                qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
-                qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
-                qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
-
                 xfs_qm_dqdestroy(dqp);
         } else {
                 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
@@ -656,6 +680,13 @@ xfs_qm_init_quotainfo(
                 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
         }
 
+        if (XFS_IS_UQUOTA_RUNNING(mp))
+                xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
+        if (XFS_IS_GQUOTA_RUNNING(mp))
+                xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
+        if (XFS_IS_PQUOTA_RUNNING(mp))
+                xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);
+
         qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
         qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
         qinf->qi_shrinker.seeks = DEFAULT_SEEKS;