From: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
Add timers fields to the incore dquot, and use that instead of the ones
in qcore. This eliminates a bunch of endian conversions and will
eventually allow us to remove qcore entirely.
Signed-off-by: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
Reviewed-by: Chandan Babu R <chandanrlinux@xxxxxxxxx>
Reviewed-by: Christoph Hellwig <hch@xxxxxx>
Reviewed-by: Allison Collins <allison.henderson@xxxxxxxxxx>
---
fs/xfs/xfs_dquot.c | 41 +++++++++++++++++++++++------------------
fs/xfs/xfs_dquot.h | 7 +++++++
fs/xfs/xfs_qm.c | 15 ++++++---------
fs/xfs/xfs_qm_syscalls.c | 18 ++++++++----------
fs/xfs/xfs_trans_dquot.c | 6 +++---
5 files changed, 47 insertions(+), 40 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 44a082cb6b87..16ad0cefe5b5 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -117,7 +117,6 @@ xfs_qm_adjust_dqtimers(
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(dq->q_id);
@@ -132,13 +131,13 @@ xfs_qm_adjust_dqtimers(
ASSERT(dq->q_rtb.softlimit <= dq->q_rtb.hardlimit);
#endif
- if (!d->d_btimer) {
+ if (!dq->q_blk.timer) {
if ((dq->q_blk.softlimit &&
(dq->q_blk.count > dq->q_blk.softlimit)) ||
(dq->q_blk.hardlimit &&
(dq->q_blk.count > dq->q_blk.hardlimit))) {
- d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +
- defq->btimelimit);
+ dq->q_blk.timer = ktime_get_real_seconds() +
+ defq->btimelimit;
} else {
dq->q_blk.warnings = 0;
}
@@ -147,17 +146,17 @@ xfs_qm_adjust_dqtimers(
(dq->q_blk.count <= dq->q_blk.softlimit)) &&
(!dq->q_blk.hardlimit ||
(dq->q_blk.count <= dq->q_blk.hardlimit))) {
- d->d_btimer = 0;
+ dq->q_blk.timer = 0;
}
}
- if (!d->d_itimer) {
+ if (!dq->q_ino.timer) {
if ((dq->q_ino.softlimit &&
(dq->q_ino.count > dq->q_ino.softlimit)) ||
(dq->q_ino.hardlimit &&
(dq->q_ino.count > dq->q_ino.hardlimit))) {
- d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +
- defq->itimelimit);
+ dq->q_ino.timer = ktime_get_real_seconds() +
+ defq->itimelimit;
} else {
dq->q_ino.warnings = 0;
}
@@ -166,17 +165,17 @@ xfs_qm_adjust_dqtimers(
(dq->q_ino.count <= dq->q_ino.softlimit)) &&
(!dq->q_ino.hardlimit ||
(dq->q_ino.count <= dq->q_ino.hardlimit))) {
- d->d_itimer = 0;
+ dq->q_ino.timer = 0;
}
}
- if (!d->d_rtbtimer) {
+ if (!dq->q_rtb.timer) {
if ((dq->q_rtb.softlimit &&
(dq->q_rtb.count > dq->q_rtb.softlimit)) ||
(dq->q_rtb.hardlimit &&
(dq->q_rtb.count > dq->q_rtb.hardlimit))) {
- d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +
- defq->rtbtimelimit);
+ dq->q_rtb.timer = ktime_get_real_seconds() +
+ defq->rtbtimelimit;
} else {
dq->q_rtb.warnings = 0;
}
@@ -185,7 +184,7 @@ xfs_qm_adjust_dqtimers(
(dq->q_rtb.count <= dq->q_rtb.softlimit)) &&
(!dq->q_rtb.hardlimit ||
(dq->q_rtb.count <= dq->q_rtb.hardlimit))) {
- d->d_rtbtimer = 0;
+ dq->q_rtb.timer = 0;
}
}
}
@@ -553,6 +552,10 @@ xfs_dquot_from_disk(
dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns);
dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns);
+ dqp->q_blk.timer = be32_to_cpu(ddqp->d_btimer);
+ dqp->q_ino.timer = be32_to_cpu(ddqp->d_itimer);
+ dqp->q_rtb.timer = be32_to_cpu(ddqp->d_rtbtimer);
+
/*
* Reservation counters are defined as reservation plus current usage
* to avoid having to add every time.
@@ -588,6 +591,10 @@ xfs_dquot_to_disk(
ddqp->d_bwarns = cpu_to_be16(dqp->q_blk.warnings);
ddqp->d_iwarns = cpu_to_be16(dqp->q_ino.warnings);
ddqp->d_rtbwarns = cpu_to_be16(dqp->q_rtb.warnings);
+
+ ddqp->d_btimer = cpu_to_be32(dqp->q_blk.timer);
+ ddqp->d_itimer = cpu_to_be32(dqp->q_ino.timer);
+ ddqp->d_rtbtimer = cpu_to_be32(dqp->q_rtb.timer);
}
/* Allocate and initialize the dquot buffer for this in-core dquot. */
@@ -1149,8 +1156,6 @@ static xfs_failaddr_t
xfs_qm_dqflush_check(
struct xfs_dquot *dqp)
{
- struct xfs_disk_dquot *ddq = &dqp->q_core;
-
if (dqp->q_type != XFS_DQTYPE_USER &&
dqp->q_type != XFS_DQTYPE_GROUP &&
dqp->q_type != XFS_DQTYPE_PROJ)
@@ -1160,15 +1165,15 @@ xfs_qm_dqflush_check(
return NULL;
if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit &&
- !ddq->d_btimer)
+ !dqp->q_blk.timer)
return __this_address;
if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit &&
- !ddq->d_itimer)
+ !dqp->q_ino.timer)
return __this_address;
if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit &&
- !ddq->d_rtbtimer)
+ !dqp->q_rtb.timer)
return __this_address;
return NULL;
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 4c6460637e55..6ad89ccb80c0 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -38,6 +38,13 @@ struct xfs_dquot_res {
xfs_qcnt_t hardlimit;
xfs_qcnt_t softlimit;
+ /*
+ * For root dquots, this is the default grace period, in seconds.
+ * Otherwise, this is when the quota grace period expires,
+ * in seconds since the Unix epoch.
+ */
+ time64_t timer;
+
/*
* For root dquots, this is the maximum number of warnings that will
* be issued for this quota type. Otherwise, this is the number of
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 5633c03109c0..f0418a9c8364 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -577,7 +577,6 @@ xfs_qm_init_timelimits(
{
struct xfs_quotainfo *qinf = mp->m_quotainfo;
struct xfs_def_quota *defq;
- struct xfs_disk_dquot *ddqp;
struct xfs_dquot *dqp;
int error;
@@ -601,19 +600,17 @@ xfs_qm_init_timelimits(
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)
- defq->btimelimit = be32_to_cpu(ddqp->d_btimer);
- if (ddqp->d_itimer)
- defq->itimelimit = be32_to_cpu(ddqp->d_itimer);
- if (ddqp->d_rtbtimer)
- defq->rtbtimelimit = be32_to_cpu(ddqp->d_rtbtimer);
+ if (dqp->q_blk.timer)
+ defq->btimelimit = dqp->q_blk.timer;
+ if (dqp->q_ino.timer)
+ defq->itimelimit = dqp->q_ino.timer;
+ if (dqp->q_rtb.timer)
+ defq->rtbtimelimit = dqp->q_rtb.timer;
if (dqp->q_blk.warnings)
defq->bwarnlimit = dqp->q_blk.warnings;
if (dqp->q_ino.warnings)
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 4352169b644c..3bb844317d02 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -447,7 +447,6 @@ xfs_qm_scall_setqlim(
struct qc_dqblk *newlim)
{
struct xfs_quotainfo *q = mp->m_quotainfo;
- struct xfs_disk_dquot *ddq;
struct xfs_dquot *dqp;
struct xfs_trans *tp;
struct xfs_def_quota *defq;
@@ -488,7 +487,6 @@ xfs_qm_scall_setqlim(
xfs_dqlock(dqp);
xfs_trans_dqjoin(tp, dqp);
- ddq = &dqp->q_core;
/*
* Make sure that hardlimits are >= soft limits before changing.
@@ -573,11 +571,11 @@ xfs_qm_scall_setqlim(
* the soft limit.
*/
if (newlim->d_fieldmask & QC_SPC_TIMER)
- ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer);
+ dqp->q_blk.timer = newlim->d_spc_timer;
if (newlim->d_fieldmask & QC_INO_TIMER)
- ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer);
+ dqp->q_ino.timer = newlim->d_ino_timer;
if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
- ddq->d_rtbtimer = cpu_to_be32(newlim->d_rt_spc_timer);
+ dqp->q_rtb.timer = newlim->d_rt_spc_timer;
if (id == 0) {
if (newlim->d_fieldmask & QC_SPC_TIMER)
@@ -621,18 +619,18 @@ xfs_qm_scall_getquota_fill_qc(
memset(dst, 0, sizeof(*dst));
dst->d_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_blk.hardlimit);
dst->d_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_blk.softlimit);
- dst->d_ino_hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
- dst->d_ino_softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
+ dst->d_ino_hardlimit = dqp->q_ino.hardlimit;
+ dst->d_ino_softlimit = dqp->q_ino.softlimit;
dst->d_space = XFS_FSB_TO_B(mp, dqp->q_blk.reserved);
dst->d_ino_count = dqp->q_ino.reserved;
- dst->d_spc_timer = be32_to_cpu(dqp->q_core.d_btimer);
- dst->d_ino_timer = be32_to_cpu(dqp->q_core.d_itimer);
+ dst->d_spc_timer = dqp->q_blk.timer;
+ dst->d_ino_timer = dqp->q_ino.timer;
dst->d_ino_warns = dqp->q_ino.warnings;
dst->d_spc_warns = dqp->q_blk.warnings;
dst->d_rt_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.hardlimit);
dst->d_rt_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.softlimit);
dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_rtb.reserved);
- dst->d_rt_spc_timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
+ dst->d_rt_spc_timer = dqp->q_rtb.timer;
dst->d_rt_spc_warns = dqp->q_rtb.warnings;
/*
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 995636a63685..71f771c2fb34 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -598,7 +598,7 @@ xfs_trans_dqresv(
softlimit = dqp->q_blk.softlimit;
if (!softlimit)
softlimit = defq->bsoftlimit;
- timer = be32_to_cpu(dqp->q_core.d_btimer);
+ timer = dqp->q_blk.timer;
warns = dqp->q_blk.warnings;
warnlimit = defq->bwarnlimit;
resbcountp = &dqp->q_blk.reserved;
@@ -610,7 +610,7 @@ xfs_trans_dqresv(
softlimit = dqp->q_rtb.softlimit;
if (!softlimit)
softlimit = defq->rtbsoftlimit;
- timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
+ timer = dqp->q_rtb.timer;
warns = dqp->q_rtb.warnings;
warnlimit = defq->rtbwarnlimit;
resbcountp = &dqp->q_rtb.reserved;
@@ -645,7 +645,7 @@ xfs_trans_dqresv(
}
if (ninos > 0) {
total_count = dqp->q_ino.reserved + ninos;
- timer = be32_to_cpu(dqp->q_core.d_itimer);
+ timer = dqp->q_ino.timer;
warns = dqp->q_ino.warnings;
warnlimit = defq->iwarnlimit;
hardlimit = dqp->q_ino.hardlimit;
