From: "Darrick J. Wong" <darrick.wong@oracle.com>
To: Eric Sandeen <sandeen@redhat.com>
Cc: linux-xfs@vger.kernel.org
Subject: Re: [PATCH 6/7] xfs: per-type quota timers and warn limits
Date: Thu, 21 May 2020 19:41:17 -0700 [thread overview]
Message-ID: <20200522024117.GB8230@magnolia> (raw)
In-Reply-To: <1590028518-6043-7-git-send-email-sandeen@redhat.com>
On Wed, May 20, 2020 at 09:35:17PM -0500, Eric Sandeen wrote:
> Move timers and warnings out of xfs_quotainfo and into xfs_def_quota
> so that we can utilize them on a per-type basis, rather than enforcing
> them based on the values found in the first enabled quota type.
>
> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
> [zlang: new way to get defquota in xfs_qm_init_timelimits]
> [zlang: remove redundant defq assign]
> Signed-off-by: Zorro Lang <zlang@redhat.com>
>
> Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Looks decent,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> fs/xfs/xfs_dquot.c | 10 +++++++---
> fs/xfs/xfs_qm.c | 46 +++++++++++++++++++++-------------------------
> fs/xfs/xfs_qm.h | 13 +++++++------
> fs/xfs/xfs_qm_syscalls.c | 12 ++++++------
> fs/xfs/xfs_quotaops.c | 22 +++++++++++-----------
> fs/xfs/xfs_trans_dquot.c | 6 +++---
> 6 files changed, 55 insertions(+), 54 deletions(-)
>
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 6196f7c..d5b7f03 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -116,8 +116,12 @@
> struct xfs_mount *mp,
> struct xfs_dquot *dq)
> {
> + struct xfs_quotainfo *qi = mp->m_quotainfo;
> struct xfs_disk_dquot *d = &dq->q_core;
> + struct xfs_def_quota *defq;
> +
> ASSERT(d->d_id);
> + defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
>
> #ifdef DEBUG
> if (d->d_blk_hardlimit)
> @@ -139,7 +143,7 @@
> (be64_to_cpu(d->d_bcount) >
> be64_to_cpu(d->d_blk_hardlimit)))) {
> d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +
> - mp->m_quotainfo->qi_btimelimit);
> + defq->btimelimit);
> } else {
> d->d_bwarns = 0;
> }
> @@ -162,7 +166,7 @@
> (be64_to_cpu(d->d_icount) >
> be64_to_cpu(d->d_ino_hardlimit)))) {
> d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +
> - mp->m_quotainfo->qi_itimelimit);
> + defq->itimelimit);
> } else {
> d->d_iwarns = 0;
> }
> @@ -185,7 +189,7 @@
> (be64_to_cpu(d->d_rtbcount) >
> be64_to_cpu(d->d_rtb_hardlimit)))) {
> d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +
> - mp->m_quotainfo->qi_rtbtimelimit);
> + defq->rtbtimelimit);
> } else {
> d->d_rtbwarns = 0;
> }
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index ac0b5e7f..d6cd833 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -577,19 +577,22 @@ struct xfs_qm_isolate {
> static void
> xfs_qm_init_timelimits(
> struct xfs_mount *mp,
> - struct xfs_quotainfo *qinf)
> + uint type)
> {
> + struct xfs_quotainfo *qinf = mp->m_quotainfo;
> + struct xfs_def_quota *defq;
> struct xfs_disk_dquot *ddqp;
> struct xfs_dquot *dqp;
> - uint type;
> int error;
>
> - qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
> - qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
> - qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
> - qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
> - qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
> - qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
> + defq = xfs_get_defquota(qinf, type);
> +
> + defq->btimelimit = XFS_QM_BTIMELIMIT;
> + defq->itimelimit = XFS_QM_ITIMELIMIT;
> + defq->rtbtimelimit = XFS_QM_RTBTIMELIMIT;
> + defq->bwarnlimit = XFS_QM_BWARNLIMIT;
> + defq->iwarnlimit = XFS_QM_IWARNLIMIT;
> + defq->rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
>
> /*
> * We try to get the limits from the superuser's limits fields.
> @@ -597,39 +600,30 @@ struct xfs_qm_isolate {
> *
> * 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.
> */
> - if (XFS_IS_UQUOTA_RUNNING(mp))
> - type = XFS_DQ_USER;
> - else if (XFS_IS_GQUOTA_RUNNING(mp))
> - type = XFS_DQ_GROUP;
> - else
> - type = XFS_DQ_PROJ;
> error = xfs_qm_dqget_uncached(mp, 0, type, &dqp);
> if (error)
> return;
>
> ddqp = &dqp->q_core;
> +
> /*
> * The warnings and timers set the grace period given to
> * a user or group before he or she can not perform any
> * more writing. If it is zero, a default is used.
> */
> if (ddqp->d_btimer)
> - qinf->qi_btimelimit = be32_to_cpu(ddqp->d_btimer);
> + defq->btimelimit = be32_to_cpu(ddqp->d_btimer);
> if (ddqp->d_itimer)
> - qinf->qi_itimelimit = be32_to_cpu(ddqp->d_itimer);
> + defq->itimelimit = be32_to_cpu(ddqp->d_itimer);
> if (ddqp->d_rtbtimer)
> - qinf->qi_rtbtimelimit = be32_to_cpu(ddqp->d_rtbtimer);
> + defq->rtbtimelimit = be32_to_cpu(ddqp->d_rtbtimer);
> if (ddqp->d_bwarns)
> - qinf->qi_bwarnlimit = be16_to_cpu(ddqp->d_bwarns);
> + defq->bwarnlimit = be16_to_cpu(ddqp->d_bwarns);
> if (ddqp->d_iwarns)
> - qinf->qi_iwarnlimit = be16_to_cpu(ddqp->d_iwarns);
> + defq->iwarnlimit = be16_to_cpu(ddqp->d_iwarns);
> if (ddqp->d_rtbwarns)
> - qinf->qi_rtbwarnlimit = be16_to_cpu(ddqp->d_rtbwarns);
> + defq->rtbwarnlimit = be16_to_cpu(ddqp->d_rtbwarns);
>
> xfs_qm_dqdestroy(dqp);
> }
> @@ -675,7 +669,9 @@ struct xfs_qm_isolate {
>
> mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
>
> - xfs_qm_init_timelimits(mp, qinf);
> + xfs_qm_init_timelimits(mp, XFS_DQ_USER);
> + xfs_qm_init_timelimits(mp, XFS_DQ_GROUP);
> + xfs_qm_init_timelimits(mp, XFS_DQ_PROJ);
>
> if (XFS_IS_UQUOTA_RUNNING(mp))
> xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
> diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
> index 06df406..c2d1417 100644
> --- a/fs/xfs/xfs_qm.h
> +++ b/fs/xfs/xfs_qm.h
> @@ -41,7 +41,14 @@
> */
> #define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1
>
> +/* Defaults for each quota type: time limits, warn limits, usage limits */
> struct xfs_def_quota {
> + time64_t btimelimit; /* limit for blks timer */
> + time64_t itimelimit; /* limit for inodes timer */
> + time64_t rtbtimelimit; /* limit for rt blks timer */
> + xfs_qwarncnt_t bwarnlimit; /* limit for blks warnings */
> + xfs_qwarncnt_t iwarnlimit; /* limit for inodes warnings */
> + xfs_qwarncnt_t rtbwarnlimit; /* limit for rt blks warnings */
> xfs_qcnt_t bhardlimit; /* default data blk hard limit */
> xfs_qcnt_t bsoftlimit; /* default data blk soft limit */
> xfs_qcnt_t ihardlimit; /* default inode count hard limit */
> @@ -64,12 +71,6 @@ struct xfs_quotainfo {
> struct xfs_inode *qi_pquotaip; /* project quota inode */
> struct list_lru qi_lru;
> int qi_dquots;
> - time64_t qi_btimelimit; /* limit for blks timer */
> - time64_t qi_itimelimit; /* limit for inodes timer */
> - time64_t qi_rtbtimelimit;/* limit for rt blks timer */
> - xfs_qwarncnt_t qi_bwarnlimit; /* limit for blks warnings */
> - xfs_qwarncnt_t qi_iwarnlimit; /* limit for inodes warnings */
> - xfs_qwarncnt_t qi_rtbwarnlimit;/* limit for rt blks warnings */
> struct mutex qi_quotaofflock;/* to serialize quotaoff */
> xfs_filblks_t qi_dqchunklen; /* # BBs in a chunk of dqs */
> uint qi_dqperchunk; /* # ondisk dq in above chunk */
> diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
> index 6fa08ae..9b69ce1 100644
> --- a/fs/xfs/xfs_qm_syscalls.c
> +++ b/fs/xfs/xfs_qm_syscalls.c
> @@ -563,23 +563,23 @@
> * for warnings.
> */
> if (newlim->d_fieldmask & QC_SPC_TIMER) {
> - q->qi_btimelimit = newlim->d_spc_timer;
> + defq->btimelimit = newlim->d_spc_timer;
> ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer);
> }
> if (newlim->d_fieldmask & QC_INO_TIMER) {
> - q->qi_itimelimit = newlim->d_ino_timer;
> + defq->itimelimit = newlim->d_ino_timer;
> ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer);
> }
> if (newlim->d_fieldmask & QC_RT_SPC_TIMER) {
> - q->qi_rtbtimelimit = newlim->d_rt_spc_timer;
> + defq->rtbtimelimit = newlim->d_rt_spc_timer;
> ddq->d_rtbtimer = cpu_to_be32(newlim->d_rt_spc_timer);
> }
> if (newlim->d_fieldmask & QC_SPC_WARNS)
> - q->qi_bwarnlimit = newlim->d_spc_warns;
> + defq->bwarnlimit = newlim->d_spc_warns;
> if (newlim->d_fieldmask & QC_INO_WARNS)
> - q->qi_iwarnlimit = newlim->d_ino_warns;
> + defq->iwarnlimit = newlim->d_ino_warns;
> if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
> - q->qi_rtbwarnlimit = newlim->d_rt_spc_warns;
> + defq->rtbwarnlimit = newlim->d_rt_spc_warns;
> } else {
> /*
> * If the user is now over quota, start the timelimit.
> diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
> index 411eeef..bf809b7 100644
> --- a/fs/xfs/xfs_quotaops.c
> +++ b/fs/xfs/xfs_quotaops.c
> @@ -21,9 +21,9 @@
> struct qc_type_state *tstate,
> struct xfs_mount *mp,
> struct xfs_inode *ip,
> - xfs_ino_t ino)
> + xfs_ino_t ino,
> + struct xfs_def_quota *defq)
> {
> - struct xfs_quotainfo *q = mp->m_quotainfo;
> bool tempqip = false;
>
> tstate->ino = ino;
> @@ -37,12 +37,12 @@
> tstate->flags |= QCI_SYSFILE;
> tstate->blocks = ip->i_d.di_nblocks;
> tstate->nextents = ip->i_df.if_nextents;
> - tstate->spc_timelimit = (u32)q->qi_btimelimit;
> - tstate->ino_timelimit = (u32)q->qi_itimelimit;
> - tstate->rt_spc_timelimit = (u32)q->qi_rtbtimelimit;
> - tstate->spc_warnlimit = q->qi_bwarnlimit;
> - tstate->ino_warnlimit = q->qi_iwarnlimit;
> - tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit;
> + tstate->spc_timelimit = (u32)defq->btimelimit;
> + tstate->ino_timelimit = (u32)defq->itimelimit;
> + tstate->rt_spc_timelimit = (u32)defq->rtbtimelimit;
> + tstate->spc_warnlimit = defq->bwarnlimit;
> + tstate->ino_warnlimit = defq->iwarnlimit;
> + tstate->rt_spc_warnlimit = defq->rtbwarnlimit;
> if (tempqip)
> xfs_irele(ip);
> }
> @@ -77,11 +77,11 @@
> state->s_state[PRJQUOTA].flags |= QCI_LIMITS_ENFORCED;
>
> xfs_qm_fill_state(&state->s_state[USRQUOTA], mp, q->qi_uquotaip,
> - mp->m_sb.sb_uquotino);
> + mp->m_sb.sb_uquotino, &q->qi_usr_default);
> xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip,
> - mp->m_sb.sb_gquotino);
> + mp->m_sb.sb_gquotino, &q->qi_grp_default);
> xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip,
> - mp->m_sb.sb_pquotino);
> + mp->m_sb.sb_pquotino, &q->qi_prj_default);
> return 0;
> }
>
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index edde366..c0f73b8 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -602,7 +602,7 @@
> 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;
> + warnlimit = defq->bwarnlimit;
> resbcountp = &dqp->q_res_bcount;
> } else {
> ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
> @@ -614,7 +614,7 @@
> 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;
> + warnlimit = defq->rtbwarnlimit;
> resbcountp = &dqp->q_res_rtbcount;
> }
>
> @@ -650,7 +650,7 @@
> 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;
> + warnlimit = defq->iwarnlimit;
> hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
> if (!hardlimit)
> hardlimit = defq->ihardlimit;
> --
> 1.8.3.1
>
next prev parent reply other threads:[~2020-05-22 2:41 UTC|newest]
Thread overview: 15+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-05-21 2:35 [PATCH 0/7 V3] xfs: quota fixes and enhancements Eric Sandeen
2020-05-21 2:35 ` [PATCH 1/7] xfs: group quota should return EDQUOT when prj quota enabled Eric Sandeen
2020-05-21 2:35 ` [PATCH 2/7] xfs: always return -ENOSPC on project quota reservation failure Eric Sandeen
2020-05-21 2:35 ` [PATCH 3/7] xfs: fix up some whitespace in quota code Eric Sandeen
2020-05-21 2:35 ` [PATCH 4/7] xfs: pass xfs_dquot to xfs_qm_adjust_dqtimers Eric Sandeen
2020-05-21 2:35 ` [PATCH 5/7] xfs: switch xfs_get_defquota to take explicit type Eric Sandeen
2020-05-21 9:35 ` Christoph Hellwig
2020-05-21 15:05 ` [PATCH 5/7 V2] " Eric Sandeen
2020-05-21 15:18 ` Christoph Hellwig
2020-05-22 2:29 ` Darrick J. Wong
2020-05-21 2:35 ` [PATCH 6/7] xfs: per-type quota timers and warn limits Eric Sandeen
2020-05-21 9:36 ` Christoph Hellwig
2020-05-22 2:41 ` Darrick J. Wong [this message]
2020-05-21 2:35 ` [PATCH 7/7] xfs: allow individual quota grace period extension Eric Sandeen
2020-05-21 9:37 ` Christoph Hellwig
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200522024117.GB8230@magnolia \
--to=darrick.wong@oracle.com \
--cc=linux-xfs@vger.kernel.org \
--cc=sandeen@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.