* [PATCH 01/26] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
@ 2020-07-15 1:50 ` Darrick J. Wong
2020-07-15 1:50 ` [PATCH 02/26] xfs: fix inode quota reservation checks Darrick J. Wong
` (24 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:50 UTC (permalink / raw)
To: darrick.wong
Cc: Allison Collins, Chandan Babu R, Christoph Hellwig, Brian Foster,
Dave Chinner, Dave Chinner, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
In commit 8d3d7e2b35ea, we changed xfs_qm_dqpurge to bail out if we
can't lock the dquot buf to flush the dquot. This prevents the AIL from
blocking on the dquot, but it also forgets to clear the FREEING flag on
its way out. A subsequent purge attempt will see the FREEING flag is
set and bail out, which leads to dqpurge_all failing to purge all the
dquots.
(copy-pasting from Dave Chinner's identical patch)
This was found by inspection after having xfs/305 hang 1 in ~50
iterations in a quotaoff operation:
[ 8872.301115] xfs_quota D13888 92262 91813 0x00004002
[ 8872.302538] Call Trace:
[ 8872.303193] __schedule+0x2d2/0x780
[ 8872.304108] ? do_raw_spin_unlock+0x57/0xd0
[ 8872.305198] schedule+0x6e/0xe0
[ 8872.306021] schedule_timeout+0x14d/0x300
[ 8872.307060] ? __next_timer_interrupt+0xe0/0xe0
[ 8872.308231] ? xfs_qm_dqusage_adjust+0x200/0x200
[ 8872.309422] schedule_timeout_uninterruptible+0x2a/0x30
[ 8872.310759] xfs_qm_dquot_walk.isra.0+0x15a/0x1b0
[ 8872.311971] xfs_qm_dqpurge_all+0x7f/0x90
[ 8872.313022] xfs_qm_scall_quotaoff+0x18d/0x2b0
[ 8872.314163] xfs_quota_disable+0x3a/0x60
[ 8872.315179] kernel_quotactl+0x7e2/0x8d0
[ 8872.316196] ? __do_sys_newstat+0x51/0x80
[ 8872.317238] __x64_sys_quotactl+0x1e/0x30
[ 8872.318266] do_syscall_64+0x46/0x90
[ 8872.319193] entry_SYSCALL_64_after_hwframe+0x44/0xa9
[ 8872.320490] RIP: 0033:0x7f46b5490f2a
[ 8872.321414] Code: Bad RIP value.
Returning -EAGAIN from xfs_qm_dqpurge() without clearing the
XFS_DQ_FREEING flag means the xfs_qm_dqpurge_all() code can never
free the dquot, and we loop forever waiting for the XFS_DQ_FREEING
flag to go away on the dquot that leaked it via -EAGAIN.
Fixes: 8d3d7e2b35ea ("xfs: trylock underlying buffer on dquot flush")
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
---
fs/xfs/xfs_qm.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index d6cd83317344..938023dd8ce5 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -148,6 +148,7 @@ xfs_qm_dqpurge(
error = xfs_bwrite(bp);
xfs_buf_relse(bp);
} else if (error == -EAGAIN) {
+ dqp->dq_flags &= ~XFS_DQ_FREEING;
goto out_unlock;
}
xfs_dqflock(dqp);
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 02/26] xfs: fix inode quota reservation checks
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
2020-07-15 1:50 ` [PATCH 01/26] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
@ 2020-07-15 1:50 ` Darrick J. Wong
2020-07-15 1:50 ` [PATCH 03/26] xfs: validate ondisk/incore dquot flags Darrick J. Wong
` (23 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:50 UTC (permalink / raw)
To: darrick.wong
Cc: Allison Collins, Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
xfs_trans_dqresv is the function that we use to make reservations
against resource quotas. Each resource contains two counters: the
q_core counter, which tracks resources allocated on disk; and the dquot
reservation counter, which tracks how much of that resource has either
been allocated or reserved by threads that are working on metadata
updates.
For disk blocks, we compare the proposed reservation counter against the
hard and soft limits to decide if we're going to fail the operation.
However, for inodes we inexplicably compare against the q_core counter,
not the incore reservation count.
Since the q_core counter is always lower than the reservation count and
we unlock the dquot between reservation and transaction commit, this
means that multiple threads can reserve the last inode count before we
hit the hard limit, and when they commit, we'll be well over the hard
limit.
Fix this by checking against the incore inode reservation counter, since
we would appear to maintain that correctly (and that's what we report in
GETQUOTA).
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_trans_dquot.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index c0f73b82c055..ed0ce8b301b4 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -647,7 +647,7 @@ xfs_trans_dqresv(
}
}
if (ninos > 0) {
- total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos;
+ total_count = dqp->q_res_icount + ninos;
timer = be32_to_cpu(dqp->q_core.d_itimer);
warns = be16_to_cpu(dqp->q_core.d_iwarns);
warnlimit = defq->iwarnlimit;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 03/26] xfs: validate ondisk/incore dquot flags
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
2020-07-15 1:50 ` [PATCH 01/26] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
2020-07-15 1:50 ` [PATCH 02/26] xfs: fix inode quota reservation checks Darrick J. Wong
@ 2020-07-15 1:50 ` Darrick J. Wong
2020-07-15 12:50 ` Chandan Babu R
2020-07-15 1:50 ` [PATCH 04/26] xfs: move the flags argument of xfs_qm_scall_trunc_qfiles to XFS_QMOPT_* Darrick J. Wong
` (22 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:50 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
While loading dquot records off disk, make sure that the quota type
flags are the same between the incore dquot and the ondisk dquot.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_dquot.c | 23 ++++++++++++++++++++---
1 file changed, 20 insertions(+), 3 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 76353c9a723e..7503c6695569 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -23,6 +23,7 @@
#include "xfs_trace.h"
#include "xfs_log.h"
#include "xfs_bmap_btree.h"
+#include "xfs_error.h"
/*
* Lock order:
@@ -524,13 +525,26 @@ xfs_dquot_alloc(
}
/* Copy the in-core quota fields in from the on-disk buffer. */
-STATIC void
+STATIC int
xfs_dquot_from_disk(
struct xfs_dquot *dqp,
struct xfs_buf *bp)
{
struct xfs_disk_dquot *ddqp = bp->b_addr + dqp->q_bufoffset;
+ /*
+ * Ensure that we got the type and ID we were looking for.
+ * Everything else was checked by the dquot buffer verifier.
+ */
+ if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->dq_flags ||
+ ddqp->d_id != dqp->q_core.d_id) {
+ xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
+ "Metadata corruption detected at %pS, quota %u",
+ __this_address, be32_to_cpu(dqp->q_core.d_id));
+ xfs_alert(bp->b_mount, "Unmount and run xfs_repair");
+ return -EFSCORRUPTED;
+ }
+
/* copy everything from disk dquot to the incore dquot */
memcpy(&dqp->q_core, ddqp, sizeof(struct xfs_disk_dquot));
@@ -544,6 +558,7 @@ xfs_dquot_from_disk(
/* initialize the dquot speculative prealloc thresholds */
xfs_dquot_set_prealloc_limits(dqp);
+ return 0;
}
/* Allocate and initialize the dquot buffer for this in-core dquot. */
@@ -617,9 +632,11 @@ xfs_qm_dqread(
* further.
*/
ASSERT(xfs_buf_islocked(bp));
- xfs_dquot_from_disk(dqp, bp);
-
+ error = xfs_dquot_from_disk(dqp, bp);
xfs_buf_relse(bp);
+ if (error)
+ goto err;
+
*dqpp = dqp;
return error;
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 03/26] xfs: validate ondisk/incore dquot flags
2020-07-15 1:50 ` [PATCH 03/26] xfs: validate ondisk/incore dquot flags Darrick J. Wong
@ 2020-07-15 12:50 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-15 12:50 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:20:52 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> While loading dquot records off disk, make sure that the quota type
> flags are the same between the incore dquot and the ondisk dquot.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/xfs_dquot.c | 23 ++++++++++++++++++++---
> 1 file changed, 20 insertions(+), 3 deletions(-)
>
>
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 76353c9a723e..7503c6695569 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -23,6 +23,7 @@
> #include "xfs_trace.h"
> #include "xfs_log.h"
> #include "xfs_bmap_btree.h"
> +#include "xfs_error.h"
>
> /*
> * Lock order:
> @@ -524,13 +525,26 @@ xfs_dquot_alloc(
> }
>
> /* Copy the in-core quota fields in from the on-disk buffer. */
> -STATIC void
> +STATIC int
> xfs_dquot_from_disk(
> struct xfs_dquot *dqp,
> struct xfs_buf *bp)
> {
> struct xfs_disk_dquot *ddqp = bp->b_addr + dqp->q_bufoffset;
>
> + /*
> + * Ensure that we got the type and ID we were looking for.
> + * Everything else was checked by the dquot buffer verifier.
> + */
> + if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->dq_flags ||
> + ddqp->d_id != dqp->q_core.d_id) {
> + xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
> + "Metadata corruption detected at %pS, quota %u",
> + __this_address, be32_to_cpu(dqp->q_core.d_id));
> + xfs_alert(bp->b_mount, "Unmount and run xfs_repair");
> + return -EFSCORRUPTED;
> + }
> +
> /* copy everything from disk dquot to the incore dquot */
> memcpy(&dqp->q_core, ddqp, sizeof(struct xfs_disk_dquot));
>
> @@ -544,6 +558,7 @@ xfs_dquot_from_disk(
>
> /* initialize the dquot speculative prealloc thresholds */
> xfs_dquot_set_prealloc_limits(dqp);
> + return 0;
> }
>
> /* Allocate and initialize the dquot buffer for this in-core dquot. */
> @@ -617,9 +632,11 @@ xfs_qm_dqread(
> * further.
> */
> ASSERT(xfs_buf_islocked(bp));
> - xfs_dquot_from_disk(dqp, bp);
> -
> + error = xfs_dquot_from_disk(dqp, bp);
> xfs_buf_relse(bp);
> + if (error)
> + goto err;
> +
> *dqpp = dqp;
> return error;
>
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 04/26] xfs: move the flags argument of xfs_qm_scall_trunc_qfiles to XFS_QMOPT_*
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (2 preceding siblings ...)
2020-07-15 1:50 ` [PATCH 03/26] xfs: validate ondisk/incore dquot flags Darrick J. Wong
@ 2020-07-15 1:50 ` Darrick J. Wong
2020-07-15 12:50 ` Chandan Babu R
2020-07-15 1:51 ` [PATCH 05/26] xfs: split the incore dquot type into a separate field Darrick J. Wong
` (21 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:50 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Since xfs_qm_scall_trunc_qfiles can take a bitset of quota types that we
want to truncate, change the flags argument to take XFS_QMOPT_[UGP}QUOTA
so that the next patch can start to deprecate XFS_DQ_*.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_qm_syscalls.c | 8 ++++----
fs/xfs/xfs_quotaops.c | 6 +++---
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 7effd7a28136..35fad348e3a2 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -322,23 +322,23 @@ xfs_qm_scall_trunc_qfiles(
int error = -EINVAL;
if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
- (flags & ~XFS_DQ_ALLTYPES)) {
+ (flags & ~XFS_QMOPT_QUOTALL)) {
xfs_debug(mp, "%s: flags=%x m_qflags=%x",
__func__, flags, mp->m_qflags);
return -EINVAL;
}
- if (flags & XFS_DQ_USER) {
+ if (flags & XFS_QMOPT_UQUOTA) {
error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
if (error)
return error;
}
- if (flags & XFS_DQ_GROUP) {
+ if (flags & XFS_QMOPT_GQUOTA) {
error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
if (error)
return error;
}
- if (flags & XFS_DQ_PROJ)
+ if (flags & XFS_QMOPT_PQUOTA)
error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino);
return error;
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index bf809b77a316..0868e6ee2219 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -205,11 +205,11 @@ xfs_fs_rm_xquota(
return -EINVAL;
if (uflags & FS_USER_QUOTA)
- flags |= XFS_DQ_USER;
+ flags |= XFS_QMOPT_UQUOTA;
if (uflags & FS_GROUP_QUOTA)
- flags |= XFS_DQ_GROUP;
+ flags |= XFS_QMOPT_GQUOTA;
if (uflags & FS_PROJ_QUOTA)
- flags |= XFS_DQ_PROJ;
+ flags |= XFS_QMOPT_PQUOTA;
return xfs_qm_scall_trunc_qfiles(mp, flags);
}
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 04/26] xfs: move the flags argument of xfs_qm_scall_trunc_qfiles to XFS_QMOPT_*
2020-07-15 1:50 ` [PATCH 04/26] xfs: move the flags argument of xfs_qm_scall_trunc_qfiles to XFS_QMOPT_* Darrick J. Wong
@ 2020-07-15 12:50 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-15 12:50 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:20:58 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Since xfs_qm_scall_trunc_qfiles can take a bitset of quota types that we
> want to truncate, change the flags argument to take XFS_QMOPT_[UGP}QUOTA
> so that the next patch can start to deprecate XFS_DQ_*.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/xfs_qm_syscalls.c | 8 ++++----
> fs/xfs/xfs_quotaops.c | 6 +++---
> 2 files changed, 7 insertions(+), 7 deletions(-)
>
>
> diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
> index 7effd7a28136..35fad348e3a2 100644
> --- a/fs/xfs/xfs_qm_syscalls.c
> +++ b/fs/xfs/xfs_qm_syscalls.c
> @@ -322,23 +322,23 @@ xfs_qm_scall_trunc_qfiles(
> int error = -EINVAL;
>
> if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
> - (flags & ~XFS_DQ_ALLTYPES)) {
> + (flags & ~XFS_QMOPT_QUOTALL)) {
> xfs_debug(mp, "%s: flags=%x m_qflags=%x",
> __func__, flags, mp->m_qflags);
> return -EINVAL;
> }
>
> - if (flags & XFS_DQ_USER) {
> + if (flags & XFS_QMOPT_UQUOTA) {
> error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
> if (error)
> return error;
> }
> - if (flags & XFS_DQ_GROUP) {
> + if (flags & XFS_QMOPT_GQUOTA) {
> error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
> if (error)
> return error;
> }
> - if (flags & XFS_DQ_PROJ)
> + if (flags & XFS_QMOPT_PQUOTA)
> error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino);
>
> return error;
> diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
> index bf809b77a316..0868e6ee2219 100644
> --- a/fs/xfs/xfs_quotaops.c
> +++ b/fs/xfs/xfs_quotaops.c
> @@ -205,11 +205,11 @@ xfs_fs_rm_xquota(
> return -EINVAL;
>
> if (uflags & FS_USER_QUOTA)
> - flags |= XFS_DQ_USER;
> + flags |= XFS_QMOPT_UQUOTA;
> if (uflags & FS_GROUP_QUOTA)
> - flags |= XFS_DQ_GROUP;
> + flags |= XFS_QMOPT_GQUOTA;
> if (uflags & FS_PROJ_QUOTA)
> - flags |= XFS_DQ_PROJ;
> + flags |= XFS_QMOPT_PQUOTA;
>
> return xfs_qm_scall_trunc_qfiles(mp, flags);
> }
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (3 preceding siblings ...)
2020-07-15 1:50 ` [PATCH 04/26] xfs: move the flags argument of xfs_qm_scall_trunc_qfiles to XFS_QMOPT_* Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-16 6:59 ` Chandan Babu R
2020-07-15 1:51 ` [PATCH 06/26] xfs: refactor quotacheck flags usage Darrick J. Wong
` (20 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Create a new type (xfs_dqtype_t) to represent the type of an incore
dquot (user, group, project, or none). Break the type field out from
the dq_flags field of the incore dquot. We add an explicit NONE value
for the handful of users (the dquot buffer verifier) that cannot always
know what quota type we're dealing with.
This allows us to replace all the "uint type" arguments to the quota
functions with "xfs_dqtype_t type", to make it obvious when we're
passing a quota type argument into a function.
Decoupling q_type from dq_flags in the incore dquot helps us streamline
the quota code even further -- the quota functions can perform direct
comparisons against q_type without having to do any pesky bitmasking.
Note that the incore state flags and the ondisk flags remain separate
namespaces from xfs_dqtype_t because they contain internal dquot state
that should never be exposed to quota callers.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_dquot_buf.c | 21 ++++++----
fs/xfs/libxfs/xfs_quota_defs.h | 19 ++++++++-
fs/xfs/scrub/quota.c | 19 +++++----
fs/xfs/scrub/repair.c | 10 ++---
fs/xfs/scrub/repair.h | 4 +-
fs/xfs/xfs_buf_item_recover.c | 2 -
fs/xfs/xfs_dquot.c | 75 ++++++++++++++++++++----------------
fs/xfs/xfs_dquot.h | 63 +++++++++++++++++-------------
fs/xfs/xfs_dquot_item_recover.c | 2 -
fs/xfs/xfs_icache.c | 4 +-
fs/xfs/xfs_iomap.c | 36 +++++++++--------
fs/xfs/xfs_qm.c | 82 ++++++++++++++++++++-------------------
fs/xfs/xfs_qm.h | 55 ++++++++++++--------------
fs/xfs/xfs_qm_bhv.c | 2 -
fs/xfs/xfs_qm_syscalls.c | 25 +++++-------
fs/xfs/xfs_quota.h | 10 ++---
fs/xfs/xfs_quotaops.c | 8 ++--
fs/xfs/xfs_trace.h | 5 ++
fs/xfs/xfs_trans_dquot.c | 17 ++++++--
19 files changed, 248 insertions(+), 211 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index bedc1e752b60..3b20b82a775b 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -38,8 +38,10 @@ xfs_dquot_verify(
struct xfs_mount *mp,
struct xfs_disk_dquot *ddq,
xfs_dqid_t id,
- uint type) /* used only during quotacheck */
+ xfs_dqtype_t type) /* used only during quotacheck */
{
+ uint8_t ddq_type;
+
/*
* We can encounter an uninitialized dquot buffer for 2 reasons:
* 1. If we crash while deleting the quotainode(s), and those blks got
@@ -60,11 +62,12 @@ xfs_dquot_verify(
if (ddq->d_version != XFS_DQUOT_VERSION)
return __this_address;
- if (type && ddq->d_flags != type)
+ ddq_type = ddq->d_flags & XFS_DQ_ALLTYPES;
+ if (type != XFS_DQTYPE_NONE && ddq_type != type)
return __this_address;
- if (ddq->d_flags != XFS_DQ_USER &&
- ddq->d_flags != XFS_DQ_PROJ &&
- ddq->d_flags != XFS_DQ_GROUP)
+ if (ddq_type != XFS_DQ_USER &&
+ ddq_type != XFS_DQ_PROJ &&
+ ddq_type != XFS_DQ_GROUP)
return __this_address;
if (id != -1 && id != be32_to_cpu(ddq->d_id))
@@ -95,8 +98,8 @@ xfs_failaddr_t
xfs_dqblk_verify(
struct xfs_mount *mp,
struct xfs_dqblk *dqb,
- xfs_dqid_t id,
- uint type) /* used only during quotacheck */
+ xfs_dqid_t id,
+ xfs_dqtype_t type) /* used only during quotacheck */
{
if (xfs_sb_version_hascrc(&mp->m_sb) &&
!uuid_equal(&dqb->dd_uuid, &mp->m_sb.sb_meta_uuid))
@@ -113,7 +116,7 @@ xfs_dqblk_repair(
struct xfs_mount *mp,
struct xfs_dqblk *dqb,
xfs_dqid_t id,
- uint type)
+ xfs_dqtype_t type)
{
/*
* Typically, a repair is only requested by quotacheck.
@@ -205,7 +208,7 @@ xfs_dquot_buf_verify(
if (i == 0)
id = be32_to_cpu(ddq->d_id);
- fa = xfs_dqblk_verify(mp, &dqb[i], id + i, 0);
+ fa = xfs_dqblk_verify(mp, &dqb[i], id + i, XFS_DQTYPE_NONE);
if (fa) {
if (!readahead)
xfs_buf_verifier_error(bp, -EFSCORRUPTED,
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 56d9dd787e7b..aaf85a47ae5f 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -18,6 +18,19 @@
typedef uint64_t xfs_qcnt_t;
typedef uint16_t xfs_qwarncnt_t;
+typedef uint8_t xfs_dqtype_t;
+
+#define XFS_DQTYPE_NONE (0)
+#define XFS_DQTYPE_USER (XFS_DQ_USER)
+#define XFS_DQTYPE_PROJ (XFS_DQ_PROJ)
+#define XFS_DQTYPE_GROUP (XFS_DQ_GROUP)
+
+#define XFS_DQTYPE_STRINGS \
+ { XFS_DQTYPE_NONE, "NONE" }, \
+ { XFS_DQTYPE_USER, "USER" }, \
+ { XFS_DQTYPE_PROJ, "PROJ" }, \
+ { XFS_DQTYPE_GROUP, "GROUP" }
+
/*
* flags for q_flags field in the dquot.
*/
@@ -137,11 +150,11 @@ typedef uint16_t xfs_qwarncnt_t;
#define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
extern xfs_failaddr_t xfs_dquot_verify(struct xfs_mount *mp,
- struct xfs_disk_dquot *ddq, xfs_dqid_t id, uint type);
+ struct xfs_disk_dquot *ddq, xfs_dqid_t id, xfs_dqtype_t type);
extern xfs_failaddr_t xfs_dqblk_verify(struct xfs_mount *mp,
- struct xfs_dqblk *dqb, xfs_dqid_t id, uint type);
+ struct xfs_dqblk *dqb, xfs_dqid_t id, xfs_dqtype_t type);
extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
extern void xfs_dqblk_repair(struct xfs_mount *mp, struct xfs_dqblk *dqb,
- xfs_dqid_t id, uint type);
+ xfs_dqid_t id, xfs_dqtype_t type);
#endif /* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 905a34558361..cece9f69bbfb 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -18,19 +18,20 @@
#include "scrub/common.h"
/* Convert a scrub type code to a DQ flag, or return 0 if error. */
-static inline uint
+static inline xfs_dqtype_t
xchk_quota_to_dqtype(
struct xfs_scrub *sc)
{
switch (sc->sm->sm_type) {
case XFS_SCRUB_TYPE_UQUOTA:
- return XFS_DQ_USER;
+ return XFS_DQTYPE_USER;
case XFS_SCRUB_TYPE_GQUOTA:
- return XFS_DQ_GROUP;
+ return XFS_DQTYPE_GROUP;
case XFS_SCRUB_TYPE_PQUOTA:
- return XFS_DQ_PROJ;
+ return XFS_DQTYPE_PROJ;
default:
- return 0;
+ ASSERT(0);
+ return XFS_DQTYPE_NONE;
}
}
@@ -40,7 +41,7 @@ xchk_setup_quota(
struct xfs_scrub *sc,
struct xfs_inode *ip)
{
- uint dqtype;
+ xfs_dqtype_t dqtype;
int error;
if (!XFS_IS_QUOTA_RUNNING(sc->mp) || !XFS_IS_QUOTA_ON(sc->mp))
@@ -73,7 +74,7 @@ struct xchk_quota_info {
STATIC int
xchk_quota_item(
struct xfs_dquot *dq,
- uint dqtype,
+ xfs_dqtype_t dqtype,
void *priv)
{
struct xchk_quota_info *sqi = priv;
@@ -109,7 +110,7 @@ xchk_quota_item(
sqi->last_id = id;
/* Did we get the dquot type we wanted? */
- if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
+ if (d->d_flags != dqtype)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
@@ -235,7 +236,7 @@ xchk_quota(
struct xchk_quota_info sqi;
struct xfs_mount *mp = sc->mp;
struct xfs_quotainfo *qi = mp->m_quotainfo;
- uint dqtype;
+ xfs_dqtype_t dqtype;
int error = 0;
dqtype = xchk_quota_to_dqtype(sc);
diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
index db3cfd12803d..25e86c71e7b9 100644
--- a/fs/xfs/scrub/repair.c
+++ b/fs/xfs/scrub/repair.c
@@ -899,11 +899,11 @@ xrep_find_ag_btree_roots(
void
xrep_force_quotacheck(
struct xfs_scrub *sc,
- uint dqtype)
+ xfs_dqtype_t type)
{
uint flag;
- flag = xfs_quota_chkd_flag(dqtype);
+ flag = xfs_quota_chkd_flag(type);
if (!(flag & sc->mp->m_qflags))
return;
@@ -939,11 +939,11 @@ xrep_ino_dqattach(
"inode %llu repair encountered quota error %d, quotacheck forced.",
(unsigned long long)sc->ip->i_ino, error);
if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
- xrep_force_quotacheck(sc, XFS_DQ_USER);
+ xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
- xrep_force_quotacheck(sc, XFS_DQ_GROUP);
+ xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
- xrep_force_quotacheck(sc, XFS_DQ_PROJ);
+ xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
/* fall through */
case -ESRCH:
error = 0;
diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h
index 04a47d45605b..fe77de01abe0 100644
--- a/fs/xfs/scrub/repair.h
+++ b/fs/xfs/scrub/repair.h
@@ -6,6 +6,8 @@
#ifndef __XFS_SCRUB_REPAIR_H__
#define __XFS_SCRUB_REPAIR_H__
+#include "xfs_quota_defs.h"
+
static inline int xrep_notsupported(struct xfs_scrub *sc)
{
return -EOPNOTSUPP;
@@ -49,7 +51,7 @@ struct xrep_find_ag_btree {
int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp,
struct xrep_find_ag_btree *btree_info, struct xfs_buf *agfl_bp);
-void xrep_force_quotacheck(struct xfs_scrub *sc, uint dqtype);
+void xrep_force_quotacheck(struct xfs_scrub *sc, xfs_dqtype_t type);
int xrep_ino_dqattach(struct xfs_scrub *sc);
/* Metadata repairers */
diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index 74c851f60eee..682d1ed78894 100644
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -494,7 +494,7 @@ xlog_recover_do_reg_buffer(
goto next;
}
fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr,
- -1, 0);
+ -1, XFS_DQTYPE_NONE);
if (fa) {
xfs_alert(mp,
"dquot corrupt at %pS trying to replay into block 0x%llx",
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 7503c6695569..8230faa9f66e 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -76,7 +76,7 @@ xfs_qm_adjust_dqlimits(
int prealloc = 0;
ASSERT(d->d_id);
- defq = xfs_get_defquota(q, xfs_dquot_type(dq));
+ defq = xfs_get_defquota(q, dq->q_type);
if (defq->bsoftlimit && !d->d_blk_softlimit) {
d->d_blk_softlimit = cpu_to_be64(defq->bsoftlimit);
@@ -122,7 +122,7 @@ xfs_qm_adjust_dqtimers(
struct xfs_def_quota *defq;
ASSERT(d->d_id);
- defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
+ defq = xfs_get_defquota(qi, dq->q_type);
#ifdef DEBUG
if (d->d_blk_hardlimit)
@@ -214,7 +214,7 @@ xfs_qm_init_dquot_blk(
struct xfs_trans *tp,
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct xfs_buf *bp)
{
struct xfs_quotainfo *q = mp->m_quotainfo;
@@ -246,15 +246,22 @@ xfs_qm_init_dquot_blk(
}
}
- if (type & XFS_DQ_USER) {
+ switch (type) {
+ case XFS_DQTYPE_USER:
qflag = XFS_UQUOTA_CHKD;
blftype = XFS_BLF_UDQUOT_BUF;
- } else if (type & XFS_DQ_PROJ) {
+ break;
+ case XFS_DQTYPE_PROJ:
qflag = XFS_PQUOTA_CHKD;
blftype = XFS_BLF_PDQUOT_BUF;
- } else {
+ break;
+ case XFS_DQTYPE_GROUP:
qflag = XFS_GQUOTA_CHKD;
blftype = XFS_BLF_GDQUOT_BUF;
+ break;
+ default:
+ ASSERT(0);
+ break;
}
xfs_trans_dquot_buf(tp, bp, blftype);
@@ -322,14 +329,14 @@ xfs_dquot_disk_alloc(
struct xfs_trans *tp = *tpp;
struct xfs_mount *mp = tp->t_mountp;
struct xfs_buf *bp;
- struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->dq_flags);
+ struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->q_type);
int nmaps = 1;
int error;
trace_xfs_dqalloc(dqp);
xfs_ilock(quotip, XFS_ILOCK_EXCL);
- if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
+ if (!xfs_this_quota_on(dqp->q_mount, dqp->q_type)) {
/*
* Return if this type of quotas is turned off while we didn't
* have an inode lock
@@ -367,7 +374,7 @@ xfs_dquot_disk_alloc(
* the entire thing.
*/
xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
- dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
+ dqp->q_type, bp);
xfs_buf_set_ref(bp, XFS_DQUOT_REF);
/*
@@ -414,13 +421,13 @@ xfs_dquot_disk_read(
{
struct xfs_bmbt_irec map;
struct xfs_buf *bp;
- struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->dq_flags);
+ struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->q_type);
uint lock_mode;
int nmaps = 1;
int error;
lock_mode = xfs_ilock_data_map_shared(quotip);
- if (!xfs_this_quota_on(mp, dqp->dq_flags)) {
+ if (!xfs_this_quota_on(mp, dqp->q_type)) {
/*
* Return if this type of quotas is turned off while we
* didn't have the quota inode lock.
@@ -472,13 +479,13 @@ STATIC struct xfs_dquot *
xfs_dquot_alloc(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type)
+ xfs_dqtype_t type)
{
struct xfs_dquot *dqp;
dqp = kmem_zone_zalloc(xfs_qm_dqzone, 0);
- dqp->dq_flags = type;
+ dqp->q_type = type;
dqp->q_core.d_id = cpu_to_be32(id);
dqp->q_mount = mp;
INIT_LIST_HEAD(&dqp->q_lru);
@@ -504,13 +511,13 @@ xfs_dquot_alloc(
* quotas.
*/
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
/* uses the default lock class */
break;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
break;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
break;
default:
@@ -536,7 +543,7 @@ xfs_dquot_from_disk(
* Ensure that we got the type and ID we were looking for.
* Everything else was checked by the dquot buffer verifier.
*/
- if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->dq_flags ||
+ if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->q_type ||
ddqp->d_id != dqp->q_core.d_id) {
xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
"Metadata corruption detected at %pS, quota %u",
@@ -607,7 +614,7 @@ static int
xfs_qm_dqread(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
bool can_alloc,
struct xfs_dquot **dqpp)
{
@@ -655,7 +662,7 @@ xfs_qm_dqread(
static int
xfs_dq_get_next_id(
struct xfs_mount *mp,
- uint type,
+ xfs_dqtype_t type,
xfs_dqid_t *id)
{
struct xfs_inode *quotip = xfs_quota_inode(mp, type);
@@ -779,21 +786,21 @@ xfs_qm_dqget_cache_insert(
static int
xfs_qm_dqget_checks(
struct xfs_mount *mp,
- uint type)
+ xfs_dqtype_t type)
{
if (WARN_ON_ONCE(!XFS_IS_QUOTA_RUNNING(mp)))
return -ESRCH;
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
if (!XFS_IS_UQUOTA_ON(mp))
return -ESRCH;
return 0;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
if (!XFS_IS_GQUOTA_ON(mp))
return -ESRCH;
return 0;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
if (!XFS_IS_PQUOTA_ON(mp))
return -ESRCH;
return 0;
@@ -811,7 +818,7 @@ int
xfs_qm_dqget(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
bool can_alloc,
struct xfs_dquot **O_dqpp)
{
@@ -861,7 +868,7 @@ int
xfs_qm_dqget_uncached(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct xfs_dquot **dqpp)
{
int error;
@@ -877,14 +884,14 @@ xfs_qm_dqget_uncached(
xfs_dqid_t
xfs_qm_id_for_quotatype(
struct xfs_inode *ip,
- uint type)
+ xfs_dqtype_t type)
{
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
return i_uid_read(VFS_I(ip));
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return i_gid_read(VFS_I(ip));
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return ip->i_d.di_projid;
}
ASSERT(0);
@@ -899,7 +906,7 @@ xfs_qm_id_for_quotatype(
int
xfs_qm_dqget_inode(
struct xfs_inode *ip,
- uint type,
+ xfs_dqtype_t type,
bool can_alloc,
struct xfs_dquot **O_dqpp)
{
@@ -985,7 +992,7 @@ int
xfs_qm_dqget_next(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct xfs_dquot **dqpp)
{
struct xfs_dquot *dqp;
@@ -1294,7 +1301,7 @@ xfs_qm_exit(void)
int
xfs_qm_dqiterate(
struct xfs_mount *mp,
- uint dqtype,
+ xfs_dqtype_t type,
xfs_qm_dqiterate_fn iter_fn,
void *priv)
{
@@ -1303,13 +1310,13 @@ xfs_qm_dqiterate(
int error;
do {
- error = xfs_qm_dqget_next(mp, id, dqtype, &dq);
+ error = xfs_qm_dqget_next(mp, id, type, &dq);
if (error == -ENOENT)
return 0;
if (error)
return error;
- error = iter_fn(dq, dqtype, priv);
+ error = iter_fn(dq, type, priv);
id = be32_to_cpu(dq->q_core.d_id);
xfs_qm_dqput(dq);
id++;
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 71e36c85e20b..077d0988cff9 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -34,6 +34,7 @@ struct xfs_dquot {
uint dq_flags;
struct list_head q_lru;
struct xfs_mount *q_mount;
+ xfs_dqtype_t q_type;
uint q_nrefs;
xfs_daddr_t q_blkno;
int q_bufoffset;
@@ -101,28 +102,34 @@ static inline void xfs_dqunlock(struct xfs_dquot *dqp)
mutex_unlock(&dqp->q_qlock);
}
-static inline int xfs_this_quota_on(struct xfs_mount *mp, int type)
+static inline bool
+xfs_this_quota_on(
+ struct xfs_mount *mp,
+ xfs_dqtype_t type)
{
- switch (type & XFS_DQ_ALLTYPES) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return XFS_IS_UQUOTA_ON(mp);
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return XFS_IS_GQUOTA_ON(mp);
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return XFS_IS_PQUOTA_ON(mp);
default:
- return 0;
+ return false;
}
}
-static inline struct xfs_dquot *xfs_inode_dquot(struct xfs_inode *ip, int type)
+static inline struct xfs_dquot *
+xfs_inode_dquot(
+ struct xfs_inode *ip,
+ xfs_dqtype_t type)
{
- switch (type & XFS_DQ_ALLTYPES) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return ip->i_udquot;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return ip->i_gdquot;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return ip->i_pdquot;
default:
return NULL;
@@ -146,9 +153,9 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
#define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->dq_flags & XFS_DQ_DIRTY)
-#define XFS_QM_ISUDQ(dqp) ((dqp)->dq_flags & XFS_DQ_USER)
-#define XFS_QM_ISPDQ(dqp) ((dqp)->dq_flags & XFS_DQ_PROJ)
-#define XFS_QM_ISGDQ(dqp) ((dqp)->dq_flags & XFS_DQ_GROUP)
+#define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
+#define XFS_QM_ISPDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_PROJ)
+#define XFS_QM_ISGDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_GROUP)
void xfs_qm_dqdestroy(struct xfs_dquot *dqp);
int xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);
@@ -157,18 +164,20 @@ void xfs_qm_adjust_dqtimers(struct xfs_mount *mp,
struct xfs_dquot *d);
void xfs_qm_adjust_dqlimits(struct xfs_mount *mp,
struct xfs_dquot *d);
-xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip, uint type);
+xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip,
+ xfs_dqtype_t type);
int xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
- uint type, bool can_alloc,
- struct xfs_dquot **dqpp);
-int xfs_qm_dqget_inode(struct xfs_inode *ip, uint type,
- bool can_alloc,
- struct xfs_dquot **dqpp);
+ xfs_dqtype_t type, bool can_alloc,
+ struct xfs_dquot **dqpp);
+int xfs_qm_dqget_inode(struct xfs_inode *ip,
+ xfs_dqtype_t type,
+ bool can_alloc, struct xfs_dquot **dqpp);
int xfs_qm_dqget_next(struct xfs_mount *mp, xfs_dqid_t id,
- uint type, struct xfs_dquot **dqpp);
-int xfs_qm_dqget_uncached(struct xfs_mount *mp,
- xfs_dqid_t id, uint type,
- struct xfs_dquot **dqpp);
+ xfs_dqtype_t type,
+ struct xfs_dquot **dqpp);
+int xfs_qm_dqget_uncached(struct xfs_mount *mp, xfs_dqid_t id,
+ xfs_dqtype_t type,
+ struct xfs_dquot **dqpp);
void xfs_qm_dqput(struct xfs_dquot *dqp);
void xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
@@ -183,9 +192,9 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
return dqp;
}
-typedef int (*xfs_qm_dqiterate_fn)(struct xfs_dquot *dq, uint dqtype,
- void *priv);
-int xfs_qm_dqiterate(struct xfs_mount *mp, uint dqtype,
+typedef int (*xfs_qm_dqiterate_fn)(struct xfs_dquot *dq,
+ xfs_dqtype_t type, void *priv);
+int xfs_qm_dqiterate(struct xfs_mount *mp, xfs_dqtype_t type,
xfs_qm_dqiterate_fn iter_fn, void *priv);
#endif /* __XFS_DQUOT_H__ */
diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index f9ea9f55aa7c..a39708879874 100644
--- a/fs/xfs/xfs_dquot_item_recover.c
+++ b/fs/xfs/xfs_dquot_item_recover.c
@@ -108,7 +108,7 @@ xlog_recover_dquot_commit_pass2(
*/
dq_f = item->ri_buf[0].i_addr;
ASSERT(dq_f);
- fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, 0);
+ fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, XFS_DQTYPE_NONE);
if (fa) {
xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
dq_f->qlf_id, fa);
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 58a750ce689c..3c6e936d2f99 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1424,7 +1424,7 @@ __xfs_inode_free_quota_eofblocks(
eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
- dq = xfs_inode_dquot(ip, XFS_DQ_USER);
+ dq = xfs_inode_dquot(ip, XFS_DQTYPE_USER);
if (dq && xfs_dquot_lowsp(dq)) {
eofb.eof_uid = VFS_I(ip)->i_uid;
eofb.eof_flags |= XFS_EOF_FLAGS_UID;
@@ -1433,7 +1433,7 @@ __xfs_inode_free_quota_eofblocks(
}
if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
- dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
+ dq = xfs_inode_dquot(ip, XFS_DQTYPE_GROUP);
if (dq && xfs_dquot_lowsp(dq)) {
eofb.eof_gid = VFS_I(ip)->i_gid;
eofb.eof_flags |= XFS_EOF_FLAGS_GID;
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index b9a8c3798e08..ac2cc2680d2a 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -293,11 +293,11 @@ xfs_iomap_write_direct(
STATIC bool
xfs_quota_need_throttle(
- struct xfs_inode *ip,
- int type,
- xfs_fsblock_t alloc_blocks)
+ struct xfs_inode *ip,
+ xfs_dqtype_t type,
+ xfs_fsblock_t alloc_blocks)
{
- struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
+ struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
if (!dq || !xfs_this_quota_on(ip->i_mount, type))
return false;
@@ -315,15 +315,15 @@ xfs_quota_need_throttle(
STATIC void
xfs_quota_calc_throttle(
- struct xfs_inode *ip,
- int type,
- xfs_fsblock_t *qblocks,
- int *qshift,
- int64_t *qfreesp)
+ struct xfs_inode *ip,
+ xfs_dqtype_t type,
+ xfs_fsblock_t *qblocks,
+ int *qshift,
+ int64_t *qfreesp)
{
- int64_t freesp;
- int shift = 0;
- struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
+ struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
+ int64_t freesp;
+ int shift = 0;
/* no dq, or over hi wmark, squash the prealloc completely */
if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
@@ -450,14 +450,14 @@ xfs_iomap_prealloc_size(
* Check each quota to cap the prealloc size, provide a shift value to
* throttle with and adjust amount of available space.
*/
- if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
- xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
+ if (xfs_quota_need_throttle(ip, XFS_DQTYPE_USER, alloc_blocks))
+ xfs_quota_calc_throttle(ip, XFS_DQTYPE_USER, &qblocks, &qshift,
&freesp);
- if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
- xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
+ if (xfs_quota_need_throttle(ip, XFS_DQTYPE_GROUP, alloc_blocks))
+ xfs_quota_calc_throttle(ip, XFS_DQTYPE_GROUP, &qblocks, &qshift,
&freesp);
- if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
- xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
+ if (xfs_quota_need_throttle(ip, XFS_DQTYPE_PROJ, alloc_blocks))
+ xfs_quota_calc_throttle(ip, XFS_DQTYPE_PROJ, &qblocks, &qshift,
&freesp);
/*
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 938023dd8ce5..9c455ebd20cb 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -47,7 +47,7 @@ STATIC void xfs_qm_dqfree_one(struct xfs_dquot *dqp);
STATIC int
xfs_qm_dquot_walk(
struct xfs_mount *mp,
- int type,
+ xfs_dqtype_t type,
int (*execute)(struct xfs_dquot *dqp, void *data),
void *data)
{
@@ -161,7 +161,7 @@ xfs_qm_dqpurge(
xfs_dqfunlock(dqp);
xfs_dqunlock(dqp);
- radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
be32_to_cpu(dqp->q_core.d_id));
qi->qi_dquots--;
@@ -190,11 +190,11 @@ xfs_qm_dqpurge_all(
uint flags)
{
if (flags & XFS_QMOPT_UQUOTA)
- xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
+ xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER, xfs_qm_dqpurge, NULL);
if (flags & XFS_QMOPT_GQUOTA)
- xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
+ xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP, xfs_qm_dqpurge, NULL);
if (flags & XFS_QMOPT_PQUOTA)
- xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
+ xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ, xfs_qm_dqpurge, NULL);
}
/*
@@ -251,7 +251,7 @@ STATIC int
xfs_qm_dqattach_one(
struct xfs_inode *ip,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
bool doalloc,
struct xfs_dquot **IO_idqpp)
{
@@ -332,7 +332,7 @@ xfs_qm_dqattach_locked(
if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {
error = xfs_qm_dqattach_one(ip, i_uid_read(VFS_I(ip)),
- XFS_DQ_USER, doalloc, &ip->i_udquot);
+ XFS_DQTYPE_USER, doalloc, &ip->i_udquot);
if (error)
goto done;
ASSERT(ip->i_udquot);
@@ -340,15 +340,15 @@ xfs_qm_dqattach_locked(
if (XFS_IS_GQUOTA_ON(mp) && !ip->i_gdquot) {
error = xfs_qm_dqattach_one(ip, i_gid_read(VFS_I(ip)),
- XFS_DQ_GROUP, doalloc, &ip->i_gdquot);
+ XFS_DQTYPE_GROUP, doalloc, &ip->i_gdquot);
if (error)
goto done;
ASSERT(ip->i_gdquot);
}
if (XFS_IS_PQUOTA_ON(mp) && !ip->i_pdquot) {
- error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
- doalloc, &ip->i_pdquot);
+ error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid,
+ XFS_DQTYPE_PROJ, doalloc, &ip->i_pdquot);
if (error)
goto done;
ASSERT(ip->i_pdquot);
@@ -546,7 +546,7 @@ xfs_qm_shrink_count(
STATIC void
xfs_qm_set_defquota(
struct xfs_mount *mp,
- uint type,
+ xfs_dqtype_t type,
struct xfs_quotainfo *qinf)
{
struct xfs_dquot *dqp;
@@ -559,7 +559,7 @@ xfs_qm_set_defquota(
return;
ddqp = &dqp->q_core;
- defq = xfs_get_defquota(qinf, xfs_dquot_type(dqp));
+ defq = xfs_get_defquota(qinf, type);
/*
* Timers and warnings have been already set, let's just set the
@@ -578,7 +578,7 @@ xfs_qm_set_defquota(
static void
xfs_qm_init_timelimits(
struct xfs_mount *mp,
- uint type)
+ xfs_dqtype_t type)
{
struct xfs_quotainfo *qinf = mp->m_quotainfo;
struct xfs_def_quota *defq;
@@ -670,16 +670,16 @@ xfs_qm_init_quotainfo(
mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
- xfs_qm_init_timelimits(mp, XFS_DQ_USER);
- xfs_qm_init_timelimits(mp, XFS_DQ_GROUP);
- xfs_qm_init_timelimits(mp, XFS_DQ_PROJ);
+ xfs_qm_init_timelimits(mp, XFS_DQTYPE_USER);
+ xfs_qm_init_timelimits(mp, XFS_DQTYPE_GROUP);
+ xfs_qm_init_timelimits(mp, XFS_DQTYPE_PROJ);
if (XFS_IS_UQUOTA_RUNNING(mp))
- xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
+ xfs_qm_set_defquota(mp, XFS_DQTYPE_USER, qinf);
if (XFS_IS_GQUOTA_RUNNING(mp))
- xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
+ xfs_qm_set_defquota(mp, XFS_DQTYPE_GROUP, qinf);
if (XFS_IS_PQUOTA_RUNNING(mp))
- xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);
+ xfs_qm_set_defquota(mp, XFS_DQTYPE_PROJ, qinf);
qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
@@ -829,10 +829,10 @@ xfs_qm_qino_alloc(
STATIC void
xfs_qm_reset_dqcounts(
- xfs_mount_t *mp,
- xfs_buf_t *bp,
- xfs_dqid_t id,
- uint type)
+ struct xfs_mount *mp,
+ struct xfs_buf *bp,
+ xfs_dqid_t id,
+ xfs_dqtype_t type)
{
struct xfs_dqblk *dqb;
int j;
@@ -907,11 +907,11 @@ xfs_qm_reset_dqcounts_all(
{
struct xfs_buf *bp;
int error;
- int type;
+ xfs_dqtype_t type;
ASSERT(blkcnt > 0);
- type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
- (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
+ type = flags & XFS_QMOPT_UQUOTA ? XFS_DQTYPE_USER :
+ (flags & XFS_QMOPT_PQUOTA ? XFS_DQTYPE_PROJ : XFS_DQTYPE_GROUP);
error = 0;
/*
@@ -1070,7 +1070,7 @@ xfs_qm_reset_dqcounts_buf(
STATIC int
xfs_qm_quotacheck_dqadjust(
struct xfs_inode *ip,
- uint type,
+ xfs_dqtype_t type,
xfs_qcnt_t nblks,
xfs_qcnt_t rtblks)
{
@@ -1187,21 +1187,21 @@ xfs_qm_dqusage_adjust(
* and quotaoffs don't race. (Quotachecks happen at mount time only).
*/
if (XFS_IS_UQUOTA_ON(mp)) {
- error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_USER, nblks,
+ error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_USER, nblks,
rtblks);
if (error)
goto error0;
}
if (XFS_IS_GQUOTA_ON(mp)) {
- error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_GROUP, nblks,
+ error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_GROUP, nblks,
rtblks);
if (error)
goto error0;
}
if (XFS_IS_PQUOTA_ON(mp)) {
- error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_PROJ, nblks,
+ error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_PROJ, nblks,
rtblks);
if (error)
goto error0;
@@ -1325,18 +1325,18 @@ xfs_qm_quotacheck(
* down to disk buffers if everything was updated successfully.
*/
if (XFS_IS_UQUOTA_ON(mp)) {
- error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
- &buffer_list);
+ error = xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER,
+ xfs_qm_flush_one, &buffer_list);
}
if (XFS_IS_GQUOTA_ON(mp)) {
- error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
- &buffer_list);
+ error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP,
+ xfs_qm_flush_one, &buffer_list);
if (!error)
error = error2;
}
if (XFS_IS_PQUOTA_ON(mp)) {
- error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
- &buffer_list);
+ error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ,
+ xfs_qm_flush_one, &buffer_list);
if (!error)
error = error2;
}
@@ -1598,7 +1598,7 @@ xfs_qm_dqfree_one(
struct xfs_quotainfo *qi = mp->m_quotainfo;
mutex_lock(&qi->qi_tree_lock);
- radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
be32_to_cpu(dqp->q_core.d_id));
qi->qi_dquots--;
@@ -1674,7 +1674,7 @@ xfs_qm_vop_dqalloc(
*/
xfs_iunlock(ip, lockflags);
error = xfs_qm_dqget(mp, from_kuid(user_ns, uid),
- XFS_DQ_USER, true, &uq);
+ XFS_DQTYPE_USER, true, &uq);
if (error) {
ASSERT(error != -ENOENT);
return error;
@@ -1698,7 +1698,7 @@ xfs_qm_vop_dqalloc(
if (!gid_eq(inode->i_gid, gid)) {
xfs_iunlock(ip, lockflags);
error = xfs_qm_dqget(mp, from_kgid(user_ns, gid),
- XFS_DQ_GROUP, true, &gq);
+ XFS_DQTYPE_GROUP, true, &gq);
if (error) {
ASSERT(error != -ENOENT);
goto error_rele;
@@ -1714,8 +1714,8 @@ xfs_qm_vop_dqalloc(
if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
if (ip->i_d.di_projid != prid) {
xfs_iunlock(ip, lockflags);
- error = xfs_qm_dqget(mp, (xfs_dqid_t)prid, XFS_DQ_PROJ,
- true, &pq);
+ error = xfs_qm_dqget(mp, (xfs_dqid_t)prid,
+ XFS_DQTYPE_PROJ, true, &pq);
if (error) {
ASSERT(error != -ENOENT);
goto error_rele;
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 7b0e771fcbce..27789272da95 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -83,14 +83,14 @@ struct xfs_quotainfo {
static inline struct radix_tree_root *
xfs_dquot_tree(
struct xfs_quotainfo *qi,
- int type)
+ xfs_dqtype_t type)
{
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
return &qi->qi_uquota_tree;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return &qi->qi_gquota_tree;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return &qi->qi_pquota_tree;
default:
ASSERT(0);
@@ -99,14 +99,14 @@ xfs_dquot_tree(
}
static inline struct xfs_inode *
-xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
+xfs_quota_inode(struct xfs_mount *mp, xfs_dqtype_t type)
{
- switch (dq_flags & XFS_DQ_ALLTYPES) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return mp->m_quotainfo->qi_uquotaip;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return mp->m_quotainfo->qi_gquotaip;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return mp->m_quotainfo->qi_pquotaip;
default:
ASSERT(0);
@@ -114,17 +114,6 @@ xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
return NULL;
}
-static inline int
-xfs_dquot_type(struct xfs_dquot *dqp)
-{
- if (XFS_QM_ISUDQ(dqp))
- return XFS_DQ_USER;
- if (XFS_QM_ISGDQ(dqp))
- return XFS_DQ_GROUP;
- ASSERT(XFS_QM_ISPDQ(dqp));
- return XFS_DQ_PROJ;
-}
-
extern void xfs_trans_mod_dquot(struct xfs_trans *tp, struct xfs_dquot *dqp,
uint field, int64_t delta);
extern void xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
@@ -166,24 +155,30 @@ extern void xfs_qm_dqrele_all_inodes(struct xfs_mount *, uint);
/* quota ops */
extern int xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
-extern int xfs_qm_scall_getquota(struct xfs_mount *, xfs_dqid_t,
- uint, struct qc_dqblk *);
-extern int xfs_qm_scall_getquota_next(struct xfs_mount *,
- xfs_dqid_t *, uint, struct qc_dqblk *);
-extern int xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
- struct qc_dqblk *);
+extern int xfs_qm_scall_getquota(struct xfs_mount *mp,
+ xfs_dqid_t id,
+ xfs_dqtype_t type,
+ struct qc_dqblk *dst);
+extern int xfs_qm_scall_getquota_next(struct xfs_mount *mp,
+ xfs_dqid_t *id,
+ xfs_dqtype_t type,
+ struct qc_dqblk *dst);
+extern int xfs_qm_scall_setqlim(struct xfs_mount *mp,
+ xfs_dqid_t id,
+ xfs_dqtype_t type,
+ struct qc_dqblk *newlim);
extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);
extern int xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
static inline struct xfs_def_quota *
-xfs_get_defquota(struct xfs_quotainfo *qi, int type)
+xfs_get_defquota(struct xfs_quotainfo *qi, xfs_dqtype_t type)
{
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
return &qi->qi_usr_default;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return &qi->qi_grp_default;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return &qi->qi_prj_default;
default:
ASSERT(0);
diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index fc2fa418919f..72c2c2595132 100644
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -60,7 +60,7 @@ xfs_qm_statvfs(
struct xfs_mount *mp = ip->i_mount;
struct xfs_dquot *dqp;
- if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQ_PROJ, false, &dqp)) {
+ if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQTYPE_PROJ, false, &dqp)) {
xfs_fill_statvfs_from_dquot(statp, dqp);
xfs_qm_dqput(dqp);
}
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 35fad348e3a2..c7cb8a356c88 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -443,7 +443,7 @@ int
xfs_qm_scall_setqlim(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct qc_dqblk *newlim)
{
struct xfs_quotainfo *q = mp->m_quotainfo;
@@ -479,7 +479,7 @@ xfs_qm_scall_setqlim(
goto out_unlock;
}
- defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
+ defq = xfs_get_defquota(q, dqp->q_type);
xfs_dqunlock(dqp);
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_setqlim, 0, 0, 0, &tp);
@@ -614,7 +614,7 @@ xfs_qm_scall_setqlim(
static void
xfs_qm_scall_getquota_fill_qc(
struct xfs_mount *mp,
- uint type,
+ xfs_dqtype_t type,
const struct xfs_dquot *dqp,
struct qc_dqblk *dst)
{
@@ -644,21 +644,18 @@ xfs_qm_scall_getquota_fill_qc(
* gets turned off. No need to confuse the user level code,
* so return zeroes in that case.
*/
- if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
- dqp->q_core.d_flags == XFS_DQ_USER) ||
- (!XFS_IS_GQUOTA_ENFORCED(mp) &&
- dqp->q_core.d_flags == XFS_DQ_GROUP) ||
- (!XFS_IS_PQUOTA_ENFORCED(mp) &&
- dqp->q_core.d_flags == XFS_DQ_PROJ)) {
+ if ((!XFS_IS_UQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_USER) ||
+ (!XFS_IS_GQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_GROUP) ||
+ (!XFS_IS_PQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_PROJ)) {
dst->d_spc_timer = 0;
dst->d_ino_timer = 0;
dst->d_rt_spc_timer = 0;
}
#ifdef DEBUG
- if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) ||
- (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
- (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) &&
+ if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_USER) ||
+ (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_GROUP) ||
+ (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_PROJ)) &&
dqp->q_core.d_id != 0) {
if ((dst->d_space > dst->d_spc_softlimit) &&
(dst->d_spc_softlimit > 0)) {
@@ -677,7 +674,7 @@ int
xfs_qm_scall_getquota(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct qc_dqblk *dst)
{
struct xfs_dquot *dqp;
@@ -715,7 +712,7 @@ int
xfs_qm_scall_getquota_next(
struct xfs_mount *mp,
xfs_dqid_t *id,
- uint type,
+ xfs_dqtype_t type,
struct qc_dqblk *dst)
{
struct xfs_dquot *dqp;
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index c92ae5e02ce8..06b22e35fc90 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -39,14 +39,14 @@ struct xfs_buf;
static inline uint
xfs_quota_chkd_flag(
- uint dqtype)
+ xfs_dqtype_t type)
{
- switch (dqtype) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return XFS_UQUOTA_CHKD;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return XFS_GQUOTA_CHKD;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return XFS_PQUOTA_CHKD;
default:
return 0;
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 0868e6ee2219..963c253558b3 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -85,16 +85,16 @@ xfs_fs_get_quota_state(
return 0;
}
-STATIC int
+STATIC xfs_dqtype_t
xfs_quota_type(int type)
{
switch (type) {
case USRQUOTA:
- return XFS_DQ_USER;
+ return XFS_DQTYPE_USER;
case GRPQUOTA:
- return XFS_DQ_GROUP;
+ return XFS_DQTYPE_GROUP;
default:
- return XFS_DQ_PROJ;
+ return XFS_DQTYPE_PROJ;
}
}
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 50c478374a31..f19e66da6646 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -864,6 +864,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
TP_STRUCT__entry(
__field(dev_t, dev)
__field(u32, id)
+ __field(xfs_dqtype_t, type)
__field(unsigned, flags)
__field(unsigned, nrefs)
__field(unsigned long long, res_bcount)
@@ -877,6 +878,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
TP_fast_assign(
__entry->dev = dqp->q_mount->m_super->s_dev;
__entry->id = be32_to_cpu(dqp->q_core.d_id);
+ __entry->type = dqp->q_type;
__entry->flags = dqp->dq_flags;
__entry->nrefs = dqp->q_nrefs;
__entry->res_bcount = dqp->q_res_bcount;
@@ -891,11 +893,12 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->ino_softlimit =
be64_to_cpu(dqp->q_core.d_ino_softlimit);
),
- TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx "
+ TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u res_bc 0x%llx "
"bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
"icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->id,
+ __print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
__print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
__entry->nrefs,
__entry->res_bcount,
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index ed0ce8b301b4..964f69a444a3 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -549,14 +549,21 @@ xfs_quota_warn(
struct xfs_dquot *dqp,
int type)
{
- enum quota_type qtype;
+ enum quota_type qtype;
- if (dqp->dq_flags & XFS_DQ_PROJ)
+ switch (dqp->q_type) {
+ case XFS_DQTYPE_PROJ:
qtype = PRJQUOTA;
- else if (dqp->dq_flags & XFS_DQ_USER)
+ break;
+ case XFS_DQTYPE_USER:
qtype = USRQUOTA;
- else
+ break;
+ case XFS_DQTYPE_GROUP:
qtype = GRPQUOTA;
+ break;
+ default:
+ return;
+ }
quota_send_warning(make_kqid(&init_user_ns, qtype,
be32_to_cpu(dqp->q_core.d_id)),
@@ -591,7 +598,7 @@ xfs_trans_dqresv(
xfs_dqlock(dqp);
- defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
+ defq = xfs_get_defquota(q, dqp->q_type);
if (flags & XFS_TRANS_DQ_RES_BLKS) {
hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-15 1:51 ` [PATCH 05/26] xfs: split the incore dquot type into a separate field Darrick J. Wong
@ 2020-07-16 6:59 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-16 6:59 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Wednesday 15 July 2020 7:21:08 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Create a new type (xfs_dqtype_t) to represent the type of an incore
> dquot (user, group, project, or none). Break the type field out from
> the dq_flags field of the incore dquot. We add an explicit NONE value
> for the handful of users (the dquot buffer verifier) that cannot always
> know what quota type we're dealing with.
>
> This allows us to replace all the "uint type" arguments to the quota
> functions with "xfs_dqtype_t type", to make it obvious when we're
> passing a quota type argument into a function.
>
> Decoupling q_type from dq_flags in the incore dquot helps us streamline
> the quota code even further -- the quota functions can perform direct
> comparisons against q_type without having to do any pesky bitmasking.
>
> Note that the incore state flags and the ondisk flags remain separate
> namespaces from xfs_dqtype_t because they contain internal dquot state
> that should never be exposed to quota callers.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> ---
> fs/xfs/libxfs/xfs_dquot_buf.c | 21 ++++++----
> fs/xfs/libxfs/xfs_quota_defs.h | 19 ++++++++-
> fs/xfs/scrub/quota.c | 19 +++++----
> fs/xfs/scrub/repair.c | 10 ++---
> fs/xfs/scrub/repair.h | 4 +-
> fs/xfs/xfs_buf_item_recover.c | 2 -
> fs/xfs/xfs_dquot.c | 75 ++++++++++++++++++++----------------
> fs/xfs/xfs_dquot.h | 63 +++++++++++++++++-------------
> fs/xfs/xfs_dquot_item_recover.c | 2 -
> fs/xfs/xfs_icache.c | 4 +-
> fs/xfs/xfs_iomap.c | 36 +++++++++--------
> fs/xfs/xfs_qm.c | 82 ++++++++++++++++++++-------------------
> fs/xfs/xfs_qm.h | 55 ++++++++++++--------------
> fs/xfs/xfs_qm_bhv.c | 2 -
> fs/xfs/xfs_qm_syscalls.c | 25 +++++-------
> fs/xfs/xfs_quota.h | 10 ++---
> fs/xfs/xfs_quotaops.c | 8 ++--
> fs/xfs/xfs_trace.h | 5 ++
> fs/xfs/xfs_trans_dquot.c | 17 ++++++--
> 19 files changed, 248 insertions(+), 211 deletions(-)
>
>
> diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
> index bedc1e752b60..3b20b82a775b 100644
> --- a/fs/xfs/libxfs/xfs_dquot_buf.c
> +++ b/fs/xfs/libxfs/xfs_dquot_buf.c
> @@ -38,8 +38,10 @@ xfs_dquot_verify(
> struct xfs_mount *mp,
> struct xfs_disk_dquot *ddq,
> xfs_dqid_t id,
> - uint type) /* used only during quotacheck */
> + xfs_dqtype_t type) /* used only during quotacheck */
> {
> + uint8_t ddq_type;
> +
> /*
> * We can encounter an uninitialized dquot buffer for 2 reasons:
> * 1. If we crash while deleting the quotainode(s), and those blks got
> @@ -60,11 +62,12 @@ xfs_dquot_verify(
> if (ddq->d_version != XFS_DQUOT_VERSION)
> return __this_address;
>
> - if (type && ddq->d_flags != type)
> + ddq_type = ddq->d_flags & XFS_DQ_ALLTYPES;
> + if (type != XFS_DQTYPE_NONE && ddq_type != type)
> return __this_address;
> - if (ddq->d_flags != XFS_DQ_USER &&
> - ddq->d_flags != XFS_DQ_PROJ &&
> - ddq->d_flags != XFS_DQ_GROUP)
> + if (ddq_type != XFS_DQ_USER &&
> + ddq_type != XFS_DQ_PROJ &&
> + ddq_type != XFS_DQ_GROUP)
> return __this_address;
>
> if (id != -1 && id != be32_to_cpu(ddq->d_id))
> @@ -95,8 +98,8 @@ xfs_failaddr_t
> xfs_dqblk_verify(
> struct xfs_mount *mp,
> struct xfs_dqblk *dqb,
> - xfs_dqid_t id,
> - uint type) /* used only during quotacheck */
> + xfs_dqid_t id,
> + xfs_dqtype_t type) /* used only during quotacheck */
> {
> if (xfs_sb_version_hascrc(&mp->m_sb) &&
> !uuid_equal(&dqb->dd_uuid, &mp->m_sb.sb_meta_uuid))
> @@ -113,7 +116,7 @@ xfs_dqblk_repair(
> struct xfs_mount *mp,
> struct xfs_dqblk *dqb,
> xfs_dqid_t id,
> - uint type)
> + xfs_dqtype_t type)
> {
> /*
> * Typically, a repair is only requested by quotacheck.
> @@ -205,7 +208,7 @@ xfs_dquot_buf_verify(
> if (i == 0)
> id = be32_to_cpu(ddq->d_id);
>
> - fa = xfs_dqblk_verify(mp, &dqb[i], id + i, 0);
> + fa = xfs_dqblk_verify(mp, &dqb[i], id + i, XFS_DQTYPE_NONE);
> if (fa) {
> if (!readahead)
> xfs_buf_verifier_error(bp, -EFSCORRUPTED,
> diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
> index 56d9dd787e7b..aaf85a47ae5f 100644
> --- a/fs/xfs/libxfs/xfs_quota_defs.h
> +++ b/fs/xfs/libxfs/xfs_quota_defs.h
> @@ -18,6 +18,19 @@
> typedef uint64_t xfs_qcnt_t;
> typedef uint16_t xfs_qwarncnt_t;
>
> +typedef uint8_t xfs_dqtype_t;
> +
> +#define XFS_DQTYPE_NONE (0)
> +#define XFS_DQTYPE_USER (XFS_DQ_USER)
> +#define XFS_DQTYPE_PROJ (XFS_DQ_PROJ)
> +#define XFS_DQTYPE_GROUP (XFS_DQ_GROUP)
> +
> +#define XFS_DQTYPE_STRINGS \
> + { XFS_DQTYPE_NONE, "NONE" }, \
> + { XFS_DQTYPE_USER, "USER" }, \
> + { XFS_DQTYPE_PROJ, "PROJ" }, \
> + { XFS_DQTYPE_GROUP, "GROUP" }
> +
> /*
> * flags for q_flags field in the dquot.
> */
> @@ -137,11 +150,11 @@ typedef uint16_t xfs_qwarncnt_t;
> #define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
>
> extern xfs_failaddr_t xfs_dquot_verify(struct xfs_mount *mp,
> - struct xfs_disk_dquot *ddq, xfs_dqid_t id, uint type);
> + struct xfs_disk_dquot *ddq, xfs_dqid_t id, xfs_dqtype_t type);
> extern xfs_failaddr_t xfs_dqblk_verify(struct xfs_mount *mp,
> - struct xfs_dqblk *dqb, xfs_dqid_t id, uint type);
> + struct xfs_dqblk *dqb, xfs_dqid_t id, xfs_dqtype_t type);
> extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
> extern void xfs_dqblk_repair(struct xfs_mount *mp, struct xfs_dqblk *dqb,
> - xfs_dqid_t id, uint type);
> + xfs_dqid_t id, xfs_dqtype_t type);
>
> #endif /* __XFS_QUOTA_H__ */
> diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
> index 905a34558361..cece9f69bbfb 100644
> --- a/fs/xfs/scrub/quota.c
> +++ b/fs/xfs/scrub/quota.c
> @@ -18,19 +18,20 @@
> #include "scrub/common.h"
>
> /* Convert a scrub type code to a DQ flag, or return 0 if error. */
> -static inline uint
> +static inline xfs_dqtype_t
> xchk_quota_to_dqtype(
> struct xfs_scrub *sc)
> {
> switch (sc->sm->sm_type) {
> case XFS_SCRUB_TYPE_UQUOTA:
> - return XFS_DQ_USER;
> + return XFS_DQTYPE_USER;
> case XFS_SCRUB_TYPE_GQUOTA:
> - return XFS_DQ_GROUP;
> + return XFS_DQTYPE_GROUP;
> case XFS_SCRUB_TYPE_PQUOTA:
> - return XFS_DQ_PROJ;
> + return XFS_DQTYPE_PROJ;
> default:
> - return 0;
> + ASSERT(0);
> + return XFS_DQTYPE_NONE;
> }
> }
>
> @@ -40,7 +41,7 @@ xchk_setup_quota(
> struct xfs_scrub *sc,
> struct xfs_inode *ip)
> {
> - uint dqtype;
> + xfs_dqtype_t dqtype;
> int error;
>
> if (!XFS_IS_QUOTA_RUNNING(sc->mp) || !XFS_IS_QUOTA_ON(sc->mp))
> @@ -73,7 +74,7 @@ struct xchk_quota_info {
> STATIC int
> xchk_quota_item(
> struct xfs_dquot *dq,
> - uint dqtype,
> + xfs_dqtype_t dqtype,
> void *priv)
> {
> struct xchk_quota_info *sqi = priv;
> @@ -109,7 +110,7 @@ xchk_quota_item(
> sqi->last_id = id;
>
> /* Did we get the dquot type we wanted? */
> - if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
> + if (d->d_flags != dqtype)
> xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
> @@ -235,7 +236,7 @@ xchk_quota(
> struct xchk_quota_info sqi;
> struct xfs_mount *mp = sc->mp;
> struct xfs_quotainfo *qi = mp->m_quotainfo;
> - uint dqtype;
> + xfs_dqtype_t dqtype;
> int error = 0;
>
> dqtype = xchk_quota_to_dqtype(sc);
> diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
> index db3cfd12803d..25e86c71e7b9 100644
> --- a/fs/xfs/scrub/repair.c
> +++ b/fs/xfs/scrub/repair.c
> @@ -899,11 +899,11 @@ xrep_find_ag_btree_roots(
> void
> xrep_force_quotacheck(
> struct xfs_scrub *sc,
> - uint dqtype)
> + xfs_dqtype_t type)
> {
> uint flag;
>
> - flag = xfs_quota_chkd_flag(dqtype);
> + flag = xfs_quota_chkd_flag(type);
> if (!(flag & sc->mp->m_qflags))
> return;
>
> @@ -939,11 +939,11 @@ xrep_ino_dqattach(
> "inode %llu repair encountered quota error %d, quotacheck forced.",
> (unsigned long long)sc->ip->i_ino, error);
> if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
> - xrep_force_quotacheck(sc, XFS_DQ_USER);
> + xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
> if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
> - xrep_force_quotacheck(sc, XFS_DQ_GROUP);
> + xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
> if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
> - xrep_force_quotacheck(sc, XFS_DQ_PROJ);
> + xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
> /* fall through */
> case -ESRCH:
> error = 0;
> diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h
> index 04a47d45605b..fe77de01abe0 100644
> --- a/fs/xfs/scrub/repair.h
> +++ b/fs/xfs/scrub/repair.h
> @@ -6,6 +6,8 @@
> #ifndef __XFS_SCRUB_REPAIR_H__
> #define __XFS_SCRUB_REPAIR_H__
>
> +#include "xfs_quota_defs.h"
> +
> static inline int xrep_notsupported(struct xfs_scrub *sc)
> {
> return -EOPNOTSUPP;
> @@ -49,7 +51,7 @@ struct xrep_find_ag_btree {
>
> int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp,
> struct xrep_find_ag_btree *btree_info, struct xfs_buf *agfl_bp);
> -void xrep_force_quotacheck(struct xfs_scrub *sc, uint dqtype);
> +void xrep_force_quotacheck(struct xfs_scrub *sc, xfs_dqtype_t type);
> int xrep_ino_dqattach(struct xfs_scrub *sc);
>
> /* Metadata repairers */
> diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
> index 74c851f60eee..682d1ed78894 100644
> --- a/fs/xfs/xfs_buf_item_recover.c
> +++ b/fs/xfs/xfs_buf_item_recover.c
> @@ -494,7 +494,7 @@ xlog_recover_do_reg_buffer(
> goto next;
> }
> fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr,
> - -1, 0);
> + -1, XFS_DQTYPE_NONE);
> if (fa) {
> xfs_alert(mp,
> "dquot corrupt at %pS trying to replay into block 0x%llx",
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 7503c6695569..8230faa9f66e 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -76,7 +76,7 @@ xfs_qm_adjust_dqlimits(
> int prealloc = 0;
>
> ASSERT(d->d_id);
> - defq = xfs_get_defquota(q, xfs_dquot_type(dq));
> + defq = xfs_get_defquota(q, dq->q_type);
>
> if (defq->bsoftlimit && !d->d_blk_softlimit) {
> d->d_blk_softlimit = cpu_to_be64(defq->bsoftlimit);
> @@ -122,7 +122,7 @@ xfs_qm_adjust_dqtimers(
> struct xfs_def_quota *defq;
>
> ASSERT(d->d_id);
> - defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
> + defq = xfs_get_defquota(qi, dq->q_type);
>
> #ifdef DEBUG
> if (d->d_blk_hardlimit)
> @@ -214,7 +214,7 @@ xfs_qm_init_dquot_blk(
> struct xfs_trans *tp,
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> struct xfs_buf *bp)
> {
> struct xfs_quotainfo *q = mp->m_quotainfo;
> @@ -246,15 +246,22 @@ xfs_qm_init_dquot_blk(
> }
> }
>
> - if (type & XFS_DQ_USER) {
> + switch (type) {
> + case XFS_DQTYPE_USER:
> qflag = XFS_UQUOTA_CHKD;
> blftype = XFS_BLF_UDQUOT_BUF;
> - } else if (type & XFS_DQ_PROJ) {
> + break;
> + case XFS_DQTYPE_PROJ:
> qflag = XFS_PQUOTA_CHKD;
> blftype = XFS_BLF_PDQUOT_BUF;
> - } else {
> + break;
> + case XFS_DQTYPE_GROUP:
> qflag = XFS_GQUOTA_CHKD;
> blftype = XFS_BLF_GDQUOT_BUF;
> + break;
> + default:
> + ASSERT(0);
> + break;
> }
>
> xfs_trans_dquot_buf(tp, bp, blftype);
> @@ -322,14 +329,14 @@ xfs_dquot_disk_alloc(
> struct xfs_trans *tp = *tpp;
> struct xfs_mount *mp = tp->t_mountp;
> struct xfs_buf *bp;
> - struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->dq_flags);
> + struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->q_type);
> int nmaps = 1;
> int error;
>
> trace_xfs_dqalloc(dqp);
>
> xfs_ilock(quotip, XFS_ILOCK_EXCL);
> - if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
> + if (!xfs_this_quota_on(dqp->q_mount, dqp->q_type)) {
> /*
> * Return if this type of quotas is turned off while we didn't
> * have an inode lock
> @@ -367,7 +374,7 @@ xfs_dquot_disk_alloc(
> * the entire thing.
> */
> xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
> - dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
> + dqp->q_type, bp);
> xfs_buf_set_ref(bp, XFS_DQUOT_REF);
>
> /*
> @@ -414,13 +421,13 @@ xfs_dquot_disk_read(
> {
> struct xfs_bmbt_irec map;
> struct xfs_buf *bp;
> - struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->dq_flags);
> + struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->q_type);
> uint lock_mode;
> int nmaps = 1;
> int error;
>
> lock_mode = xfs_ilock_data_map_shared(quotip);
> - if (!xfs_this_quota_on(mp, dqp->dq_flags)) {
> + if (!xfs_this_quota_on(mp, dqp->q_type)) {
> /*
> * Return if this type of quotas is turned off while we
> * didn't have the quota inode lock.
> @@ -472,13 +479,13 @@ STATIC struct xfs_dquot *
> xfs_dquot_alloc(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type)
> + xfs_dqtype_t type)
> {
> struct xfs_dquot *dqp;
>
> dqp = kmem_zone_zalloc(xfs_qm_dqzone, 0);
>
> - dqp->dq_flags = type;
> + dqp->q_type = type;
> dqp->q_core.d_id = cpu_to_be32(id);
> dqp->q_mount = mp;
> INIT_LIST_HEAD(&dqp->q_lru);
> @@ -504,13 +511,13 @@ xfs_dquot_alloc(
> * quotas.
> */
> switch (type) {
> - case XFS_DQ_USER:
> + case XFS_DQTYPE_USER:
> /* uses the default lock class */
> break;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
> break;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
> break;
> default:
> @@ -536,7 +543,7 @@ xfs_dquot_from_disk(
> * Ensure that we got the type and ID we were looking for.
> * Everything else was checked by the dquot buffer verifier.
> */
> - if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->dq_flags ||
> + if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->q_type ||
> ddqp->d_id != dqp->q_core.d_id) {
> xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
> "Metadata corruption detected at %pS, quota %u",
> @@ -607,7 +614,7 @@ static int
> xfs_qm_dqread(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> bool can_alloc,
> struct xfs_dquot **dqpp)
> {
> @@ -655,7 +662,7 @@ xfs_qm_dqread(
> static int
> xfs_dq_get_next_id(
> struct xfs_mount *mp,
> - uint type,
> + xfs_dqtype_t type,
> xfs_dqid_t *id)
> {
> struct xfs_inode *quotip = xfs_quota_inode(mp, type);
> @@ -779,21 +786,21 @@ xfs_qm_dqget_cache_insert(
> static int
> xfs_qm_dqget_checks(
> struct xfs_mount *mp,
> - uint type)
> + xfs_dqtype_t type)
> {
> if (WARN_ON_ONCE(!XFS_IS_QUOTA_RUNNING(mp)))
> return -ESRCH;
>
> switch (type) {
> - case XFS_DQ_USER:
> + case XFS_DQTYPE_USER:
> if (!XFS_IS_UQUOTA_ON(mp))
> return -ESRCH;
> return 0;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> if (!XFS_IS_GQUOTA_ON(mp))
> return -ESRCH;
> return 0;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> if (!XFS_IS_PQUOTA_ON(mp))
> return -ESRCH;
> return 0;
> @@ -811,7 +818,7 @@ int
> xfs_qm_dqget(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> bool can_alloc,
> struct xfs_dquot **O_dqpp)
> {
> @@ -861,7 +868,7 @@ int
> xfs_qm_dqget_uncached(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> struct xfs_dquot **dqpp)
> {
> int error;
> @@ -877,14 +884,14 @@ xfs_qm_dqget_uncached(
> xfs_dqid_t
> xfs_qm_id_for_quotatype(
> struct xfs_inode *ip,
> - uint type)
> + xfs_dqtype_t type)
> {
> switch (type) {
> - case XFS_DQ_USER:
> + case XFS_DQTYPE_USER:
> return i_uid_read(VFS_I(ip));
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return i_gid_read(VFS_I(ip));
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return ip->i_d.di_projid;
> }
> ASSERT(0);
> @@ -899,7 +906,7 @@ xfs_qm_id_for_quotatype(
> int
> xfs_qm_dqget_inode(
> struct xfs_inode *ip,
> - uint type,
> + xfs_dqtype_t type,
> bool can_alloc,
> struct xfs_dquot **O_dqpp)
> {
> @@ -985,7 +992,7 @@ int
> xfs_qm_dqget_next(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> struct xfs_dquot **dqpp)
> {
> struct xfs_dquot *dqp;
> @@ -1294,7 +1301,7 @@ xfs_qm_exit(void)
> int
> xfs_qm_dqiterate(
> struct xfs_mount *mp,
> - uint dqtype,
> + xfs_dqtype_t type,
> xfs_qm_dqiterate_fn iter_fn,
> void *priv)
> {
> @@ -1303,13 +1310,13 @@ xfs_qm_dqiterate(
> int error;
>
> do {
> - error = xfs_qm_dqget_next(mp, id, dqtype, &dq);
> + error = xfs_qm_dqget_next(mp, id, type, &dq);
> if (error == -ENOENT)
> return 0;
> if (error)
> return error;
>
> - error = iter_fn(dq, dqtype, priv);
> + error = iter_fn(dq, type, priv);
> id = be32_to_cpu(dq->q_core.d_id);
> xfs_qm_dqput(dq);
> id++;
> diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
> index 71e36c85e20b..077d0988cff9 100644
> --- a/fs/xfs/xfs_dquot.h
> +++ b/fs/xfs/xfs_dquot.h
> @@ -34,6 +34,7 @@ struct xfs_dquot {
> uint dq_flags;
> struct list_head q_lru;
> struct xfs_mount *q_mount;
> + xfs_dqtype_t q_type;
> uint q_nrefs;
> xfs_daddr_t q_blkno;
> int q_bufoffset;
> @@ -101,28 +102,34 @@ static inline void xfs_dqunlock(struct xfs_dquot *dqp)
> mutex_unlock(&dqp->q_qlock);
> }
>
> -static inline int xfs_this_quota_on(struct xfs_mount *mp, int type)
> +static inline bool
> +xfs_this_quota_on(
> + struct xfs_mount *mp,
> + xfs_dqtype_t type)
> {
> - switch (type & XFS_DQ_ALLTYPES) {
> - case XFS_DQ_USER:
> + switch (type) {
> + case XFS_DQTYPE_USER:
> return XFS_IS_UQUOTA_ON(mp);
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return XFS_IS_GQUOTA_ON(mp);
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return XFS_IS_PQUOTA_ON(mp);
> default:
> - return 0;
> + return false;
> }
> }
>
> -static inline struct xfs_dquot *xfs_inode_dquot(struct xfs_inode *ip, int type)
> +static inline struct xfs_dquot *
> +xfs_inode_dquot(
> + struct xfs_inode *ip,
> + xfs_dqtype_t type)
> {
> - switch (type & XFS_DQ_ALLTYPES) {
> - case XFS_DQ_USER:
> + switch (type) {
> + case XFS_DQTYPE_USER:
> return ip->i_udquot;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return ip->i_gdquot;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return ip->i_pdquot;
> default:
> return NULL;
> @@ -146,9 +153,9 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
>
> #define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
> #define XFS_DQ_IS_DIRTY(dqp) ((dqp)->dq_flags & XFS_DQ_DIRTY)
> -#define XFS_QM_ISUDQ(dqp) ((dqp)->dq_flags & XFS_DQ_USER)
> -#define XFS_QM_ISPDQ(dqp) ((dqp)->dq_flags & XFS_DQ_PROJ)
> -#define XFS_QM_ISGDQ(dqp) ((dqp)->dq_flags & XFS_DQ_GROUP)
> +#define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
> +#define XFS_QM_ISPDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_PROJ)
> +#define XFS_QM_ISGDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_GROUP)
>
> void xfs_qm_dqdestroy(struct xfs_dquot *dqp);
> int xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);
> @@ -157,18 +164,20 @@ void xfs_qm_adjust_dqtimers(struct xfs_mount *mp,
> struct xfs_dquot *d);
> void xfs_qm_adjust_dqlimits(struct xfs_mount *mp,
> struct xfs_dquot *d);
> -xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip, uint type);
> +xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip,
> + xfs_dqtype_t type);
> int xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
> - uint type, bool can_alloc,
> - struct xfs_dquot **dqpp);
> -int xfs_qm_dqget_inode(struct xfs_inode *ip, uint type,
> - bool can_alloc,
> - struct xfs_dquot **dqpp);
> + xfs_dqtype_t type, bool can_alloc,
> + struct xfs_dquot **dqpp);
> +int xfs_qm_dqget_inode(struct xfs_inode *ip,
> + xfs_dqtype_t type,
> + bool can_alloc, struct xfs_dquot **dqpp);
> int xfs_qm_dqget_next(struct xfs_mount *mp, xfs_dqid_t id,
> - uint type, struct xfs_dquot **dqpp);
> -int xfs_qm_dqget_uncached(struct xfs_mount *mp,
> - xfs_dqid_t id, uint type,
> - struct xfs_dquot **dqpp);
> + xfs_dqtype_t type,
> + struct xfs_dquot **dqpp);
> +int xfs_qm_dqget_uncached(struct xfs_mount *mp, xfs_dqid_t id,
> + xfs_dqtype_t type,
> + struct xfs_dquot **dqpp);
> void xfs_qm_dqput(struct xfs_dquot *dqp);
>
> void xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
> @@ -183,9 +192,9 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
> return dqp;
> }
>
> -typedef int (*xfs_qm_dqiterate_fn)(struct xfs_dquot *dq, uint dqtype,
> - void *priv);
> -int xfs_qm_dqiterate(struct xfs_mount *mp, uint dqtype,
> +typedef int (*xfs_qm_dqiterate_fn)(struct xfs_dquot *dq,
> + xfs_dqtype_t type, void *priv);
> +int xfs_qm_dqiterate(struct xfs_mount *mp, xfs_dqtype_t type,
> xfs_qm_dqiterate_fn iter_fn, void *priv);
>
> #endif /* __XFS_DQUOT_H__ */
> diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
> index f9ea9f55aa7c..a39708879874 100644
> --- a/fs/xfs/xfs_dquot_item_recover.c
> +++ b/fs/xfs/xfs_dquot_item_recover.c
> @@ -108,7 +108,7 @@ xlog_recover_dquot_commit_pass2(
> */
> dq_f = item->ri_buf[0].i_addr;
> ASSERT(dq_f);
> - fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, 0);
> + fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, XFS_DQTYPE_NONE);
> if (fa) {
> xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
> dq_f->qlf_id, fa);
> diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> index 58a750ce689c..3c6e936d2f99 100644
> --- a/fs/xfs/xfs_icache.c
> +++ b/fs/xfs/xfs_icache.c
> @@ -1424,7 +1424,7 @@ __xfs_inode_free_quota_eofblocks(
> eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
>
> if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
> - dq = xfs_inode_dquot(ip, XFS_DQ_USER);
> + dq = xfs_inode_dquot(ip, XFS_DQTYPE_USER);
> if (dq && xfs_dquot_lowsp(dq)) {
> eofb.eof_uid = VFS_I(ip)->i_uid;
> eofb.eof_flags |= XFS_EOF_FLAGS_UID;
> @@ -1433,7 +1433,7 @@ __xfs_inode_free_quota_eofblocks(
> }
>
> if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
> - dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
> + dq = xfs_inode_dquot(ip, XFS_DQTYPE_GROUP);
> if (dq && xfs_dquot_lowsp(dq)) {
> eofb.eof_gid = VFS_I(ip)->i_gid;
> eofb.eof_flags |= XFS_EOF_FLAGS_GID;
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index b9a8c3798e08..ac2cc2680d2a 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -293,11 +293,11 @@ xfs_iomap_write_direct(
>
> STATIC bool
> xfs_quota_need_throttle(
> - struct xfs_inode *ip,
> - int type,
> - xfs_fsblock_t alloc_blocks)
> + struct xfs_inode *ip,
> + xfs_dqtype_t type,
> + xfs_fsblock_t alloc_blocks)
> {
> - struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
> + struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
>
> if (!dq || !xfs_this_quota_on(ip->i_mount, type))
> return false;
> @@ -315,15 +315,15 @@ xfs_quota_need_throttle(
>
> STATIC void
> xfs_quota_calc_throttle(
> - struct xfs_inode *ip,
> - int type,
> - xfs_fsblock_t *qblocks,
> - int *qshift,
> - int64_t *qfreesp)
> + struct xfs_inode *ip,
> + xfs_dqtype_t type,
> + xfs_fsblock_t *qblocks,
> + int *qshift,
> + int64_t *qfreesp)
> {
> - int64_t freesp;
> - int shift = 0;
> - struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
> + struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
> + int64_t freesp;
> + int shift = 0;
>
> /* no dq, or over hi wmark, squash the prealloc completely */
> if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
> @@ -450,14 +450,14 @@ xfs_iomap_prealloc_size(
> * Check each quota to cap the prealloc size, provide a shift value to
> * throttle with and adjust amount of available space.
> */
> - if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
> - xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
> + if (xfs_quota_need_throttle(ip, XFS_DQTYPE_USER, alloc_blocks))
> + xfs_quota_calc_throttle(ip, XFS_DQTYPE_USER, &qblocks, &qshift,
> &freesp);
> - if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
> - xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
> + if (xfs_quota_need_throttle(ip, XFS_DQTYPE_GROUP, alloc_blocks))
> + xfs_quota_calc_throttle(ip, XFS_DQTYPE_GROUP, &qblocks, &qshift,
> &freesp);
> - if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
> - xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
> + if (xfs_quota_need_throttle(ip, XFS_DQTYPE_PROJ, alloc_blocks))
> + xfs_quota_calc_throttle(ip, XFS_DQTYPE_PROJ, &qblocks, &qshift,
> &freesp);
>
> /*
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index 938023dd8ce5..9c455ebd20cb 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -47,7 +47,7 @@ STATIC void xfs_qm_dqfree_one(struct xfs_dquot *dqp);
> STATIC int
> xfs_qm_dquot_walk(
> struct xfs_mount *mp,
> - int type,
> + xfs_dqtype_t type,
> int (*execute)(struct xfs_dquot *dqp, void *data),
> void *data)
> {
> @@ -161,7 +161,7 @@ xfs_qm_dqpurge(
> xfs_dqfunlock(dqp);
> xfs_dqunlock(dqp);
>
> - radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
> + radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
> be32_to_cpu(dqp->q_core.d_id));
> qi->qi_dquots--;
>
> @@ -190,11 +190,11 @@ xfs_qm_dqpurge_all(
> uint flags)
> {
> if (flags & XFS_QMOPT_UQUOTA)
> - xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
> + xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER, xfs_qm_dqpurge, NULL);
> if (flags & XFS_QMOPT_GQUOTA)
> - xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
> + xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP, xfs_qm_dqpurge, NULL);
> if (flags & XFS_QMOPT_PQUOTA)
> - xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
> + xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ, xfs_qm_dqpurge, NULL);
> }
>
> /*
> @@ -251,7 +251,7 @@ STATIC int
> xfs_qm_dqattach_one(
> struct xfs_inode *ip,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> bool doalloc,
> struct xfs_dquot **IO_idqpp)
> {
> @@ -332,7 +332,7 @@ xfs_qm_dqattach_locked(
>
> if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {
> error = xfs_qm_dqattach_one(ip, i_uid_read(VFS_I(ip)),
> - XFS_DQ_USER, doalloc, &ip->i_udquot);
> + XFS_DQTYPE_USER, doalloc, &ip->i_udquot);
> if (error)
> goto done;
> ASSERT(ip->i_udquot);
> @@ -340,15 +340,15 @@ xfs_qm_dqattach_locked(
>
> if (XFS_IS_GQUOTA_ON(mp) && !ip->i_gdquot) {
> error = xfs_qm_dqattach_one(ip, i_gid_read(VFS_I(ip)),
> - XFS_DQ_GROUP, doalloc, &ip->i_gdquot);
> + XFS_DQTYPE_GROUP, doalloc, &ip->i_gdquot);
> if (error)
> goto done;
> ASSERT(ip->i_gdquot);
> }
>
> if (XFS_IS_PQUOTA_ON(mp) && !ip->i_pdquot) {
> - error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
> - doalloc, &ip->i_pdquot);
> + error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid,
> + XFS_DQTYPE_PROJ, doalloc, &ip->i_pdquot);
> if (error)
> goto done;
> ASSERT(ip->i_pdquot);
> @@ -546,7 +546,7 @@ xfs_qm_shrink_count(
> STATIC void
> xfs_qm_set_defquota(
> struct xfs_mount *mp,
> - uint type,
> + xfs_dqtype_t type,
> struct xfs_quotainfo *qinf)
> {
> struct xfs_dquot *dqp;
> @@ -559,7 +559,7 @@ xfs_qm_set_defquota(
> return;
>
> ddqp = &dqp->q_core;
> - defq = xfs_get_defquota(qinf, xfs_dquot_type(dqp));
> + defq = xfs_get_defquota(qinf, type);
>
> /*
> * Timers and warnings have been already set, let's just set the
> @@ -578,7 +578,7 @@ xfs_qm_set_defquota(
> static void
> xfs_qm_init_timelimits(
> struct xfs_mount *mp,
> - uint type)
> + xfs_dqtype_t type)
> {
> struct xfs_quotainfo *qinf = mp->m_quotainfo;
> struct xfs_def_quota *defq;
> @@ -670,16 +670,16 @@ xfs_qm_init_quotainfo(
>
> mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
>
> - xfs_qm_init_timelimits(mp, XFS_DQ_USER);
> - xfs_qm_init_timelimits(mp, XFS_DQ_GROUP);
> - xfs_qm_init_timelimits(mp, XFS_DQ_PROJ);
> + xfs_qm_init_timelimits(mp, XFS_DQTYPE_USER);
> + xfs_qm_init_timelimits(mp, XFS_DQTYPE_GROUP);
> + xfs_qm_init_timelimits(mp, XFS_DQTYPE_PROJ);
>
> if (XFS_IS_UQUOTA_RUNNING(mp))
> - xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
> + xfs_qm_set_defquota(mp, XFS_DQTYPE_USER, qinf);
> if (XFS_IS_GQUOTA_RUNNING(mp))
> - xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
> + xfs_qm_set_defquota(mp, XFS_DQTYPE_GROUP, qinf);
> if (XFS_IS_PQUOTA_RUNNING(mp))
> - xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);
> + xfs_qm_set_defquota(mp, XFS_DQTYPE_PROJ, qinf);
>
> qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
> qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
> @@ -829,10 +829,10 @@ xfs_qm_qino_alloc(
>
> STATIC void
> xfs_qm_reset_dqcounts(
> - xfs_mount_t *mp,
> - xfs_buf_t *bp,
> - xfs_dqid_t id,
> - uint type)
> + struct xfs_mount *mp,
> + struct xfs_buf *bp,
> + xfs_dqid_t id,
> + xfs_dqtype_t type)
> {
> struct xfs_dqblk *dqb;
> int j;
> @@ -907,11 +907,11 @@ xfs_qm_reset_dqcounts_all(
> {
> struct xfs_buf *bp;
> int error;
> - int type;
> + xfs_dqtype_t type;
>
> ASSERT(blkcnt > 0);
> - type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
> - (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
> + type = flags & XFS_QMOPT_UQUOTA ? XFS_DQTYPE_USER :
> + (flags & XFS_QMOPT_PQUOTA ? XFS_DQTYPE_PROJ : XFS_DQTYPE_GROUP);
> error = 0;
>
> /*
> @@ -1070,7 +1070,7 @@ xfs_qm_reset_dqcounts_buf(
> STATIC int
> xfs_qm_quotacheck_dqadjust(
> struct xfs_inode *ip,
> - uint type,
> + xfs_dqtype_t type,
> xfs_qcnt_t nblks,
> xfs_qcnt_t rtblks)
> {
> @@ -1187,21 +1187,21 @@ xfs_qm_dqusage_adjust(
> * and quotaoffs don't race. (Quotachecks happen at mount time only).
> */
> if (XFS_IS_UQUOTA_ON(mp)) {
> - error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_USER, nblks,
> + error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_USER, nblks,
> rtblks);
> if (error)
> goto error0;
> }
>
> if (XFS_IS_GQUOTA_ON(mp)) {
> - error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_GROUP, nblks,
> + error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_GROUP, nblks,
> rtblks);
> if (error)
> goto error0;
> }
>
> if (XFS_IS_PQUOTA_ON(mp)) {
> - error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_PROJ, nblks,
> + error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_PROJ, nblks,
> rtblks);
> if (error)
> goto error0;
> @@ -1325,18 +1325,18 @@ xfs_qm_quotacheck(
> * down to disk buffers if everything was updated successfully.
> */
> if (XFS_IS_UQUOTA_ON(mp)) {
> - error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
> - &buffer_list);
> + error = xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER,
> + xfs_qm_flush_one, &buffer_list);
> }
> if (XFS_IS_GQUOTA_ON(mp)) {
> - error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
> - &buffer_list);
> + error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP,
> + xfs_qm_flush_one, &buffer_list);
> if (!error)
> error = error2;
> }
> if (XFS_IS_PQUOTA_ON(mp)) {
> - error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
> - &buffer_list);
> + error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ,
> + xfs_qm_flush_one, &buffer_list);
> if (!error)
> error = error2;
> }
> @@ -1598,7 +1598,7 @@ xfs_qm_dqfree_one(
> struct xfs_quotainfo *qi = mp->m_quotainfo;
>
> mutex_lock(&qi->qi_tree_lock);
> - radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
> + radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
> be32_to_cpu(dqp->q_core.d_id));
>
> qi->qi_dquots--;
> @@ -1674,7 +1674,7 @@ xfs_qm_vop_dqalloc(
> */
> xfs_iunlock(ip, lockflags);
> error = xfs_qm_dqget(mp, from_kuid(user_ns, uid),
> - XFS_DQ_USER, true, &uq);
> + XFS_DQTYPE_USER, true, &uq);
> if (error) {
> ASSERT(error != -ENOENT);
> return error;
> @@ -1698,7 +1698,7 @@ xfs_qm_vop_dqalloc(
> if (!gid_eq(inode->i_gid, gid)) {
> xfs_iunlock(ip, lockflags);
> error = xfs_qm_dqget(mp, from_kgid(user_ns, gid),
> - XFS_DQ_GROUP, true, &gq);
> + XFS_DQTYPE_GROUP, true, &gq);
> if (error) {
> ASSERT(error != -ENOENT);
> goto error_rele;
> @@ -1714,8 +1714,8 @@ xfs_qm_vop_dqalloc(
> if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
> if (ip->i_d.di_projid != prid) {
> xfs_iunlock(ip, lockflags);
> - error = xfs_qm_dqget(mp, (xfs_dqid_t)prid, XFS_DQ_PROJ,
> - true, &pq);
> + error = xfs_qm_dqget(mp, (xfs_dqid_t)prid,
> + XFS_DQTYPE_PROJ, true, &pq);
> if (error) {
> ASSERT(error != -ENOENT);
> goto error_rele;
> diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
> index 7b0e771fcbce..27789272da95 100644
> --- a/fs/xfs/xfs_qm.h
> +++ b/fs/xfs/xfs_qm.h
> @@ -83,14 +83,14 @@ struct xfs_quotainfo {
> static inline struct radix_tree_root *
> xfs_dquot_tree(
> struct xfs_quotainfo *qi,
> - int type)
> + xfs_dqtype_t type)
> {
> switch (type) {
> - case XFS_DQ_USER:
> + case XFS_DQTYPE_USER:
> return &qi->qi_uquota_tree;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return &qi->qi_gquota_tree;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return &qi->qi_pquota_tree;
> default:
> ASSERT(0);
> @@ -99,14 +99,14 @@ xfs_dquot_tree(
> }
>
> static inline struct xfs_inode *
> -xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
> +xfs_quota_inode(struct xfs_mount *mp, xfs_dqtype_t type)
> {
> - switch (dq_flags & XFS_DQ_ALLTYPES) {
> - case XFS_DQ_USER:
> + switch (type) {
> + case XFS_DQTYPE_USER:
> return mp->m_quotainfo->qi_uquotaip;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return mp->m_quotainfo->qi_gquotaip;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return mp->m_quotainfo->qi_pquotaip;
> default:
> ASSERT(0);
> @@ -114,17 +114,6 @@ xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
> return NULL;
> }
>
> -static inline int
> -xfs_dquot_type(struct xfs_dquot *dqp)
> -{
> - if (XFS_QM_ISUDQ(dqp))
> - return XFS_DQ_USER;
> - if (XFS_QM_ISGDQ(dqp))
> - return XFS_DQ_GROUP;
> - ASSERT(XFS_QM_ISPDQ(dqp));
> - return XFS_DQ_PROJ;
> -}
> -
> extern void xfs_trans_mod_dquot(struct xfs_trans *tp, struct xfs_dquot *dqp,
> uint field, int64_t delta);
> extern void xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
> @@ -166,24 +155,30 @@ extern void xfs_qm_dqrele_all_inodes(struct xfs_mount *, uint);
>
> /* quota ops */
> extern int xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
> -extern int xfs_qm_scall_getquota(struct xfs_mount *, xfs_dqid_t,
> - uint, struct qc_dqblk *);
> -extern int xfs_qm_scall_getquota_next(struct xfs_mount *,
> - xfs_dqid_t *, uint, struct qc_dqblk *);
> -extern int xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
> - struct qc_dqblk *);
> +extern int xfs_qm_scall_getquota(struct xfs_mount *mp,
> + xfs_dqid_t id,
> + xfs_dqtype_t type,
> + struct qc_dqblk *dst);
> +extern int xfs_qm_scall_getquota_next(struct xfs_mount *mp,
> + xfs_dqid_t *id,
> + xfs_dqtype_t type,
> + struct qc_dqblk *dst);
> +extern int xfs_qm_scall_setqlim(struct xfs_mount *mp,
> + xfs_dqid_t id,
> + xfs_dqtype_t type,
> + struct qc_dqblk *newlim);
> extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);
> extern int xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
>
> static inline struct xfs_def_quota *
> -xfs_get_defquota(struct xfs_quotainfo *qi, int type)
> +xfs_get_defquota(struct xfs_quotainfo *qi, xfs_dqtype_t type)
> {
> switch (type) {
> - case XFS_DQ_USER:
> + case XFS_DQTYPE_USER:
> return &qi->qi_usr_default;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return &qi->qi_grp_default;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return &qi->qi_prj_default;
> default:
> ASSERT(0);
> diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
> index fc2fa418919f..72c2c2595132 100644
> --- a/fs/xfs/xfs_qm_bhv.c
> +++ b/fs/xfs/xfs_qm_bhv.c
> @@ -60,7 +60,7 @@ xfs_qm_statvfs(
> struct xfs_mount *mp = ip->i_mount;
> struct xfs_dquot *dqp;
>
> - if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQ_PROJ, false, &dqp)) {
> + if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQTYPE_PROJ, false, &dqp)) {
> xfs_fill_statvfs_from_dquot(statp, dqp);
> xfs_qm_dqput(dqp);
> }
> diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
> index 35fad348e3a2..c7cb8a356c88 100644
> --- a/fs/xfs/xfs_qm_syscalls.c
> +++ b/fs/xfs/xfs_qm_syscalls.c
> @@ -443,7 +443,7 @@ int
> xfs_qm_scall_setqlim(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> struct qc_dqblk *newlim)
> {
> struct xfs_quotainfo *q = mp->m_quotainfo;
> @@ -479,7 +479,7 @@ xfs_qm_scall_setqlim(
> goto out_unlock;
> }
>
> - defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
> + defq = xfs_get_defquota(q, dqp->q_type);
> xfs_dqunlock(dqp);
>
> error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_setqlim, 0, 0, 0, &tp);
> @@ -614,7 +614,7 @@ xfs_qm_scall_setqlim(
> static void
> xfs_qm_scall_getquota_fill_qc(
> struct xfs_mount *mp,
> - uint type,
> + xfs_dqtype_t type,
> const struct xfs_dquot *dqp,
> struct qc_dqblk *dst)
> {
> @@ -644,21 +644,18 @@ xfs_qm_scall_getquota_fill_qc(
> * gets turned off. No need to confuse the user level code,
> * so return zeroes in that case.
> */
> - if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
> - dqp->q_core.d_flags == XFS_DQ_USER) ||
> - (!XFS_IS_GQUOTA_ENFORCED(mp) &&
> - dqp->q_core.d_flags == XFS_DQ_GROUP) ||
> - (!XFS_IS_PQUOTA_ENFORCED(mp) &&
> - dqp->q_core.d_flags == XFS_DQ_PROJ)) {
> + if ((!XFS_IS_UQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_USER) ||
> + (!XFS_IS_GQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_GROUP) ||
> + (!XFS_IS_PQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_PROJ)) {
> dst->d_spc_timer = 0;
> dst->d_ino_timer = 0;
> dst->d_rt_spc_timer = 0;
> }
>
> #ifdef DEBUG
> - if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) ||
> - (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
> - (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) &&
> + if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_USER) ||
> + (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_GROUP) ||
> + (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_PROJ)) &&
> dqp->q_core.d_id != 0) {
> if ((dst->d_space > dst->d_spc_softlimit) &&
> (dst->d_spc_softlimit > 0)) {
> @@ -677,7 +674,7 @@ int
> xfs_qm_scall_getquota(
> struct xfs_mount *mp,
> xfs_dqid_t id,
> - uint type,
> + xfs_dqtype_t type,
> struct qc_dqblk *dst)
> {
> struct xfs_dquot *dqp;
> @@ -715,7 +712,7 @@ int
> xfs_qm_scall_getquota_next(
> struct xfs_mount *mp,
> xfs_dqid_t *id,
> - uint type,
> + xfs_dqtype_t type,
> struct qc_dqblk *dst)
> {
> struct xfs_dquot *dqp;
> diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
> index c92ae5e02ce8..06b22e35fc90 100644
> --- a/fs/xfs/xfs_quota.h
> +++ b/fs/xfs/xfs_quota.h
> @@ -39,14 +39,14 @@ struct xfs_buf;
>
> static inline uint
> xfs_quota_chkd_flag(
> - uint dqtype)
> + xfs_dqtype_t type)
> {
> - switch (dqtype) {
> - case XFS_DQ_USER:
> + switch (type) {
> + case XFS_DQTYPE_USER:
> return XFS_UQUOTA_CHKD;
> - case XFS_DQ_GROUP:
> + case XFS_DQTYPE_GROUP:
> return XFS_GQUOTA_CHKD;
> - case XFS_DQ_PROJ:
> + case XFS_DQTYPE_PROJ:
> return XFS_PQUOTA_CHKD;
> default:
> return 0;
> diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
> index 0868e6ee2219..963c253558b3 100644
> --- a/fs/xfs/xfs_quotaops.c
> +++ b/fs/xfs/xfs_quotaops.c
> @@ -85,16 +85,16 @@ xfs_fs_get_quota_state(
> return 0;
> }
>
> -STATIC int
> +STATIC xfs_dqtype_t
> xfs_quota_type(int type)
> {
> switch (type) {
> case USRQUOTA:
> - return XFS_DQ_USER;
> + return XFS_DQTYPE_USER;
> case GRPQUOTA:
> - return XFS_DQ_GROUP;
> + return XFS_DQTYPE_GROUP;
> default:
> - return XFS_DQ_PROJ;
> + return XFS_DQTYPE_PROJ;
> }
> }
>
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index 50c478374a31..f19e66da6646 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -864,6 +864,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
> TP_STRUCT__entry(
> __field(dev_t, dev)
> __field(u32, id)
> + __field(xfs_dqtype_t, type)
> __field(unsigned, flags)
> __field(unsigned, nrefs)
> __field(unsigned long long, res_bcount)
> @@ -877,6 +878,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
> TP_fast_assign(
> __entry->dev = dqp->q_mount->m_super->s_dev;
> __entry->id = be32_to_cpu(dqp->q_core.d_id);
> + __entry->type = dqp->q_type;
> __entry->flags = dqp->dq_flags;
> __entry->nrefs = dqp->q_nrefs;
> __entry->res_bcount = dqp->q_res_bcount;
> @@ -891,11 +893,12 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
> __entry->ino_softlimit =
> be64_to_cpu(dqp->q_core.d_ino_softlimit);
> ),
> - TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx "
> + TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u res_bc 0x%llx "
> "bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
> "icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]",
> MAJOR(__entry->dev), MINOR(__entry->dev),
> __entry->id,
> + __print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
> __print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
> __entry->nrefs,
> __entry->res_bcount,
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index ed0ce8b301b4..964f69a444a3 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -549,14 +549,21 @@ xfs_quota_warn(
> struct xfs_dquot *dqp,
> int type)
> {
> - enum quota_type qtype;
> + enum quota_type qtype;
>
> - if (dqp->dq_flags & XFS_DQ_PROJ)
> + switch (dqp->q_type) {
> + case XFS_DQTYPE_PROJ:
> qtype = PRJQUOTA;
> - else if (dqp->dq_flags & XFS_DQ_USER)
> + break;
> + case XFS_DQTYPE_USER:
> qtype = USRQUOTA;
> - else
> + break;
> + case XFS_DQTYPE_GROUP:
> qtype = GRPQUOTA;
> + break;
> + default:
> + return;
> + }
>
> quota_send_warning(make_kqid(&init_user_ns, qtype,
> be32_to_cpu(dqp->q_core.d_id)),
> @@ -591,7 +598,7 @@ xfs_trans_dqresv(
>
> xfs_dqlock(dqp);
>
> - defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
> + defq = xfs_get_defquota(q, dqp->q_type);
>
> if (flags & XFS_TRANS_DQ_RES_BLKS) {
> hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 06/26] xfs: refactor quotacheck flags usage
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (4 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 05/26] xfs: split the incore dquot type into a separate field Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-16 6:59 ` Chandan Babu R
2020-07-15 1:51 ` [PATCH 07/26] xfs: rename dquot incore state flags Darrick J. Wong
` (19 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
We only use the XFS_QMOPT flags in quotacheck to signal the quota type,
so rip out all the flags handling and just pass the type all the way
through.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_qm.c | 18 +++++++-----------
1 file changed, 7 insertions(+), 11 deletions(-)
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 9c455ebd20cb..939ee728d9af 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -902,17 +902,13 @@ xfs_qm_reset_dqcounts_all(
xfs_dqid_t firstid,
xfs_fsblock_t bno,
xfs_filblks_t blkcnt,
- uint flags,
+ xfs_dqtype_t type,
struct list_head *buffer_list)
{
struct xfs_buf *bp;
- int error;
- xfs_dqtype_t type;
+ int error = 0;
ASSERT(blkcnt > 0);
- type = flags & XFS_QMOPT_UQUOTA ? XFS_DQTYPE_USER :
- (flags & XFS_QMOPT_PQUOTA ? XFS_DQTYPE_PROJ : XFS_DQTYPE_GROUP);
- error = 0;
/*
* Blkcnt arg can be a very big number, and might even be
@@ -972,7 +968,7 @@ STATIC int
xfs_qm_reset_dqcounts_buf(
struct xfs_mount *mp,
struct xfs_inode *qip,
- uint flags,
+ xfs_dqtype_t type,
struct list_head *buffer_list)
{
struct xfs_bmbt_irec *map;
@@ -1048,7 +1044,7 @@ xfs_qm_reset_dqcounts_buf(
error = xfs_qm_reset_dqcounts_all(mp, firstid,
map[i].br_startblock,
map[i].br_blockcount,
- flags, buffer_list);
+ type, buffer_list);
if (error)
goto out;
}
@@ -1292,7 +1288,7 @@ xfs_qm_quotacheck(
* We don't log our changes till later.
*/
if (uip) {
- error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_QMOPT_UQUOTA,
+ error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_DQTYPE_USER,
&buffer_list);
if (error)
goto error_return;
@@ -1300,7 +1296,7 @@ xfs_qm_quotacheck(
}
if (gip) {
- error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_QMOPT_GQUOTA,
+ error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_DQTYPE_GROUP,
&buffer_list);
if (error)
goto error_return;
@@ -1308,7 +1304,7 @@ xfs_qm_quotacheck(
}
if (pip) {
- error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_QMOPT_PQUOTA,
+ error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_DQTYPE_PROJ,
&buffer_list);
if (error)
goto error_return;
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 06/26] xfs: refactor quotacheck flags usage
2020-07-15 1:51 ` [PATCH 06/26] xfs: refactor quotacheck flags usage Darrick J. Wong
@ 2020-07-16 6:59 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-16 6:59 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:21:14 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> We only use the XFS_QMOPT flags in quotacheck to signal the quota type,
> so rip out all the flags handling and just pass the type all the way
> through.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/xfs_qm.c | 18 +++++++-----------
> 1 file changed, 7 insertions(+), 11 deletions(-)
>
>
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index 9c455ebd20cb..939ee728d9af 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -902,17 +902,13 @@ xfs_qm_reset_dqcounts_all(
> xfs_dqid_t firstid,
> xfs_fsblock_t bno,
> xfs_filblks_t blkcnt,
> - uint flags,
> + xfs_dqtype_t type,
> struct list_head *buffer_list)
> {
> struct xfs_buf *bp;
> - int error;
> - xfs_dqtype_t type;
> + int error = 0;
>
> ASSERT(blkcnt > 0);
> - type = flags & XFS_QMOPT_UQUOTA ? XFS_DQTYPE_USER :
> - (flags & XFS_QMOPT_PQUOTA ? XFS_DQTYPE_PROJ : XFS_DQTYPE_GROUP);
> - error = 0;
>
> /*
> * Blkcnt arg can be a very big number, and might even be
> @@ -972,7 +968,7 @@ STATIC int
> xfs_qm_reset_dqcounts_buf(
> struct xfs_mount *mp,
> struct xfs_inode *qip,
> - uint flags,
> + xfs_dqtype_t type,
> struct list_head *buffer_list)
> {
> struct xfs_bmbt_irec *map;
> @@ -1048,7 +1044,7 @@ xfs_qm_reset_dqcounts_buf(
> error = xfs_qm_reset_dqcounts_all(mp, firstid,
> map[i].br_startblock,
> map[i].br_blockcount,
> - flags, buffer_list);
> + type, buffer_list);
> if (error)
> goto out;
> }
> @@ -1292,7 +1288,7 @@ xfs_qm_quotacheck(
> * We don't log our changes till later.
> */
> if (uip) {
> - error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_QMOPT_UQUOTA,
> + error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_DQTYPE_USER,
> &buffer_list);
> if (error)
> goto error_return;
> @@ -1300,7 +1296,7 @@ xfs_qm_quotacheck(
> }
>
> if (gip) {
> - error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_QMOPT_GQUOTA,
> + error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_DQTYPE_GROUP,
> &buffer_list);
> if (error)
> goto error_return;
> @@ -1308,7 +1304,7 @@ xfs_qm_quotacheck(
> }
>
> if (pip) {
> - error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_QMOPT_PQUOTA,
> + error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_DQTYPE_PROJ,
> &buffer_list);
> if (error)
> goto error_return;
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 07/26] xfs: rename dquot incore state flags
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (5 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 06/26] xfs: refactor quotacheck flags usage Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-16 6:59 ` Chandan Babu R
2020-07-15 1:51 ` [PATCH 08/26] xfs: move the ondisk dquot flags to their own namespace Darrick J. Wong
` (18 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Rename the existing incore dquot "dq_flags" field to "q_flags" to match
everything else in the structure, then move the two actual dquot state
flags to the XFS_DQFLAG_ namespace from XFS_DQ_.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/libxfs/xfs_quota_defs.h | 10 +++++-----
fs/xfs/xfs_dquot.c | 6 +++---
fs/xfs/xfs_dquot.h | 4 ++--
fs/xfs/xfs_qm.c | 12 ++++++------
fs/xfs/xfs_qm_syscalls.c | 2 +-
fs/xfs/xfs_trace.h | 4 ++--
fs/xfs/xfs_trans_dquot.c | 2 +-
7 files changed, 20 insertions(+), 20 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index aaf85a47ae5f..2109fe621e1f 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -37,17 +37,17 @@ typedef uint8_t xfs_dqtype_t;
#define XFS_DQ_USER 0x0001 /* a user quota */
#define XFS_DQ_PROJ 0x0002 /* project quota */
#define XFS_DQ_GROUP 0x0004 /* a group quota */
-#define XFS_DQ_DIRTY 0x0008 /* dquot is dirty */
-#define XFS_DQ_FREEING 0x0010 /* dquot is being torn down */
+#define XFS_DQFLAG_DIRTY 0x0008 /* dquot is dirty */
+#define XFS_DQFLAG_FREEING 0x0010 /* dquot is being torn down */
#define XFS_DQ_ALLTYPES (XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
-#define XFS_DQ_FLAGS \
+#define XFS_DQFLAG_STRINGS \
{ XFS_DQ_USER, "USER" }, \
{ XFS_DQ_PROJ, "PROJ" }, \
{ XFS_DQ_GROUP, "GROUP" }, \
- { XFS_DQ_DIRTY, "DIRTY" }, \
- { XFS_DQ_FREEING, "FREEING" }
+ { XFS_DQFLAG_DIRTY, "DIRTY" }, \
+ { XFS_DQFLAG_FREEING, "FREEING" }
/*
* We have the possibility of all three quota types being active at once, and
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 8230faa9f66e..91d81a346801 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -730,7 +730,7 @@ xfs_qm_dqget_cache_lookup(
}
xfs_dqlock(dqp);
- if (dqp->dq_flags & XFS_DQ_FREEING) {
+ if (dqp->q_flags & XFS_DQFLAG_FREEING) {
xfs_dqunlock(dqp);
mutex_unlock(&qi->qi_tree_lock);
trace_xfs_dqget_freeing(dqp);
@@ -1186,7 +1186,7 @@ xfs_qm_dqflush(
/*
* Clear the dirty field and remember the flush lsn for later use.
*/
- dqp->dq_flags &= ~XFS_DQ_DIRTY;
+ dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
&dqp->q_logitem.qli_item.li_lsn);
@@ -1227,7 +1227,7 @@ xfs_qm_dqflush(
return 0;
out_abort:
- dqp->dq_flags &= ~XFS_DQ_DIRTY;
+ dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
xfs_trans_ail_delete(lip, 0);
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
out_unlock:
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 077d0988cff9..7f3f734bced8 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -31,10 +31,10 @@ enum {
* The incore dquot structure
*/
struct xfs_dquot {
- uint dq_flags;
struct list_head q_lru;
struct xfs_mount *q_mount;
xfs_dqtype_t q_type;
+ uint16_t q_flags;
uint q_nrefs;
xfs_daddr_t q_blkno;
int q_bufoffset;
@@ -152,7 +152,7 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
}
#define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
-#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->dq_flags & XFS_DQ_DIRTY)
+#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->q_flags & XFS_DQFLAG_DIRTY)
#define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
#define XFS_QM_ISPDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_PROJ)
#define XFS_QM_ISGDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_GROUP)
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 939ee728d9af..aabb08e85cd7 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -124,10 +124,10 @@ xfs_qm_dqpurge(
int error = -EAGAIN;
xfs_dqlock(dqp);
- if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0)
+ if ((dqp->q_flags & XFS_DQFLAG_FREEING) || dqp->q_nrefs != 0)
goto out_unlock;
- dqp->dq_flags |= XFS_DQ_FREEING;
+ dqp->q_flags |= XFS_DQFLAG_FREEING;
xfs_dqflock(dqp);
@@ -148,7 +148,7 @@ xfs_qm_dqpurge(
error = xfs_bwrite(bp);
xfs_buf_relse(bp);
} else if (error == -EAGAIN) {
- dqp->dq_flags &= ~XFS_DQ_FREEING;
+ dqp->q_flags &= ~XFS_DQFLAG_FREEING;
goto out_unlock;
}
xfs_dqflock(dqp);
@@ -474,7 +474,7 @@ xfs_qm_dquot_isolate(
/*
* Prevent lookups now that we are past the point of no return.
*/
- dqp->dq_flags |= XFS_DQ_FREEING;
+ dqp->q_flags |= XFS_DQFLAG_FREEING;
xfs_dqunlock(dqp);
ASSERT(dqp->q_nrefs == 0);
@@ -1113,7 +1113,7 @@ xfs_qm_quotacheck_dqadjust(
xfs_qm_adjust_dqtimers(mp, dqp);
}
- dqp->dq_flags |= XFS_DQ_DIRTY;
+ dqp->q_flags |= XFS_DQFLAG_DIRTY;
xfs_qm_dqput(dqp);
return 0;
}
@@ -1219,7 +1219,7 @@ xfs_qm_flush_one(
int error = 0;
xfs_dqlock(dqp);
- if (dqp->dq_flags & XFS_DQ_FREEING)
+ if (dqp->q_flags & XFS_DQFLAG_FREEING)
goto out_unlock;
if (!XFS_DQ_IS_DIRTY(dqp))
goto out_unlock;
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index c7cb8a356c88..7f157275e370 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -598,7 +598,7 @@ xfs_qm_scall_setqlim(
*/
xfs_qm_adjust_dqtimers(mp, dqp);
}
- dqp->dq_flags |= XFS_DQ_DIRTY;
+ dqp->q_flags |= XFS_DQFLAG_DIRTY;
xfs_trans_log_dquot(tp, dqp);
error = xfs_trans_commit(tp);
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index f19e66da6646..0b6738070619 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -879,7 +879,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->dev = dqp->q_mount->m_super->s_dev;
__entry->id = be32_to_cpu(dqp->q_core.d_id);
__entry->type = dqp->q_type;
- __entry->flags = dqp->dq_flags;
+ __entry->flags = dqp->q_flags;
__entry->nrefs = dqp->q_nrefs;
__entry->res_bcount = dqp->q_res_bcount;
__entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
@@ -899,7 +899,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->id,
__print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
- __print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
+ __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
__entry->nrefs,
__entry->res_bcount,
__entry->bcount,
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 964f69a444a3..bdbd8e88c772 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -391,7 +391,7 @@ xfs_trans_apply_dquot_deltas(
xfs_qm_adjust_dqtimers(tp->t_mountp, dqp);
}
- dqp->dq_flags |= XFS_DQ_DIRTY;
+ dqp->q_flags |= XFS_DQFLAG_DIRTY;
/*
* add this to the list of items to get logged
*/
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 07/26] xfs: rename dquot incore state flags
2020-07-15 1:51 ` [PATCH 07/26] xfs: rename dquot incore state flags Darrick J. Wong
@ 2020-07-16 6:59 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-16 6:59 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:21:20 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Rename the existing incore dquot "dq_flags" field to "q_flags" to match
> everything else in the structure, then move the two actual dquot state
> flags to the XFS_DQFLAG_ namespace from XFS_DQ_.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/libxfs/xfs_quota_defs.h | 10 +++++-----
> fs/xfs/xfs_dquot.c | 6 +++---
> fs/xfs/xfs_dquot.h | 4 ++--
> fs/xfs/xfs_qm.c | 12 ++++++------
> fs/xfs/xfs_qm_syscalls.c | 2 +-
> fs/xfs/xfs_trace.h | 4 ++--
> fs/xfs/xfs_trans_dquot.c | 2 +-
> 7 files changed, 20 insertions(+), 20 deletions(-)
>
>
> diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
> index aaf85a47ae5f..2109fe621e1f 100644
> --- a/fs/xfs/libxfs/xfs_quota_defs.h
> +++ b/fs/xfs/libxfs/xfs_quota_defs.h
> @@ -37,17 +37,17 @@ typedef uint8_t xfs_dqtype_t;
> #define XFS_DQ_USER 0x0001 /* a user quota */
> #define XFS_DQ_PROJ 0x0002 /* project quota */
> #define XFS_DQ_GROUP 0x0004 /* a group quota */
> -#define XFS_DQ_DIRTY 0x0008 /* dquot is dirty */
> -#define XFS_DQ_FREEING 0x0010 /* dquot is being torn down */
> +#define XFS_DQFLAG_DIRTY 0x0008 /* dquot is dirty */
> +#define XFS_DQFLAG_FREEING 0x0010 /* dquot is being torn down */
>
> #define XFS_DQ_ALLTYPES (XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
>
> -#define XFS_DQ_FLAGS \
> +#define XFS_DQFLAG_STRINGS \
> { XFS_DQ_USER, "USER" }, \
> { XFS_DQ_PROJ, "PROJ" }, \
> { XFS_DQ_GROUP, "GROUP" }, \
> - { XFS_DQ_DIRTY, "DIRTY" }, \
> - { XFS_DQ_FREEING, "FREEING" }
> + { XFS_DQFLAG_DIRTY, "DIRTY" }, \
> + { XFS_DQFLAG_FREEING, "FREEING" }
>
> /*
> * We have the possibility of all three quota types being active at once, and
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 8230faa9f66e..91d81a346801 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -730,7 +730,7 @@ xfs_qm_dqget_cache_lookup(
> }
>
> xfs_dqlock(dqp);
> - if (dqp->dq_flags & XFS_DQ_FREEING) {
> + if (dqp->q_flags & XFS_DQFLAG_FREEING) {
> xfs_dqunlock(dqp);
> mutex_unlock(&qi->qi_tree_lock);
> trace_xfs_dqget_freeing(dqp);
> @@ -1186,7 +1186,7 @@ xfs_qm_dqflush(
> /*
> * Clear the dirty field and remember the flush lsn for later use.
> */
> - dqp->dq_flags &= ~XFS_DQ_DIRTY;
> + dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
>
> xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
> &dqp->q_logitem.qli_item.li_lsn);
> @@ -1227,7 +1227,7 @@ xfs_qm_dqflush(
> return 0;
>
> out_abort:
> - dqp->dq_flags &= ~XFS_DQ_DIRTY;
> + dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
> xfs_trans_ail_delete(lip, 0);
> xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
> out_unlock:
> diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
> index 077d0988cff9..7f3f734bced8 100644
> --- a/fs/xfs/xfs_dquot.h
> +++ b/fs/xfs/xfs_dquot.h
> @@ -31,10 +31,10 @@ enum {
> * The incore dquot structure
> */
> struct xfs_dquot {
> - uint dq_flags;
> struct list_head q_lru;
> struct xfs_mount *q_mount;
> xfs_dqtype_t q_type;
> + uint16_t q_flags;
> uint q_nrefs;
> xfs_daddr_t q_blkno;
> int q_bufoffset;
> @@ -152,7 +152,7 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
> }
>
> #define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
> -#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->dq_flags & XFS_DQ_DIRTY)
> +#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->q_flags & XFS_DQFLAG_DIRTY)
> #define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
> #define XFS_QM_ISPDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_PROJ)
> #define XFS_QM_ISGDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_GROUP)
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index 939ee728d9af..aabb08e85cd7 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -124,10 +124,10 @@ xfs_qm_dqpurge(
> int error = -EAGAIN;
>
> xfs_dqlock(dqp);
> - if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0)
> + if ((dqp->q_flags & XFS_DQFLAG_FREEING) || dqp->q_nrefs != 0)
> goto out_unlock;
>
> - dqp->dq_flags |= XFS_DQ_FREEING;
> + dqp->q_flags |= XFS_DQFLAG_FREEING;
>
> xfs_dqflock(dqp);
>
> @@ -148,7 +148,7 @@ xfs_qm_dqpurge(
> error = xfs_bwrite(bp);
> xfs_buf_relse(bp);
> } else if (error == -EAGAIN) {
> - dqp->dq_flags &= ~XFS_DQ_FREEING;
> + dqp->q_flags &= ~XFS_DQFLAG_FREEING;
> goto out_unlock;
> }
> xfs_dqflock(dqp);
> @@ -474,7 +474,7 @@ xfs_qm_dquot_isolate(
> /*
> * Prevent lookups now that we are past the point of no return.
> */
> - dqp->dq_flags |= XFS_DQ_FREEING;
> + dqp->q_flags |= XFS_DQFLAG_FREEING;
> xfs_dqunlock(dqp);
>
> ASSERT(dqp->q_nrefs == 0);
> @@ -1113,7 +1113,7 @@ xfs_qm_quotacheck_dqadjust(
> xfs_qm_adjust_dqtimers(mp, dqp);
> }
>
> - dqp->dq_flags |= XFS_DQ_DIRTY;
> + dqp->q_flags |= XFS_DQFLAG_DIRTY;
> xfs_qm_dqput(dqp);
> return 0;
> }
> @@ -1219,7 +1219,7 @@ xfs_qm_flush_one(
> int error = 0;
>
> xfs_dqlock(dqp);
> - if (dqp->dq_flags & XFS_DQ_FREEING)
> + if (dqp->q_flags & XFS_DQFLAG_FREEING)
> goto out_unlock;
> if (!XFS_DQ_IS_DIRTY(dqp))
> goto out_unlock;
> diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
> index c7cb8a356c88..7f157275e370 100644
> --- a/fs/xfs/xfs_qm_syscalls.c
> +++ b/fs/xfs/xfs_qm_syscalls.c
> @@ -598,7 +598,7 @@ xfs_qm_scall_setqlim(
> */
> xfs_qm_adjust_dqtimers(mp, dqp);
> }
> - dqp->dq_flags |= XFS_DQ_DIRTY;
> + dqp->q_flags |= XFS_DQFLAG_DIRTY;
> xfs_trans_log_dquot(tp, dqp);
>
> error = xfs_trans_commit(tp);
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index f19e66da6646..0b6738070619 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -879,7 +879,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
> __entry->dev = dqp->q_mount->m_super->s_dev;
> __entry->id = be32_to_cpu(dqp->q_core.d_id);
> __entry->type = dqp->q_type;
> - __entry->flags = dqp->dq_flags;
> + __entry->flags = dqp->q_flags;
> __entry->nrefs = dqp->q_nrefs;
> __entry->res_bcount = dqp->q_res_bcount;
> __entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
> @@ -899,7 +899,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
> MAJOR(__entry->dev), MINOR(__entry->dev),
> __entry->id,
> __print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
> - __print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
> + __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
> __entry->nrefs,
> __entry->res_bcount,
> __entry->bcount,
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index 964f69a444a3..bdbd8e88c772 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -391,7 +391,7 @@ xfs_trans_apply_dquot_deltas(
> xfs_qm_adjust_dqtimers(tp->t_mountp, dqp);
> }
>
> - dqp->dq_flags |= XFS_DQ_DIRTY;
> + dqp->q_flags |= XFS_DQFLAG_DIRTY;
> /*
> * add this to the list of items to get logged
> */
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 08/26] xfs: move the ondisk dquot flags to their own namespace
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (6 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 07/26] xfs: rename dquot incore state flags Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-15 1:51 ` [PATCH 09/26] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
` (17 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
For the ondisk dquot records, rename the d_flags field to d_type, and
then create a separate XFS_DDQTYPE_ namespace for those flags. Since we
now have a verifier that will spot dquots with unknown flags or invalid
quota types, we can drop the corresponding checks from the online
scrubber.
Note that we can also move the incore XFS_DQFLAG_ values lower in the
bitmask now that the separation is complete.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_dquot_buf.c | 12 +++++++-----
fs/xfs/libxfs/xfs_format.h | 13 ++++++++++++-
fs/xfs/libxfs/xfs_quota_defs.h | 18 +++++-------------
fs/xfs/scrub/quota.c | 4 ----
fs/xfs/xfs_buf_item_recover.c | 6 +++---
fs/xfs/xfs_dquot.c | 4 ++--
fs/xfs/xfs_dquot_item_recover.c | 10 +++++-----
fs/xfs/xfs_qm.c | 2 +-
8 files changed, 35 insertions(+), 34 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index 3b20b82a775b..a2ea40677069 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -62,12 +62,14 @@ xfs_dquot_verify(
if (ddq->d_version != XFS_DQUOT_VERSION)
return __this_address;
- ddq_type = ddq->d_flags & XFS_DQ_ALLTYPES;
+ if (ddq->d_type & ~XFS_DDQTYPE_ANY)
+ return __this_address;
+ ddq_type = ddq->d_type & XFS_DDQTYPE_REC_MASK;
if (type != XFS_DQTYPE_NONE && ddq_type != type)
return __this_address;
- if (ddq_type != XFS_DQ_USER &&
- ddq_type != XFS_DQ_PROJ &&
- ddq_type != XFS_DQ_GROUP)
+ if (ddq_type != XFS_DDQTYPE_USER &&
+ ddq_type != XFS_DDQTYPE_PROJ &&
+ ddq_type != XFS_DDQTYPE_GROUP)
return __this_address;
if (id != -1 && id != be32_to_cpu(ddq->d_id))
@@ -126,7 +128,7 @@ xfs_dqblk_repair(
dqb->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
dqb->dd_diskdq.d_version = XFS_DQUOT_VERSION;
- dqb->dd_diskdq.d_flags = type;
+ dqb->dd_diskdq.d_type = type;
dqb->dd_diskdq.d_id = cpu_to_be32(id);
if (xfs_sb_version_hascrc(&mp->m_sb)) {
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index b42a52bfa1e9..79fbabeb476c 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1149,6 +1149,17 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
#define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
#define XFS_DQUOT_VERSION (uint8_t)0x01 /* latest version number */
+#define XFS_DDQTYPE_USER 0x01 /* user dquot record */
+#define XFS_DDQTYPE_PROJ 0x02 /* project dquot record */
+#define XFS_DDQTYPE_GROUP 0x04 /* group dquot record */
+
+/* bitmask to determine if this is a user/group/project dquot */
+#define XFS_DDQTYPE_REC_MASK (XFS_DDQTYPE_USER | \
+ XFS_DDQTYPE_PROJ | \
+ XFS_DDQTYPE_GROUP)
+
+#define XFS_DDQTYPE_ANY (XFS_DDQTYPE_REC_MASK)
+
/*
* This is the main portion of the on-disk representation of quota
* information for a user. This is the q_core of the struct xfs_dquot that
@@ -1158,7 +1169,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
struct xfs_disk_dquot {
__be16 d_magic; /* dquot magic = XFS_DQUOT_MAGIC */
__u8 d_version; /* dquot version */
- __u8 d_flags; /* XFS_DQ_USER/PROJ/GROUP */
+ __u8 d_type; /* XFS_DDQTYPE_* */
__be32 d_id; /* user,project,group id */
__be64 d_blk_hardlimit;/* absolute limit on disk blks */
__be64 d_blk_softlimit;/* preferred limit on disk blks */
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 2109fe621e1f..d4b81645cd3f 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -21,9 +21,9 @@ typedef uint16_t xfs_qwarncnt_t;
typedef uint8_t xfs_dqtype_t;
#define XFS_DQTYPE_NONE (0)
-#define XFS_DQTYPE_USER (XFS_DQ_USER)
-#define XFS_DQTYPE_PROJ (XFS_DQ_PROJ)
-#define XFS_DQTYPE_GROUP (XFS_DQ_GROUP)
+#define XFS_DQTYPE_USER (XFS_DDQTYPE_USER)
+#define XFS_DQTYPE_PROJ (XFS_DDQTYPE_PROJ)
+#define XFS_DQTYPE_GROUP (XFS_DDQTYPE_GROUP)
#define XFS_DQTYPE_STRINGS \
{ XFS_DQTYPE_NONE, "NONE" }, \
@@ -34,18 +34,10 @@ typedef uint8_t xfs_dqtype_t;
/*
* flags for q_flags field in the dquot.
*/
-#define XFS_DQ_USER 0x0001 /* a user quota */
-#define XFS_DQ_PROJ 0x0002 /* project quota */
-#define XFS_DQ_GROUP 0x0004 /* a group quota */
-#define XFS_DQFLAG_DIRTY 0x0008 /* dquot is dirty */
-#define XFS_DQFLAG_FREEING 0x0010 /* dquot is being torn down */
-
-#define XFS_DQ_ALLTYPES (XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
+#define XFS_DQFLAG_DIRTY (1 << 0) /* dquot is dirty */
+#define XFS_DQFLAG_FREEING (1 << 1) /* dquot is being torn down */
#define XFS_DQFLAG_STRINGS \
- { XFS_DQ_USER, "USER" }, \
- { XFS_DQ_PROJ, "PROJ" }, \
- { XFS_DQ_GROUP, "GROUP" }, \
{ XFS_DQFLAG_DIRTY, "DIRTY" }, \
{ XFS_DQFLAG_FREEING, "FREEING" }
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index cece9f69bbfb..023820d45a50 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -109,10 +109,6 @@ xchk_quota_item(
sqi->last_id = id;
- /* Did we get the dquot type we wanted? */
- if (d->d_flags != dqtype)
- xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
-
if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index 682d1ed78894..bc9f58a71fa0 100644
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -547,11 +547,11 @@ xlog_recover_do_dquot_buffer(
type = 0;
if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
- type |= XFS_DQ_USER;
+ type |= XFS_DDQTYPE_USER;
if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
- type |= XFS_DQ_PROJ;
+ type |= XFS_DDQTYPE_PROJ;
if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
- type |= XFS_DQ_GROUP;
+ type |= XFS_DDQTYPE_GROUP;
/*
* This type of quotas was turned off, so ignore this buffer
*/
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 91d81a346801..6fcea0d3989e 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -238,7 +238,7 @@ xfs_qm_init_dquot_blk(
d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
d->dd_diskdq.d_id = cpu_to_be32(curid);
- d->dd_diskdq.d_flags = type;
+ d->dd_diskdq.d_type = type;
if (xfs_sb_version_hascrc(&mp->m_sb)) {
uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
@@ -543,7 +543,7 @@ xfs_dquot_from_disk(
* Ensure that we got the type and ID we were looking for.
* Everything else was checked by the dquot buffer verifier.
*/
- if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->q_type ||
+ if ((ddqp->d_type & XFS_DDQTYPE_REC_MASK) != dqp->q_type ||
ddqp->d_id != dqp->q_core.d_id) {
xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
"Metadata corruption detected at %pS, quota %u",
diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index a39708879874..6709ea324778 100644
--- a/fs/xfs/xfs_dquot_item_recover.c
+++ b/fs/xfs/xfs_dquot_item_recover.c
@@ -39,7 +39,7 @@ xlog_recover_dquot_ra_pass2(
if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
return;
- type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
+ type = recddq->d_type & XFS_DDQTYPE_REC_MASK;
ASSERT(type);
if (log->l_quotaoffs_flag & type)
return;
@@ -91,7 +91,7 @@ xlog_recover_dquot_commit_pass2(
/*
* This type of quotas was turned off, so ignore this record.
*/
- type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
+ type = recddq->d_type & XFS_DDQTYPE_REC_MASK;
ASSERT(type);
if (log->l_quotaoffs_flag & type)
return 0;
@@ -185,11 +185,11 @@ xlog_recover_quotaoff_commit_pass1(
* group/project quotaoff or both.
*/
if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
- log->l_quotaoffs_flag |= XFS_DQ_USER;
+ log->l_quotaoffs_flag |= XFS_DDQTYPE_USER;
if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
- log->l_quotaoffs_flag |= XFS_DQ_PROJ;
+ log->l_quotaoffs_flag |= XFS_DDQTYPE_PROJ;
if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
- log->l_quotaoffs_flag |= XFS_DQ_GROUP;
+ log->l_quotaoffs_flag |= XFS_DDQTYPE_GROUP;
return 0;
}
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index aabb08e85cd7..f6c18cc0c970 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -869,7 +869,7 @@ xfs_qm_reset_dqcounts(
* Reset type in case we are reusing group quota file for
* project quotas or vice versa
*/
- ddq->d_flags = type;
+ ddq->d_type = type;
ddq->d_bcount = 0;
ddq->d_icount = 0;
ddq->d_rtbcount = 0;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 09/26] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (7 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 08/26] xfs: move the ondisk dquot flags to their own namespace Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-20 5:37 ` Chandan Babu R
2020-07-15 1:51 ` [PATCH 10/26] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
` (16 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Move the dquot cluster size #define to xfs_format.h. It is an important
part of the ondisk format because the ondisk dquot record size is not an
even power of two, which means that the buffer size we use is
significant here because the kernel leaves slack space at the end of the
buffer to avoid having to deal with a dquot record crossing a block
boundary.
This is also an excuse to fix one of the longstanding discrepancies
between kernel and userspace libxfs headers.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/libxfs/xfs_format.h | 16 ++++++++++++++++
fs/xfs/xfs_qm.h | 11 -----------
2 files changed, 16 insertions(+), 11 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 79fbabeb476c..76d34b77031a 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1209,6 +1209,22 @@ typedef struct xfs_dqblk {
#define XFS_DQUOT_CRC_OFF offsetof(struct xfs_dqblk, dd_crc)
+/*
+ * This defines the unit of allocation of dquots.
+ *
+ * Currently, it is just one file system block, and a 4K blk contains 30
+ * (136 * 30 = 4080) dquots. It's probably not worth trying to make
+ * this more dynamic.
+ *
+ * However, if this number is changed, we have to make sure that we don't
+ * implicitly assume that we do allocations in chunks of a single filesystem
+ * block in the dquot/xqm code.
+ *
+ * This is part of the ondisk format because the structure size is not a power
+ * of two, which leaves slack at the end of the disk block.
+ */
+#define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1
+
/*
* Remote symlink format and access functions.
*/
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 27789272da95..c5d0716b378e 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -30,17 +30,6 @@ extern struct kmem_zone *xfs_qm_dqtrxzone;
!dqp->q_core.d_rtbcount && \
!dqp->q_core.d_icount)
-/*
- * This defines the unit of allocation of dquots.
- * Currently, it is just one file system block, and a 4K blk contains 30
- * (136 * 30 = 4080) dquots. It's probably not worth trying to make
- * this more dynamic.
- * XXXsup However, if this number is changed, we have to make sure that we don't
- * implicitly assume that we do allocations in chunks of a single filesystem
- * block in the dquot/xqm code.
- */
-#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 */
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 09/26] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format
2020-07-15 1:51 ` [PATCH 09/26] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
@ 2020-07-20 5:37 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-20 5:37 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:21:33 AM IST Darrick xJ. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Move the dquot cluster size #define to xfs_format.h. It is an important
> part of the ondisk format because the ondisk dquot record size is not an
> even power of two, which means that the buffer size we use is
> significant here because the kernel leaves slack space at the end of the
> buffer to avoid having to deal with a dquot record crossing a block
> boundary.
>
> This is also an excuse to fix one of the longstanding discrepancies
> between kernel and userspace libxfs headers.
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/libxfs/xfs_format.h | 16 ++++++++++++++++
> fs/xfs/xfs_qm.h | 11 -----------
> 2 files changed, 16 insertions(+), 11 deletions(-)
>
>
> diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> index 79fbabeb476c..76d34b77031a 100644
> --- a/fs/xfs/libxfs/xfs_format.h
> +++ b/fs/xfs/libxfs/xfs_format.h
> @@ -1209,6 +1209,22 @@ typedef struct xfs_dqblk {
>
> #define XFS_DQUOT_CRC_OFF offsetof(struct xfs_dqblk, dd_crc)
>
> +/*
> + * This defines the unit of allocation of dquots.
> + *
> + * Currently, it is just one file system block, and a 4K blk contains 30
> + * (136 * 30 = 4080) dquots. It's probably not worth trying to make
> + * this more dynamic.
> + *
> + * However, if this number is changed, we have to make sure that we don't
> + * implicitly assume that we do allocations in chunks of a single filesystem
> + * block in the dquot/xqm code.
> + *
> + * This is part of the ondisk format because the structure size is not a power
> + * of two, which leaves slack at the end of the disk block.
> + */
> +#define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1
> +
> /*
> * Remote symlink format and access functions.
> */
> diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
> index 27789272da95..c5d0716b378e 100644
> --- a/fs/xfs/xfs_qm.h
> +++ b/fs/xfs/xfs_qm.h
> @@ -30,17 +30,6 @@ extern struct kmem_zone *xfs_qm_dqtrxzone;
> !dqp->q_core.d_rtbcount && \
> !dqp->q_core.d_icount)
>
> -/*
> - * This defines the unit of allocation of dquots.
> - * Currently, it is just one file system block, and a 4K blk contains 30
> - * (136 * 30 = 4080) dquots. It's probably not worth trying to make
> - * this more dynamic.
> - * XXXsup However, if this number is changed, we have to make sure that we don't
> - * implicitly assume that we do allocations in chunks of a single filesystem
> - * block in the dquot/xqm code.
> - */
> -#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 */
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 10/26] xfs: stop using q_core.d_flags in the quota code
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (8 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 09/26] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-20 5:37 ` Chandan Babu R
2020-07-15 1:51 ` [PATCH 11/26] xfs: stop using q_core.d_id " Darrick J. Wong
` (15 subsequent siblings)
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Use the incore dq_flags to figure out the dquot type. This is the first
step towards removing xfs_disk_dquot from the incore dquot.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_dquot.c | 34 ++++++++++++++++++++++++++++++++--
fs/xfs/xfs_dquot.h | 2 ++
fs/xfs/xfs_dquot_item.c | 6 ++++--
3 files changed, 38 insertions(+), 4 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 6fcea0d3989e..93b5b7277cb8 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -568,6 +568,15 @@ xfs_dquot_from_disk(
return 0;
}
+/* Copy the in-core quota fields into the on-disk buffer. */
+void
+xfs_dquot_to_disk(
+ struct xfs_disk_dquot *ddqp,
+ struct xfs_dquot *dqp)
+{
+ memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
+}
+
/* Allocate and initialize the dquot buffer for this in-core dquot. */
static int
xfs_qm_dqread_alloc(
@@ -1122,6 +1131,19 @@ xfs_dquot_done(
}
}
+/* Check incore dquot for errors before we flush. */
+static xfs_failaddr_t
+xfs_qm_dqflush_check(
+ struct xfs_dquot *dqp)
+{
+ if (dqp->q_type != XFS_DQTYPE_USER &&
+ dqp->q_type != XFS_DQTYPE_GROUP &&
+ dqp->q_type != XFS_DQTYPE_PROJ)
+ return __this_address;
+
+ return NULL;
+}
+
/*
* Write a modified dquot to disk.
* The dquot must be locked and the flush lock too taken by caller.
@@ -1180,8 +1202,16 @@ xfs_qm_dqflush(
goto out_abort;
}
- /* This is the only portion of data that needs to persist */
- memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
+ fa = xfs_qm_dqflush_check(dqp);
+ if (fa) {
+ xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
+ be32_to_cpu(dqp->q_core.d_id), fa);
+ xfs_buf_relse(bp);
+ error = -EFSCORRUPTED;
+ goto out_abort;
+ }
+
+ xfs_dquot_to_disk(ddqp, dqp);
/*
* Clear the dirty field and remember the flush lsn for later use.
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 7f3f734bced8..84399d1d8188 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -151,6 +151,8 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
return false;
}
+void xfs_dquot_to_disk(struct xfs_disk_dquot *ddqp, struct xfs_dquot *dqp);
+
#define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->q_flags & XFS_DQFLAG_DIRTY)
#define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c
index d7e4de7151d7..fc21e48c889c 100644
--- a/fs/xfs/xfs_dquot_item.c
+++ b/fs/xfs/xfs_dquot_item.c
@@ -45,6 +45,7 @@ xfs_qm_dquot_logitem_format(
struct xfs_log_item *lip,
struct xfs_log_vec *lv)
{
+ struct xfs_disk_dquot ddq;
struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip);
struct xfs_log_iovec *vecp = NULL;
struct xfs_dq_logformat *qlf;
@@ -58,8 +59,9 @@ xfs_qm_dquot_logitem_format(
qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset;
xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat));
- xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT,
- &qlip->qli_dquot->q_core,
+ xfs_dquot_to_disk(&ddq, qlip->qli_dquot);
+
+ xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT, &ddq,
sizeof(struct xfs_disk_dquot));
}
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 10/26] xfs: stop using q_core.d_flags in the quota code
2020-07-15 1:51 ` [PATCH 10/26] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
@ 2020-07-20 5:37 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-20 5:37 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:21:40 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Use the incore dq_flags to figure out the dquot type. This is the first
> step towards removing xfs_disk_dquot from the incore dquot.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/xfs_dquot.c | 34 ++++++++++++++++++++++++++++++++--
> fs/xfs/xfs_dquot.h | 2 ++
> fs/xfs/xfs_dquot_item.c | 6 ++++--
> 3 files changed, 38 insertions(+), 4 deletions(-)
>
>
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 6fcea0d3989e..93b5b7277cb8 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -568,6 +568,15 @@ xfs_dquot_from_disk(
> return 0;
> }
>
> +/* Copy the in-core quota fields into the on-disk buffer. */
> +void
> +xfs_dquot_to_disk(
> + struct xfs_disk_dquot *ddqp,
> + struct xfs_dquot *dqp)
> +{
> + memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
> +}
> +
> /* Allocate and initialize the dquot buffer for this in-core dquot. */
> static int
> xfs_qm_dqread_alloc(
> @@ -1122,6 +1131,19 @@ xfs_dquot_done(
> }
> }
>
> +/* Check incore dquot for errors before we flush. */
> +static xfs_failaddr_t
> +xfs_qm_dqflush_check(
> + struct xfs_dquot *dqp)
> +{
> + if (dqp->q_type != XFS_DQTYPE_USER &&
> + dqp->q_type != XFS_DQTYPE_GROUP &&
> + dqp->q_type != XFS_DQTYPE_PROJ)
> + return __this_address;
> +
> + return NULL;
> +}
> +
> /*
> * Write a modified dquot to disk.
> * The dquot must be locked and the flush lock too taken by caller.
> @@ -1180,8 +1202,16 @@ xfs_qm_dqflush(
> goto out_abort;
> }
>
> - /* This is the only portion of data that needs to persist */
> - memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
> + fa = xfs_qm_dqflush_check(dqp);
> + if (fa) {
> + xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
> + be32_to_cpu(dqp->q_core.d_id), fa);
> + xfs_buf_relse(bp);
> + error = -EFSCORRUPTED;
> + goto out_abort;
> + }
> +
> + xfs_dquot_to_disk(ddqp, dqp);
>
> /*
> * Clear the dirty field and remember the flush lsn for later use.
> diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
> index 7f3f734bced8..84399d1d8188 100644
> --- a/fs/xfs/xfs_dquot.h
> +++ b/fs/xfs/xfs_dquot.h
> @@ -151,6 +151,8 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
> return false;
> }
>
> +void xfs_dquot_to_disk(struct xfs_disk_dquot *ddqp, struct xfs_dquot *dqp);
> +
> #define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
> #define XFS_DQ_IS_DIRTY(dqp) ((dqp)->q_flags & XFS_DQFLAG_DIRTY)
> #define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
> diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c
> index d7e4de7151d7..fc21e48c889c 100644
> --- a/fs/xfs/xfs_dquot_item.c
> +++ b/fs/xfs/xfs_dquot_item.c
> @@ -45,6 +45,7 @@ xfs_qm_dquot_logitem_format(
> struct xfs_log_item *lip,
> struct xfs_log_vec *lv)
> {
> + struct xfs_disk_dquot ddq;
> struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip);
> struct xfs_log_iovec *vecp = NULL;
> struct xfs_dq_logformat *qlf;
> @@ -58,8 +59,9 @@ xfs_qm_dquot_logitem_format(
> qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset;
> xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat));
>
> - xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT,
> - &qlip->qli_dquot->q_core,
> + xfs_dquot_to_disk(&ddq, qlip->qli_dquot);
> +
> + xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT, &ddq,
> sizeof(struct xfs_disk_dquot));
> }
>
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 11/26] xfs: stop using q_core.d_id in the quota code
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (9 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 10/26] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-15 1:51 ` [PATCH 12/26] xfs: use a per-resource struct for incore dquot data Darrick J. Wong
` (14 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Christoph Hellwig, Allison Collins, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add a dquot id field to the incore dquot, and use that instead of the
one in qcore. This eliminates a bunch of endian conversions and will
eventually allow us to remove qcore entirely.
We also rearrange the start of xfs_dquot to remove padding holes, saving
8 bytes.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
---
fs/xfs/scrub/quota.c | 19 ++++++++++++-------
fs/xfs/xfs_dquot.c | 26 +++++++++++---------------
fs/xfs/xfs_dquot.h | 3 ++-
fs/xfs/xfs_dquot_item.c | 2 +-
fs/xfs/xfs_qm.c | 22 ++++++++++------------
fs/xfs/xfs_qm_syscalls.c | 4 ++--
fs/xfs/xfs_trace.h | 2 +-
fs/xfs/xfs_trans_dquot.c | 8 +++-----
8 files changed, 42 insertions(+), 44 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 023820d45a50..0d43a9adf5ae 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -93,7 +93,6 @@ xchk_quota_item(
unsigned long long icount;
unsigned long long rcount;
xfs_ino_t fs_icount;
- xfs_dqid_t id = be32_to_cpu(d->d_id);
int error = 0;
if (xchk_should_terminate(sc, &error))
@@ -103,11 +102,11 @@ xchk_quota_item(
* Except for the root dquot, the actual dquot we got must either have
* the same or higher id as we saw before.
*/
- offset = id / qi->qi_dqperchunk;
- if (id && id <= sqi->last_id)
+ offset = dq->q_id / qi->qi_dqperchunk;
+ if (dq->q_id && dq->q_id <= sqi->last_id)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
- sqi->last_id = id;
+ sqi->last_id = dq->q_id;
if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
@@ -172,13 +171,19 @@ xchk_quota_item(
* lower limit than the actual usage. However, we flag it for
* admin review.
*/
- if (id != 0 && bhard != 0 && bcount > bhard)
+ if (dq->q_id == 0)
+ goto out;
+
+ if (bhard != 0 && bcount > bhard)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (id != 0 && ihard != 0 && icount > ihard)
+
+ if (ihard != 0 && icount > ihard)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (id != 0 && rhard != 0 && rcount > rhard)
+
+ if (rhard != 0 && rcount > rhard)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
+out:
if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
return -EFSCORRUPTED;
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 93b5b7277cb8..5a7f8e49ec2b 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -75,7 +75,7 @@ xfs_qm_adjust_dqlimits(
struct xfs_def_quota *defq;
int prealloc = 0;
- ASSERT(d->d_id);
+ ASSERT(dq->q_id);
defq = xfs_get_defquota(q, dq->q_type);
if (defq->bsoftlimit && !d->d_blk_softlimit) {
@@ -121,7 +121,7 @@ xfs_qm_adjust_dqtimers(
struct xfs_disk_dquot *d = &dq->q_core;
struct xfs_def_quota *defq;
- ASSERT(d->d_id);
+ ASSERT(dq->q_id);
defq = xfs_get_defquota(qi, dq->q_type);
#ifdef DEBUG
@@ -373,8 +373,7 @@ xfs_dquot_disk_alloc(
* Make a chunk of dquots out of this buffer and log
* the entire thing.
*/
- xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
- dqp->q_type, bp);
+ xfs_qm_init_dquot_blk(tp, mp, dqp->q_id, dqp->q_type, bp);
xfs_buf_set_ref(bp, XFS_DQUOT_REF);
/*
@@ -486,7 +485,7 @@ xfs_dquot_alloc(
dqp = kmem_zone_zalloc(xfs_qm_dqzone, 0);
dqp->q_type = type;
- dqp->q_core.d_id = cpu_to_be32(id);
+ dqp->q_id = id;
dqp->q_mount = mp;
INIT_LIST_HEAD(&dqp->q_lru);
mutex_init(&dqp->q_qlock);
@@ -544,10 +543,10 @@ xfs_dquot_from_disk(
* Everything else was checked by the dquot buffer verifier.
*/
if ((ddqp->d_type & XFS_DDQTYPE_REC_MASK) != dqp->q_type ||
- ddqp->d_id != dqp->q_core.d_id) {
+ be32_to_cpu(ddqp->d_id) != dqp->q_id) {
xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
"Metadata corruption detected at %pS, quota %u",
- __this_address, be32_to_cpu(dqp->q_core.d_id));
+ __this_address, dqp->q_id);
xfs_alert(bp->b_mount, "Unmount and run xfs_repair");
return -EFSCORRUPTED;
}
@@ -1192,11 +1191,10 @@ xfs_qm_dqflush(
ddqp = &dqb->dd_diskdq;
/* sanity check the in-core structure before we flush */
- fa = xfs_dquot_verify(mp, &dqp->q_core, be32_to_cpu(dqp->q_core.d_id),
- 0);
+ fa = xfs_dquot_verify(mp, &dqp->q_core, dqp->q_id, 0);
if (fa) {
xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
- be32_to_cpu(dqp->q_core.d_id), fa);
+ dqp->q_id, fa);
xfs_buf_relse(bp);
error = -EFSCORRUPTED;
goto out_abort;
@@ -1205,7 +1203,7 @@ xfs_qm_dqflush(
fa = xfs_qm_dqflush_check(dqp);
if (fa) {
xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
- be32_to_cpu(dqp->q_core.d_id), fa);
+ dqp->q_id, fa);
xfs_buf_relse(bp);
error = -EFSCORRUPTED;
goto out_abort;
@@ -1278,8 +1276,7 @@ xfs_dqlock2(
{
if (d1 && d2) {
ASSERT(d1 != d2);
- if (be32_to_cpu(d1->q_core.d_id) >
- be32_to_cpu(d2->q_core.d_id)) {
+ if (d1->q_id > d2->q_id) {
mutex_lock(&d2->q_qlock);
mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
} else {
@@ -1347,9 +1344,8 @@ xfs_qm_dqiterate(
return error;
error = iter_fn(dq, type, priv);
- id = be32_to_cpu(dq->q_core.d_id);
+ id = dq->q_id;
xfs_qm_dqput(dq);
- id++;
} while (error == 0 && id != 0);
return error;
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 84399d1d8188..9da4cb3d752b 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -35,9 +35,10 @@ struct xfs_dquot {
struct xfs_mount *q_mount;
xfs_dqtype_t q_type;
uint16_t q_flags;
+ xfs_dqid_t q_id;
uint q_nrefs;
- xfs_daddr_t q_blkno;
int q_bufoffset;
+ xfs_daddr_t q_blkno;
xfs_fileoff_t q_fileoffset;
struct xfs_disk_dquot q_core;
diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c
index fc21e48c889c..8c1fdf37ee8f 100644
--- a/fs/xfs/xfs_dquot_item.c
+++ b/fs/xfs/xfs_dquot_item.c
@@ -53,7 +53,7 @@ xfs_qm_dquot_logitem_format(
qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QFORMAT);
qlf->qlf_type = XFS_LI_DQUOT;
qlf->qlf_size = 2;
- qlf->qlf_id = be32_to_cpu(qlip->qli_dquot->q_core.d_id);
+ qlf->qlf_id = qlip->qli_dquot->q_id;
qlf->qlf_blkno = qlip->qli_dquot->q_blkno;
qlf->qlf_len = 1;
qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset;
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index f6c18cc0c970..f63922277120 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -79,7 +79,7 @@ xfs_qm_dquot_walk(
for (i = 0; i < nr_found; i++) {
struct xfs_dquot *dqp = batch[i];
- next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
+ next_index = dqp->q_id + 1;
error = execute(batch[i], data);
if (error == -EAGAIN) {
@@ -161,8 +161,7 @@ xfs_qm_dqpurge(
xfs_dqfunlock(dqp);
xfs_dqunlock(dqp);
- radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
- be32_to_cpu(dqp->q_core.d_id));
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type), dqp->q_id);
qi->qi_dquots--;
/*
@@ -1108,7 +1107,7 @@ xfs_qm_quotacheck_dqadjust(
*
* There are no timers for the default values set in the root dquot.
*/
- if (dqp->q_core.d_id) {
+ if (dqp->q_id) {
xfs_qm_adjust_dqlimits(mp, dqp);
xfs_qm_adjust_dqtimers(mp, dqp);
}
@@ -1594,8 +1593,7 @@ xfs_qm_dqfree_one(
struct xfs_quotainfo *qi = mp->m_quotainfo;
mutex_lock(&qi->qi_tree_lock);
- radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
- be32_to_cpu(dqp->q_core.d_id));
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type), dqp->q_id);
qi->qi_dquots--;
mutex_unlock(&qi->qi_tree_lock);
@@ -1819,7 +1817,7 @@ xfs_qm_vop_chown_reserve(
XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
if (XFS_IS_UQUOTA_ON(mp) && udqp &&
- i_uid_read(VFS_I(ip)) != be32_to_cpu(udqp->q_core.d_id)) {
+ i_uid_read(VFS_I(ip)) != udqp->q_id) {
udq_delblks = udqp;
/*
* If there are delayed allocation blocks, then we have to
@@ -1832,7 +1830,7 @@ xfs_qm_vop_chown_reserve(
}
}
if (XFS_IS_GQUOTA_ON(ip->i_mount) && gdqp &&
- i_gid_read(VFS_I(ip)) != be32_to_cpu(gdqp->q_core.d_id)) {
+ i_gid_read(VFS_I(ip)) != gdqp->q_id) {
gdq_delblks = gdqp;
if (delblks) {
ASSERT(ip->i_gdquot);
@@ -1841,7 +1839,7 @@ xfs_qm_vop_chown_reserve(
}
if (XFS_IS_PQUOTA_ON(ip->i_mount) && pdqp &&
- ip->i_d.di_projid != be32_to_cpu(pdqp->q_core.d_id)) {
+ ip->i_d.di_projid != pdqp->q_id) {
pdq_delblks = pdqp;
if (delblks) {
ASSERT(ip->i_pdquot);
@@ -1925,21 +1923,21 @@ xfs_qm_vop_create_dqattach(
if (udqp && XFS_IS_UQUOTA_ON(mp)) {
ASSERT(ip->i_udquot == NULL);
- ASSERT(i_uid_read(VFS_I(ip)) == be32_to_cpu(udqp->q_core.d_id));
+ ASSERT(i_uid_read(VFS_I(ip)) == udqp->q_id);
ip->i_udquot = xfs_qm_dqhold(udqp);
xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
}
if (gdqp && XFS_IS_GQUOTA_ON(mp)) {
ASSERT(ip->i_gdquot == NULL);
- ASSERT(i_gid_read(VFS_I(ip)) == be32_to_cpu(gdqp->q_core.d_id));
+ ASSERT(i_gid_read(VFS_I(ip)) == gdqp->q_id);
ip->i_gdquot = xfs_qm_dqhold(gdqp);
xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
}
if (pdqp && XFS_IS_PQUOTA_ON(mp)) {
ASSERT(ip->i_pdquot == NULL);
- ASSERT(ip->i_d.di_projid == be32_to_cpu(pdqp->q_core.d_id));
+ ASSERT(ip->i_d.di_projid == pdqp->q_id);
ip->i_pdquot = xfs_qm_dqhold(pdqp);
xfs_trans_mod_dquot(tp, pdqp, XFS_TRANS_DQ_ICOUNT, 1);
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 7f157275e370..15158e5e07e6 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -656,7 +656,7 @@ xfs_qm_scall_getquota_fill_qc(
if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_USER) ||
(XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_GROUP) ||
(XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_PROJ)) &&
- dqp->q_core.d_id != 0) {
+ dqp->q_id != 0) {
if ((dst->d_space > dst->d_spc_softlimit) &&
(dst->d_spc_softlimit > 0)) {
ASSERT(dst->d_spc_timer != 0);
@@ -723,7 +723,7 @@ xfs_qm_scall_getquota_next(
return error;
/* Fill in the ID we actually read from disk */
- *id = be32_to_cpu(dqp->q_core.d_id);
+ *id = dqp->q_id;
xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst);
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 0b6738070619..8a73d30c4a87 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -877,7 +877,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
), \
TP_fast_assign(
__entry->dev = dqp->q_mount->m_super->s_dev;
- __entry->id = be32_to_cpu(dqp->q_core.d_id);
+ __entry->id = dqp->q_id;
__entry->type = dqp->q_type;
__entry->flags = dqp->q_flags;
__entry->nrefs = dqp->q_nrefs;
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index bdbd8e88c772..302aee9ccf80 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -386,7 +386,7 @@ xfs_trans_apply_dquot_deltas(
* Get any default limits in use.
* Start/reset the timer(s) if needed.
*/
- if (d->d_id) {
+ if (dqp->q_id) {
xfs_qm_adjust_dqlimits(tp->t_mountp, dqp);
xfs_qm_adjust_dqtimers(tp->t_mountp, dqp);
}
@@ -565,8 +565,7 @@ xfs_quota_warn(
return;
}
- quota_send_warning(make_kqid(&init_user_ns, qtype,
- be32_to_cpu(dqp->q_core.d_id)),
+ quota_send_warning(make_kqid(&init_user_ns, qtype, dqp->q_id),
mp->m_super->s_dev, type);
}
@@ -625,8 +624,7 @@ xfs_trans_dqresv(
resbcountp = &dqp->q_res_rtbcount;
}
- if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
- dqp->q_core.d_id &&
+ if ((flags & XFS_QMOPT_FORCE_RES) == 0 && dqp->q_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)))) {
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 12/26] xfs: use a per-resource struct for incore dquot data
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (10 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 11/26] xfs: stop using q_core.d_id " Darrick J. Wong
@ 2020-07-15 1:51 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 13/26] xfs: stop using q_core limits in the quota code Darrick J. Wong
` (13 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:51 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Christoph Hellwig, Allison Collins, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Introduce a new struct xfs_dquot_res that we'll use to track all the
incore data for a particular resource type (block, inode, rt block).
This will help us (once we've eliminated q_core) to declutter quota
functions that currently open-code field access or pass around fields
around explicitly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
---
fs/xfs/xfs_dquot.c | 6 +++---
fs/xfs/xfs_dquot.h | 18 +++++++++++-------
fs/xfs/xfs_iomap.c | 6 +++---
fs/xfs/xfs_qm.c | 6 +++---
fs/xfs/xfs_qm_bhv.c | 8 ++++----
fs/xfs/xfs_qm_syscalls.c | 6 +++---
fs/xfs/xfs_trace.h | 2 +-
fs/xfs/xfs_trans_dquot.c | 44 ++++++++++++++++++++++----------------------
8 files changed, 50 insertions(+), 46 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 5a7f8e49ec2b..5a13750a705f 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -558,9 +558,9 @@ xfs_dquot_from_disk(
* Reservation counters are defined as reservation plus current usage
* to avoid having to add every time.
*/
- dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
- dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
- dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
+ dqp->q_blk.reserved = be64_to_cpu(ddqp->d_bcount);
+ dqp->q_ino.reserved = be64_to_cpu(ddqp->d_icount);
+ dqp->q_rtb.reserved = be64_to_cpu(ddqp->d_rtbcount);
/* initialize the dquot speculative prealloc thresholds */
xfs_dquot_set_prealloc_limits(dqp);
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 9da4cb3d752b..95a1a31a6597 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -27,6 +27,11 @@ enum {
XFS_QLOWSP_MAX
};
+struct xfs_dquot_res {
+ /* Total resources allocated and reserved. */
+ xfs_qcnt_t reserved;
+};
+
/*
* The incore dquot structure
*/
@@ -41,14 +46,13 @@ struct xfs_dquot {
xfs_daddr_t q_blkno;
xfs_fileoff_t q_fileoffset;
+ struct xfs_dquot_res q_blk; /* regular blocks */
+ struct xfs_dquot_res q_ino; /* inodes */
+ struct xfs_dquot_res q_rtb; /* realtime blocks */
+
struct xfs_disk_dquot q_core;
struct xfs_dq_logitem q_logitem;
- /* total regular nblks used+reserved */
- xfs_qcnt_t q_res_bcount;
- /* total inos allocd+reserved */
- xfs_qcnt_t q_res_icount;
- /* total realtime blks used+reserved */
- xfs_qcnt_t q_res_rtbcount;
+
xfs_qcnt_t q_prealloc_lo_wmark;
xfs_qcnt_t q_prealloc_hi_wmark;
int64_t q_low_space[XFS_QLOWSP_MAX];
@@ -145,7 +149,7 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
{
int64_t freesp;
- freesp = be64_to_cpu(dqp->q_core.d_blk_hardlimit) - dqp->q_res_bcount;
+ freesp = be64_to_cpu(dqp->q_core.d_blk_hardlimit) - dqp->q_blk.reserved;
if (freesp < dqp->q_low_space[XFS_QLOWSP_1_PCNT])
return true;
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index ac2cc2680d2a..0e3f62cde375 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -307,7 +307,7 @@ xfs_quota_need_throttle(
return false;
/* under the lo watermark, no throttle */
- if (dq->q_res_bcount + alloc_blocks < dq->q_prealloc_lo_wmark)
+ if (dq->q_blk.reserved + alloc_blocks < dq->q_prealloc_lo_wmark)
return false;
return true;
@@ -326,13 +326,13 @@ xfs_quota_calc_throttle(
int shift = 0;
/* no dq, or over hi wmark, squash the prealloc completely */
- if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
+ if (!dq || dq->q_blk.reserved >= dq->q_prealloc_hi_wmark) {
*qblocks = 0;
*qfreesp = 0;
return;
}
- freesp = dq->q_prealloc_hi_wmark - dq->q_res_bcount;
+ freesp = dq->q_prealloc_hi_wmark - dq->q_blk.reserved;
if (freesp < dq->q_low_space[XFS_QLOWSP_5_PCNT]) {
shift = 2;
if (freesp < dq->q_low_space[XFS_QLOWSP_3_PCNT])
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index f63922277120..d10eb4828135 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1092,14 +1092,14 @@ xfs_qm_quotacheck_dqadjust(
* resource usage.
*/
be64_add_cpu(&dqp->q_core.d_icount, 1);
- dqp->q_res_icount++;
+ dqp->q_ino.reserved++;
if (nblks) {
be64_add_cpu(&dqp->q_core.d_bcount, nblks);
- dqp->q_res_bcount += nblks;
+ dqp->q_blk.reserved += nblks;
}
if (rtblks) {
be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
- dqp->q_res_rtbcount += rtblks;
+ dqp->q_rtb.reserved += rtblks;
}
/*
diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index 72c2c2595132..ca1e502e7075 100644
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -29,8 +29,8 @@ xfs_fill_statvfs_from_dquot(
if (limit && statp->f_blocks > limit) {
statp->f_blocks = limit;
statp->f_bfree = statp->f_bavail =
- (statp->f_blocks > dqp->q_res_bcount) ?
- (statp->f_blocks - dqp->q_res_bcount) : 0;
+ (statp->f_blocks > dqp->q_blk.reserved) ?
+ (statp->f_blocks - dqp->q_blk.reserved) : 0;
}
limit = dqp->q_core.d_ino_softlimit ?
@@ -39,8 +39,8 @@ xfs_fill_statvfs_from_dquot(
if (limit && statp->f_files > limit) {
statp->f_files = limit;
statp->f_ffree =
- (statp->f_files > dqp->q_res_icount) ?
- (statp->f_files - dqp->q_res_icount) : 0;
+ (statp->f_files > dqp->q_ino.reserved) ?
+ (statp->f_files - dqp->q_ino.reserved) : 0;
}
}
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 15158e5e07e6..ae22536fa111 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -625,8 +625,8 @@ xfs_qm_scall_getquota_fill_qc(
XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_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_space = XFS_FSB_TO_B(mp, dqp->q_res_bcount);
- dst->d_ino_count = dqp->q_res_icount;
+ 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_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns);
@@ -635,7 +635,7 @@ xfs_qm_scall_getquota_fill_qc(
XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_hardlimit));
dst->d_rt_spc_softlimit =
XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_softlimit));
- dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_res_rtbcount);
+ 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_warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 8a73d30c4a87..92258e6486c9 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -881,7 +881,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->type = dqp->q_type;
__entry->flags = dqp->q_flags;
__entry->nrefs = dqp->q_nrefs;
- __entry->res_bcount = dqp->q_res_bcount;
+ __entry->res_bcount = dqp->q_blk.reserved;
__entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
__entry->icount = be64_to_cpu(dqp->q_core.d_icount);
__entry->blk_hardlimit =
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 302aee9ccf80..d1448d8d4642 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -409,11 +409,11 @@ xfs_trans_apply_dquot_deltas(
if (qtrx->qt_blk_res != blk_res_used) {
if (qtrx->qt_blk_res > blk_res_used)
- dqp->q_res_bcount -= (xfs_qcnt_t)
+ dqp->q_blk.reserved -= (xfs_qcnt_t)
(qtrx->qt_blk_res -
blk_res_used);
else
- dqp->q_res_bcount -= (xfs_qcnt_t)
+ dqp->q_blk.reserved -= (xfs_qcnt_t)
(blk_res_used -
qtrx->qt_blk_res);
}
@@ -426,7 +426,7 @@ xfs_trans_apply_dquot_deltas(
* deliberately skip quota reservations.
*/
if (qtrx->qt_bcount_delta) {
- dqp->q_res_bcount +=
+ dqp->q_blk.reserved +=
(xfs_qcnt_t)qtrx->qt_bcount_delta;
}
}
@@ -437,17 +437,17 @@ xfs_trans_apply_dquot_deltas(
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)
+ dqp->q_rtb.reserved -= (xfs_qcnt_t)
(qtrx->qt_rtblk_res -
qtrx->qt_rtblk_res_used);
else
- dqp->q_res_rtbcount -= (xfs_qcnt_t)
+ dqp->q_rtb.reserved -= (xfs_qcnt_t)
(qtrx->qt_rtblk_res_used -
qtrx->qt_rtblk_res);
}
} else {
if (qtrx->qt_rtbcount_delta)
- dqp->q_res_rtbcount +=
+ dqp->q_rtb.reserved +=
(xfs_qcnt_t)qtrx->qt_rtbcount_delta;
}
@@ -458,20 +458,20 @@ xfs_trans_apply_dquot_deltas(
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)
+ dqp->q_ino.reserved -= (xfs_qcnt_t)
(qtrx->qt_ino_res -
qtrx->qt_ino_res_used);
} else {
if (qtrx->qt_icount_delta)
- dqp->q_res_icount +=
+ dqp->q_ino.reserved +=
(xfs_qcnt_t)qtrx->qt_icount_delta;
}
- ASSERT(dqp->q_res_bcount >=
+ ASSERT(dqp->q_blk.reserved >=
be64_to_cpu(dqp->q_core.d_bcount));
- ASSERT(dqp->q_res_icount >=
+ ASSERT(dqp->q_ino.reserved >=
be64_to_cpu(dqp->q_core.d_icount));
- ASSERT(dqp->q_res_rtbcount >=
+ ASSERT(dqp->q_rtb.reserved >=
be64_to_cpu(dqp->q_core.d_rtbcount));
}
}
@@ -516,7 +516,7 @@ xfs_trans_unreserve_and_mod_dquots(
if (qtrx->qt_blk_res) {
xfs_dqlock(dqp);
locked = true;
- dqp->q_res_bcount -=
+ dqp->q_blk.reserved -=
(xfs_qcnt_t)qtrx->qt_blk_res;
}
if (qtrx->qt_ino_res) {
@@ -524,7 +524,7 @@ xfs_trans_unreserve_and_mod_dquots(
xfs_dqlock(dqp);
locked = true;
}
- dqp->q_res_icount -=
+ dqp->q_ino.reserved -=
(xfs_qcnt_t)qtrx->qt_ino_res;
}
@@ -533,7 +533,7 @@ xfs_trans_unreserve_and_mod_dquots(
xfs_dqlock(dqp);
locked = true;
}
- dqp->q_res_rtbcount -=
+ dqp->q_rtb.reserved -=
(xfs_qcnt_t)qtrx->qt_rtblk_res;
}
if (locked)
@@ -609,7 +609,7 @@ xfs_trans_dqresv(
timer = be32_to_cpu(dqp->q_core.d_btimer);
warns = be16_to_cpu(dqp->q_core.d_bwarns);
warnlimit = defq->bwarnlimit;
- resbcountp = &dqp->q_res_bcount;
+ resbcountp = &dqp->q_blk.reserved;
} else {
ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
@@ -621,7 +621,7 @@ xfs_trans_dqresv(
timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
warnlimit = defq->rtbwarnlimit;
- resbcountp = &dqp->q_res_rtbcount;
+ resbcountp = &dqp->q_rtb.reserved;
}
if ((flags & XFS_QMOPT_FORCE_RES) == 0 && dqp->q_id &&
@@ -652,7 +652,7 @@ xfs_trans_dqresv(
}
}
if (ninos > 0) {
- total_count = dqp->q_res_icount + ninos;
+ total_count = dqp->q_ino.reserved + ninos;
timer = be32_to_cpu(dqp->q_core.d_itimer);
warns = be16_to_cpu(dqp->q_core.d_iwarns);
warnlimit = defq->iwarnlimit;
@@ -682,11 +682,11 @@ xfs_trans_dqresv(
/*
* Change the reservation, but not the actual usage.
- * Note that q_res_bcount = q_core.d_bcount + resv
+ * Note that q_blk.reserved = q_core.d_bcount + resv
*/
(*resbcountp) += (xfs_qcnt_t)nblks;
if (ninos != 0)
- dqp->q_res_icount += (xfs_qcnt_t)ninos;
+ dqp->q_ino.reserved += (xfs_qcnt_t)ninos;
/*
* note the reservation amt in the trans struct too,
@@ -707,9 +707,9 @@ xfs_trans_dqresv(
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));
+ ASSERT(dqp->q_blk.reserved >= be64_to_cpu(dqp->q_core.d_bcount));
+ ASSERT(dqp->q_rtb.reserved >= be64_to_cpu(dqp->q_core.d_rtbcount));
+ ASSERT(dqp->q_ino.reserved >= be64_to_cpu(dqp->q_core.d_icount));
xfs_dqunlock(dqp);
return 0;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 13/26] xfs: stop using q_core limits in the quota code
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (11 preceding siblings ...)
2020-07-15 1:51 ` [PATCH 12/26] xfs: use a per-resource struct for incore dquot data Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 14/26] xfs: stop using q_core counters " Darrick J. Wong
` (12 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Christoph Hellwig, Allison Collins, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add limits fields in 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@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
---
fs/xfs/scrub/quota.c | 36 ++++--------
fs/xfs/xfs_dquot.c | 136 ++++++++++++++++++++++++++--------------------
fs/xfs/xfs_dquot.h | 6 ++
fs/xfs/xfs_qm.c | 18 ++----
fs/xfs/xfs_qm.h | 12 ++--
fs/xfs/xfs_qm_bhv.c | 12 ++--
fs/xfs/xfs_qm_syscalls.c | 40 ++++++--------
fs/xfs/xfs_trace.h | 12 +---
fs/xfs/xfs_trans_dquot.c | 12 ++--
9 files changed, 140 insertions(+), 144 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 0d43a9adf5ae..ca20c260e760 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -83,12 +83,6 @@ xchk_quota_item(
struct xfs_disk_dquot *d = &dq->q_core;
struct xfs_quotainfo *qi = mp->m_quotainfo;
xfs_fileoff_t offset;
- unsigned long long bsoft;
- unsigned long long isoft;
- unsigned long long rsoft;
- unsigned long long bhard;
- unsigned long long ihard;
- unsigned long long rhard;
unsigned long long bcount;
unsigned long long icount;
unsigned long long rcount;
@@ -111,15 +105,6 @@ xchk_quota_item(
if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
- /* Check the limits. */
- bhard = be64_to_cpu(d->d_blk_hardlimit);
- ihard = be64_to_cpu(d->d_ino_hardlimit);
- rhard = be64_to_cpu(d->d_rtb_hardlimit);
-
- bsoft = be64_to_cpu(d->d_blk_softlimit);
- isoft = be64_to_cpu(d->d_ino_softlimit);
- rsoft = be64_to_cpu(d->d_rtb_softlimit);
-
/*
* Warn if the hard limits are larger than the fs.
* Administrators can do this, though in production this seems
@@ -128,19 +113,19 @@ xchk_quota_item(
* Complain about corruption if the soft limit is greater than
* the hard limit.
*/
- if (bhard > mp->m_sb.sb_dblocks)
+ if (dq->q_blk.hardlimit > mp->m_sb.sb_dblocks)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (bsoft > bhard)
+ if (dq->q_blk.softlimit > dq->q_blk.hardlimit)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
- if (ihard > M_IGEO(mp)->maxicount)
+ if (dq->q_ino.hardlimit > M_IGEO(mp)->maxicount)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (isoft > ihard)
+ if (dq->q_ino.softlimit > dq->q_ino.hardlimit)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
- if (rhard > mp->m_sb.sb_rblocks)
+ if (dq->q_rtb.hardlimit > mp->m_sb.sb_rblocks)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (rsoft > rhard)
+ if (dq->q_rtb.softlimit > dq->q_rtb.hardlimit)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
/* Check the resource counts. */
@@ -174,13 +159,16 @@ xchk_quota_item(
if (dq->q_id == 0)
goto out;
- if (bhard != 0 && bcount > bhard)
+ if (dq->q_blk.hardlimit != 0 &&
+ bcount > dq->q_blk.hardlimit)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (ihard != 0 && icount > ihard)
+ if (dq->q_ino.hardlimit != 0 &&
+ icount > dq->q_ino.hardlimit)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
- if (rhard != 0 && rcount > rhard)
+ if (dq->q_rtb.hardlimit != 0 &&
+ rcount > dq->q_rtb.hardlimit)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
out:
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 5a13750a705f..6663d108c740 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -71,29 +71,28 @@ xfs_qm_adjust_dqlimits(
struct xfs_dquot *dq)
{
struct xfs_quotainfo *q = mp->m_quotainfo;
- struct xfs_disk_dquot *d = &dq->q_core;
struct xfs_def_quota *defq;
int prealloc = 0;
ASSERT(dq->q_id);
defq = xfs_get_defquota(q, dq->q_type);
- if (defq->bsoftlimit && !d->d_blk_softlimit) {
- d->d_blk_softlimit = cpu_to_be64(defq->bsoftlimit);
+ if (defq->bsoftlimit && !dq->q_blk.softlimit) {
+ dq->q_blk.softlimit = defq->bsoftlimit;
prealloc = 1;
}
- if (defq->bhardlimit && !d->d_blk_hardlimit) {
- d->d_blk_hardlimit = cpu_to_be64(defq->bhardlimit);
+ if (defq->bhardlimit && !dq->q_blk.hardlimit) {
+ dq->q_blk.hardlimit = defq->bhardlimit;
prealloc = 1;
}
- if (defq->isoftlimit && !d->d_ino_softlimit)
- d->d_ino_softlimit = cpu_to_be64(defq->isoftlimit);
- if (defq->ihardlimit && !d->d_ino_hardlimit)
- d->d_ino_hardlimit = cpu_to_be64(defq->ihardlimit);
- if (defq->rtbsoftlimit && !d->d_rtb_softlimit)
- d->d_rtb_softlimit = cpu_to_be64(defq->rtbsoftlimit);
- if (defq->rtbhardlimit && !d->d_rtb_hardlimit)
- d->d_rtb_hardlimit = cpu_to_be64(defq->rtbhardlimit);
+ if (defq->isoftlimit && !dq->q_ino.softlimit)
+ dq->q_ino.softlimit = defq->isoftlimit;
+ if (defq->ihardlimit && !dq->q_ino.hardlimit)
+ dq->q_ino.hardlimit = defq->ihardlimit;
+ if (defq->rtbsoftlimit && !dq->q_rtb.softlimit)
+ dq->q_rtb.softlimit = defq->rtbsoftlimit;
+ if (defq->rtbhardlimit && !dq->q_rtb.hardlimit)
+ dq->q_rtb.hardlimit = defq->rtbhardlimit;
if (prealloc)
xfs_dquot_set_prealloc_limits(dq);
@@ -125,82 +124,67 @@ xfs_qm_adjust_dqtimers(
defq = xfs_get_defquota(qi, dq->q_type);
#ifdef DEBUG
- if (d->d_blk_hardlimit)
- ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
- be64_to_cpu(d->d_blk_hardlimit));
- if (d->d_ino_hardlimit)
- ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
- be64_to_cpu(d->d_ino_hardlimit));
- if (d->d_rtb_hardlimit)
- ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
- be64_to_cpu(d->d_rtb_hardlimit));
+ if (dq->q_blk.hardlimit)
+ ASSERT(dq->q_blk.softlimit <= dq->q_blk.hardlimit);
+ if (dq->q_ino.hardlimit)
+ ASSERT(dq->q_ino.softlimit <= dq->q_ino.hardlimit);
+ if (dq->q_rtb.hardlimit)
+ ASSERT(dq->q_rtb.softlimit <= dq->q_rtb.hardlimit);
#endif
if (!d->d_btimer) {
- if ((d->d_blk_softlimit &&
- (be64_to_cpu(d->d_bcount) >
- be64_to_cpu(d->d_blk_softlimit))) ||
- (d->d_blk_hardlimit &&
- (be64_to_cpu(d->d_bcount) >
- be64_to_cpu(d->d_blk_hardlimit)))) {
+ if ((dq->q_blk.softlimit &&
+ (be64_to_cpu(d->d_bcount) > dq->q_blk.softlimit)) ||
+ (dq->q_blk.hardlimit &&
+ (be64_to_cpu(d->d_bcount) > dq->q_blk.hardlimit))) {
d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +
defq->btimelimit);
} else {
d->d_bwarns = 0;
}
} else {
- if ((!d->d_blk_softlimit ||
- (be64_to_cpu(d->d_bcount) <=
- be64_to_cpu(d->d_blk_softlimit))) &&
- (!d->d_blk_hardlimit ||
- (be64_to_cpu(d->d_bcount) <=
- be64_to_cpu(d->d_blk_hardlimit)))) {
+ if ((!dq->q_blk.softlimit ||
+ (be64_to_cpu(d->d_bcount) <= dq->q_blk.softlimit)) &&
+ (!dq->q_blk.hardlimit ||
+ (be64_to_cpu(d->d_bcount) <= dq->q_blk.hardlimit))) {
d->d_btimer = 0;
}
}
if (!d->d_itimer) {
- if ((d->d_ino_softlimit &&
- (be64_to_cpu(d->d_icount) >
- be64_to_cpu(d->d_ino_softlimit))) ||
- (d->d_ino_hardlimit &&
- (be64_to_cpu(d->d_icount) >
- be64_to_cpu(d->d_ino_hardlimit)))) {
+ if ((dq->q_ino.softlimit &&
+ (be64_to_cpu(d->d_icount) > dq->q_ino.softlimit)) ||
+ (dq->q_ino.hardlimit &&
+ (be64_to_cpu(d->d_icount) > dq->q_ino.hardlimit))) {
d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +
defq->itimelimit);
} else {
d->d_iwarns = 0;
}
} else {
- if ((!d->d_ino_softlimit ||
- (be64_to_cpu(d->d_icount) <=
- be64_to_cpu(d->d_ino_softlimit))) &&
- (!d->d_ino_hardlimit ||
- (be64_to_cpu(d->d_icount) <=
- be64_to_cpu(d->d_ino_hardlimit)))) {
+ if ((!dq->q_ino.softlimit ||
+ (be64_to_cpu(d->d_icount) <= dq->q_ino.softlimit)) &&
+ (!dq->q_ino.hardlimit ||
+ (be64_to_cpu(d->d_icount) <= dq->q_ino.hardlimit))) {
d->d_itimer = 0;
}
}
if (!d->d_rtbtimer) {
- if ((d->d_rtb_softlimit &&
- (be64_to_cpu(d->d_rtbcount) >
- be64_to_cpu(d->d_rtb_softlimit))) ||
- (d->d_rtb_hardlimit &&
- (be64_to_cpu(d->d_rtbcount) >
- be64_to_cpu(d->d_rtb_hardlimit)))) {
+ if ((dq->q_rtb.softlimit &&
+ (be64_to_cpu(d->d_rtbcount) > dq->q_rtb.softlimit)) ||
+ (dq->q_rtb.hardlimit &&
+ (be64_to_cpu(d->d_rtbcount) > dq->q_rtb.hardlimit))) {
d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +
defq->rtbtimelimit);
} else {
d->d_rtbwarns = 0;
}
} else {
- if ((!d->d_rtb_softlimit ||
- (be64_to_cpu(d->d_rtbcount) <=
- be64_to_cpu(d->d_rtb_softlimit))) &&
- (!d->d_rtb_hardlimit ||
- (be64_to_cpu(d->d_rtbcount) <=
- be64_to_cpu(d->d_rtb_hardlimit)))) {
+ if ((!dq->q_rtb.softlimit ||
+ (be64_to_cpu(d->d_rtbcount) <= dq->q_rtb.softlimit)) &&
+ (!dq->q_rtb.hardlimit ||
+ (be64_to_cpu(d->d_rtbcount) <= dq->q_rtb.hardlimit))) {
d->d_rtbtimer = 0;
}
}
@@ -298,8 +282,8 @@ xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
{
uint64_t space;
- dqp->q_prealloc_hi_wmark = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
- dqp->q_prealloc_lo_wmark = be64_to_cpu(dqp->q_core.d_blk_softlimit);
+ dqp->q_prealloc_hi_wmark = dqp->q_blk.hardlimit;
+ dqp->q_prealloc_lo_wmark = dqp->q_blk.softlimit;
if (!dqp->q_prealloc_lo_wmark) {
dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
do_div(dqp->q_prealloc_lo_wmark, 100);
@@ -553,6 +537,12 @@ xfs_dquot_from_disk(
/* copy everything from disk dquot to the incore dquot */
memcpy(&dqp->q_core, ddqp, sizeof(struct xfs_disk_dquot));
+ dqp->q_blk.hardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
+ dqp->q_blk.softlimit = be64_to_cpu(ddqp->d_blk_softlimit);
+ dqp->q_ino.hardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
+ dqp->q_ino.softlimit = be64_to_cpu(ddqp->d_ino_softlimit);
+ dqp->q_rtb.hardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
+ dqp->q_rtb.softlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
/*
* Reservation counters are defined as reservation plus current usage
@@ -574,6 +564,12 @@ xfs_dquot_to_disk(
struct xfs_dquot *dqp)
{
memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
+ ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit);
+ ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit);
+ ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit);
+ ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit);
+ ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit);
+ ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit);
}
/* Allocate and initialize the dquot buffer for this in-core dquot. */
@@ -1135,11 +1131,31 @@ 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)
return __this_address;
+ if (dqp->q_id == 0)
+ return NULL;
+
+ if (dqp->q_blk.softlimit &&
+ be64_to_cpu(ddq->d_bcount) > dqp->q_blk.softlimit &&
+ !ddq->d_btimer)
+ return __this_address;
+
+ if (dqp->q_ino.softlimit &&
+ be64_to_cpu(ddq->d_icount) > dqp->q_ino.softlimit &&
+ !ddq->d_itimer)
+ return __this_address;
+
+ if (dqp->q_rtb.softlimit &&
+ be64_to_cpu(ddq->d_rtbcount) > dqp->q_rtb.softlimit &&
+ !ddq->d_rtbtimer)
+ return __this_address;
+
return NULL;
}
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 95a1a31a6597..26f325b84023 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -30,6 +30,10 @@ enum {
struct xfs_dquot_res {
/* Total resources allocated and reserved. */
xfs_qcnt_t reserved;
+
+ /* Absolute and preferred limits. */
+ xfs_qcnt_t hardlimit;
+ xfs_qcnt_t softlimit;
};
/*
@@ -149,7 +153,7 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
{
int64_t freesp;
- freesp = be64_to_cpu(dqp->q_core.d_blk_hardlimit) - dqp->q_blk.reserved;
+ freesp = dqp->q_blk.hardlimit - dqp->q_blk.reserved;
if (freesp < dqp->q_low_space[XFS_QLOWSP_1_PCNT])
return true;
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index d10eb4828135..5a38350308c9 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -549,27 +549,23 @@ xfs_qm_set_defquota(
struct xfs_quotainfo *qinf)
{
struct xfs_dquot *dqp;
- struct xfs_def_quota *defq;
- struct xfs_disk_dquot *ddqp;
+ struct xfs_def_quota *defq = xfs_get_defquota(qinf, type);
int error;
error = xfs_qm_dqget_uncached(mp, 0, type, &dqp);
if (error)
return;
- ddqp = &dqp->q_core;
- defq = xfs_get_defquota(qinf, type);
-
/*
* 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);
+ defq->bhardlimit = dqp->q_blk.hardlimit;
+ defq->bsoftlimit = dqp->q_blk.softlimit;
+ defq->ihardlimit = dqp->q_ino.hardlimit;
+ defq->isoftlimit = dqp->q_ino.softlimit;
+ defq->rtbhardlimit = dqp->q_rtb.hardlimit;
+ defq->rtbsoftlimit = dqp->q_rtb.softlimit;
xfs_qm_dqdestroy(dqp);
}
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index c5d0716b378e..48ddde099f6b 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -20,12 +20,12 @@ extern struct kmem_zone *xfs_qm_dqtrxzone;
#define XFS_DQITER_MAP_SIZE 10
#define XFS_IS_DQUOT_UNINITIALIZED(dqp) ( \
- !dqp->q_core.d_blk_hardlimit && \
- !dqp->q_core.d_blk_softlimit && \
- !dqp->q_core.d_rtb_hardlimit && \
- !dqp->q_core.d_rtb_softlimit && \
- !dqp->q_core.d_ino_hardlimit && \
- !dqp->q_core.d_ino_softlimit && \
+ !dqp->q_blk.hardlimit && \
+ !dqp->q_blk.softlimit && \
+ !dqp->q_rtb.hardlimit && \
+ !dqp->q_rtb.softlimit && \
+ !dqp->q_ino.hardlimit && \
+ !dqp->q_ino.softlimit && \
!dqp->q_core.d_bcount && \
!dqp->q_core.d_rtbcount && \
!dqp->q_core.d_icount)
diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index ca1e502e7075..639398091ad6 100644
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -23,9 +23,9 @@ xfs_fill_statvfs_from_dquot(
{
uint64_t limit;
- limit = dqp->q_core.d_blk_softlimit ?
- be64_to_cpu(dqp->q_core.d_blk_softlimit) :
- be64_to_cpu(dqp->q_core.d_blk_hardlimit);
+ limit = dqp->q_blk.softlimit ?
+ dqp->q_blk.softlimit :
+ dqp->q_blk.hardlimit;
if (limit && statp->f_blocks > limit) {
statp->f_blocks = limit;
statp->f_bfree = statp->f_bavail =
@@ -33,9 +33,9 @@ xfs_fill_statvfs_from_dquot(
(statp->f_blocks - dqp->q_blk.reserved) : 0;
}
- limit = dqp->q_core.d_ino_softlimit ?
- be64_to_cpu(dqp->q_core.d_ino_softlimit) :
- be64_to_cpu(dqp->q_core.d_ino_hardlimit);
+ limit = dqp->q_ino.softlimit ?
+ dqp->q_ino.softlimit :
+ dqp->q_ino.hardlimit;
if (limit && statp->f_files > limit) {
statp->f_files = limit;
statp->f_ffree =
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index ae22536fa111..7aebd588bdf7 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -495,13 +495,13 @@ xfs_qm_scall_setqlim(
*/
hard = (newlim->d_fieldmask & QC_SPC_HARD) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_hardlimit) :
- be64_to_cpu(ddq->d_blk_hardlimit);
+ dqp->q_blk.hardlimit;
soft = (newlim->d_fieldmask & QC_SPC_SOFT) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_softlimit) :
- be64_to_cpu(ddq->d_blk_softlimit);
+ dqp->q_blk.softlimit;
if (hard == 0 || hard >= soft) {
- ddq->d_blk_hardlimit = cpu_to_be64(hard);
- ddq->d_blk_softlimit = cpu_to_be64(soft);
+ dqp->q_blk.hardlimit = hard;
+ dqp->q_blk.softlimit = soft;
xfs_dquot_set_prealloc_limits(dqp);
if (id == 0) {
defq->bhardlimit = hard;
@@ -512,13 +512,13 @@ xfs_qm_scall_setqlim(
}
hard = (newlim->d_fieldmask & QC_RT_SPC_HARD) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_hardlimit) :
- be64_to_cpu(ddq->d_rtb_hardlimit);
+ dqp->q_rtb.hardlimit;
soft = (newlim->d_fieldmask & QC_RT_SPC_SOFT) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_softlimit) :
- be64_to_cpu(ddq->d_rtb_softlimit);
+ dqp->q_rtb.softlimit;
if (hard == 0 || hard >= soft) {
- ddq->d_rtb_hardlimit = cpu_to_be64(hard);
- ddq->d_rtb_softlimit = cpu_to_be64(soft);
+ dqp->q_rtb.hardlimit = hard;
+ dqp->q_rtb.softlimit = soft;
if (id == 0) {
defq->rtbhardlimit = hard;
defq->rtbsoftlimit = soft;
@@ -529,13 +529,13 @@ xfs_qm_scall_setqlim(
hard = (newlim->d_fieldmask & QC_INO_HARD) ?
(xfs_qcnt_t) newlim->d_ino_hardlimit :
- be64_to_cpu(ddq->d_ino_hardlimit);
+ dqp->q_ino.hardlimit;
soft = (newlim->d_fieldmask & QC_INO_SOFT) ?
(xfs_qcnt_t) newlim->d_ino_softlimit :
- be64_to_cpu(ddq->d_ino_softlimit);
+ dqp->q_ino.softlimit;
if (hard == 0 || hard >= soft) {
- ddq->d_ino_hardlimit = cpu_to_be64(hard);
- ddq->d_ino_softlimit = cpu_to_be64(soft);
+ dqp->q_ino.hardlimit = hard;
+ dqp->q_ino.softlimit = soft;
if (id == 0) {
defq->ihardlimit = hard;
defq->isoftlimit = soft;
@@ -619,10 +619,8 @@ xfs_qm_scall_getquota_fill_qc(
struct qc_dqblk *dst)
{
memset(dst, 0, sizeof(*dst));
- dst->d_spc_hardlimit =
- XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_hardlimit));
- dst->d_spc_softlimit =
- XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_softlimit));
+ 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_space = XFS_FSB_TO_B(mp, dqp->q_blk.reserved);
@@ -631,10 +629,8 @@ xfs_qm_scall_getquota_fill_qc(
dst->d_ino_timer = be32_to_cpu(dqp->q_core.d_itimer);
dst->d_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns);
dst->d_spc_warns = be16_to_cpu(dqp->q_core.d_bwarns);
- dst->d_rt_spc_hardlimit =
- XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_hardlimit));
- dst->d_rt_spc_softlimit =
- XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_softlimit));
+ 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_warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
@@ -661,8 +657,8 @@ xfs_qm_scall_getquota_fill_qc(
(dst->d_spc_softlimit > 0)) {
ASSERT(dst->d_spc_timer != 0);
}
- if ((dst->d_ino_count > dst->d_ino_softlimit) &&
- (dst->d_ino_softlimit > 0)) {
+ if ((dst->d_ino_count > dqp->q_ino.softlimit) &&
+ (dqp->q_ino.softlimit > 0)) {
ASSERT(dst->d_ino_timer != 0);
}
}
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 92258e6486c9..216e68ee83c2 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -884,14 +884,10 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->res_bcount = dqp->q_blk.reserved;
__entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
__entry->icount = be64_to_cpu(dqp->q_core.d_icount);
- __entry->blk_hardlimit =
- be64_to_cpu(dqp->q_core.d_blk_hardlimit);
- __entry->blk_softlimit =
- be64_to_cpu(dqp->q_core.d_blk_softlimit);
- __entry->ino_hardlimit =
- be64_to_cpu(dqp->q_core.d_ino_hardlimit);
- __entry->ino_softlimit =
- be64_to_cpu(dqp->q_core.d_ino_softlimit);
+ __entry->blk_hardlimit = dqp->q_blk.hardlimit;
+ __entry->blk_softlimit = dqp->q_blk.softlimit;
+ __entry->ino_hardlimit = dqp->q_ino.hardlimit;
+ __entry->ino_softlimit = dqp->q_ino.softlimit;
),
TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u res_bc 0x%llx "
"bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index d1448d8d4642..66e36574c887 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -600,10 +600,10 @@ xfs_trans_dqresv(
defq = xfs_get_defquota(q, dqp->q_type);
if (flags & XFS_TRANS_DQ_RES_BLKS) {
- hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
+ hardlimit = dqp->q_blk.hardlimit;
if (!hardlimit)
hardlimit = defq->bhardlimit;
- softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);
+ softlimit = dqp->q_blk.softlimit;
if (!softlimit)
softlimit = defq->bsoftlimit;
timer = be32_to_cpu(dqp->q_core.d_btimer);
@@ -612,10 +612,10 @@ xfs_trans_dqresv(
resbcountp = &dqp->q_blk.reserved;
} else {
ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
- hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
+ hardlimit = dqp->q_rtb.hardlimit;
if (!hardlimit)
hardlimit = defq->rtbhardlimit;
- softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);
+ softlimit = dqp->q_rtb.softlimit;
if (!softlimit)
softlimit = defq->rtbsoftlimit;
timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
@@ -656,10 +656,10 @@ xfs_trans_dqresv(
timer = be32_to_cpu(dqp->q_core.d_itimer);
warns = be16_to_cpu(dqp->q_core.d_iwarns);
warnlimit = defq->iwarnlimit;
- hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
+ hardlimit = dqp->q_ino.hardlimit;
if (!hardlimit)
hardlimit = defq->ihardlimit;
- softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
+ softlimit = dqp->q_ino.softlimit;
if (!softlimit)
softlimit = defq->isoftlimit;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 14/26] xfs: stop using q_core counters in the quota code
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (12 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 13/26] xfs: stop using q_core limits in the quota code Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 15/26] xfs: stop using q_core warning " Darrick J. Wong
` (11 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Christoph Hellwig, Allison Collins, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add counter 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@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
---
fs/xfs/scrub/quota.c | 18 ++++++------------
fs/xfs/xfs_dquot.c | 47 +++++++++++++++++++++++++---------------------
fs/xfs/xfs_dquot.h | 3 +++
fs/xfs/xfs_qm.c | 6 +++---
fs/xfs/xfs_qm.h | 6 +++---
fs/xfs/xfs_trace.h | 4 ++--
fs/xfs/xfs_trans_dquot.c | 34 +++++++++++++--------------------
7 files changed, 56 insertions(+), 62 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index ca20c260e760..d002af3ab164 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -83,9 +83,6 @@ xchk_quota_item(
struct xfs_disk_dquot *d = &dq->q_core;
struct xfs_quotainfo *qi = mp->m_quotainfo;
xfs_fileoff_t offset;
- unsigned long long bcount;
- unsigned long long icount;
- unsigned long long rcount;
xfs_ino_t fs_icount;
int error = 0;
@@ -129,9 +126,6 @@ xchk_quota_item(
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
/* Check the resource counts. */
- bcount = be64_to_cpu(d->d_bcount);
- icount = be64_to_cpu(d->d_icount);
- rcount = be64_to_cpu(d->d_rtbcount);
fs_icount = percpu_counter_sum(&mp->m_icount);
/*
@@ -140,15 +134,15 @@ xchk_quota_item(
* if there are no quota limits.
*/
if (xfs_sb_version_hasreflink(&mp->m_sb)) {
- if (mp->m_sb.sb_dblocks < bcount)
+ if (mp->m_sb.sb_dblocks < dq->q_blk.count)
xchk_fblock_set_warning(sc, XFS_DATA_FORK,
offset);
} else {
- if (mp->m_sb.sb_dblocks < bcount)
+ if (mp->m_sb.sb_dblocks < dq->q_blk.count)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
offset);
}
- if (icount > fs_icount || rcount > mp->m_sb.sb_rblocks)
+ if (dq->q_ino.count > fs_icount || dq->q_rtb.count > mp->m_sb.sb_rblocks)
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
/*
@@ -160,15 +154,15 @@ xchk_quota_item(
goto out;
if (dq->q_blk.hardlimit != 0 &&
- bcount > dq->q_blk.hardlimit)
+ dq->q_blk.count > dq->q_blk.hardlimit)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
if (dq->q_ino.hardlimit != 0 &&
- icount > dq->q_ino.hardlimit)
+ dq->q_ino.count > dq->q_ino.hardlimit)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
if (dq->q_rtb.hardlimit != 0 &&
- rcount > dq->q_rtb.hardlimit)
+ dq->q_rtb.count > dq->q_rtb.hardlimit)
xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
out:
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 6663d108c740..921307cf2c6f 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -134,9 +134,9 @@ xfs_qm_adjust_dqtimers(
if (!d->d_btimer) {
if ((dq->q_blk.softlimit &&
- (be64_to_cpu(d->d_bcount) > dq->q_blk.softlimit)) ||
+ (dq->q_blk.count > dq->q_blk.softlimit)) ||
(dq->q_blk.hardlimit &&
- (be64_to_cpu(d->d_bcount) > dq->q_blk.hardlimit))) {
+ (dq->q_blk.count > dq->q_blk.hardlimit))) {
d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +
defq->btimelimit);
} else {
@@ -144,18 +144,18 @@ xfs_qm_adjust_dqtimers(
}
} else {
if ((!dq->q_blk.softlimit ||
- (be64_to_cpu(d->d_bcount) <= dq->q_blk.softlimit)) &&
+ (dq->q_blk.count <= dq->q_blk.softlimit)) &&
(!dq->q_blk.hardlimit ||
- (be64_to_cpu(d->d_bcount) <= dq->q_blk.hardlimit))) {
+ (dq->q_blk.count <= dq->q_blk.hardlimit))) {
d->d_btimer = 0;
}
}
if (!d->d_itimer) {
if ((dq->q_ino.softlimit &&
- (be64_to_cpu(d->d_icount) > dq->q_ino.softlimit)) ||
+ (dq->q_ino.count > dq->q_ino.softlimit)) ||
(dq->q_ino.hardlimit &&
- (be64_to_cpu(d->d_icount) > dq->q_ino.hardlimit))) {
+ (dq->q_ino.count > dq->q_ino.hardlimit))) {
d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +
defq->itimelimit);
} else {
@@ -163,18 +163,18 @@ xfs_qm_adjust_dqtimers(
}
} else {
if ((!dq->q_ino.softlimit ||
- (be64_to_cpu(d->d_icount) <= dq->q_ino.softlimit)) &&
+ (dq->q_ino.count <= dq->q_ino.softlimit)) &&
(!dq->q_ino.hardlimit ||
- (be64_to_cpu(d->d_icount) <= dq->q_ino.hardlimit))) {
+ (dq->q_ino.count <= dq->q_ino.hardlimit))) {
d->d_itimer = 0;
}
}
if (!d->d_rtbtimer) {
if ((dq->q_rtb.softlimit &&
- (be64_to_cpu(d->d_rtbcount) > dq->q_rtb.softlimit)) ||
+ (dq->q_rtb.count > dq->q_rtb.softlimit)) ||
(dq->q_rtb.hardlimit &&
- (be64_to_cpu(d->d_rtbcount) > dq->q_rtb.hardlimit))) {
+ (dq->q_rtb.count > dq->q_rtb.hardlimit))) {
d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +
defq->rtbtimelimit);
} else {
@@ -182,9 +182,9 @@ xfs_qm_adjust_dqtimers(
}
} else {
if ((!dq->q_rtb.softlimit ||
- (be64_to_cpu(d->d_rtbcount) <= dq->q_rtb.softlimit)) &&
+ (dq->q_rtb.count <= dq->q_rtb.softlimit)) &&
(!dq->q_rtb.hardlimit ||
- (be64_to_cpu(d->d_rtbcount) <= dq->q_rtb.hardlimit))) {
+ (dq->q_rtb.count <= dq->q_rtb.hardlimit))) {
d->d_rtbtimer = 0;
}
}
@@ -544,13 +544,17 @@ xfs_dquot_from_disk(
dqp->q_rtb.hardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
dqp->q_rtb.softlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
+ dqp->q_blk.count = be64_to_cpu(ddqp->d_bcount);
+ dqp->q_ino.count = be64_to_cpu(ddqp->d_icount);
+ dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount);
+
/*
* Reservation counters are defined as reservation plus current usage
* to avoid having to add every time.
*/
- dqp->q_blk.reserved = be64_to_cpu(ddqp->d_bcount);
- dqp->q_ino.reserved = be64_to_cpu(ddqp->d_icount);
- dqp->q_rtb.reserved = be64_to_cpu(ddqp->d_rtbcount);
+ dqp->q_blk.reserved = dqp->q_blk.count;
+ dqp->q_ino.reserved = dqp->q_ino.count;
+ dqp->q_rtb.reserved = dqp->q_rtb.count;
/* initialize the dquot speculative prealloc thresholds */
xfs_dquot_set_prealloc_limits(dqp);
@@ -570,6 +574,10 @@ xfs_dquot_to_disk(
ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit);
ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit);
ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit);
+
+ ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count);
+ ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);
+ ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);
}
/* Allocate and initialize the dquot buffer for this in-core dquot. */
@@ -1141,18 +1149,15 @@ xfs_qm_dqflush_check(
if (dqp->q_id == 0)
return NULL;
- if (dqp->q_blk.softlimit &&
- be64_to_cpu(ddq->d_bcount) > dqp->q_blk.softlimit &&
+ if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit &&
!ddq->d_btimer)
return __this_address;
- if (dqp->q_ino.softlimit &&
- be64_to_cpu(ddq->d_icount) > dqp->q_ino.softlimit &&
+ if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit &&
!ddq->d_itimer)
return __this_address;
- if (dqp->q_rtb.softlimit &&
- be64_to_cpu(ddq->d_rtbcount) > dqp->q_rtb.softlimit &&
+ if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit &&
!ddq->d_rtbtimer)
return __this_address;
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 26f325b84023..f470731d3cfd 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -31,6 +31,9 @@ struct xfs_dquot_res {
/* Total resources allocated and reserved. */
xfs_qcnt_t reserved;
+ /* Total resources allocated. */
+ xfs_qcnt_t count;
+
/* Absolute and preferred limits. */
xfs_qcnt_t hardlimit;
xfs_qcnt_t softlimit;
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 5a38350308c9..6c5fe57699fa 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1087,14 +1087,14 @@ xfs_qm_quotacheck_dqadjust(
* Adjust the inode count and the block count to reflect this inode's
* resource usage.
*/
- be64_add_cpu(&dqp->q_core.d_icount, 1);
+ dqp->q_ino.count++;
dqp->q_ino.reserved++;
if (nblks) {
- be64_add_cpu(&dqp->q_core.d_bcount, nblks);
+ dqp->q_blk.count += nblks;
dqp->q_blk.reserved += nblks;
}
if (rtblks) {
- be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
+ dqp->q_rtb.count += rtblks;
dqp->q_rtb.reserved += rtblks;
}
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 48ddde099f6b..0e4ceb0dcfbc 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -26,9 +26,9 @@ extern struct kmem_zone *xfs_qm_dqtrxzone;
!dqp->q_rtb.softlimit && \
!dqp->q_ino.hardlimit && \
!dqp->q_ino.softlimit && \
- !dqp->q_core.d_bcount && \
- !dqp->q_core.d_rtbcount && \
- !dqp->q_core.d_icount)
+ !dqp->q_blk.count && \
+ !dqp->q_rtb.count && \
+ !dqp->q_ino.count)
/* Defaults for each quota type: time limits, warn limits, usage limits */
struct xfs_def_quota {
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 216e68ee83c2..b6541f7d1b7d 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -882,8 +882,8 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->flags = dqp->q_flags;
__entry->nrefs = dqp->q_nrefs;
__entry->res_bcount = dqp->q_blk.reserved;
- __entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
- __entry->icount = be64_to_cpu(dqp->q_core.d_icount);
+ __entry->bcount = dqp->q_blk.count;
+ __entry->icount = dqp->q_ino.count;
__entry->blk_hardlimit = dqp->q_blk.hardlimit;
__entry->blk_softlimit = dqp->q_blk.softlimit;
__entry->ino_hardlimit = dqp->q_ino.hardlimit;
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 66e36574c887..96d4691df26e 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -309,7 +309,6 @@ xfs_trans_apply_dquot_deltas(
int i, j;
struct xfs_dquot *dqp;
struct xfs_dqtrx *qtrx, *qa;
- struct xfs_disk_dquot *d;
int64_t totalbdelta;
int64_t totalrtbdelta;
@@ -341,7 +340,6 @@ xfs_trans_apply_dquot_deltas(
/*
* adjust the actual number of blocks used
*/
- d = &dqp->q_core;
/*
* The issue here is - sometimes we don't make a blkquota
@@ -362,25 +360,22 @@ xfs_trans_apply_dquot_deltas(
qtrx->qt_delrtb_delta;
#ifdef DEBUG
if (totalbdelta < 0)
- ASSERT(be64_to_cpu(d->d_bcount) >=
- -totalbdelta);
+ ASSERT(dqp->q_blk.count >= -totalbdelta);
if (totalrtbdelta < 0)
- ASSERT(be64_to_cpu(d->d_rtbcount) >=
- -totalrtbdelta);
+ ASSERT(dqp->q_rtb.count >= -totalrtbdelta);
if (qtrx->qt_icount_delta < 0)
- ASSERT(be64_to_cpu(d->d_icount) >=
- -qtrx->qt_icount_delta);
+ ASSERT(dqp->q_ino.count >= -qtrx->qt_icount_delta);
#endif
if (totalbdelta)
- be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
+ dqp->q_blk.count += totalbdelta;
if (qtrx->qt_icount_delta)
- be64_add_cpu(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta);
+ dqp->q_ino.count += qtrx->qt_icount_delta;
if (totalrtbdelta)
- be64_add_cpu(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta);
+ dqp->q_rtb.count += totalrtbdelta;
/*
* Get any default limits in use.
@@ -467,12 +462,9 @@ xfs_trans_apply_dquot_deltas(
(xfs_qcnt_t)qtrx->qt_icount_delta;
}
- ASSERT(dqp->q_blk.reserved >=
- be64_to_cpu(dqp->q_core.d_bcount));
- ASSERT(dqp->q_ino.reserved >=
- be64_to_cpu(dqp->q_core.d_icount));
- ASSERT(dqp->q_rtb.reserved >=
- be64_to_cpu(dqp->q_core.d_rtbcount));
+ ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
+ ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
+ ASSERT(dqp->q_rtb.reserved >= dqp->q_rtb.count);
}
}
}
@@ -682,7 +674,7 @@ xfs_trans_dqresv(
/*
* Change the reservation, but not the actual usage.
- * Note that q_blk.reserved = q_core.d_bcount + resv
+ * Note that q_blk.reserved = q_blk.count + resv
*/
(*resbcountp) += (xfs_qcnt_t)nblks;
if (ninos != 0)
@@ -707,9 +699,9 @@ xfs_trans_dqresv(
XFS_TRANS_DQ_RES_INOS,
ninos);
}
- ASSERT(dqp->q_blk.reserved >= be64_to_cpu(dqp->q_core.d_bcount));
- ASSERT(dqp->q_rtb.reserved >= be64_to_cpu(dqp->q_core.d_rtbcount));
- ASSERT(dqp->q_ino.reserved >= be64_to_cpu(dqp->q_core.d_icount));
+ ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
+ ASSERT(dqp->q_rtb.reserved >= dqp->q_rtb.count);
+ ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
xfs_dqunlock(dqp);
return 0;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 15/26] xfs: stop using q_core warning counters in the quota code
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (13 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 14/26] xfs: stop using q_core counters " Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 16/26] xfs: stop using q_core timers " Darrick J. Wong
` (10 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Christoph Hellwig, Allison Collins, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add warning counter 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@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
---
fs/xfs/xfs_dquot.c | 14 +++++++++++---
fs/xfs/xfs_dquot.h | 8 ++++++++
fs/xfs/xfs_qm.c | 12 ++++++------
fs/xfs/xfs_qm_syscalls.c | 12 ++++++------
fs/xfs/xfs_trans_dquot.c | 6 +++---
5 files changed, 34 insertions(+), 18 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 921307cf2c6f..db9473b49cc0 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -140,7 +140,7 @@ xfs_qm_adjust_dqtimers(
d->d_btimer = cpu_to_be32(ktime_get_real_seconds() +
defq->btimelimit);
} else {
- d->d_bwarns = 0;
+ dq->q_blk.warnings = 0;
}
} else {
if ((!dq->q_blk.softlimit ||
@@ -159,7 +159,7 @@ xfs_qm_adjust_dqtimers(
d->d_itimer = cpu_to_be32(ktime_get_real_seconds() +
defq->itimelimit);
} else {
- d->d_iwarns = 0;
+ dq->q_ino.warnings = 0;
}
} else {
if ((!dq->q_ino.softlimit ||
@@ -178,7 +178,7 @@ xfs_qm_adjust_dqtimers(
d->d_rtbtimer = cpu_to_be32(ktime_get_real_seconds() +
defq->rtbtimelimit);
} else {
- d->d_rtbwarns = 0;
+ dq->q_rtb.warnings = 0;
}
} else {
if ((!dq->q_rtb.softlimit ||
@@ -548,6 +548,10 @@ xfs_dquot_from_disk(
dqp->q_ino.count = be64_to_cpu(ddqp->d_icount);
dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount);
+ dqp->q_blk.warnings = be16_to_cpu(ddqp->d_bwarns);
+ dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns);
+ dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns);
+
/*
* Reservation counters are defined as reservation plus current usage
* to avoid having to add every time.
@@ -578,6 +582,10 @@ xfs_dquot_to_disk(
ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count);
ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);
ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);
+
+ 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);
}
/* Allocate and initialize the dquot buffer for this in-core dquot. */
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index f470731d3cfd..4c6460637e55 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -37,6 +37,14 @@ struct xfs_dquot_res {
/* Absolute and preferred limits. */
xfs_qcnt_t hardlimit;
xfs_qcnt_t softlimit;
+
+ /*
+ * For root dquots, this is the maximum number of warnings that will
+ * be issued for this quota type. Otherwise, this is the number of
+ * warnings issued against this quota. Note that none of this is
+ * implemented.
+ */
+ xfs_qwarncnt_t warnings;
};
/*
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 6c5fe57699fa..bc3182ef9564 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -614,12 +614,12 @@ xfs_qm_init_timelimits(
defq->itimelimit = be32_to_cpu(ddqp->d_itimer);
if (ddqp->d_rtbtimer)
defq->rtbtimelimit = be32_to_cpu(ddqp->d_rtbtimer);
- if (ddqp->d_bwarns)
- defq->bwarnlimit = be16_to_cpu(ddqp->d_bwarns);
- if (ddqp->d_iwarns)
- defq->iwarnlimit = be16_to_cpu(ddqp->d_iwarns);
- if (ddqp->d_rtbwarns)
- defq->rtbwarnlimit = be16_to_cpu(ddqp->d_rtbwarns);
+ if (dqp->q_blk.warnings)
+ defq->bwarnlimit = dqp->q_blk.warnings;
+ if (dqp->q_ino.warnings)
+ defq->iwarnlimit = dqp->q_ino.warnings;
+ if (dqp->q_rtb.warnings)
+ defq->rtbwarnlimit = dqp->q_rtb.warnings;
xfs_qm_dqdestroy(dqp);
}
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 7aebd588bdf7..4352169b644c 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -548,11 +548,11 @@ xfs_qm_scall_setqlim(
* Update warnings counter(s) if requested
*/
if (newlim->d_fieldmask & QC_SPC_WARNS)
- ddq->d_bwarns = cpu_to_be16(newlim->d_spc_warns);
+ dqp->q_blk.warnings = newlim->d_spc_warns;
if (newlim->d_fieldmask & QC_INO_WARNS)
- ddq->d_iwarns = cpu_to_be16(newlim->d_ino_warns);
+ dqp->q_ino.warnings = newlim->d_ino_warns;
if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
- ddq->d_rtbwarns = cpu_to_be16(newlim->d_rt_spc_warns);
+ dqp->q_rtb.warnings = newlim->d_rt_spc_warns;
if (id == 0) {
if (newlim->d_fieldmask & QC_SPC_WARNS)
@@ -627,13 +627,13 @@ xfs_qm_scall_getquota_fill_qc(
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_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns);
- dst->d_spc_warns = be16_to_cpu(dqp->q_core.d_bwarns);
+ 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_warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
+ dst->d_rt_spc_warns = dqp->q_rtb.warnings;
/*
* Internally, we don't reset all the timers when quota enforcement
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 96d4691df26e..995636a63685 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -599,7 +599,7 @@ xfs_trans_dqresv(
if (!softlimit)
softlimit = defq->bsoftlimit;
timer = be32_to_cpu(dqp->q_core.d_btimer);
- warns = be16_to_cpu(dqp->q_core.d_bwarns);
+ warns = dqp->q_blk.warnings;
warnlimit = defq->bwarnlimit;
resbcountp = &dqp->q_blk.reserved;
} else {
@@ -611,7 +611,7 @@ xfs_trans_dqresv(
if (!softlimit)
softlimit = defq->rtbsoftlimit;
timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
- warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
+ warns = dqp->q_rtb.warnings;
warnlimit = defq->rtbwarnlimit;
resbcountp = &dqp->q_rtb.reserved;
}
@@ -646,7 +646,7 @@ xfs_trans_dqresv(
if (ninos > 0) {
total_count = dqp->q_ino.reserved + ninos;
timer = be32_to_cpu(dqp->q_core.d_itimer);
- warns = be16_to_cpu(dqp->q_core.d_iwarns);
+ warns = dqp->q_ino.warnings;
warnlimit = defq->iwarnlimit;
hardlimit = dqp->q_ino.hardlimit;
if (!hardlimit)
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 16/26] xfs: stop using q_core timers in the quota code
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (14 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 15/26] xfs: stop using q_core warning " Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 17/26] xfs: remove qcore from incore dquots Darrick J. Wong
` (9 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Christoph Hellwig, Allison Collins, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
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@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
---
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 db9473b49cc0..ad17ce622805 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;
}
}
}
@@ -552,6 +551,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.
@@ -586,6 +589,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. */
@@ -1147,8 +1154,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)
@@ -1158,15 +1163,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 bc3182ef9564..4305bbcdb97d 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;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 17/26] xfs: remove qcore from incore dquots
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (15 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 16/26] xfs: stop using q_core timers " Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 18/26] xfs: refactor default quota limits by resource Darrick J. Wong
` (8 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong; +Cc: Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Now that we've stopped using qcore entirely, drop it from the incore
dquot.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/libxfs/xfs_format.h | 7 +++----
fs/xfs/scrub/quota.c | 4 ----
fs/xfs/xfs_dquot.c | 36 +++++++++++++-----------------------
fs/xfs/xfs_dquot.h | 1 -
4 files changed, 16 insertions(+), 32 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 76d34b77031a..adc3ca11c012 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1161,10 +1161,9 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
#define XFS_DDQTYPE_ANY (XFS_DDQTYPE_REC_MASK)
/*
- * This is the main portion of the on-disk representation of quota
- * information for a user. This is the q_core of the struct xfs_dquot that
- * is kept in kernel memory. We pad this with some more expansion room
- * to construct the on disk structure.
+ * This is the main portion of the on-disk representation of quota information
+ * for a user. We pad this with some more expansion room to construct the on
+ * disk structure.
*/
struct xfs_disk_dquot {
__be16 d_magic; /* dquot magic = XFS_DQUOT_MAGIC */
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index d002af3ab164..f045895f28ff 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -80,7 +80,6 @@ xchk_quota_item(
struct xchk_quota_info *sqi = priv;
struct xfs_scrub *sc = sqi->sc;
struct xfs_mount *mp = sc->mp;
- struct xfs_disk_dquot *d = &dq->q_core;
struct xfs_quotainfo *qi = mp->m_quotainfo;
xfs_fileoff_t offset;
xfs_ino_t fs_icount;
@@ -99,9 +98,6 @@ xchk_quota_item(
sqi->last_id = dq->q_id;
- if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
- xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
-
/*
* Warn if the hard limits are larger than the fs.
* Administrators can do this, though in production this seems
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index ad17ce622805..75b22560244e 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -535,7 +535,6 @@ xfs_dquot_from_disk(
}
/* copy everything from disk dquot to the incore dquot */
- memcpy(&dqp->q_core, ddqp, sizeof(struct xfs_disk_dquot));
dqp->q_blk.hardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
dqp->q_blk.softlimit = be64_to_cpu(ddqp->d_blk_softlimit);
dqp->q_ino.hardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
@@ -574,7 +573,13 @@ xfs_dquot_to_disk(
struct xfs_disk_dquot *ddqp,
struct xfs_dquot *dqp)
{
- memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
+ ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
+ ddqp->d_version = XFS_DQUOT_VERSION;
+ ddqp->d_type = dqp->q_type;
+ ddqp->d_id = cpu_to_be32(dqp->q_id);
+ ddqp->d_pad0 = 0;
+ ddqp->d_pad = 0;
+
ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit);
ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit);
ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit);
@@ -1193,8 +1198,7 @@ xfs_qm_dqflush(
struct xfs_mount *mp = dqp->q_mount;
struct xfs_log_item *lip = &dqp->q_logitem.qli_item;
struct xfs_buf *bp;
- struct xfs_dqblk *dqb;
- struct xfs_disk_dquot *ddqp;
+ struct xfs_dqblk *dqblk;
xfs_failaddr_t fa;
int error;
@@ -1218,22 +1222,6 @@ xfs_qm_dqflush(
if (error)
goto out_abort;
- /*
- * Calculate the location of the dquot inside the buffer.
- */
- dqb = bp->b_addr + dqp->q_bufoffset;
- ddqp = &dqb->dd_diskdq;
-
- /* sanity check the in-core structure before we flush */
- fa = xfs_dquot_verify(mp, &dqp->q_core, dqp->q_id, 0);
- if (fa) {
- xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
- dqp->q_id, fa);
- xfs_buf_relse(bp);
- error = -EFSCORRUPTED;
- goto out_abort;
- }
-
fa = xfs_qm_dqflush_check(dqp);
if (fa) {
xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
@@ -1243,7 +1231,9 @@ xfs_qm_dqflush(
goto out_abort;
}
- xfs_dquot_to_disk(ddqp, dqp);
+ /* Flush the incore dquot to the ondisk buffer. */
+ dqblk = bp->b_addr + dqp->q_bufoffset;
+ xfs_dquot_to_disk(&dqblk->dd_diskdq, dqp);
/*
* Clear the dirty field and remember the flush lsn for later use.
@@ -1263,8 +1253,8 @@ xfs_qm_dqflush(
* of a dquot without an up-to-date CRC getting to disk.
*/
if (xfs_sb_version_hascrc(&mp->m_sb)) {
- dqb->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
- xfs_update_cksum((char *)dqb, sizeof(struct xfs_dqblk),
+ dqblk->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
+ xfs_update_cksum((char *)dqblk, sizeof(struct xfs_dqblk),
XFS_DQUOT_CRC_OFF);
}
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 6ad89ccb80c0..9bcfa3330f25 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -72,7 +72,6 @@ struct xfs_dquot {
struct xfs_dquot_res q_ino; /* inodes */
struct xfs_dquot_res q_rtb; /* realtime blocks */
- struct xfs_disk_dquot q_core;
struct xfs_dq_logitem q_logitem;
xfs_qcnt_t q_prealloc_lo_wmark;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 18/26] xfs: refactor default quota limits by resource
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (16 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 17/26] xfs: remove qcore from incore dquots Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 19/26] xfs: remove unnecessary arguments from quota adjust functions Darrick J. Wong
` (7 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong; +Cc: Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Now that we've split up the dquot resource fields into separate structs,
do the same for the default limits to enable further refactoring.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_dquot.c | 30 +++++++++++++++---------------
fs/xfs/xfs_qm.c | 36 ++++++++++++++++++------------------
fs/xfs/xfs_qm.h | 22 ++++++++++------------
fs/xfs/xfs_qm_syscalls.c | 24 ++++++++++++------------
fs/xfs/xfs_quotaops.c | 12 ++++++------
fs/xfs/xfs_trans_dquot.c | 18 +++++++++---------
6 files changed, 70 insertions(+), 72 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 75b22560244e..8107bb094641 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -77,22 +77,22 @@ xfs_qm_adjust_dqlimits(
ASSERT(dq->q_id);
defq = xfs_get_defquota(q, dq->q_type);
- if (defq->bsoftlimit && !dq->q_blk.softlimit) {
- dq->q_blk.softlimit = defq->bsoftlimit;
+ if (defq->blk.soft && !dq->q_blk.softlimit) {
+ dq->q_blk.softlimit = defq->blk.soft;
prealloc = 1;
}
- if (defq->bhardlimit && !dq->q_blk.hardlimit) {
- dq->q_blk.hardlimit = defq->bhardlimit;
+ if (defq->blk.hard && !dq->q_blk.hardlimit) {
+ dq->q_blk.hardlimit = defq->blk.hard;
prealloc = 1;
}
- if (defq->isoftlimit && !dq->q_ino.softlimit)
- dq->q_ino.softlimit = defq->isoftlimit;
- if (defq->ihardlimit && !dq->q_ino.hardlimit)
- dq->q_ino.hardlimit = defq->ihardlimit;
- if (defq->rtbsoftlimit && !dq->q_rtb.softlimit)
- dq->q_rtb.softlimit = defq->rtbsoftlimit;
- if (defq->rtbhardlimit && !dq->q_rtb.hardlimit)
- dq->q_rtb.hardlimit = defq->rtbhardlimit;
+ if (defq->ino.soft && !dq->q_ino.softlimit)
+ dq->q_ino.softlimit = defq->ino.soft;
+ if (defq->ino.hard && !dq->q_ino.hardlimit)
+ dq->q_ino.hardlimit = defq->ino.hard;
+ if (defq->rtb.soft && !dq->q_rtb.softlimit)
+ dq->q_rtb.softlimit = defq->rtb.soft;
+ if (defq->rtb.hard && !dq->q_rtb.hardlimit)
+ dq->q_rtb.hardlimit = defq->rtb.hard;
if (prealloc)
xfs_dquot_set_prealloc_limits(dq);
@@ -137,7 +137,7 @@ xfs_qm_adjust_dqtimers(
(dq->q_blk.hardlimit &&
(dq->q_blk.count > dq->q_blk.hardlimit))) {
dq->q_blk.timer = ktime_get_real_seconds() +
- defq->btimelimit;
+ defq->blk.time;
} else {
dq->q_blk.warnings = 0;
}
@@ -156,7 +156,7 @@ xfs_qm_adjust_dqtimers(
(dq->q_ino.hardlimit &&
(dq->q_ino.count > dq->q_ino.hardlimit))) {
dq->q_ino.timer = ktime_get_real_seconds() +
- defq->itimelimit;
+ defq->ino.time;
} else {
dq->q_ino.warnings = 0;
}
@@ -175,7 +175,7 @@ xfs_qm_adjust_dqtimers(
(dq->q_rtb.hardlimit &&
(dq->q_rtb.count > dq->q_rtb.hardlimit))) {
dq->q_rtb.timer = ktime_get_real_seconds() +
- defq->rtbtimelimit;
+ defq->rtb.time;
} else {
dq->q_rtb.warnings = 0;
}
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 4305bbcdb97d..6ebf5bed65a7 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -560,12 +560,12 @@ xfs_qm_set_defquota(
* Timers and warnings have been already set, let's just set the
* default limits for this quota type
*/
- defq->bhardlimit = dqp->q_blk.hardlimit;
- defq->bsoftlimit = dqp->q_blk.softlimit;
- defq->ihardlimit = dqp->q_ino.hardlimit;
- defq->isoftlimit = dqp->q_ino.softlimit;
- defq->rtbhardlimit = dqp->q_rtb.hardlimit;
- defq->rtbsoftlimit = dqp->q_rtb.softlimit;
+ defq->blk.hard = dqp->q_blk.hardlimit;
+ defq->blk.soft = dqp->q_blk.softlimit;
+ defq->ino.hard = dqp->q_ino.hardlimit;
+ defq->ino.soft = dqp->q_ino.softlimit;
+ defq->rtb.hard = dqp->q_rtb.hardlimit;
+ defq->rtb.soft = dqp->q_rtb.softlimit;
xfs_qm_dqdestroy(dqp);
}
@@ -582,12 +582,12 @@ xfs_qm_init_timelimits(
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;
+ defq->blk.time = XFS_QM_BTIMELIMIT;
+ defq->ino.time = XFS_QM_ITIMELIMIT;
+ defq->rtb.time = XFS_QM_RTBTIMELIMIT;
+ defq->blk.warn = XFS_QM_BWARNLIMIT;
+ defq->ino.warn = XFS_QM_IWARNLIMIT;
+ defq->rtb.warn = XFS_QM_RTBWARNLIMIT;
/*
* We try to get the limits from the superuser's limits fields.
@@ -606,17 +606,17 @@ xfs_qm_init_timelimits(
* more writing. If it is zero, a default is used.
*/
if (dqp->q_blk.timer)
- defq->btimelimit = dqp->q_blk.timer;
+ defq->blk.time = dqp->q_blk.timer;
if (dqp->q_ino.timer)
- defq->itimelimit = dqp->q_ino.timer;
+ defq->ino.time = dqp->q_ino.timer;
if (dqp->q_rtb.timer)
- defq->rtbtimelimit = dqp->q_rtb.timer;
+ defq->rtb.time = dqp->q_rtb.timer;
if (dqp->q_blk.warnings)
- defq->bwarnlimit = dqp->q_blk.warnings;
+ defq->blk.warn = dqp->q_blk.warnings;
if (dqp->q_ino.warnings)
- defq->iwarnlimit = dqp->q_ino.warnings;
+ defq->ino.warn = dqp->q_ino.warnings;
if (dqp->q_rtb.warnings)
- defq->rtbwarnlimit = dqp->q_rtb.warnings;
+ defq->rtb.warn = dqp->q_rtb.warnings;
xfs_qm_dqdestroy(dqp);
}
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 0e4ceb0dcfbc..9c078c35d924 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -30,20 +30,18 @@ extern struct kmem_zone *xfs_qm_dqtrxzone;
!dqp->q_rtb.count && \
!dqp->q_ino.count)
+struct xfs_quota_limits {
+ xfs_qcnt_t hard; /* default hard limit */
+ xfs_qcnt_t soft; /* default soft limit */
+ time64_t time; /* limit for timers */
+ xfs_qwarncnt_t warn; /* limit for warnings */
+};
+
/* 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 */
- xfs_qcnt_t isoftlimit; /* default inode count soft limit */
- xfs_qcnt_t rtbhardlimit; /* default realtime blk hard limit */
- xfs_qcnt_t rtbsoftlimit; /* default realtime blk soft limit */
+ struct xfs_quota_limits blk;
+ struct xfs_quota_limits ino;
+ struct xfs_quota_limits rtb;
};
/*
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 3bb844317d02..b0c932086d59 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -502,8 +502,8 @@ xfs_qm_scall_setqlim(
dqp->q_blk.softlimit = soft;
xfs_dquot_set_prealloc_limits(dqp);
if (id == 0) {
- defq->bhardlimit = hard;
- defq->bsoftlimit = soft;
+ defq->blk.hard = hard;
+ defq->blk.soft = soft;
}
} else {
xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
@@ -518,8 +518,8 @@ xfs_qm_scall_setqlim(
dqp->q_rtb.hardlimit = hard;
dqp->q_rtb.softlimit = soft;
if (id == 0) {
- defq->rtbhardlimit = hard;
- defq->rtbsoftlimit = soft;
+ defq->rtb.hard = hard;
+ defq->rtb.soft = soft;
}
} else {
xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
@@ -535,8 +535,8 @@ xfs_qm_scall_setqlim(
dqp->q_ino.hardlimit = hard;
dqp->q_ino.softlimit = soft;
if (id == 0) {
- defq->ihardlimit = hard;
- defq->isoftlimit = soft;
+ defq->ino.hard = hard;
+ defq->ino.soft = soft;
}
} else {
xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
@@ -554,11 +554,11 @@ xfs_qm_scall_setqlim(
if (id == 0) {
if (newlim->d_fieldmask & QC_SPC_WARNS)
- defq->bwarnlimit = newlim->d_spc_warns;
+ defq->blk.warn = newlim->d_spc_warns;
if (newlim->d_fieldmask & QC_INO_WARNS)
- defq->iwarnlimit = newlim->d_ino_warns;
+ defq->ino.warn = newlim->d_ino_warns;
if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
- defq->rtbwarnlimit = newlim->d_rt_spc_warns;
+ defq->rtb.warn = newlim->d_rt_spc_warns;
}
/*
@@ -579,11 +579,11 @@ xfs_qm_scall_setqlim(
if (id == 0) {
if (newlim->d_fieldmask & QC_SPC_TIMER)
- defq->btimelimit = newlim->d_spc_timer;
+ defq->blk.time = newlim->d_spc_timer;
if (newlim->d_fieldmask & QC_INO_TIMER)
- defq->itimelimit = newlim->d_ino_timer;
+ defq->ino.time = newlim->d_ino_timer;
if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
- defq->rtbtimelimit = newlim->d_rt_spc_timer;
+ defq->rtb.time = newlim->d_rt_spc_timer;
}
if (id != 0) {
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 963c253558b3..d27c0e852c0b 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -37,12 +37,12 @@ xfs_qm_fill_state(
tstate->flags |= QCI_SYSFILE;
tstate->blocks = ip->i_d.di_nblocks;
tstate->nextents = ip->i_df.if_nextents;
- 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;
+ tstate->spc_timelimit = (u32)defq->blk.time;
+ tstate->ino_timelimit = (u32)defq->ino.time;
+ tstate->rt_spc_timelimit = (u32)defq->rtb.time;
+ tstate->spc_warnlimit = defq->blk.warn;
+ tstate->ino_warnlimit = defq->ino.warn;
+ tstate->rt_spc_warnlimit = defq->rtb.warn;
if (tempqip)
xfs_irele(ip);
}
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 71f771c2fb34..f08d37747e7e 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -594,25 +594,25 @@ xfs_trans_dqresv(
if (flags & XFS_TRANS_DQ_RES_BLKS) {
hardlimit = dqp->q_blk.hardlimit;
if (!hardlimit)
- hardlimit = defq->bhardlimit;
+ hardlimit = defq->blk.hard;
softlimit = dqp->q_blk.softlimit;
if (!softlimit)
- softlimit = defq->bsoftlimit;
+ softlimit = defq->blk.soft;
timer = dqp->q_blk.timer;
warns = dqp->q_blk.warnings;
- warnlimit = defq->bwarnlimit;
+ warnlimit = defq->blk.warn;
resbcountp = &dqp->q_blk.reserved;
} else {
ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
hardlimit = dqp->q_rtb.hardlimit;
if (!hardlimit)
- hardlimit = defq->rtbhardlimit;
+ hardlimit = defq->rtb.hard;
softlimit = dqp->q_rtb.softlimit;
if (!softlimit)
- softlimit = defq->rtbsoftlimit;
+ softlimit = defq->rtb.soft;
timer = dqp->q_rtb.timer;
warns = dqp->q_rtb.warnings;
- warnlimit = defq->rtbwarnlimit;
+ warnlimit = defq->rtb.warn;
resbcountp = &dqp->q_rtb.reserved;
}
@@ -647,13 +647,13 @@ xfs_trans_dqresv(
total_count = dqp->q_ino.reserved + ninos;
timer = dqp->q_ino.timer;
warns = dqp->q_ino.warnings;
- warnlimit = defq->iwarnlimit;
+ warnlimit = defq->ino.warn;
hardlimit = dqp->q_ino.hardlimit;
if (!hardlimit)
- hardlimit = defq->ihardlimit;
+ hardlimit = defq->ino.hard;
softlimit = dqp->q_ino.softlimit;
if (!softlimit)
- softlimit = defq->isoftlimit;
+ softlimit = defq->ino.soft;
if (hardlimit && total_count > hardlimit) {
xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 19/26] xfs: remove unnecessary arguments from quota adjust functions
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (17 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 18/26] xfs: refactor default quota limits by resource Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 20/26] xfs: refactor quota exceeded test Darrick J. Wong
` (6 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong; +Cc: Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
struct xfs_dquot already has a pointer to the xfs mount, so remove the
redundant parameter from xfs_qm_adjust_dq*.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_dquot.c | 4 ++--
fs/xfs/xfs_dquot.h | 6 ++----
fs/xfs/xfs_qm.c | 4 ++--
fs/xfs/xfs_qm_syscalls.c | 2 +-
fs/xfs/xfs_trans_dquot.c | 4 ++--
5 files changed, 9 insertions(+), 11 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 8107bb094641..648fecd959a1 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -67,9 +67,9 @@ xfs_qm_dqdestroy(
*/
void
xfs_qm_adjust_dqlimits(
- struct xfs_mount *mp,
struct xfs_dquot *dq)
{
+ struct xfs_mount *mp = dq->q_mount;
struct xfs_quotainfo *q = mp->m_quotainfo;
struct xfs_def_quota *defq;
int prealloc = 0;
@@ -113,9 +113,9 @@ xfs_qm_adjust_dqlimits(
*/
void
xfs_qm_adjust_dqtimers(
- struct xfs_mount *mp,
struct xfs_dquot *dq)
{
+ struct xfs_mount *mp = dq->q_mount;
struct xfs_quotainfo *qi = mp->m_quotainfo;
struct xfs_def_quota *defq;
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 9bcfa3330f25..f55e40dfb9ed 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -188,10 +188,8 @@ void xfs_dquot_to_disk(struct xfs_disk_dquot *ddqp, struct xfs_dquot *dqp);
void xfs_qm_dqdestroy(struct xfs_dquot *dqp);
int xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);
void xfs_qm_dqunpin_wait(struct xfs_dquot *dqp);
-void xfs_qm_adjust_dqtimers(struct xfs_mount *mp,
- struct xfs_dquot *d);
-void xfs_qm_adjust_dqlimits(struct xfs_mount *mp,
- struct xfs_dquot *d);
+void xfs_qm_adjust_dqtimers(struct xfs_dquot *d);
+void xfs_qm_adjust_dqlimits(struct xfs_dquot *d);
xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip,
xfs_dqtype_t type);
int xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 6ebf5bed65a7..c0680bd1a148 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1101,8 +1101,8 @@ xfs_qm_quotacheck_dqadjust(
* There are no timers for the default values set in the root dquot.
*/
if (dqp->q_id) {
- xfs_qm_adjust_dqlimits(mp, dqp);
- xfs_qm_adjust_dqtimers(mp, dqp);
+ xfs_qm_adjust_dqlimits(dqp);
+ xfs_qm_adjust_dqtimers(dqp);
}
dqp->q_flags |= XFS_DQFLAG_DIRTY;
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index b0c932086d59..aea4be4da424 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -594,7 +594,7 @@ xfs_qm_scall_setqlim(
* is on or off. We don't really want to bother with iterating
* over all ondisk dquots and turning the timers on/off.
*/
- xfs_qm_adjust_dqtimers(mp, dqp);
+ xfs_qm_adjust_dqtimers(dqp);
}
dqp->q_flags |= XFS_DQFLAG_DIRTY;
xfs_trans_log_dquot(tp, dqp);
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index f08d37747e7e..53c133fd4f18 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -382,8 +382,8 @@ xfs_trans_apply_dquot_deltas(
* Start/reset the timer(s) if needed.
*/
if (dqp->q_id) {
- xfs_qm_adjust_dqlimits(tp->t_mountp, dqp);
- xfs_qm_adjust_dqtimers(tp->t_mountp, dqp);
+ xfs_qm_adjust_dqlimits(dqp);
+ xfs_qm_adjust_dqtimers(dqp);
}
dqp->q_flags |= XFS_DQFLAG_DIRTY;
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 20/26] xfs: refactor quota exceeded test
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (18 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 19/26] xfs: remove unnecessary arguments from quota adjust functions Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 21/26] xfs: refactor xfs_qm_scall_setqlim Darrick J. Wong
` (5 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong; +Cc: Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Refactor the open-coded test for whether or not we're over quota.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_dquot.c | 91 +++++++++++++++-------------------------------------
1 file changed, 26 insertions(+), 65 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 648fecd959a1..e44f80700005 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -98,6 +98,29 @@ xfs_qm_adjust_dqlimits(
xfs_dquot_set_prealloc_limits(dq);
}
+/*
+ * Determine if this quota counter is over either limit and set the quota
+ * timers as appropriate.
+ */
+static inline void
+xfs_qm_adjust_res_timer(
+ struct xfs_dquot_res *res,
+ struct xfs_quota_limits *qlim)
+{
+ ASSERT(res->hardlimit == 0 || res->softlimit <= res->hardlimit);
+
+ if ((res->softlimit && res->count > res->softlimit) ||
+ (res->hardlimit && res->count > res->hardlimit)) {
+ if (res->timer == 0)
+ res->timer = ktime_get_real_seconds() + qlim->time;
+ } else {
+ if (res->timer == 0)
+ res->warnings = 0;
+ else
+ res->timer = 0;
+ }
+}
+
/*
* Check the limits and timers of a dquot and start or reset timers
* if necessary.
@@ -122,71 +145,9 @@ xfs_qm_adjust_dqtimers(
ASSERT(dq->q_id);
defq = xfs_get_defquota(qi, dq->q_type);
-#ifdef DEBUG
- if (dq->q_blk.hardlimit)
- ASSERT(dq->q_blk.softlimit <= dq->q_blk.hardlimit);
- if (dq->q_ino.hardlimit)
- ASSERT(dq->q_ino.softlimit <= dq->q_ino.hardlimit);
- if (dq->q_rtb.hardlimit)
- ASSERT(dq->q_rtb.softlimit <= dq->q_rtb.hardlimit);
-#endif
-
- 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))) {
- dq->q_blk.timer = ktime_get_real_seconds() +
- defq->blk.time;
- } else {
- dq->q_blk.warnings = 0;
- }
- } else {
- 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))) {
- dq->q_blk.timer = 0;
- }
- }
-
- 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))) {
- dq->q_ino.timer = ktime_get_real_seconds() +
- defq->ino.time;
- } else {
- dq->q_ino.warnings = 0;
- }
- } else {
- 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))) {
- dq->q_ino.timer = 0;
- }
- }
-
- 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))) {
- dq->q_rtb.timer = ktime_get_real_seconds() +
- defq->rtb.time;
- } else {
- dq->q_rtb.warnings = 0;
- }
- } else {
- 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))) {
- dq->q_rtb.timer = 0;
- }
- }
+ xfs_qm_adjust_res_timer(&dq->q_blk, &defq->blk);
+ xfs_qm_adjust_res_timer(&dq->q_ino, &defq->ino);
+ xfs_qm_adjust_res_timer(&dq->q_rtb, &defq->rtb);
}
/*
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 21/26] xfs: refactor xfs_qm_scall_setqlim
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (19 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 20/26] xfs: refactor quota exceeded test Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:52 ` [PATCH 22/26] xfs: refactor xfs_trans_dqresv Darrick J. Wong
` (4 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong
Cc: Christoph Hellwig, Allison Collins, Chandan Babu R, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Now that we can pass around quota resource and limit structures, clean
up the open-coded field setting in xfs_qm_scall_setqlim.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
fs/xfs/xfs_qm_syscalls.c | 164 ++++++++++++++++++++++++++--------------------
1 file changed, 93 insertions(+), 71 deletions(-)
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index aea4be4da424..4f06d2dc18d0 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -436,6 +436,58 @@ xfs_qm_scall_quotaon(
#define XFS_QC_MASK \
(QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK)
+/*
+ * Adjust limits of this quota, and the defaults if passed in. Returns true
+ * if the new limits made sense and were applied, false otherwise.
+ */
+static inline bool
+xfs_setqlim_limits(
+ struct xfs_mount *mp,
+ struct xfs_dquot_res *res,
+ struct xfs_quota_limits *qlim,
+ xfs_qcnt_t hard,
+ xfs_qcnt_t soft,
+ const char *tag)
+{
+ /* The hard limit can't be less than the soft limit. */
+ if (hard != 0 && hard < soft) {
+ xfs_debug(mp, "%shard %lld < %ssoft %lld", tag, hard, tag,
+ soft);
+ return false;
+ }
+
+ res->hardlimit = hard;
+ res->softlimit = soft;
+ if (qlim) {
+ qlim->hard = hard;
+ qlim->soft = soft;
+ }
+
+ return true;
+}
+
+static inline void
+xfs_setqlim_warns(
+ struct xfs_dquot_res *res,
+ struct xfs_quota_limits *qlim,
+ int warns)
+{
+ res->warnings = warns;
+ if (qlim)
+ qlim->warn = warns;
+}
+
+static inline void
+xfs_setqlim_timer(
+ struct xfs_dquot_res *res,
+ struct xfs_quota_limits *qlim,
+ s64 timer)
+{
+ res->timer = timer;
+ if (qlim)
+ qlim->time = timer;
+}
+
/*
* Adjust quota limits, and start/stop timers accordingly.
*/
@@ -450,6 +502,8 @@ xfs_qm_scall_setqlim(
struct xfs_dquot *dqp;
struct xfs_trans *tp;
struct xfs_def_quota *defq;
+ struct xfs_dquot_res *res;
+ struct xfs_quota_limits *qlim;
int error;
xfs_qcnt_t hard, soft;
@@ -489,102 +543,70 @@ xfs_qm_scall_setqlim(
xfs_trans_dqjoin(tp, dqp);
/*
+ * Update quota limits, warnings, and timers, and the defaults
+ * if we're touching id == 0.
+ *
* Make sure that hardlimits are >= soft limits before changing.
+ *
+ * Update warnings counter(s) if requested.
+ *
+ * Timelimits for the super user set the relative time the other users
+ * can be over quota for this file system. If it is zero a default is
+ * used. Ditto for the default soft and hard limit values (already
+ * done, above), and for warnings.
+ *
+ * For other IDs, userspace can bump out the grace period if over
+ * the soft limit.
*/
+
+ /* Blocks on the data device. */
hard = (newlim->d_fieldmask & QC_SPC_HARD) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_hardlimit) :
dqp->q_blk.hardlimit;
soft = (newlim->d_fieldmask & QC_SPC_SOFT) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_softlimit) :
dqp->q_blk.softlimit;
- if (hard == 0 || hard >= soft) {
- dqp->q_blk.hardlimit = hard;
- dqp->q_blk.softlimit = soft;
+ res = &dqp->q_blk;
+ qlim = id == 0 ? &defq->blk : NULL;
+
+ if (xfs_setqlim_limits(mp, res, qlim, hard, soft, "blk"))
xfs_dquot_set_prealloc_limits(dqp);
- if (id == 0) {
- defq->blk.hard = hard;
- defq->blk.soft = soft;
- }
- } else {
- xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
- }
+ if (newlim->d_fieldmask & QC_SPC_WARNS)
+ xfs_setqlim_warns(res, qlim, newlim->d_spc_warns);
+ if (newlim->d_fieldmask & QC_SPC_TIMER)
+ xfs_setqlim_timer(res, qlim, newlim->d_spc_timer);
+
+ /* Blocks on the realtime device. */
hard = (newlim->d_fieldmask & QC_RT_SPC_HARD) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_hardlimit) :
dqp->q_rtb.hardlimit;
soft = (newlim->d_fieldmask & QC_RT_SPC_SOFT) ?
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_softlimit) :
dqp->q_rtb.softlimit;
- if (hard == 0 || hard >= soft) {
- dqp->q_rtb.hardlimit = hard;
- dqp->q_rtb.softlimit = soft;
- if (id == 0) {
- defq->rtb.hard = hard;
- defq->rtb.soft = soft;
- }
- } else {
- xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
- }
+ res = &dqp->q_rtb;
+ qlim = id == 0 ? &defq->rtb : NULL;
+ xfs_setqlim_limits(mp, res, qlim, hard, soft, "rtb");
+ if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
+ xfs_setqlim_warns(res, qlim, newlim->d_rt_spc_warns);
+ if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
+ xfs_setqlim_timer(res, qlim, newlim->d_rt_spc_timer);
+
+ /* Inodes */
hard = (newlim->d_fieldmask & QC_INO_HARD) ?
(xfs_qcnt_t) newlim->d_ino_hardlimit :
dqp->q_ino.hardlimit;
soft = (newlim->d_fieldmask & QC_INO_SOFT) ?
(xfs_qcnt_t) newlim->d_ino_softlimit :
dqp->q_ino.softlimit;
- if (hard == 0 || hard >= soft) {
- dqp->q_ino.hardlimit = hard;
- dqp->q_ino.softlimit = soft;
- if (id == 0) {
- defq->ino.hard = hard;
- defq->ino.soft = soft;
- }
- } else {
- xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
- }
+ res = &dqp->q_ino;
+ qlim = id == 0 ? &defq->ino : NULL;
- /*
- * Update warnings counter(s) if requested
- */
- if (newlim->d_fieldmask & QC_SPC_WARNS)
- dqp->q_blk.warnings = newlim->d_spc_warns;
+ xfs_setqlim_limits(mp, res, qlim, hard, soft, "ino");
if (newlim->d_fieldmask & QC_INO_WARNS)
- dqp->q_ino.warnings = newlim->d_ino_warns;
- if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
- dqp->q_rtb.warnings = newlim->d_rt_spc_warns;
-
- if (id == 0) {
- if (newlim->d_fieldmask & QC_SPC_WARNS)
- defq->blk.warn = newlim->d_spc_warns;
- if (newlim->d_fieldmask & QC_INO_WARNS)
- defq->ino.warn = newlim->d_ino_warns;
- if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
- defq->rtb.warn = newlim->d_rt_spc_warns;
- }
-
- /*
- * Timelimits for the super user set the relative time the other users
- * can be over quota for this file system. If it is zero a default is
- * used. Ditto for the default soft and hard limit values (already
- * done, above), and for warnings.
- *
- * For other IDs, userspace can bump out the grace period if over
- * the soft limit.
- */
- if (newlim->d_fieldmask & QC_SPC_TIMER)
- dqp->q_blk.timer = newlim->d_spc_timer;
+ xfs_setqlim_warns(res, qlim, newlim->d_ino_warns);
if (newlim->d_fieldmask & QC_INO_TIMER)
- dqp->q_ino.timer = newlim->d_ino_timer;
- if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
- dqp->q_rtb.timer = newlim->d_rt_spc_timer;
-
- if (id == 0) {
- if (newlim->d_fieldmask & QC_SPC_TIMER)
- defq->blk.time = newlim->d_spc_timer;
- if (newlim->d_fieldmask & QC_INO_TIMER)
- defq->ino.time = newlim->d_ino_timer;
- if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
- defq->rtb.time = newlim->d_rt_spc_timer;
- }
+ xfs_setqlim_timer(res, qlim, newlim->d_ino_timer);
if (id != 0) {
/*
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 22/26] xfs: refactor xfs_trans_dqresv
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (20 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 21/26] xfs: refactor xfs_qm_scall_setqlim Darrick J. Wong
@ 2020-07-15 1:52 ` Darrick J. Wong
2020-07-15 1:53 ` [PATCH 23/26] xfs: refactor xfs_trans_apply_dquot_deltas Darrick J. Wong
` (3 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:52 UTC (permalink / raw)
To: darrick.wong
Cc: Chandan Babu R, Allison Collins, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Now that we've refactored the resource usage and limits into
per-resource structures, we can refactor some of the open-coded
reservation limit checking in xfs_trans_dqresv.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_trans_dquot.c | 153 +++++++++++++++++++++++-----------------------
1 file changed, 78 insertions(+), 75 deletions(-)
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 53c133fd4f18..cce457ad220b 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -561,6 +561,58 @@ xfs_quota_warn(
mp->m_super->s_dev, type);
}
+/*
+ * Decide if we can make an additional reservation against a quota resource.
+ * Returns an inode QUOTA_NL_ warning code and whether or not it's fatal.
+ *
+ * Note that we assume that the numeric difference between the inode and block
+ * warning codes will always be 3 since it's userspace ABI now, and will never
+ * decrease the quota reservation, so the *BELOW messages are irrelevant.
+ */
+static inline int
+xfs_dqresv_check(
+ struct xfs_dquot_res *res,
+ struct xfs_quota_limits *qlim,
+ int64_t delta,
+ bool *fatal)
+{
+ xfs_qcnt_t hardlimit = res->hardlimit;
+ xfs_qcnt_t softlimit = res->softlimit;
+ xfs_qcnt_t total_count = res->reserved + delta;
+
+ BUILD_BUG_ON(QUOTA_NL_BHARDWARN != QUOTA_NL_IHARDWARN + 3);
+ BUILD_BUG_ON(QUOTA_NL_BSOFTLONGWARN != QUOTA_NL_ISOFTLONGWARN + 3);
+ BUILD_BUG_ON(QUOTA_NL_BSOFTWARN != QUOTA_NL_ISOFTWARN + 3);
+
+ *fatal = false;
+ if (delta <= 0)
+ return QUOTA_NL_NOWARN;
+
+ if (!hardlimit)
+ hardlimit = qlim->hard;
+ if (!softlimit)
+ softlimit = qlim->soft;
+
+ if (hardlimit && total_count > hardlimit) {
+ *fatal = true;
+ return QUOTA_NL_IHARDWARN;
+ }
+
+ if (softlimit && total_count > softlimit) {
+ time64_t now = ktime_get_real_seconds();
+
+ if ((res->timer != 0 && now > res->timer) ||
+ (res->warnings != 0 && res->warnings >= qlim->warn)) {
+ *fatal = true;
+ return QUOTA_NL_ISOFTLONGWARN;
+ }
+
+ return QUOTA_NL_ISOFTWARN;
+ }
+
+ return QUOTA_NL_NOWARN;
+}
+
/*
* This reserves disk blocks and inodes against a dquot.
* Flags indicate if the dquot is to be locked here and also
@@ -576,99 +628,51 @@ xfs_trans_dqresv(
long ninos,
uint flags)
{
- xfs_qcnt_t hardlimit;
- xfs_qcnt_t softlimit;
- time64_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;
-
+ struct xfs_dquot_res *blkres;
+ struct xfs_quota_limits *qlim;
xfs_dqlock(dqp);
defq = xfs_get_defquota(q, dqp->q_type);
if (flags & XFS_TRANS_DQ_RES_BLKS) {
- hardlimit = dqp->q_blk.hardlimit;
- if (!hardlimit)
- hardlimit = defq->blk.hard;
- softlimit = dqp->q_blk.softlimit;
- if (!softlimit)
- softlimit = defq->blk.soft;
- timer = dqp->q_blk.timer;
- warns = dqp->q_blk.warnings;
- warnlimit = defq->blk.warn;
- resbcountp = &dqp->q_blk.reserved;
+ blkres = &dqp->q_blk;
+ qlim = &defq->blk;
} else {
- ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
- hardlimit = dqp->q_rtb.hardlimit;
- if (!hardlimit)
- hardlimit = defq->rtb.hard;
- softlimit = dqp->q_rtb.softlimit;
- if (!softlimit)
- softlimit = defq->rtb.soft;
- timer = dqp->q_rtb.timer;
- warns = dqp->q_rtb.warnings;
- warnlimit = defq->rtb.warn;
- resbcountp = &dqp->q_rtb.reserved;
+ blkres = &dqp->q_rtb;
+ qlim = &defq->rtb;
}
if ((flags & XFS_QMOPT_FORCE_RES) == 0 && dqp->q_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) {
+ int quota_nl;
+ bool fatal;
+
+ /*
+ * dquot is locked already. See if we'd go over the hardlimit
+ * or exceed the timelimit if we'd reserve resources.
+ */
+ quota_nl = xfs_dqresv_check(blkres, qlim, nblks, &fatal);
+ if (quota_nl != QUOTA_NL_NOWARN) {
/*
- * dquot is locked already. See if we'd go over the
- * hardlimit or exceed the timelimit if we allocate
- * nblks.
+ * Quota block warning codes are 3 more than the inode
+ * codes, which we check above.
*/
- total_count = *resbcountp + nblks;
- if (hardlimit && total_count > hardlimit) {
- xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN);
+ xfs_quota_warn(mp, dqp, quota_nl + 3);
+ if (fatal)
goto error_return;
- }
- if (softlimit && total_count > softlimit) {
- if ((timer != 0 &&
- ktime_get_real_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 = dqp->q_ino.reserved + ninos;
- timer = dqp->q_ino.timer;
- warns = dqp->q_ino.warnings;
- warnlimit = defq->ino.warn;
- hardlimit = dqp->q_ino.hardlimit;
- if (!hardlimit)
- hardlimit = defq->ino.hard;
- softlimit = dqp->q_ino.softlimit;
- if (!softlimit)
- softlimit = defq->ino.soft;
- if (hardlimit && total_count > hardlimit) {
- xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
+ quota_nl = xfs_dqresv_check(&dqp->q_ino, &defq->ino, ninos,
+ &fatal);
+ if (quota_nl != QUOTA_NL_NOWARN) {
+ xfs_quota_warn(mp, dqp, quota_nl);
+ if (fatal)
goto error_return;
- }
- if (softlimit && total_count > softlimit) {
- if ((timer != 0 &&
- ktime_get_real_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);
- }
}
}
@@ -676,9 +680,8 @@ xfs_trans_dqresv(
* Change the reservation, but not the actual usage.
* Note that q_blk.reserved = q_blk.count + resv
*/
- (*resbcountp) += (xfs_qcnt_t)nblks;
- if (ninos != 0)
- dqp->q_ino.reserved += (xfs_qcnt_t)ninos;
+ blkres->reserved += (xfs_qcnt_t)nblks;
+ dqp->q_ino.reserved += (xfs_qcnt_t)ninos;
/*
* note the reservation amt in the trans struct too,
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 23/26] xfs: refactor xfs_trans_apply_dquot_deltas
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (21 preceding siblings ...)
2020-07-15 1:52 ` [PATCH 22/26] xfs: refactor xfs_trans_dqresv Darrick J. Wong
@ 2020-07-15 1:53 ` Darrick J. Wong
2020-07-15 1:53 ` [PATCH 24/26] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits Darrick J. Wong
` (2 subsequent siblings)
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:53 UTC (permalink / raw)
To: darrick.wong
Cc: Allison Collins, Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Hoist the code that adjusts the incore quota reservation count
adjustments into a separate function, both to reduce the level of
indentation and also to reduce the amount of open-coded logic.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_trans_dquot.c | 103 +++++++++++++++++++++-------------------------
1 file changed, 46 insertions(+), 57 deletions(-)
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index cce457ad220b..78201ff3696b 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -293,6 +293,37 @@ xfs_trans_dqlockedjoin(
}
}
+/* Apply dqtrx changes to the quota reservation counters. */
+static inline void
+xfs_apply_quota_reservation_deltas(
+ struct xfs_dquot_res *res,
+ uint64_t reserved,
+ int64_t res_used,
+ int64_t count_delta)
+{
+ if (reserved != 0) {
+ /*
+ * Subtle math here: If reserved > res_used (the normal case),
+ * we're simply subtracting the unused transaction quota
+ * reservation from the dquot reservation.
+ *
+ * If, however, res_used > reserved, then we have allocated
+ * more quota blocks than were reserved for the transaction.
+ * We must add that excess to the dquot reservation since it
+ * tracks (usage + resv) and by definition we didn't reserve
+ * that excess.
+ */
+ res->reserved -= abs(reserved - res_used);
+ } else if (count_delta != 0) {
+ /*
+ * 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.
+ */
+ res->reserved += count_delta;
+ }
+}
/*
* Called by xfs_trans_commit() and similar in spirit to
@@ -327,6 +358,8 @@ xfs_trans_apply_dquot_deltas(
xfs_trans_dqlockedjoin(tp, qa);
for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
+ uint64_t blk_res_used;
+
qtrx = &qa[i];
/*
* The array of dquots is filled
@@ -396,71 +429,27 @@ xfs_trans_apply_dquot_deltas(
* 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;
+ blk_res_used = max_t(int64_t, 0, qtrx->qt_bcount_delta);
+ xfs_apply_quota_reservation_deltas(&dqp->q_blk,
+ qtrx->qt_blk_res, blk_res_used,
+ qtrx->qt_bcount_delta);
- 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_blk.reserved -= (xfs_qcnt_t)
- (qtrx->qt_blk_res -
- blk_res_used);
- else
- dqp->q_blk.reserved -= (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_blk.reserved +=
- (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_rtb.reserved -= (xfs_qcnt_t)
- (qtrx->qt_rtblk_res -
- qtrx->qt_rtblk_res_used);
- else
- dqp->q_rtb.reserved -= (xfs_qcnt_t)
- (qtrx->qt_rtblk_res_used -
- qtrx->qt_rtblk_res);
- }
- } else {
- if (qtrx->qt_rtbcount_delta)
- dqp->q_rtb.reserved +=
- (xfs_qcnt_t)qtrx->qt_rtbcount_delta;
- }
+ xfs_apply_quota_reservation_deltas(&dqp->q_rtb,
+ qtrx->qt_rtblk_res,
+ qtrx->qt_rtblk_res_used,
+ 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_ino.reserved -= (xfs_qcnt_t)
- (qtrx->qt_ino_res -
- qtrx->qt_ino_res_used);
- } else {
- if (qtrx->qt_icount_delta)
- dqp->q_ino.reserved +=
- (xfs_qcnt_t)qtrx->qt_icount_delta;
- }
+ ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
+ xfs_apply_quota_reservation_deltas(&dqp->q_ino,
+ qtrx->qt_ino_res,
+ qtrx->qt_ino_res_used,
+ qtrx->qt_icount_delta);
ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
^ permalink raw reply related [flat|nested] 47+ messages in thread* [PATCH 24/26] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (22 preceding siblings ...)
2020-07-15 1:53 ` [PATCH 23/26] xfs: refactor xfs_trans_apply_dquot_deltas Darrick J. Wong
@ 2020-07-15 1:53 ` Darrick J. Wong
2020-07-20 5:38 ` Chandan Babu R
2020-07-15 1:53 ` [PATCH 25/26] xfs: actually bump warning counts when we send warnings Darrick J. Wong
2020-07-15 1:53 ` [PATCH 26/26] xfs: add more dquot tracepoints Darrick J. Wong
25 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:53 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
We always initialize the default quota limits to something nowadays, so
we don't need to check that the defaults are set to something before
using them.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_dquot.c | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index e44f80700005..2b52913073b3 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -77,21 +77,21 @@ xfs_qm_adjust_dqlimits(
ASSERT(dq->q_id);
defq = xfs_get_defquota(q, dq->q_type);
- if (defq->blk.soft && !dq->q_blk.softlimit) {
+ if (!dq->q_blk.softlimit) {
dq->q_blk.softlimit = defq->blk.soft;
prealloc = 1;
}
- if (defq->blk.hard && !dq->q_blk.hardlimit) {
+ if (!dq->q_blk.hardlimit) {
dq->q_blk.hardlimit = defq->blk.hard;
prealloc = 1;
}
- if (defq->ino.soft && !dq->q_ino.softlimit)
+ if (!dq->q_ino.softlimit)
dq->q_ino.softlimit = defq->ino.soft;
- if (defq->ino.hard && !dq->q_ino.hardlimit)
+ if (!dq->q_ino.hardlimit)
dq->q_ino.hardlimit = defq->ino.hard;
- if (defq->rtb.soft && !dq->q_rtb.softlimit)
+ if (!dq->q_rtb.softlimit)
dq->q_rtb.softlimit = defq->rtb.soft;
- if (defq->rtb.hard && !dq->q_rtb.hardlimit)
+ if (!dq->q_rtb.hardlimit)
dq->q_rtb.hardlimit = defq->rtb.hard;
if (prealloc)
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 24/26] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits
2020-07-15 1:53 ` [PATCH 24/26] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits Darrick J. Wong
@ 2020-07-20 5:38 ` Chandan Babu R
0 siblings, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-20 5:38 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:23:11 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> We always initialize the default quota limits to something nowadays, so
> we don't need to check that the defaults are set to something before
> using them.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/xfs_dquot.c | 12 ++++++------
> 1 file changed, 6 insertions(+), 6 deletions(-)
>
>
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index e44f80700005..2b52913073b3 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -77,21 +77,21 @@ xfs_qm_adjust_dqlimits(
> ASSERT(dq->q_id);
> defq = xfs_get_defquota(q, dq->q_type);
>
> - if (defq->blk.soft && !dq->q_blk.softlimit) {
> + if (!dq->q_blk.softlimit) {
> dq->q_blk.softlimit = defq->blk.soft;
> prealloc = 1;
> }
> - if (defq->blk.hard && !dq->q_blk.hardlimit) {
> + if (!dq->q_blk.hardlimit) {
> dq->q_blk.hardlimit = defq->blk.hard;
> prealloc = 1;
> }
> - if (defq->ino.soft && !dq->q_ino.softlimit)
> + if (!dq->q_ino.softlimit)
> dq->q_ino.softlimit = defq->ino.soft;
> - if (defq->ino.hard && !dq->q_ino.hardlimit)
> + if (!dq->q_ino.hardlimit)
> dq->q_ino.hardlimit = defq->ino.hard;
> - if (defq->rtb.soft && !dq->q_rtb.softlimit)
> + if (!dq->q_rtb.softlimit)
> dq->q_rtb.softlimit = defq->rtb.soft;
> - if (defq->rtb.hard && !dq->q_rtb.hardlimit)
> + if (!dq->q_rtb.hardlimit)
> dq->q_rtb.hardlimit = defq->rtb.hard;
>
> if (prealloc)
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 25/26] xfs: actually bump warning counts when we send warnings
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (23 preceding siblings ...)
2020-07-15 1:53 ` [PATCH 24/26] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits Darrick J. Wong
@ 2020-07-15 1:53 ` Darrick J. Wong
2020-07-20 5:38 ` Chandan Babu R
2022-03-01 19:31 ` Quota warning woes (was: [PATCH 25/26] xfs: actually bump warning counts when we send warnings) Eric Sandeen
2020-07-15 1:53 ` [PATCH 26/26] xfs: add more dquot tracepoints Darrick J. Wong
25 siblings, 2 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:53 UTC (permalink / raw)
To: darrick.wong; +Cc: Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Currently, xfs quotas have the ability to send netlink warnings when a
user exceeds the limits. They also have all the support code necessary
to convert softlimit warnings into failures if the number of warnings
exceeds a limit set by the administrator. Unfortunately, we never
actually increase the warning counter, so this never actually happens.
Make it so we actually do something useful with the warning counts.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_trans_dquot.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 78201ff3696b..cbd92d8b693d 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -596,6 +596,7 @@ xfs_dqresv_check(
return QUOTA_NL_ISOFTLONGWARN;
}
+ res->warnings++;
return QUOTA_NL_ISOFTWARN;
}
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 25/26] xfs: actually bump warning counts when we send warnings
2020-07-15 1:53 ` [PATCH 25/26] xfs: actually bump warning counts when we send warnings Darrick J. Wong
@ 2020-07-20 5:38 ` Chandan Babu R
2022-03-01 19:31 ` Quota warning woes (was: [PATCH 25/26] xfs: actually bump warning counts when we send warnings) Eric Sandeen
1 sibling, 0 replies; 47+ messages in thread
From: Chandan Babu R @ 2020-07-20 5:38 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wednesday 15 July 2020 7:23:18 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Currently, xfs quotas have the ability to send netlink warnings when a
> user exceeds the limits. They also have all the support code necessary
> to convert softlimit warnings into failures if the number of warnings
> exceeds a limit set by the administrator. Unfortunately, we never
> actually increase the warning counter, so this never actually happens.
> Make it so we actually do something useful with the warning counts.
>
The changes look good to me.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/xfs_trans_dquot.c | 1 +
> 1 file changed, 1 insertion(+)
>
>
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index 78201ff3696b..cbd92d8b693d 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -596,6 +596,7 @@ xfs_dqresv_check(
> return QUOTA_NL_ISOFTLONGWARN;
> }
>
> + res->warnings++;
> return QUOTA_NL_ISOFTWARN;
> }
>
>
>
--
chandan
^ permalink raw reply [flat|nested] 47+ messages in thread
* Quota warning woes (was: [PATCH 25/26] xfs: actually bump warning counts when we send warnings)
2020-07-15 1:53 ` [PATCH 25/26] xfs: actually bump warning counts when we send warnings Darrick J. Wong
2020-07-20 5:38 ` Chandan Babu R
@ 2022-03-01 19:31 ` Eric Sandeen
2022-03-02 18:19 ` Eric Sandeen
1 sibling, 1 reply; 47+ messages in thread
From: Eric Sandeen @ 2022-03-01 19:31 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On 7/14/20 8:53 PM, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Currently, xfs quotas have the ability to send netlink warnings when a
> user exceeds the limits. They also have all the support code necessary
> to convert softlimit warnings into failures if the number of warnings
> exceeds a limit set by the administrator. Unfortunately, we never
> actually increase the warning counter, so this never actually happens.
> Make it so we actually do something useful with the warning counts.
>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
Sooo I got a bug report that this essentially breaks the timer for
soft quota, because we now (and quite rapidly) hit the default
5-warning limit well before we hit any reasonable timer that may
have been set, and disallow more space usage.
And those warnings rack up in somewhat unexpected (to me, anyway)
ways. With a default max warning count of 5, I go over soft quota
exactly once, touch/create 2 more empty inodes, and I'm done:
# rm -f /mnt/xfs/*
# xfs_quota -x -c 'report -h' /mnt/xfs
User quota on /mnt/xfs (/dev/loop1)
Blocks
User ID Used Soft Hard Warn/Grace
---------- ---------------------------------
root 0 0 0 05 [0 days]
quota_test 0 1M 550M 00 [------]
# sudo -u quota_test dd bs=1100k count=1 if=/dev/zero of=/mnt/xfs/test
1126400 bytes (1.1 MB) copied, 0.00136115 s, 828 MB/s
# xfs_quota -x -c 'report -h' /mnt/xfs
User quota on /mnt/xfs (/dev/loop1)
Blocks
User ID Used Soft Hard Warn/Grace
---------- ---------------------------------
root 0 0 0 05 [0 days]
quota_test 1.1M 1M 550M 01 [------]
# sudo -u quota_test touch /mnt/xfs/a
# xfs_quota -x -c 'report -h' /mnt/xfs
User quota on /mnt/xfs (/dev/loop1)
Blocks
User ID Used Soft Hard Warn/Grace
---------- ---------------------------------
root 0 0 0 05 [0 days]
quota_test 1.1M 1M 550M 03 [6 days]
# sudo -u quota_test touch /mnt/xfs/b
# xfs_quota -x -c 'report -h' /mnt/xfs
User quota on /mnt/xfs (/dev/loop1)
Blocks
User ID Used Soft Hard Warn/Grace
---------- ---------------------------------
root 0 0 0 05 [0 days]
quota_test 1.1M 1M 550M 05 [6 days]
# sudo -u quota_test touch /mnt/xfs/c
touch: cannot touch ‘/mnt/xfs/c’: Disk quota exceeded
And the xfs_quota manpage doesn't even say that this is supposed
to be a transition to a hard limit, although the code does seem
to think so ...
"Allows the quota warnings limit (i.e. the number of times a warning
will be send to someone over quota) to be viewed and modified."
There are other oddities too, like a (default) 0 day timer means
"no timer" but a 0 warning count means "you get no warnings.
you're done when you hit the soft quota."
And the xfs_quota interface for setting the warnings is unexpectedly
different from the interface for timers, as well.
So ... thoughts?
TBH I'd almost suggest reverting the increment until this is sorted,
but I presume you changed this for a reason. :) (And it's been there
a pretty long time, now.)
Thanks,
-Erifc
^ permalink raw reply [flat|nested] 47+ messages in thread* Re: Quota warning woes (was: [PATCH 25/26] xfs: actually bump warning counts when we send warnings)
2022-03-01 19:31 ` Quota warning woes (was: [PATCH 25/26] xfs: actually bump warning counts when we send warnings) Eric Sandeen
@ 2022-03-02 18:19 ` Eric Sandeen
2022-03-03 0:38 ` Darrick J. Wong
0 siblings, 1 reply; 47+ messages in thread
From: Eric Sandeen @ 2022-03-02 18:19 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On 3/1/22 1:31 PM, Eric Sandeen wrote:
> On 7/14/20 8:53 PM, Darrick J. Wong wrote:
>> From: Darrick J. Wong <darrick.wong@oracle.com>
>>
>> Currently, xfs quotas have the ability to send netlink warnings when a
>> user exceeds the limits. They also have all the support code necessary
>> to convert softlimit warnings into failures if the number of warnings
>> exceeds a limit set by the administrator. Unfortunately, we never
>> actually increase the warning counter, so this never actually happens.
>> Make it so we actually do something useful with the warning counts.
>>
>> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
>> Reviewed-by: Christoph Hellwig <hch@lst.de>
>
> Sooo I got a bug report that this essentially breaks the timer for
> soft quota, because we now (and quite rapidly) hit the default
> 5-warning limit well before we hit any reasonable timer that may
> have been set, and disallow more space usage.
>
> And those warnings rack up in somewhat unexpected (to me, anyway)
> ways. With a default max warning count of 5, I go over soft quota
> exactly once, touch/create 2 more empty inodes, and I'm done:
Looking at this some more, I think it was never clear when the warnings
should get incremented. An old IRIX document[1] says:
"With soft limits, whenever a user logs in with a usage greater than his
soft limit, he or she will be warned (via/bin/login(1))."
Which seems to indicate that perhaps the warning was intended to be
once per login, not once per allocation attempt. Also ...
Ancient XFS code had a "xfs_qm_dqwarn()" function which incremented the
warning count, but it never had any callers until the day it was removed
in 2005, so it's not at all clear what the warning frequency was supposed
to be or what should trigger it, from the code archives.
Hence, my modest proposal would be to just remove the warning limits
infrastructure altogether. It's never worked, nobody has ever asked for it
(?), and its intent is not clear. My only hesitation is that Darrick added
the warning increment, so perhaps he knows of a current use case that
matters?
thanks,
-Eric
[1] https://irix7.com/techpubs/007-0603-100.pdf
^ permalink raw reply [flat|nested] 47+ messages in thread
* Re: Quota warning woes (was: [PATCH 25/26] xfs: actually bump warning counts when we send warnings)
2022-03-02 18:19 ` Eric Sandeen
@ 2022-03-03 0:38 ` Darrick J. Wong
0 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2022-03-03 0:38 UTC (permalink / raw)
To: Eric Sandeen; +Cc: Darrick J. Wong, Christoph Hellwig, linux-xfs
On Wed, Mar 02, 2022 at 12:19:21PM -0600, Eric Sandeen wrote:
> On 3/1/22 1:31 PM, Eric Sandeen wrote:
> > On 7/14/20 8:53 PM, Darrick J. Wong wrote:
> >> From: Darrick J. Wong <darrick.wong@oracle.com>
> >>
> >> Currently, xfs quotas have the ability to send netlink warnings when a
> >> user exceeds the limits. They also have all the support code necessary
> >> to convert softlimit warnings into failures if the number of warnings
> >> exceeds a limit set by the administrator. Unfortunately, we never
> >> actually increase the warning counter, so this never actually happens.
> >> Make it so we actually do something useful with the warning counts.
> >>
> >> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> >> Reviewed-by: Christoph Hellwig <hch@lst.de>
> >
> > Sooo I got a bug report that this essentially breaks the timer for
> > soft quota, because we now (and quite rapidly) hit the default
> > 5-warning limit well before we hit any reasonable timer that may
> > have been set, and disallow more space usage.
> >
> > And those warnings rack up in somewhat unexpected (to me, anyway)
> > ways. With a default max warning count of 5, I go over soft quota
> > exactly once, touch/create 2 more empty inodes, and I'm done:
>
> Looking at this some more, I think it was never clear when the warnings
> should get incremented. An old IRIX document[1] says:
>
> "With soft limits, whenever a user logs in with a usage greater than his
> soft limit, he or she will be warned (via/bin/login(1))."
>
> Which seems to indicate that perhaps the warning was intended to be
> once per login, not once per allocation attempt. Also ...
>
> Ancient XFS code had a "xfs_qm_dqwarn()" function which incremented the
> warning count, but it never had any callers until the day it was removed
> in 2005, so it's not at all clear what the warning frequency was supposed
> to be or what should trigger it, from the code archives.
>
> Hence, my modest proposal would be to just remove the warning limits
> infrastructure altogether. It's never worked, nobody has ever asked for it
> (?), and its intent is not clear. My only hesitation is that Darrick added
> the warning increment, so perhaps he knows of a current use case that
> matters?
None specifically, but it's a feature, albeit a poorly documented and
previously broken one. VFS quotas don't seem to have any warning
limits, so I suppose there's not a lot of precedent to go on.
That said -- I don't how gutting a feature (especially since it's now
been *working* for a year and a half) is the solution here. If you
think the default warning limit is too low, then perhaps we should
increase it. If you don't like that a single user operation can bump
the warning counter multiple times, then propose adding a flag to the
dqtrx structure so that we only bump the warning counter *once* per
transaction. "It's never worked" is not true -- this fix was added for
5.9, and it's now shipped in two LTS kernels.
On the other hand, if you think this feature is totally worthless and it
should go away, there's a deprecation process for that.
--D
>
> thanks,
> -Eric
>
> [1] https://irix7.com/techpubs/007-0603-100.pdf
^ permalink raw reply [flat|nested] 47+ messages in thread
* [PATCH 26/26] xfs: add more dquot tracepoints
2020-07-15 1:50 [PATCH v4 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (24 preceding siblings ...)
2020-07-15 1:53 ` [PATCH 25/26] xfs: actually bump warning counts when we send warnings Darrick J. Wong
@ 2020-07-15 1:53 ` Darrick J. Wong
25 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 1:53 UTC (permalink / raw)
To: darrick.wong
Cc: Allison Collins, Chandan Babu R, Christoph Hellwig, linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Add all the xfs_dquot fields to the tracepoint for that type; add a new
tracepoint type for the qtrx structure (dquot transaction deltas); and
use our new tracepoints. This makes it easier for the author to trace
changes to dquot counters for debugging.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Allison Collins <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_trace.h | 145 +++++++++++++++++++++++++++++++++++++++++++++-
fs/xfs/xfs_trans_dquot.c | 21 +++++++
2 files changed, 164 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index b6541f7d1b7d..31438da52724 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -36,6 +36,7 @@ struct xfs_owner_info;
struct xfs_trans_res;
struct xfs_inobt_rec_incore;
union xfs_btree_ptr;
+struct xfs_dqtrx;
#define XFS_ATTR_FILTER_FLAGS \
{ XFS_ATTR_ROOT, "ROOT" }, \
@@ -868,29 +869,46 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__field(unsigned, flags)
__field(unsigned, nrefs)
__field(unsigned long long, res_bcount)
+ __field(unsigned long long, res_rtbcount)
+ __field(unsigned long long, res_icount)
+
__field(unsigned long long, bcount)
+ __field(unsigned long long, rtbcount)
__field(unsigned long long, icount)
+
__field(unsigned long long, blk_hardlimit)
__field(unsigned long long, blk_softlimit)
+ __field(unsigned long long, rtb_hardlimit)
+ __field(unsigned long long, rtb_softlimit)
__field(unsigned long long, ino_hardlimit)
__field(unsigned long long, ino_softlimit)
- ), \
+ ),
TP_fast_assign(
__entry->dev = dqp->q_mount->m_super->s_dev;
__entry->id = dqp->q_id;
__entry->type = dqp->q_type;
__entry->flags = dqp->q_flags;
__entry->nrefs = dqp->q_nrefs;
+
__entry->res_bcount = dqp->q_blk.reserved;
+ __entry->res_rtbcount = dqp->q_rtb.reserved;
+ __entry->res_icount = dqp->q_ino.reserved;
+
__entry->bcount = dqp->q_blk.count;
+ __entry->rtbcount = dqp->q_rtb.count;
__entry->icount = dqp->q_ino.count;
+
__entry->blk_hardlimit = dqp->q_blk.hardlimit;
__entry->blk_softlimit = dqp->q_blk.softlimit;
+ __entry->rtb_hardlimit = dqp->q_rtb.hardlimit;
+ __entry->rtb_softlimit = dqp->q_rtb.softlimit;
__entry->ino_hardlimit = dqp->q_ino.hardlimit;
__entry->ino_softlimit = dqp->q_ino.softlimit;
),
- TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u res_bc 0x%llx "
+ TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u "
+ "res_bc 0x%llx res_rtbc 0x%llx res_ic 0x%llx "
"bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
+ "rtbcnt 0x%llx rtbhardlimit 0x%llx rtbsoftlimit 0x%llx "
"icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->id,
@@ -898,9 +916,14 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
__entry->nrefs,
__entry->res_bcount,
+ __entry->res_rtbcount,
+ __entry->res_icount,
__entry->bcount,
__entry->blk_hardlimit,
__entry->blk_softlimit,
+ __entry->rtbcount,
+ __entry->rtb_hardlimit,
+ __entry->rtb_softlimit,
__entry->icount,
__entry->ino_hardlimit,
__entry->ino_softlimit)
@@ -931,6 +954,124 @@ DEFINE_DQUOT_EVENT(xfs_dqrele);
DEFINE_DQUOT_EVENT(xfs_dqflush);
DEFINE_DQUOT_EVENT(xfs_dqflush_force);
DEFINE_DQUOT_EVENT(xfs_dqflush_done);
+DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_before);
+DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_after);
+
+#define XFS_QMOPT_FLAGS \
+ { XFS_QMOPT_UQUOTA, "UQUOTA" }, \
+ { XFS_QMOPT_PQUOTA, "PQUOTA" }, \
+ { XFS_QMOPT_FORCE_RES, "FORCE_RES" }, \
+ { XFS_QMOPT_SBVERSION, "SBVERSION" }, \
+ { XFS_QMOPT_GQUOTA, "GQUOTA" }, \
+ { XFS_QMOPT_INHERIT, "INHERIT" }, \
+ { XFS_QMOPT_RES_REGBLKS, "RES_REGBLKS" }, \
+ { XFS_QMOPT_RES_RTBLKS, "RES_RTBLKS" }, \
+ { XFS_QMOPT_BCOUNT, "BCOUNT" }, \
+ { XFS_QMOPT_ICOUNT, "ICOUNT" }, \
+ { XFS_QMOPT_RTBCOUNT, "RTBCOUNT" }, \
+ { XFS_QMOPT_DELBCOUNT, "DELBCOUNT" }, \
+ { XFS_QMOPT_DELRTBCOUNT, "DELRTBCOUNT" }, \
+ { XFS_QMOPT_RES_INOS, "RES_INOS" }
+
+TRACE_EVENT(xfs_trans_mod_dquot,
+ TP_PROTO(struct xfs_trans *tp, struct xfs_dquot *dqp,
+ unsigned int field, int64_t delta),
+ TP_ARGS(tp, dqp, field, delta),
+ TP_STRUCT__entry(
+ __field(dev_t, dev)
+ __field(xfs_dqtype_t, type)
+ __field(unsigned int, flags)
+ __field(unsigned int, dqid)
+ __field(unsigned int, field)
+ __field(int64_t, delta)
+ ),
+ TP_fast_assign(
+ __entry->dev = tp->t_mountp->m_super->s_dev;
+ __entry->type = dqp->q_type;
+ __entry->flags = dqp->q_flags;
+ __entry->dqid = dqp->q_id;
+ __entry->field = field;
+ __entry->delta = delta;
+ ),
+ TP_printk("dev %d:%d dquot id 0x%x type %s flags %s field %s delta %lld",
+ MAJOR(__entry->dev), MINOR(__entry->dev),
+ __entry->dqid,
+ __print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
+ __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS),
+ __print_flags(__entry->field, "|", XFS_QMOPT_FLAGS),
+ __entry->delta)
+);
+
+DECLARE_EVENT_CLASS(xfs_dqtrx_class,
+ TP_PROTO(struct xfs_dqtrx *qtrx),
+ TP_ARGS(qtrx),
+ TP_STRUCT__entry(
+ __field(dev_t, dev)
+ __field(xfs_dqtype_t, type)
+ __field(unsigned int, flags)
+ __field(u32, dqid)
+
+ __field(uint64_t, blk_res)
+ __field(int64_t, bcount_delta)
+ __field(int64_t, delbcnt_delta)
+
+ __field(uint64_t, rtblk_res)
+ __field(uint64_t, rtblk_res_used)
+ __field(int64_t, rtbcount_delta)
+ __field(int64_t, delrtb_delta)
+
+ __field(uint64_t, ino_res)
+ __field(uint64_t, ino_res_used)
+ __field(int64_t, icount_delta)
+ ),
+ TP_fast_assign(
+ __entry->dev = qtrx->qt_dquot->q_mount->m_super->s_dev;
+ __entry->type = qtrx->qt_dquot->q_type;
+ __entry->flags = qtrx->qt_dquot->q_flags;
+ __entry->dqid = qtrx->qt_dquot->q_id;
+
+ __entry->blk_res = qtrx->qt_blk_res;
+ __entry->bcount_delta = qtrx->qt_bcount_delta;
+ __entry->delbcnt_delta = qtrx->qt_delbcnt_delta;
+
+ __entry->rtblk_res = qtrx->qt_rtblk_res;
+ __entry->rtblk_res_used = qtrx->qt_rtblk_res_used;
+ __entry->rtbcount_delta = qtrx->qt_rtbcount_delta;
+ __entry->delrtb_delta = qtrx->qt_delrtb_delta;
+
+ __entry->ino_res = qtrx->qt_ino_res;
+ __entry->ino_res_used = qtrx->qt_ino_res_used;
+ __entry->icount_delta = qtrx->qt_icount_delta;
+ ),
+ TP_printk("dev %d:%d dquot id 0x%x type %s"
+ "blk_res %llu bcount_delta %lld delbcnt_delta %lld "
+ "rtblk_res %llu rtblk_res_used %llu rtbcount_delta %lld delrtb_delta %lld "
+ "ino_res %llu ino_res_used %llu icount_delta %lld",
+ MAJOR(__entry->dev), MINOR(__entry->dev),
+ __entry->dqid,
+ __print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
+
+ __entry->blk_res,
+ __entry->bcount_delta,
+ __entry->delbcnt_delta,
+
+ __entry->rtblk_res,
+ __entry->rtblk_res_used,
+ __entry->rtbcount_delta,
+ __entry->delrtb_delta,
+
+ __entry->ino_res,
+ __entry->ino_res_used,
+ __entry->icount_delta)
+)
+
+#define DEFINE_DQTRX_EVENT(name) \
+DEFINE_EVENT(xfs_dqtrx_class, name, \
+ TP_PROTO(struct xfs_dqtrx *qtrx), \
+ TP_ARGS(qtrx))
+DEFINE_DQTRX_EVENT(xfs_trans_apply_dquot_deltas);
+DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_before);
+DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_after);
DECLARE_EVENT_CLASS(xfs_loggrant_class,
TP_PROTO(struct xlog *log, struct xlog_ticket *tic),
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index cbd92d8b693d..6e0eabbbd3ba 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -15,6 +15,7 @@
#include "xfs_trans_priv.h"
#include "xfs_quota.h"
#include "xfs_qm.h"
+#include "xfs_trace.h"
STATIC void xfs_trans_alloc_dqinfo(xfs_trans_t *);
@@ -203,6 +204,11 @@ xfs_trans_mod_dquot(
if (qtrx->qt_dquot == NULL)
qtrx->qt_dquot = dqp;
+ if (delta) {
+ trace_xfs_trans_mod_dquot_before(qtrx);
+ trace_xfs_trans_mod_dquot(tp, dqp, field, delta);
+ }
+
switch (field) {
/*
@@ -266,6 +272,10 @@ xfs_trans_mod_dquot(
default:
ASSERT(0);
}
+
+ if (delta)
+ trace_xfs_trans_mod_dquot_after(qtrx);
+
tp->t_flags |= XFS_TRANS_DQ_DIRTY;
}
@@ -391,6 +401,13 @@ xfs_trans_apply_dquot_deltas(
qtrx->qt_delbcnt_delta;
totalrtbdelta = qtrx->qt_rtbcount_delta +
qtrx->qt_delrtb_delta;
+
+ if (totalbdelta != 0 || totalrtbdelta != 0 ||
+ qtrx->qt_icount_delta != 0) {
+ trace_xfs_trans_apply_dquot_deltas_before(dqp);
+ trace_xfs_trans_apply_dquot_deltas(qtrx);
+ }
+
#ifdef DEBUG
if (totalbdelta < 0)
ASSERT(dqp->q_blk.count >= -totalbdelta);
@@ -410,6 +427,10 @@ xfs_trans_apply_dquot_deltas(
if (totalrtbdelta)
dqp->q_rtb.count += totalrtbdelta;
+ if (totalbdelta != 0 || totalrtbdelta != 0 ||
+ qtrx->qt_icount_delta != 0)
+ trace_xfs_trans_apply_dquot_deltas_after(dqp);
+
/*
* Get any default limits in use.
* Start/reset the timer(s) if needed.
^ permalink raw reply related [flat|nested] 47+ messages in thread
* [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-14 1:31 [PATCH v3 00/26] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
@ 2020-07-14 1:32 ` Darrick J. Wong
2020-07-14 7:57 ` Christoph Hellwig
0 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-14 1:32 UTC (permalink / raw)
To: darrick.wong; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Create a new type (xfs_dqtype_t) to represent the type of an incore
dquot. Break the type field out from the dq_flags field of the incore
dquot.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_dquot_buf.c | 24 +++++++----
fs/xfs/libxfs/xfs_quota_defs.h | 36 +++++++++++++++--
fs/xfs/scrub/quota.c | 19 +++++----
fs/xfs/scrub/repair.c | 10 ++---
fs/xfs/scrub/repair.h | 4 +-
fs/xfs/xfs_buf_item_recover.c | 2 -
fs/xfs/xfs_dquot.c | 78 ++++++++++++++++++++----------------
fs/xfs/xfs_dquot.h | 63 +++++++++++++++++------------
fs/xfs/xfs_dquot_item_recover.c | 2 -
fs/xfs/xfs_icache.c | 4 +-
fs/xfs/xfs_iomap.c | 36 ++++++++---------
fs/xfs/xfs_qm.c | 84 ++++++++++++++++++++-------------------
fs/xfs/xfs_qm.h | 55 ++++++++++++--------------
fs/xfs/xfs_qm_bhv.c | 2 -
fs/xfs/xfs_qm_syscalls.c | 25 +++++-------
fs/xfs/xfs_quota.h | 10 ++---
fs/xfs/xfs_quotaops.c | 8 ++--
fs/xfs/xfs_trace.h | 5 ++
fs/xfs/xfs_trans_dquot.c | 17 ++++++--
19 files changed, 270 insertions(+), 214 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index bedc1e752b60..910c4066d11b 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -38,8 +38,10 @@ xfs_dquot_verify(
struct xfs_mount *mp,
struct xfs_disk_dquot *ddq,
xfs_dqid_t id,
- uint type) /* used only during quotacheck */
+ xfs_dqtype_t type) /* used only during quotacheck */
{
+ uint8_t ddq_type;
+
/*
* We can encounter an uninitialized dquot buffer for 2 reasons:
* 1. If we crash while deleting the quotainode(s), and those blks got
@@ -60,11 +62,13 @@ xfs_dquot_verify(
if (ddq->d_version != XFS_DQUOT_VERSION)
return __this_address;
- if (type && ddq->d_flags != type)
+ ddq_type = ddq->d_flags & XFS_DQ_ALLTYPES;
+ if (type != XFS_DQTYPE_NONE &&
+ ddq_type != xfs_dquot_type_to_disk(type))
return __this_address;
- if (ddq->d_flags != XFS_DQ_USER &&
- ddq->d_flags != XFS_DQ_PROJ &&
- ddq->d_flags != XFS_DQ_GROUP)
+ if (ddq_type != XFS_DQ_USER &&
+ ddq_type != XFS_DQ_PROJ &&
+ ddq_type != XFS_DQ_GROUP)
return __this_address;
if (id != -1 && id != be32_to_cpu(ddq->d_id))
@@ -95,8 +99,8 @@ xfs_failaddr_t
xfs_dqblk_verify(
struct xfs_mount *mp,
struct xfs_dqblk *dqb,
- xfs_dqid_t id,
- uint type) /* used only during quotacheck */
+ xfs_dqid_t id,
+ xfs_dqtype_t type) /* used only during quotacheck */
{
if (xfs_sb_version_hascrc(&mp->m_sb) &&
!uuid_equal(&dqb->dd_uuid, &mp->m_sb.sb_meta_uuid))
@@ -113,7 +117,7 @@ xfs_dqblk_repair(
struct xfs_mount *mp,
struct xfs_dqblk *dqb,
xfs_dqid_t id,
- uint type)
+ xfs_dqtype_t type)
{
/*
* Typically, a repair is only requested by quotacheck.
@@ -123,7 +127,7 @@ xfs_dqblk_repair(
dqb->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
dqb->dd_diskdq.d_version = XFS_DQUOT_VERSION;
- dqb->dd_diskdq.d_flags = type;
+ dqb->dd_diskdq.d_flags = xfs_dquot_type_to_disk(type);
dqb->dd_diskdq.d_id = cpu_to_be32(id);
if (xfs_sb_version_hascrc(&mp->m_sb)) {
@@ -205,7 +209,7 @@ xfs_dquot_buf_verify(
if (i == 0)
id = be32_to_cpu(ddq->d_id);
- fa = xfs_dqblk_verify(mp, &dqb[i], id + i, 0);
+ fa = xfs_dqblk_verify(mp, &dqb[i], id + i, XFS_DQTYPE_NONE);
if (fa) {
if (!readahead)
xfs_buf_verifier_error(bp, -EFSCORRUPTED,
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 56d9dd787e7b..0285252b0c23 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -18,6 +18,19 @@
typedef uint64_t xfs_qcnt_t;
typedef uint16_t xfs_qwarncnt_t;
+typedef uint8_t xfs_dqtype_t;
+
+#define XFS_DQTYPE_NONE (0)
+#define XFS_DQTYPE_USER (1)
+#define XFS_DQTYPE_PROJ (2)
+#define XFS_DQTYPE_GROUP (3)
+
+#define XFS_DQTYPE_STRINGS \
+ { XFS_DQTYPE_NONE, "NONE?" }, \
+ { XFS_DQTYPE_USER, "USER" }, \
+ { XFS_DQTYPE_PROJ, "PROJ" }, \
+ { XFS_DQTYPE_GROUP, "GROUP" }
+
/*
* flags for q_flags field in the dquot.
*/
@@ -36,6 +49,23 @@ typedef uint16_t xfs_qwarncnt_t;
{ XFS_DQ_DIRTY, "DIRTY" }, \
{ XFS_DQ_FREEING, "FREEING" }
+static inline __u8
+xfs_dquot_type_to_disk(
+ xfs_dqtype_t type)
+{
+ switch (type) {
+ case XFS_DQTYPE_USER:
+ return XFS_DQ_USER;
+ case XFS_DQTYPE_GROUP:
+ return XFS_DQ_GROUP;
+ case XFS_DQTYPE_PROJ:
+ return XFS_DQ_PROJ;
+ default:
+ ASSERT(0);
+ return 0;
+ }
+}
+
/*
* We have the possibility of all three quota types being active at once, and
* hence free space modification requires modification of all three current
@@ -137,11 +167,11 @@ typedef uint16_t xfs_qwarncnt_t;
#define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
extern xfs_failaddr_t xfs_dquot_verify(struct xfs_mount *mp,
- struct xfs_disk_dquot *ddq, xfs_dqid_t id, uint type);
+ struct xfs_disk_dquot *ddq, xfs_dqid_t id, xfs_dqtype_t type);
extern xfs_failaddr_t xfs_dqblk_verify(struct xfs_mount *mp,
- struct xfs_dqblk *dqb, xfs_dqid_t id, uint type);
+ struct xfs_dqblk *dqb, xfs_dqid_t id, xfs_dqtype_t type);
extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
extern void xfs_dqblk_repair(struct xfs_mount *mp, struct xfs_dqblk *dqb,
- xfs_dqid_t id, uint type);
+ xfs_dqid_t id, xfs_dqtype_t type);
#endif /* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 905a34558361..b665b62c43fe 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -18,19 +18,20 @@
#include "scrub/common.h"
/* Convert a scrub type code to a DQ flag, or return 0 if error. */
-static inline uint
+static inline xfs_dqtype_t
xchk_quota_to_dqtype(
struct xfs_scrub *sc)
{
switch (sc->sm->sm_type) {
case XFS_SCRUB_TYPE_UQUOTA:
- return XFS_DQ_USER;
+ return XFS_DQTYPE_USER;
case XFS_SCRUB_TYPE_GQUOTA:
- return XFS_DQ_GROUP;
+ return XFS_DQTYPE_GROUP;
case XFS_SCRUB_TYPE_PQUOTA:
- return XFS_DQ_PROJ;
+ return XFS_DQTYPE_PROJ;
default:
- return 0;
+ ASSERT(0);
+ return XFS_DQTYPE_NONE;
}
}
@@ -40,7 +41,7 @@ xchk_setup_quota(
struct xfs_scrub *sc,
struct xfs_inode *ip)
{
- uint dqtype;
+ xfs_dqtype_t dqtype;
int error;
if (!XFS_IS_QUOTA_RUNNING(sc->mp) || !XFS_IS_QUOTA_ON(sc->mp))
@@ -73,7 +74,7 @@ struct xchk_quota_info {
STATIC int
xchk_quota_item(
struct xfs_dquot *dq,
- uint dqtype,
+ xfs_dqtype_t dqtype,
void *priv)
{
struct xchk_quota_info *sqi = priv;
@@ -109,7 +110,7 @@ xchk_quota_item(
sqi->last_id = id;
/* Did we get the dquot type we wanted? */
- if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
+ if (d->d_flags != xfs_dquot_type_to_disk(dqtype))
xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
@@ -235,7 +236,7 @@ xchk_quota(
struct xchk_quota_info sqi;
struct xfs_mount *mp = sc->mp;
struct xfs_quotainfo *qi = mp->m_quotainfo;
- uint dqtype;
+ xfs_dqtype_t dqtype;
int error = 0;
dqtype = xchk_quota_to_dqtype(sc);
diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
index db3cfd12803d..25e86c71e7b9 100644
--- a/fs/xfs/scrub/repair.c
+++ b/fs/xfs/scrub/repair.c
@@ -899,11 +899,11 @@ xrep_find_ag_btree_roots(
void
xrep_force_quotacheck(
struct xfs_scrub *sc,
- uint dqtype)
+ xfs_dqtype_t type)
{
uint flag;
- flag = xfs_quota_chkd_flag(dqtype);
+ flag = xfs_quota_chkd_flag(type);
if (!(flag & sc->mp->m_qflags))
return;
@@ -939,11 +939,11 @@ xrep_ino_dqattach(
"inode %llu repair encountered quota error %d, quotacheck forced.",
(unsigned long long)sc->ip->i_ino, error);
if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
- xrep_force_quotacheck(sc, XFS_DQ_USER);
+ xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
- xrep_force_quotacheck(sc, XFS_DQ_GROUP);
+ xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
- xrep_force_quotacheck(sc, XFS_DQ_PROJ);
+ xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
/* fall through */
case -ESRCH:
error = 0;
diff --git a/fs/xfs/scrub/repair.h b/fs/xfs/scrub/repair.h
index 04a47d45605b..fe77de01abe0 100644
--- a/fs/xfs/scrub/repair.h
+++ b/fs/xfs/scrub/repair.h
@@ -6,6 +6,8 @@
#ifndef __XFS_SCRUB_REPAIR_H__
#define __XFS_SCRUB_REPAIR_H__
+#include "xfs_quota_defs.h"
+
static inline int xrep_notsupported(struct xfs_scrub *sc)
{
return -EOPNOTSUPP;
@@ -49,7 +51,7 @@ struct xrep_find_ag_btree {
int xrep_find_ag_btree_roots(struct xfs_scrub *sc, struct xfs_buf *agf_bp,
struct xrep_find_ag_btree *btree_info, struct xfs_buf *agfl_bp);
-void xrep_force_quotacheck(struct xfs_scrub *sc, uint dqtype);
+void xrep_force_quotacheck(struct xfs_scrub *sc, xfs_dqtype_t type);
int xrep_ino_dqattach(struct xfs_scrub *sc);
/* Metadata repairers */
diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index 74c851f60eee..682d1ed78894 100644
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -494,7 +494,7 @@ xlog_recover_do_reg_buffer(
goto next;
}
fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr,
- -1, 0);
+ -1, XFS_DQTYPE_NONE);
if (fa) {
xfs_alert(mp,
"dquot corrupt at %pS trying to replay into block 0x%llx",
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 7503c6695569..ddaa5968e98e 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -76,7 +76,7 @@ xfs_qm_adjust_dqlimits(
int prealloc = 0;
ASSERT(d->d_id);
- defq = xfs_get_defquota(q, xfs_dquot_type(dq));
+ defq = xfs_get_defquota(q, dq->q_type);
if (defq->bsoftlimit && !d->d_blk_softlimit) {
d->d_blk_softlimit = cpu_to_be64(defq->bsoftlimit);
@@ -122,7 +122,7 @@ xfs_qm_adjust_dqtimers(
struct xfs_def_quota *defq;
ASSERT(d->d_id);
- defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
+ defq = xfs_get_defquota(qi, dq->q_type);
#ifdef DEBUG
if (d->d_blk_hardlimit)
@@ -214,7 +214,7 @@ xfs_qm_init_dquot_blk(
struct xfs_trans *tp,
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct xfs_buf *bp)
{
struct xfs_quotainfo *q = mp->m_quotainfo;
@@ -238,7 +238,7 @@ xfs_qm_init_dquot_blk(
d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
d->dd_diskdq.d_id = cpu_to_be32(curid);
- d->dd_diskdq.d_flags = type;
+ d->dd_diskdq.d_flags = xfs_dquot_type_to_disk(type);
if (xfs_sb_version_hascrc(&mp->m_sb)) {
uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
@@ -246,15 +246,22 @@ xfs_qm_init_dquot_blk(
}
}
- if (type & XFS_DQ_USER) {
+ switch (type) {
+ case XFS_DQTYPE_USER:
qflag = XFS_UQUOTA_CHKD;
blftype = XFS_BLF_UDQUOT_BUF;
- } else if (type & XFS_DQ_PROJ) {
+ break;
+ case XFS_DQTYPE_PROJ:
qflag = XFS_PQUOTA_CHKD;
blftype = XFS_BLF_PDQUOT_BUF;
- } else {
+ break;
+ case XFS_DQTYPE_GROUP:
qflag = XFS_GQUOTA_CHKD;
blftype = XFS_BLF_GDQUOT_BUF;
+ break;
+ default:
+ ASSERT(0);
+ break;
}
xfs_trans_dquot_buf(tp, bp, blftype);
@@ -322,14 +329,14 @@ xfs_dquot_disk_alloc(
struct xfs_trans *tp = *tpp;
struct xfs_mount *mp = tp->t_mountp;
struct xfs_buf *bp;
- struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->dq_flags);
+ struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->q_type);
int nmaps = 1;
int error;
trace_xfs_dqalloc(dqp);
xfs_ilock(quotip, XFS_ILOCK_EXCL);
- if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
+ if (!xfs_this_quota_on(dqp->q_mount, dqp->q_type)) {
/*
* Return if this type of quotas is turned off while we didn't
* have an inode lock
@@ -367,7 +374,7 @@ xfs_dquot_disk_alloc(
* the entire thing.
*/
xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
- dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
+ dqp->q_type, bp);
xfs_buf_set_ref(bp, XFS_DQUOT_REF);
/*
@@ -414,13 +421,13 @@ xfs_dquot_disk_read(
{
struct xfs_bmbt_irec map;
struct xfs_buf *bp;
- struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->dq_flags);
+ struct xfs_inode *quotip = xfs_quota_inode(mp, dqp->q_type);
uint lock_mode;
int nmaps = 1;
int error;
lock_mode = xfs_ilock_data_map_shared(quotip);
- if (!xfs_this_quota_on(mp, dqp->dq_flags)) {
+ if (!xfs_this_quota_on(mp, dqp->q_type)) {
/*
* Return if this type of quotas is turned off while we
* didn't have the quota inode lock.
@@ -472,13 +479,13 @@ STATIC struct xfs_dquot *
xfs_dquot_alloc(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type)
+ xfs_dqtype_t type)
{
struct xfs_dquot *dqp;
dqp = kmem_zone_zalloc(xfs_qm_dqzone, 0);
- dqp->dq_flags = type;
+ dqp->q_type = type;
dqp->q_core.d_id = cpu_to_be32(id);
dqp->q_mount = mp;
INIT_LIST_HEAD(&dqp->q_lru);
@@ -504,13 +511,13 @@ xfs_dquot_alloc(
* quotas.
*/
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
/* uses the default lock class */
break;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
break;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
break;
default:
@@ -531,12 +538,13 @@ xfs_dquot_from_disk(
struct xfs_buf *bp)
{
struct xfs_disk_dquot *ddqp = bp->b_addr + dqp->q_bufoffset;
+ __u8 ddq_type = xfs_dquot_type_to_disk(dqp->q_type);
/*
* Ensure that we got the type and ID we were looking for.
* Everything else was checked by the dquot buffer verifier.
*/
- if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->dq_flags ||
+ if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != ddq_type ||
ddqp->d_id != dqp->q_core.d_id) {
xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
"Metadata corruption detected at %pS, quota %u",
@@ -607,7 +615,7 @@ static int
xfs_qm_dqread(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
bool can_alloc,
struct xfs_dquot **dqpp)
{
@@ -655,7 +663,7 @@ xfs_qm_dqread(
static int
xfs_dq_get_next_id(
struct xfs_mount *mp,
- uint type,
+ xfs_dqtype_t type,
xfs_dqid_t *id)
{
struct xfs_inode *quotip = xfs_quota_inode(mp, type);
@@ -779,21 +787,21 @@ xfs_qm_dqget_cache_insert(
static int
xfs_qm_dqget_checks(
struct xfs_mount *mp,
- uint type)
+ xfs_dqtype_t type)
{
if (WARN_ON_ONCE(!XFS_IS_QUOTA_RUNNING(mp)))
return -ESRCH;
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
if (!XFS_IS_UQUOTA_ON(mp))
return -ESRCH;
return 0;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
if (!XFS_IS_GQUOTA_ON(mp))
return -ESRCH;
return 0;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
if (!XFS_IS_PQUOTA_ON(mp))
return -ESRCH;
return 0;
@@ -811,7 +819,7 @@ int
xfs_qm_dqget(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
bool can_alloc,
struct xfs_dquot **O_dqpp)
{
@@ -861,7 +869,7 @@ int
xfs_qm_dqget_uncached(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct xfs_dquot **dqpp)
{
int error;
@@ -877,14 +885,14 @@ xfs_qm_dqget_uncached(
xfs_dqid_t
xfs_qm_id_for_quotatype(
struct xfs_inode *ip,
- uint type)
+ xfs_dqtype_t type)
{
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
return i_uid_read(VFS_I(ip));
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return i_gid_read(VFS_I(ip));
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return ip->i_d.di_projid;
}
ASSERT(0);
@@ -899,7 +907,7 @@ xfs_qm_id_for_quotatype(
int
xfs_qm_dqget_inode(
struct xfs_inode *ip,
- uint type,
+ xfs_dqtype_t type,
bool can_alloc,
struct xfs_dquot **O_dqpp)
{
@@ -985,7 +993,7 @@ int
xfs_qm_dqget_next(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct xfs_dquot **dqpp)
{
struct xfs_dquot *dqp;
@@ -1294,7 +1302,7 @@ xfs_qm_exit(void)
int
xfs_qm_dqiterate(
struct xfs_mount *mp,
- uint dqtype,
+ xfs_dqtype_t type,
xfs_qm_dqiterate_fn iter_fn,
void *priv)
{
@@ -1303,13 +1311,13 @@ xfs_qm_dqiterate(
int error;
do {
- error = xfs_qm_dqget_next(mp, id, dqtype, &dq);
+ error = xfs_qm_dqget_next(mp, id, type, &dq);
if (error == -ENOENT)
return 0;
if (error)
return error;
- error = iter_fn(dq, dqtype, priv);
+ error = iter_fn(dq, type, priv);
id = be32_to_cpu(dq->q_core.d_id);
xfs_qm_dqput(dq);
id++;
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 71e36c85e20b..077d0988cff9 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -34,6 +34,7 @@ struct xfs_dquot {
uint dq_flags;
struct list_head q_lru;
struct xfs_mount *q_mount;
+ xfs_dqtype_t q_type;
uint q_nrefs;
xfs_daddr_t q_blkno;
int q_bufoffset;
@@ -101,28 +102,34 @@ static inline void xfs_dqunlock(struct xfs_dquot *dqp)
mutex_unlock(&dqp->q_qlock);
}
-static inline int xfs_this_quota_on(struct xfs_mount *mp, int type)
+static inline bool
+xfs_this_quota_on(
+ struct xfs_mount *mp,
+ xfs_dqtype_t type)
{
- switch (type & XFS_DQ_ALLTYPES) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return XFS_IS_UQUOTA_ON(mp);
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return XFS_IS_GQUOTA_ON(mp);
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return XFS_IS_PQUOTA_ON(mp);
default:
- return 0;
+ return false;
}
}
-static inline struct xfs_dquot *xfs_inode_dquot(struct xfs_inode *ip, int type)
+static inline struct xfs_dquot *
+xfs_inode_dquot(
+ struct xfs_inode *ip,
+ xfs_dqtype_t type)
{
- switch (type & XFS_DQ_ALLTYPES) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return ip->i_udquot;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return ip->i_gdquot;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return ip->i_pdquot;
default:
return NULL;
@@ -146,9 +153,9 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
#define XFS_DQ_IS_LOCKED(dqp) (mutex_is_locked(&((dqp)->q_qlock)))
#define XFS_DQ_IS_DIRTY(dqp) ((dqp)->dq_flags & XFS_DQ_DIRTY)
-#define XFS_QM_ISUDQ(dqp) ((dqp)->dq_flags & XFS_DQ_USER)
-#define XFS_QM_ISPDQ(dqp) ((dqp)->dq_flags & XFS_DQ_PROJ)
-#define XFS_QM_ISGDQ(dqp) ((dqp)->dq_flags & XFS_DQ_GROUP)
+#define XFS_QM_ISUDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_USER)
+#define XFS_QM_ISPDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_PROJ)
+#define XFS_QM_ISGDQ(dqp) ((dqp)->q_type == XFS_DQTYPE_GROUP)
void xfs_qm_dqdestroy(struct xfs_dquot *dqp);
int xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);
@@ -157,18 +164,20 @@ void xfs_qm_adjust_dqtimers(struct xfs_mount *mp,
struct xfs_dquot *d);
void xfs_qm_adjust_dqlimits(struct xfs_mount *mp,
struct xfs_dquot *d);
-xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip, uint type);
+xfs_dqid_t xfs_qm_id_for_quotatype(struct xfs_inode *ip,
+ xfs_dqtype_t type);
int xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
- uint type, bool can_alloc,
- struct xfs_dquot **dqpp);
-int xfs_qm_dqget_inode(struct xfs_inode *ip, uint type,
- bool can_alloc,
- struct xfs_dquot **dqpp);
+ xfs_dqtype_t type, bool can_alloc,
+ struct xfs_dquot **dqpp);
+int xfs_qm_dqget_inode(struct xfs_inode *ip,
+ xfs_dqtype_t type,
+ bool can_alloc, struct xfs_dquot **dqpp);
int xfs_qm_dqget_next(struct xfs_mount *mp, xfs_dqid_t id,
- uint type, struct xfs_dquot **dqpp);
-int xfs_qm_dqget_uncached(struct xfs_mount *mp,
- xfs_dqid_t id, uint type,
- struct xfs_dquot **dqpp);
+ xfs_dqtype_t type,
+ struct xfs_dquot **dqpp);
+int xfs_qm_dqget_uncached(struct xfs_mount *mp, xfs_dqid_t id,
+ xfs_dqtype_t type,
+ struct xfs_dquot **dqpp);
void xfs_qm_dqput(struct xfs_dquot *dqp);
void xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
@@ -183,9 +192,9 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
return dqp;
}
-typedef int (*xfs_qm_dqiterate_fn)(struct xfs_dquot *dq, uint dqtype,
- void *priv);
-int xfs_qm_dqiterate(struct xfs_mount *mp, uint dqtype,
+typedef int (*xfs_qm_dqiterate_fn)(struct xfs_dquot *dq,
+ xfs_dqtype_t type, void *priv);
+int xfs_qm_dqiterate(struct xfs_mount *mp, xfs_dqtype_t type,
xfs_qm_dqiterate_fn iter_fn, void *priv);
#endif /* __XFS_DQUOT_H__ */
diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index f9ea9f55aa7c..a39708879874 100644
--- a/fs/xfs/xfs_dquot_item_recover.c
+++ b/fs/xfs/xfs_dquot_item_recover.c
@@ -108,7 +108,7 @@ xlog_recover_dquot_commit_pass2(
*/
dq_f = item->ri_buf[0].i_addr;
ASSERT(dq_f);
- fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, 0);
+ fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, XFS_DQTYPE_NONE);
if (fa) {
xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
dq_f->qlf_id, fa);
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 58a750ce689c..3c6e936d2f99 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1424,7 +1424,7 @@ __xfs_inode_free_quota_eofblocks(
eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
- dq = xfs_inode_dquot(ip, XFS_DQ_USER);
+ dq = xfs_inode_dquot(ip, XFS_DQTYPE_USER);
if (dq && xfs_dquot_lowsp(dq)) {
eofb.eof_uid = VFS_I(ip)->i_uid;
eofb.eof_flags |= XFS_EOF_FLAGS_UID;
@@ -1433,7 +1433,7 @@ __xfs_inode_free_quota_eofblocks(
}
if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
- dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
+ dq = xfs_inode_dquot(ip, XFS_DQTYPE_GROUP);
if (dq && xfs_dquot_lowsp(dq)) {
eofb.eof_gid = VFS_I(ip)->i_gid;
eofb.eof_flags |= XFS_EOF_FLAGS_GID;
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index b9a8c3798e08..ac2cc2680d2a 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -293,11 +293,11 @@ xfs_iomap_write_direct(
STATIC bool
xfs_quota_need_throttle(
- struct xfs_inode *ip,
- int type,
- xfs_fsblock_t alloc_blocks)
+ struct xfs_inode *ip,
+ xfs_dqtype_t type,
+ xfs_fsblock_t alloc_blocks)
{
- struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
+ struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
if (!dq || !xfs_this_quota_on(ip->i_mount, type))
return false;
@@ -315,15 +315,15 @@ xfs_quota_need_throttle(
STATIC void
xfs_quota_calc_throttle(
- struct xfs_inode *ip,
- int type,
- xfs_fsblock_t *qblocks,
- int *qshift,
- int64_t *qfreesp)
+ struct xfs_inode *ip,
+ xfs_dqtype_t type,
+ xfs_fsblock_t *qblocks,
+ int *qshift,
+ int64_t *qfreesp)
{
- int64_t freesp;
- int shift = 0;
- struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
+ struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
+ int64_t freesp;
+ int shift = 0;
/* no dq, or over hi wmark, squash the prealloc completely */
if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
@@ -450,14 +450,14 @@ xfs_iomap_prealloc_size(
* Check each quota to cap the prealloc size, provide a shift value to
* throttle with and adjust amount of available space.
*/
- if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
- xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
+ if (xfs_quota_need_throttle(ip, XFS_DQTYPE_USER, alloc_blocks))
+ xfs_quota_calc_throttle(ip, XFS_DQTYPE_USER, &qblocks, &qshift,
&freesp);
- if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
- xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
+ if (xfs_quota_need_throttle(ip, XFS_DQTYPE_GROUP, alloc_blocks))
+ xfs_quota_calc_throttle(ip, XFS_DQTYPE_GROUP, &qblocks, &qshift,
&freesp);
- if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
- xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
+ if (xfs_quota_need_throttle(ip, XFS_DQTYPE_PROJ, alloc_blocks))
+ xfs_quota_calc_throttle(ip, XFS_DQTYPE_PROJ, &qblocks, &qshift,
&freesp);
/*
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 938023dd8ce5..c67776eb6bcc 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -47,7 +47,7 @@ STATIC void xfs_qm_dqfree_one(struct xfs_dquot *dqp);
STATIC int
xfs_qm_dquot_walk(
struct xfs_mount *mp,
- int type,
+ xfs_dqtype_t type,
int (*execute)(struct xfs_dquot *dqp, void *data),
void *data)
{
@@ -161,7 +161,7 @@ xfs_qm_dqpurge(
xfs_dqfunlock(dqp);
xfs_dqunlock(dqp);
- radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
be32_to_cpu(dqp->q_core.d_id));
qi->qi_dquots--;
@@ -190,11 +190,11 @@ xfs_qm_dqpurge_all(
uint flags)
{
if (flags & XFS_QMOPT_UQUOTA)
- xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
+ xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER, xfs_qm_dqpurge, NULL);
if (flags & XFS_QMOPT_GQUOTA)
- xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
+ xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP, xfs_qm_dqpurge, NULL);
if (flags & XFS_QMOPT_PQUOTA)
- xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
+ xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ, xfs_qm_dqpurge, NULL);
}
/*
@@ -251,7 +251,7 @@ STATIC int
xfs_qm_dqattach_one(
struct xfs_inode *ip,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
bool doalloc,
struct xfs_dquot **IO_idqpp)
{
@@ -332,7 +332,7 @@ xfs_qm_dqattach_locked(
if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {
error = xfs_qm_dqattach_one(ip, i_uid_read(VFS_I(ip)),
- XFS_DQ_USER, doalloc, &ip->i_udquot);
+ XFS_DQTYPE_USER, doalloc, &ip->i_udquot);
if (error)
goto done;
ASSERT(ip->i_udquot);
@@ -340,15 +340,15 @@ xfs_qm_dqattach_locked(
if (XFS_IS_GQUOTA_ON(mp) && !ip->i_gdquot) {
error = xfs_qm_dqattach_one(ip, i_gid_read(VFS_I(ip)),
- XFS_DQ_GROUP, doalloc, &ip->i_gdquot);
+ XFS_DQTYPE_GROUP, doalloc, &ip->i_gdquot);
if (error)
goto done;
ASSERT(ip->i_gdquot);
}
if (XFS_IS_PQUOTA_ON(mp) && !ip->i_pdquot) {
- error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
- doalloc, &ip->i_pdquot);
+ error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid,
+ XFS_DQTYPE_PROJ, doalloc, &ip->i_pdquot);
if (error)
goto done;
ASSERT(ip->i_pdquot);
@@ -546,7 +546,7 @@ xfs_qm_shrink_count(
STATIC void
xfs_qm_set_defquota(
struct xfs_mount *mp,
- uint type,
+ xfs_dqtype_t type,
struct xfs_quotainfo *qinf)
{
struct xfs_dquot *dqp;
@@ -559,7 +559,7 @@ xfs_qm_set_defquota(
return;
ddqp = &dqp->q_core;
- defq = xfs_get_defquota(qinf, xfs_dquot_type(dqp));
+ defq = xfs_get_defquota(qinf, type);
/*
* Timers and warnings have been already set, let's just set the
@@ -578,7 +578,7 @@ xfs_qm_set_defquota(
static void
xfs_qm_init_timelimits(
struct xfs_mount *mp,
- uint type)
+ xfs_dqtype_t type)
{
struct xfs_quotainfo *qinf = mp->m_quotainfo;
struct xfs_def_quota *defq;
@@ -670,16 +670,16 @@ xfs_qm_init_quotainfo(
mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
- xfs_qm_init_timelimits(mp, XFS_DQ_USER);
- xfs_qm_init_timelimits(mp, XFS_DQ_GROUP);
- xfs_qm_init_timelimits(mp, XFS_DQ_PROJ);
+ xfs_qm_init_timelimits(mp, XFS_DQTYPE_USER);
+ xfs_qm_init_timelimits(mp, XFS_DQTYPE_GROUP);
+ xfs_qm_init_timelimits(mp, XFS_DQTYPE_PROJ);
if (XFS_IS_UQUOTA_RUNNING(mp))
- xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
+ xfs_qm_set_defquota(mp, XFS_DQTYPE_USER, qinf);
if (XFS_IS_GQUOTA_RUNNING(mp))
- xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
+ xfs_qm_set_defquota(mp, XFS_DQTYPE_GROUP, qinf);
if (XFS_IS_PQUOTA_RUNNING(mp))
- xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);
+ xfs_qm_set_defquota(mp, XFS_DQTYPE_PROJ, qinf);
qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
@@ -829,10 +829,10 @@ xfs_qm_qino_alloc(
STATIC void
xfs_qm_reset_dqcounts(
- xfs_mount_t *mp,
- xfs_buf_t *bp,
- xfs_dqid_t id,
- uint type)
+ struct xfs_mount *mp,
+ struct xfs_buf *bp,
+ xfs_dqid_t id,
+ xfs_dqtype_t type)
{
struct xfs_dqblk *dqb;
int j;
@@ -869,7 +869,7 @@ xfs_qm_reset_dqcounts(
* Reset type in case we are reusing group quota file for
* project quotas or vice versa
*/
- ddq->d_flags = type;
+ ddq->d_flags = xfs_dquot_type_to_disk(type);
ddq->d_bcount = 0;
ddq->d_icount = 0;
ddq->d_rtbcount = 0;
@@ -907,11 +907,11 @@ xfs_qm_reset_dqcounts_all(
{
struct xfs_buf *bp;
int error;
- int type;
+ xfs_dqtype_t type;
ASSERT(blkcnt > 0);
- type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
- (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
+ type = flags & XFS_QMOPT_UQUOTA ? XFS_DQTYPE_USER :
+ (flags & XFS_QMOPT_PQUOTA ? XFS_DQTYPE_PROJ : XFS_DQTYPE_GROUP);
error = 0;
/*
@@ -1070,7 +1070,7 @@ xfs_qm_reset_dqcounts_buf(
STATIC int
xfs_qm_quotacheck_dqadjust(
struct xfs_inode *ip,
- uint type,
+ xfs_dqtype_t type,
xfs_qcnt_t nblks,
xfs_qcnt_t rtblks)
{
@@ -1187,21 +1187,21 @@ xfs_qm_dqusage_adjust(
* and quotaoffs don't race. (Quotachecks happen at mount time only).
*/
if (XFS_IS_UQUOTA_ON(mp)) {
- error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_USER, nblks,
+ error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_USER, nblks,
rtblks);
if (error)
goto error0;
}
if (XFS_IS_GQUOTA_ON(mp)) {
- error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_GROUP, nblks,
+ error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_GROUP, nblks,
rtblks);
if (error)
goto error0;
}
if (XFS_IS_PQUOTA_ON(mp)) {
- error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_PROJ, nblks,
+ error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_PROJ, nblks,
rtblks);
if (error)
goto error0;
@@ -1325,18 +1325,18 @@ xfs_qm_quotacheck(
* down to disk buffers if everything was updated successfully.
*/
if (XFS_IS_UQUOTA_ON(mp)) {
- error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
- &buffer_list);
+ error = xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER,
+ xfs_qm_flush_one, &buffer_list);
}
if (XFS_IS_GQUOTA_ON(mp)) {
- error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
- &buffer_list);
+ error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP,
+ xfs_qm_flush_one, &buffer_list);
if (!error)
error = error2;
}
if (XFS_IS_PQUOTA_ON(mp)) {
- error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
- &buffer_list);
+ error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ,
+ xfs_qm_flush_one, &buffer_list);
if (!error)
error = error2;
}
@@ -1598,7 +1598,7 @@ xfs_qm_dqfree_one(
struct xfs_quotainfo *qi = mp->m_quotainfo;
mutex_lock(&qi->qi_tree_lock);
- radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->q_type),
be32_to_cpu(dqp->q_core.d_id));
qi->qi_dquots--;
@@ -1674,7 +1674,7 @@ xfs_qm_vop_dqalloc(
*/
xfs_iunlock(ip, lockflags);
error = xfs_qm_dqget(mp, from_kuid(user_ns, uid),
- XFS_DQ_USER, true, &uq);
+ XFS_DQTYPE_USER, true, &uq);
if (error) {
ASSERT(error != -ENOENT);
return error;
@@ -1698,7 +1698,7 @@ xfs_qm_vop_dqalloc(
if (!gid_eq(inode->i_gid, gid)) {
xfs_iunlock(ip, lockflags);
error = xfs_qm_dqget(mp, from_kgid(user_ns, gid),
- XFS_DQ_GROUP, true, &gq);
+ XFS_DQTYPE_GROUP, true, &gq);
if (error) {
ASSERT(error != -ENOENT);
goto error_rele;
@@ -1714,8 +1714,8 @@ xfs_qm_vop_dqalloc(
if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
if (ip->i_d.di_projid != prid) {
xfs_iunlock(ip, lockflags);
- error = xfs_qm_dqget(mp, (xfs_dqid_t)prid, XFS_DQ_PROJ,
- true, &pq);
+ error = xfs_qm_dqget(mp, (xfs_dqid_t)prid,
+ XFS_DQTYPE_PROJ, true, &pq);
if (error) {
ASSERT(error != -ENOENT);
goto error_rele;
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 7b0e771fcbce..27789272da95 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -83,14 +83,14 @@ struct xfs_quotainfo {
static inline struct radix_tree_root *
xfs_dquot_tree(
struct xfs_quotainfo *qi,
- int type)
+ xfs_dqtype_t type)
{
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
return &qi->qi_uquota_tree;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return &qi->qi_gquota_tree;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return &qi->qi_pquota_tree;
default:
ASSERT(0);
@@ -99,14 +99,14 @@ xfs_dquot_tree(
}
static inline struct xfs_inode *
-xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
+xfs_quota_inode(struct xfs_mount *mp, xfs_dqtype_t type)
{
- switch (dq_flags & XFS_DQ_ALLTYPES) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return mp->m_quotainfo->qi_uquotaip;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return mp->m_quotainfo->qi_gquotaip;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return mp->m_quotainfo->qi_pquotaip;
default:
ASSERT(0);
@@ -114,17 +114,6 @@ xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
return NULL;
}
-static inline int
-xfs_dquot_type(struct xfs_dquot *dqp)
-{
- if (XFS_QM_ISUDQ(dqp))
- return XFS_DQ_USER;
- if (XFS_QM_ISGDQ(dqp))
- return XFS_DQ_GROUP;
- ASSERT(XFS_QM_ISPDQ(dqp));
- return XFS_DQ_PROJ;
-}
-
extern void xfs_trans_mod_dquot(struct xfs_trans *tp, struct xfs_dquot *dqp,
uint field, int64_t delta);
extern void xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
@@ -166,24 +155,30 @@ extern void xfs_qm_dqrele_all_inodes(struct xfs_mount *, uint);
/* quota ops */
extern int xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
-extern int xfs_qm_scall_getquota(struct xfs_mount *, xfs_dqid_t,
- uint, struct qc_dqblk *);
-extern int xfs_qm_scall_getquota_next(struct xfs_mount *,
- xfs_dqid_t *, uint, struct qc_dqblk *);
-extern int xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
- struct qc_dqblk *);
+extern int xfs_qm_scall_getquota(struct xfs_mount *mp,
+ xfs_dqid_t id,
+ xfs_dqtype_t type,
+ struct qc_dqblk *dst);
+extern int xfs_qm_scall_getquota_next(struct xfs_mount *mp,
+ xfs_dqid_t *id,
+ xfs_dqtype_t type,
+ struct qc_dqblk *dst);
+extern int xfs_qm_scall_setqlim(struct xfs_mount *mp,
+ xfs_dqid_t id,
+ xfs_dqtype_t type,
+ struct qc_dqblk *newlim);
extern int xfs_qm_scall_quotaon(struct xfs_mount *, uint);
extern int xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
static inline struct xfs_def_quota *
-xfs_get_defquota(struct xfs_quotainfo *qi, int type)
+xfs_get_defquota(struct xfs_quotainfo *qi, xfs_dqtype_t type)
{
switch (type) {
- case XFS_DQ_USER:
+ case XFS_DQTYPE_USER:
return &qi->qi_usr_default;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return &qi->qi_grp_default;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return &qi->qi_prj_default;
default:
ASSERT(0);
diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index fc2fa418919f..72c2c2595132 100644
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -60,7 +60,7 @@ xfs_qm_statvfs(
struct xfs_mount *mp = ip->i_mount;
struct xfs_dquot *dqp;
- if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQ_PROJ, false, &dqp)) {
+ if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQTYPE_PROJ, false, &dqp)) {
xfs_fill_statvfs_from_dquot(statp, dqp);
xfs_qm_dqput(dqp);
}
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 35fad348e3a2..c7cb8a356c88 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -443,7 +443,7 @@ int
xfs_qm_scall_setqlim(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct qc_dqblk *newlim)
{
struct xfs_quotainfo *q = mp->m_quotainfo;
@@ -479,7 +479,7 @@ xfs_qm_scall_setqlim(
goto out_unlock;
}
- defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
+ defq = xfs_get_defquota(q, dqp->q_type);
xfs_dqunlock(dqp);
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_setqlim, 0, 0, 0, &tp);
@@ -614,7 +614,7 @@ xfs_qm_scall_setqlim(
static void
xfs_qm_scall_getquota_fill_qc(
struct xfs_mount *mp,
- uint type,
+ xfs_dqtype_t type,
const struct xfs_dquot *dqp,
struct qc_dqblk *dst)
{
@@ -644,21 +644,18 @@ xfs_qm_scall_getquota_fill_qc(
* gets turned off. No need to confuse the user level code,
* so return zeroes in that case.
*/
- if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
- dqp->q_core.d_flags == XFS_DQ_USER) ||
- (!XFS_IS_GQUOTA_ENFORCED(mp) &&
- dqp->q_core.d_flags == XFS_DQ_GROUP) ||
- (!XFS_IS_PQUOTA_ENFORCED(mp) &&
- dqp->q_core.d_flags == XFS_DQ_PROJ)) {
+ if ((!XFS_IS_UQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_USER) ||
+ (!XFS_IS_GQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_GROUP) ||
+ (!XFS_IS_PQUOTA_ENFORCED(mp) && dqp->q_type == XFS_DQTYPE_PROJ)) {
dst->d_spc_timer = 0;
dst->d_ino_timer = 0;
dst->d_rt_spc_timer = 0;
}
#ifdef DEBUG
- if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) ||
- (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
- (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) &&
+ if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_USER) ||
+ (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_GROUP) ||
+ (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_PROJ)) &&
dqp->q_core.d_id != 0) {
if ((dst->d_space > dst->d_spc_softlimit) &&
(dst->d_spc_softlimit > 0)) {
@@ -677,7 +674,7 @@ int
xfs_qm_scall_getquota(
struct xfs_mount *mp,
xfs_dqid_t id,
- uint type,
+ xfs_dqtype_t type,
struct qc_dqblk *dst)
{
struct xfs_dquot *dqp;
@@ -715,7 +712,7 @@ int
xfs_qm_scall_getquota_next(
struct xfs_mount *mp,
xfs_dqid_t *id,
- uint type,
+ xfs_dqtype_t type,
struct qc_dqblk *dst)
{
struct xfs_dquot *dqp;
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index c92ae5e02ce8..06b22e35fc90 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -39,14 +39,14 @@ struct xfs_buf;
static inline uint
xfs_quota_chkd_flag(
- uint dqtype)
+ xfs_dqtype_t type)
{
- switch (dqtype) {
- case XFS_DQ_USER:
+ switch (type) {
+ case XFS_DQTYPE_USER:
return XFS_UQUOTA_CHKD;
- case XFS_DQ_GROUP:
+ case XFS_DQTYPE_GROUP:
return XFS_GQUOTA_CHKD;
- case XFS_DQ_PROJ:
+ case XFS_DQTYPE_PROJ:
return XFS_PQUOTA_CHKD;
default:
return 0;
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 0868e6ee2219..963c253558b3 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -85,16 +85,16 @@ xfs_fs_get_quota_state(
return 0;
}
-STATIC int
+STATIC xfs_dqtype_t
xfs_quota_type(int type)
{
switch (type) {
case USRQUOTA:
- return XFS_DQ_USER;
+ return XFS_DQTYPE_USER;
case GRPQUOTA:
- return XFS_DQ_GROUP;
+ return XFS_DQTYPE_GROUP;
default:
- return XFS_DQ_PROJ;
+ return XFS_DQTYPE_PROJ;
}
}
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 50c478374a31..f19e66da6646 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -864,6 +864,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
TP_STRUCT__entry(
__field(dev_t, dev)
__field(u32, id)
+ __field(xfs_dqtype_t, type)
__field(unsigned, flags)
__field(unsigned, nrefs)
__field(unsigned long long, res_bcount)
@@ -877,6 +878,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
TP_fast_assign(
__entry->dev = dqp->q_mount->m_super->s_dev;
__entry->id = be32_to_cpu(dqp->q_core.d_id);
+ __entry->type = dqp->q_type;
__entry->flags = dqp->dq_flags;
__entry->nrefs = dqp->q_nrefs;
__entry->res_bcount = dqp->q_res_bcount;
@@ -891,11 +893,12 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->ino_softlimit =
be64_to_cpu(dqp->q_core.d_ino_softlimit);
),
- TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx "
+ TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u res_bc 0x%llx "
"bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
"icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->id,
+ __print_symbolic(__entry->type, XFS_DQTYPE_STRINGS),
__print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
__entry->nrefs,
__entry->res_bcount,
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index ed0ce8b301b4..964f69a444a3 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -549,14 +549,21 @@ xfs_quota_warn(
struct xfs_dquot *dqp,
int type)
{
- enum quota_type qtype;
+ enum quota_type qtype;
- if (dqp->dq_flags & XFS_DQ_PROJ)
+ switch (dqp->q_type) {
+ case XFS_DQTYPE_PROJ:
qtype = PRJQUOTA;
- else if (dqp->dq_flags & XFS_DQ_USER)
+ break;
+ case XFS_DQTYPE_USER:
qtype = USRQUOTA;
- else
+ break;
+ case XFS_DQTYPE_GROUP:
qtype = GRPQUOTA;
+ break;
+ default:
+ return;
+ }
quota_send_warning(make_kqid(&init_user_ns, qtype,
be32_to_cpu(dqp->q_core.d_id)),
@@ -591,7 +598,7 @@ xfs_trans_dqresv(
xfs_dqlock(dqp);
- defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
+ defq = xfs_get_defquota(q, dqp->q_type);
if (flags & XFS_TRANS_DQ_RES_BLKS) {
hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-14 1:32 ` [PATCH 05/26] xfs: split the incore dquot type into a separate field Darrick J. Wong
@ 2020-07-14 7:57 ` Christoph Hellwig
2020-07-14 18:05 ` Darrick J. Wong
0 siblings, 1 reply; 47+ messages in thread
From: Christoph Hellwig @ 2020-07-14 7:57 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Create a new type (xfs_dqtype_t) to represent the type of an incore
> dquot. Break the type field out from the dq_flags field of the incore
> dquot.
I don't understand why we need separate in-core vs on-disk values for
the type. Why not something like this on top of the whole series:
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index 889e34b1a03335..ef9b8559ff6197 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -62,15 +62,14 @@ xfs_dquot_verify(
if (ddq->d_version != XFS_DQUOT_VERSION)
return __this_address;
- if (ddq->d_type & ~XFS_DDQTYPE_ANY)
+ if (ddq->d_type & ~XFS_DQTYPE_ANY)
return __this_address;
- ddq_type = ddq->d_type & XFS_DDQTYPE_REC_MASK;
- if (type != XFS_DQTYPE_NONE &&
- ddq_type != xfs_dquot_type_to_disk(type))
+ ddq_type = ddq->d_type & XFS_DQTYPE_REC_MASK;
+ if (type != XFS_DQTYPE_NONE && ddq_type != type)
return __this_address;
- if (ddq_type != XFS_DDQTYPE_USER &&
- ddq_type != XFS_DDQTYPE_PROJ &&
- ddq_type != XFS_DDQTYPE_GROUP)
+ if (ddq_type != XFS_DQTYPE_USER &&
+ ddq_type != XFS_DQTYPE_PROJ &&
+ ddq_type != XFS_DQTYPE_GROUP)
return __this_address;
if (id != -1 && id != be32_to_cpu(ddq->d_id))
@@ -129,7 +128,7 @@ xfs_dqblk_repair(
dqb->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
dqb->dd_diskdq.d_version = XFS_DQUOT_VERSION;
- dqb->dd_diskdq.d_type = xfs_dquot_type_to_disk(type);
+ dqb->dd_diskdq.d_type = type;
dqb->dd_diskdq.d_id = cpu_to_be32(id);
if (xfs_sb_version_hascrc(&mp->m_sb)) {
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index eed0c4d5baddbe..e4178c804abf06 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1150,16 +1150,25 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
#define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
#define XFS_DQUOT_VERSION (uint8_t)0x01 /* latest version number */
-#define XFS_DDQTYPE_USER 0x01 /* user dquot record */
-#define XFS_DDQTYPE_PROJ 0x02 /* project dquot record */
-#define XFS_DDQTYPE_GROUP 0x04 /* group dquot record */
+#define XFS_DQTYPE_NONE 0
+#define XFS_DQTYPE_USER 0x01 /* user dquot record */
+#define XFS_DQTYPE_PROJ 0x02 /* project dquot record */
+#define XFS_DQTYPE_GROUP 0x04 /* group dquot record */
+
+#define XFS_DQTYPE_STRINGS \
+ { XFS_DQTYPE_NONE, "NONE" }, \
+ { XFS_DQTYPE_USER, "USER" }, \
+ { XFS_DQTYPE_PROJ, "PROJ" }, \
+ { XFS_DQTYPE_GROUP, "GROUP" }
/* bitmask to determine if this is a user/group/project dquot */
-#define XFS_DDQTYPE_REC_MASK (XFS_DDQTYPE_USER | \
- XFS_DDQTYPE_PROJ | \
- XFS_DDQTYPE_GROUP)
+#define XFS_DQTYPE_REC_MASK (XFS_DQTYPE_USER | \
+ XFS_DQTYPE_PROJ | \
+ XFS_DQTYPE_GROUP)
+
+#define XFS_DQTYPE_ANY (XFS_DQTYPE_REC_MASK)
-#define XFS_DDQTYPE_ANY (XFS_DDQTYPE_REC_MASK)
+typedef uint8_t xfs_dqtype_t;
/*
* This is the main portion of the on-disk representation of quota
@@ -1170,7 +1179,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
struct xfs_disk_dquot {
__be16 d_magic; /* dquot magic = XFS_DQUOT_MAGIC */
__u8 d_version; /* dquot version */
- __u8 d_type; /* XFS_DDQTYPE_* */
+ xfs_dqtype_t d_type; /* XFS_DQTYPE_* */
__be32 d_id; /* user,project,group id */
__be64 d_blk_hardlimit;/* absolute limit on disk blks */
__be64 d_blk_softlimit;/* preferred limit on disk blks */
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 0650fa71fa2bcf..6edd249fdef4ea 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -18,36 +18,6 @@
typedef uint64_t xfs_qcnt_t;
typedef uint16_t xfs_qwarncnt_t;
-typedef uint8_t xfs_dqtype_t;
-
-#define XFS_DQTYPE_NONE (0)
-#define XFS_DQTYPE_USER (1)
-#define XFS_DQTYPE_PROJ (2)
-#define XFS_DQTYPE_GROUP (3)
-
-#define XFS_DQTYPE_STRINGS \
- { XFS_DQTYPE_NONE, "NONE?" }, \
- { XFS_DQTYPE_USER, "USER" }, \
- { XFS_DQTYPE_PROJ, "PROJ" }, \
- { XFS_DQTYPE_GROUP, "GROUP" }
-
-static inline __u8
-xfs_dquot_type_to_disk(
- xfs_dqtype_t type)
-{
- switch (type) {
- case XFS_DQTYPE_USER:
- return XFS_DDQTYPE_USER;
- case XFS_DQTYPE_GROUP:
- return XFS_DDQTYPE_GROUP;
- case XFS_DQTYPE_PROJ:
- return XFS_DDQTYPE_PROJ;
- default:
- ASSERT(0);
- return 0;
- }
-}
-
/*
* flags for q_flags field in the dquot.
*/
diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index dd150f8bbf5a2a..c2f19d35e05dbd 100644
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -548,11 +548,11 @@ xlog_recover_do_dquot_buffer(
type = 0;
if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
- type |= XFS_DDQTYPE_USER;
+ type |= XFS_DQTYPE_USER;
if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
- type |= XFS_DDQTYPE_PROJ;
+ type |= XFS_DQTYPE_PROJ;
if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
- type |= XFS_DDQTYPE_GROUP;
+ type |= XFS_DQTYPE_GROUP;
/*
* This type of quotas was turned off, so ignore this buffer
*/
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 14b0c62943d54e..0581cb930cd75e 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -182,7 +182,7 @@ xfs_qm_init_dquot_blk(
d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
d->dd_diskdq.d_id = cpu_to_be32(curid);
- d->dd_diskdq.d_type = xfs_dquot_type_to_disk(type);
+ d->dd_diskdq.d_type = type;
if (xfs_sb_version_hascrc(&mp->m_sb)) {
uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
@@ -481,13 +481,13 @@ xfs_dquot_from_disk(
struct xfs_buf *bp)
{
struct xfs_disk_dquot *ddqp = bp->b_addr + dqp->q_bufoffset;
- __u8 ddq_type = xfs_dquot_type_to_disk(dqp->q_type);
+ __u8 ddq_type = dqp->q_type;
/*
* Ensure that we got the type and ID we were looking for.
* Everything else was checked by the dquot buffer verifier.
*/
- if ((ddqp->d_type & XFS_DDQTYPE_REC_MASK) != ddq_type ||
+ if ((ddqp->d_type & XFS_DQTYPE_REC_MASK) != ddq_type ||
be32_to_cpu(ddqp->d_id) != dqp->q_id) {
xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
"Metadata corruption detected at %pS, quota %u",
@@ -537,7 +537,7 @@ xfs_dquot_to_disk(
{
ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
ddqp->d_version = XFS_DQUOT_VERSION;
- ddqp->d_type = xfs_dquot_type_to_disk(dqp->q_type);
+ ddqp->d_type = dqp->q_type;
ddqp->d_id = cpu_to_be32(dqp->q_id);
ddqp->d_pad0 = 0;
ddqp->d_pad = 0;
diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index 0955f183a02758..b5afb9fb8cd4fd 100644
--- a/fs/xfs/xfs_dquot_item_recover.c
+++ b/fs/xfs/xfs_dquot_item_recover.c
@@ -39,7 +39,7 @@ xlog_recover_dquot_ra_pass2(
if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
return;
- type = recddq->d_type & XFS_DDQTYPE_REC_MASK;
+ type = recddq->d_type & XFS_DQTYPE_REC_MASK;
ASSERT(type);
if (log->l_quotaoffs_flag & type)
return;
@@ -91,7 +91,7 @@ xlog_recover_dquot_commit_pass2(
/*
* This type of quotas was turned off, so ignore this record.
*/
- type = recddq->d_type & XFS_DDQTYPE_REC_MASK;
+ type = recddq->d_type & XFS_DQTYPE_REC_MASK;
ASSERT(type);
if (log->l_quotaoffs_flag & type)
return 0;
@@ -185,11 +185,11 @@ xlog_recover_quotaoff_commit_pass1(
* group/project quotaoff or both.
*/
if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
- log->l_quotaoffs_flag |= XFS_DDQTYPE_USER;
+ log->l_quotaoffs_flag |= XFS_DQTYPE_USER;
if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
- log->l_quotaoffs_flag |= XFS_DDQTYPE_PROJ;
+ log->l_quotaoffs_flag |= XFS_DQTYPE_PROJ;
if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
- log->l_quotaoffs_flag |= XFS_DDQTYPE_GROUP;
+ log->l_quotaoffs_flag |= XFS_DQTYPE_GROUP;
return 0;
}
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-14 7:57 ` Christoph Hellwig
@ 2020-07-14 18:05 ` Darrick J. Wong
2020-07-15 17:43 ` Christoph Hellwig
0 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-14 18:05 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-xfs
On Tue, Jul 14, 2020 at 08:57:56AM +0100, Christoph Hellwig wrote:
> On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> > From: Darrick J. Wong <darrick.wong@oracle.com>
> >
> > Create a new type (xfs_dqtype_t) to represent the type of an incore
> > dquot. Break the type field out from the dq_flags field of the incore
> > dquot.
>
> I don't understand why we need separate in-core vs on-disk values for
> the type. Why not something like this on top of the whole series:
I want to keep the ondisk d_type values separate from the incore q_type
values because they don't describe exactly the same concepts:
First, the incore qtype has a NONE value that we can pass to the dquot
core verifier when we don't actually know if this is a user, group, or
project dquot. This should never end up on disk.
Second, xfs_dqtype_t is a (barely concealed) enumeration type for quota
callers to tell us that they want to perform an action on behalf of
user, group, or project quotas. The incore q_flags and the ondisk
d_type contain internal state that should not be exposed to quota
callers.
I feel a need to reiterate that I'm about to start adding more flags to
d_type (for y2038+ time support), for which it will be very important to
keep d_type and q_{type,flags} separate.
I will change the series to define the DQTYPE flags to match the DDQTYPE
flags when they do overlap so that I can drop xfs_dquot_type_to_disk,
but I'm not going to separate the flag/type/whatever namespaces just to
combine them again.
--D
> diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
> index 889e34b1a03335..ef9b8559ff6197 100644
> --- a/fs/xfs/libxfs/xfs_dquot_buf.c
> +++ b/fs/xfs/libxfs/xfs_dquot_buf.c
> @@ -62,15 +62,14 @@ xfs_dquot_verify(
> if (ddq->d_version != XFS_DQUOT_VERSION)
> return __this_address;
>
> - if (ddq->d_type & ~XFS_DDQTYPE_ANY)
> + if (ddq->d_type & ~XFS_DQTYPE_ANY)
> return __this_address;
> - ddq_type = ddq->d_type & XFS_DDQTYPE_REC_MASK;
> - if (type != XFS_DQTYPE_NONE &&
> - ddq_type != xfs_dquot_type_to_disk(type))
> + ddq_type = ddq->d_type & XFS_DQTYPE_REC_MASK;
> + if (type != XFS_DQTYPE_NONE && ddq_type != type)
> return __this_address;
> - if (ddq_type != XFS_DDQTYPE_USER &&
> - ddq_type != XFS_DDQTYPE_PROJ &&
> - ddq_type != XFS_DDQTYPE_GROUP)
> + if (ddq_type != XFS_DQTYPE_USER &&
> + ddq_type != XFS_DQTYPE_PROJ &&
> + ddq_type != XFS_DQTYPE_GROUP)
> return __this_address;
>
> if (id != -1 && id != be32_to_cpu(ddq->d_id))
> @@ -129,7 +128,7 @@ xfs_dqblk_repair(
>
> dqb->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
> dqb->dd_diskdq.d_version = XFS_DQUOT_VERSION;
> - dqb->dd_diskdq.d_type = xfs_dquot_type_to_disk(type);
> + dqb->dd_diskdq.d_type = type;
> dqb->dd_diskdq.d_id = cpu_to_be32(id);
>
> if (xfs_sb_version_hascrc(&mp->m_sb)) {
> diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> index eed0c4d5baddbe..e4178c804abf06 100644
> --- a/fs/xfs/libxfs/xfs_format.h
> +++ b/fs/xfs/libxfs/xfs_format.h
> @@ -1150,16 +1150,25 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
> #define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
> #define XFS_DQUOT_VERSION (uint8_t)0x01 /* latest version number */
>
> -#define XFS_DDQTYPE_USER 0x01 /* user dquot record */
> -#define XFS_DDQTYPE_PROJ 0x02 /* project dquot record */
> -#define XFS_DDQTYPE_GROUP 0x04 /* group dquot record */
> +#define XFS_DQTYPE_NONE 0
> +#define XFS_DQTYPE_USER 0x01 /* user dquot record */
> +#define XFS_DQTYPE_PROJ 0x02 /* project dquot record */
> +#define XFS_DQTYPE_GROUP 0x04 /* group dquot record */
> +
> +#define XFS_DQTYPE_STRINGS \
> + { XFS_DQTYPE_NONE, "NONE" }, \
> + { XFS_DQTYPE_USER, "USER" }, \
> + { XFS_DQTYPE_PROJ, "PROJ" }, \
> + { XFS_DQTYPE_GROUP, "GROUP" }
>
> /* bitmask to determine if this is a user/group/project dquot */
> -#define XFS_DDQTYPE_REC_MASK (XFS_DDQTYPE_USER | \
> - XFS_DDQTYPE_PROJ | \
> - XFS_DDQTYPE_GROUP)
> +#define XFS_DQTYPE_REC_MASK (XFS_DQTYPE_USER | \
> + XFS_DQTYPE_PROJ | \
> + XFS_DQTYPE_GROUP)
> +
> +#define XFS_DQTYPE_ANY (XFS_DQTYPE_REC_MASK)
>
> -#define XFS_DDQTYPE_ANY (XFS_DDQTYPE_REC_MASK)
> +typedef uint8_t xfs_dqtype_t;
>
> /*
> * This is the main portion of the on-disk representation of quota
> @@ -1170,7 +1179,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
> struct xfs_disk_dquot {
> __be16 d_magic; /* dquot magic = XFS_DQUOT_MAGIC */
> __u8 d_version; /* dquot version */
> - __u8 d_type; /* XFS_DDQTYPE_* */
> + xfs_dqtype_t d_type; /* XFS_DQTYPE_* */
> __be32 d_id; /* user,project,group id */
> __be64 d_blk_hardlimit;/* absolute limit on disk blks */
> __be64 d_blk_softlimit;/* preferred limit on disk blks */
> diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
> index 0650fa71fa2bcf..6edd249fdef4ea 100644
> --- a/fs/xfs/libxfs/xfs_quota_defs.h
> +++ b/fs/xfs/libxfs/xfs_quota_defs.h
> @@ -18,36 +18,6 @@
> typedef uint64_t xfs_qcnt_t;
> typedef uint16_t xfs_qwarncnt_t;
>
> -typedef uint8_t xfs_dqtype_t;
> -
> -#define XFS_DQTYPE_NONE (0)
> -#define XFS_DQTYPE_USER (1)
> -#define XFS_DQTYPE_PROJ (2)
> -#define XFS_DQTYPE_GROUP (3)
> -
> -#define XFS_DQTYPE_STRINGS \
> - { XFS_DQTYPE_NONE, "NONE?" }, \
> - { XFS_DQTYPE_USER, "USER" }, \
> - { XFS_DQTYPE_PROJ, "PROJ" }, \
> - { XFS_DQTYPE_GROUP, "GROUP" }
> -
> -static inline __u8
> -xfs_dquot_type_to_disk(
> - xfs_dqtype_t type)
> -{
> - switch (type) {
> - case XFS_DQTYPE_USER:
> - return XFS_DDQTYPE_USER;
> - case XFS_DQTYPE_GROUP:
> - return XFS_DDQTYPE_GROUP;
> - case XFS_DQTYPE_PROJ:
> - return XFS_DDQTYPE_PROJ;
> - default:
> - ASSERT(0);
> - return 0;
> - }
> -}
> -
> /*
> * flags for q_flags field in the dquot.
> */
> diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
> index dd150f8bbf5a2a..c2f19d35e05dbd 100644
> --- a/fs/xfs/xfs_buf_item_recover.c
> +++ b/fs/xfs/xfs_buf_item_recover.c
> @@ -548,11 +548,11 @@ xlog_recover_do_dquot_buffer(
>
> type = 0;
> if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
> - type |= XFS_DDQTYPE_USER;
> + type |= XFS_DQTYPE_USER;
> if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
> - type |= XFS_DDQTYPE_PROJ;
> + type |= XFS_DQTYPE_PROJ;
> if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
> - type |= XFS_DDQTYPE_GROUP;
> + type |= XFS_DQTYPE_GROUP;
> /*
> * This type of quotas was turned off, so ignore this buffer
> */
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 14b0c62943d54e..0581cb930cd75e 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -182,7 +182,7 @@ xfs_qm_init_dquot_blk(
> d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
> d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
> d->dd_diskdq.d_id = cpu_to_be32(curid);
> - d->dd_diskdq.d_type = xfs_dquot_type_to_disk(type);
> + d->dd_diskdq.d_type = type;
> if (xfs_sb_version_hascrc(&mp->m_sb)) {
> uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
> xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
> @@ -481,13 +481,13 @@ xfs_dquot_from_disk(
> struct xfs_buf *bp)
> {
> struct xfs_disk_dquot *ddqp = bp->b_addr + dqp->q_bufoffset;
> - __u8 ddq_type = xfs_dquot_type_to_disk(dqp->q_type);
> + __u8 ddq_type = dqp->q_type;
>
> /*
> * Ensure that we got the type and ID we were looking for.
> * Everything else was checked by the dquot buffer verifier.
> */
> - if ((ddqp->d_type & XFS_DDQTYPE_REC_MASK) != ddq_type ||
> + if ((ddqp->d_type & XFS_DQTYPE_REC_MASK) != ddq_type ||
> be32_to_cpu(ddqp->d_id) != dqp->q_id) {
> xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
> "Metadata corruption detected at %pS, quota %u",
> @@ -537,7 +537,7 @@ xfs_dquot_to_disk(
> {
> ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
> ddqp->d_version = XFS_DQUOT_VERSION;
> - ddqp->d_type = xfs_dquot_type_to_disk(dqp->q_type);
> + ddqp->d_type = dqp->q_type;
> ddqp->d_id = cpu_to_be32(dqp->q_id);
> ddqp->d_pad0 = 0;
> ddqp->d_pad = 0;
> diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
> index 0955f183a02758..b5afb9fb8cd4fd 100644
> --- a/fs/xfs/xfs_dquot_item_recover.c
> +++ b/fs/xfs/xfs_dquot_item_recover.c
> @@ -39,7 +39,7 @@ xlog_recover_dquot_ra_pass2(
> if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
> return;
>
> - type = recddq->d_type & XFS_DDQTYPE_REC_MASK;
> + type = recddq->d_type & XFS_DQTYPE_REC_MASK;
> ASSERT(type);
> if (log->l_quotaoffs_flag & type)
> return;
> @@ -91,7 +91,7 @@ xlog_recover_dquot_commit_pass2(
> /*
> * This type of quotas was turned off, so ignore this record.
> */
> - type = recddq->d_type & XFS_DDQTYPE_REC_MASK;
> + type = recddq->d_type & XFS_DQTYPE_REC_MASK;
> ASSERT(type);
> if (log->l_quotaoffs_flag & type)
> return 0;
> @@ -185,11 +185,11 @@ xlog_recover_quotaoff_commit_pass1(
> * group/project quotaoff or both.
> */
> if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
> - log->l_quotaoffs_flag |= XFS_DDQTYPE_USER;
> + log->l_quotaoffs_flag |= XFS_DQTYPE_USER;
> if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
> - log->l_quotaoffs_flag |= XFS_DDQTYPE_PROJ;
> + log->l_quotaoffs_flag |= XFS_DQTYPE_PROJ;
> if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
> - log->l_quotaoffs_flag |= XFS_DDQTYPE_GROUP;
> + log->l_quotaoffs_flag |= XFS_DQTYPE_GROUP;
>
> return 0;
> }
^ permalink raw reply [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-14 18:05 ` Darrick J. Wong
@ 2020-07-15 17:43 ` Christoph Hellwig
2020-07-15 18:38 ` Darrick J. Wong
0 siblings, 1 reply; 47+ messages in thread
From: Christoph Hellwig @ 2020-07-15 17:43 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Tue, Jul 14, 2020 at 11:05:02AM -0700, Darrick J. Wong wrote:
> On Tue, Jul 14, 2020 at 08:57:56AM +0100, Christoph Hellwig wrote:
> > On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> > > From: Darrick J. Wong <darrick.wong@oracle.com>
> > >
> > > Create a new type (xfs_dqtype_t) to represent the type of an incore
> > > dquot. Break the type field out from the dq_flags field of the incore
> > > dquot.
> >
> > I don't understand why we need separate in-core vs on-disk values for
> > the type. Why not something like this on top of the whole series:
>
> I want to keep the ondisk d_type values separate from the incore q_type
> values because they don't describe exactly the same concepts:
>
> First, the incore qtype has a NONE value that we can pass to the dquot
> core verifier when we don't actually know if this is a user, group, or
> project dquot. This should never end up on disk.
Which we can trivially verify. Or just get rid of NONE, which actually
cleans things up a fair bit (patch on top of my previous one below)
> Second, xfs_dqtype_t is a (barely concealed) enumeration type for quota
> callers to tell us that they want to perform an action on behalf of
> user, group, or project quotas. The incore q_flags and the ondisk
> d_type contain internal state that should not be exposed to quota
> callers.
I don't think that is an argument, as we do the same elsewhere.
>
> I feel a need to reiterate that I'm about to start adding more flags to
> d_type (for y2038+ time support), for which it will be very important to
> keep d_type and q_{type,flags} separate.
Why? We'll just OR the bigtime flag in before writing to disk.
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index ef9b8559ff6197..c48b77c223073e 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -37,11 +37,8 @@ xfs_failaddr_t
xfs_dquot_verify(
struct xfs_mount *mp,
struct xfs_disk_dquot *ddq,
- xfs_dqid_t id,
- xfs_dqtype_t type) /* used only during quotacheck */
+ xfs_dqid_t id)
{
- uint8_t ddq_type;
-
/*
* We can encounter an uninitialized dquot buffer for 2 reasons:
* 1. If we crash while deleting the quotainode(s), and those blks got
@@ -64,13 +61,14 @@ xfs_dquot_verify(
if (ddq->d_type & ~XFS_DQTYPE_ANY)
return __this_address;
- ddq_type = ddq->d_type & XFS_DQTYPE_REC_MASK;
- if (type != XFS_DQTYPE_NONE && ddq_type != type)
- return __this_address;
- if (ddq_type != XFS_DQTYPE_USER &&
- ddq_type != XFS_DQTYPE_PROJ &&
- ddq_type != XFS_DQTYPE_GROUP)
+ switch (ddq->d_type & XFS_DQTYPE_REC_MASK) {
+ case XFS_DQTYPE_USER:
+ case XFS_DQTYPE_PROJ:
+ case XFS_DQTYPE_GROUP:
+ break;
+ default:
return __this_address;
+ }
if (id != -1 && id != be32_to_cpu(ddq->d_id))
return __this_address;
@@ -100,14 +98,12 @@ xfs_failaddr_t
xfs_dqblk_verify(
struct xfs_mount *mp,
struct xfs_dqblk *dqb,
- xfs_dqid_t id,
- xfs_dqtype_t type) /* used only during quotacheck */
+ xfs_dqid_t id)
{
if (xfs_sb_version_hascrc(&mp->m_sb) &&
!uuid_equal(&dqb->dd_uuid, &mp->m_sb.sb_meta_uuid))
return __this_address;
-
- return xfs_dquot_verify(mp, &dqb->dd_diskdq, id, type);
+ return xfs_dquot_verify(mp, &dqb->dd_diskdq, id);
}
/*
@@ -210,7 +206,7 @@ xfs_dquot_buf_verify(
if (i == 0)
id = be32_to_cpu(ddq->d_id);
- fa = xfs_dqblk_verify(mp, &dqb[i], id + i, XFS_DQTYPE_NONE);
+ fa = xfs_dqblk_verify(mp, &dqb[i], id + i);
if (fa) {
if (!readahead)
xfs_buf_verifier_error(bp, -EFSCORRUPTED,
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index e4178c804abf06..ec472131ea4b15 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1150,13 +1150,11 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
#define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
#define XFS_DQUOT_VERSION (uint8_t)0x01 /* latest version number */
-#define XFS_DQTYPE_NONE 0
#define XFS_DQTYPE_USER 0x01 /* user dquot record */
#define XFS_DQTYPE_PROJ 0x02 /* project dquot record */
#define XFS_DQTYPE_GROUP 0x04 /* group dquot record */
#define XFS_DQTYPE_STRINGS \
- { XFS_DQTYPE_NONE, "NONE" }, \
{ XFS_DQTYPE_USER, "USER" }, \
{ XFS_DQTYPE_PROJ, "PROJ" }, \
{ XFS_DQTYPE_GROUP, "GROUP" }
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 6edd249fdef4ea..5e3d6b49981707 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -129,9 +129,9 @@ typedef uint16_t xfs_qwarncnt_t;
#define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
extern xfs_failaddr_t xfs_dquot_verify(struct xfs_mount *mp,
- struct xfs_disk_dquot *ddq, xfs_dqid_t id, xfs_dqtype_t type);
+ struct xfs_disk_dquot *ddq, xfs_dqid_t id);
extern xfs_failaddr_t xfs_dqblk_verify(struct xfs_mount *mp,
- struct xfs_dqblk *dqb, xfs_dqid_t id, xfs_dqtype_t type);
+ struct xfs_dqblk *dqb, xfs_dqid_t id);
extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
extern void xfs_dqblk_repair(struct xfs_mount *mp, struct xfs_dqblk *dqb,
xfs_dqid_t id, xfs_dqtype_t type);
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index f045895f28ffb1..a8eace16fdae74 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -31,7 +31,7 @@ xchk_quota_to_dqtype(
return XFS_DQTYPE_PROJ;
default:
ASSERT(0);
- return XFS_DQTYPE_NONE;
+ return 0;
}
}
diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index c2f19d35e05dbd..e4f37c064497aa 100644
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -494,8 +494,7 @@ xlog_recover_do_reg_buffer(
item->ri_buf[i].i_len, __func__);
goto next;
}
- fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr,
- -1, XFS_DQTYPE_NONE);
+ fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr, -1);
if (fa) {
xfs_alert(mp,
"dquot corrupt at %pS trying to replay into block 0x%llx",
diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index b5afb9fb8cd4fd..2df6238ed19abc 100644
--- a/fs/xfs/xfs_dquot_item_recover.c
+++ b/fs/xfs/xfs_dquot_item_recover.c
@@ -108,7 +108,7 @@ xlog_recover_dquot_commit_pass2(
*/
dq_f = item->ri_buf[0].i_addr;
ASSERT(dq_f);
- fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, XFS_DQTYPE_NONE);
+ fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id);
if (fa) {
xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
dq_f->qlf_id, fa);
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 96171f4406e978..716b91b582ff56 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -828,7 +828,6 @@ xfs_qm_reset_dqcounts(
{
struct xfs_dqblk *dqb;
int j;
- xfs_failaddr_t fa;
trace_xfs_reset_dqcounts(bp, _RET_IP_);
@@ -853,8 +852,8 @@ xfs_qm_reset_dqcounts(
* find uninitialised dquot blks. See comment in
* xfs_dquot_verify.
*/
- fa = xfs_dqblk_verify(mp, &dqb[j], id + j, type);
- if (fa)
+ if (xfs_dqblk_verify(mp, &dqb[j], id + j, type) ||
+ dqb[j].d_type != type)
xfs_dqblk_repair(mp, &dqb[j], id + j, type);
/*
^ permalink raw reply related [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-15 17:43 ` Christoph Hellwig
@ 2020-07-15 18:38 ` Darrick J. Wong
2020-07-15 18:39 ` Christoph Hellwig
0 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 18:38 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-xfs
On Wed, Jul 15, 2020 at 06:43:40PM +0100, Christoph Hellwig wrote:
> On Tue, Jul 14, 2020 at 11:05:02AM -0700, Darrick J. Wong wrote:
> > On Tue, Jul 14, 2020 at 08:57:56AM +0100, Christoph Hellwig wrote:
> > > On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> > > > From: Darrick J. Wong <darrick.wong@oracle.com>
> > > >
> > > > Create a new type (xfs_dqtype_t) to represent the type of an incore
> > > > dquot. Break the type field out from the dq_flags field of the incore
> > > > dquot.
> > >
> > > I don't understand why we need separate in-core vs on-disk values for
> > > the type. Why not something like this on top of the whole series:
> >
> > I want to keep the ondisk d_type values separate from the incore q_type
> > values because they don't describe exactly the same concepts:
> >
> > First, the incore qtype has a NONE value that we can pass to the dquot
> > core verifier when we don't actually know if this is a user, group, or
> > project dquot. This should never end up on disk.
>
> Which we can trivially verify. Or just get rid of NONE, which actually
> cleans things up a fair bit (patch on top of my previous one below)
Ok, I'll get rid of that usage.
> > Second, xfs_dqtype_t is a (barely concealed) enumeration type for quota
> > callers to tell us that they want to perform an action on behalf of
> > user, group, or project quotas. The incore q_flags and the ondisk
> > d_type contain internal state that should not be exposed to quota
> > callers.
>
> I don't think that is an argument, as we do the same elsewhere.
>
> >
> > I feel a need to reiterate that I'm about to start adding more flags to
> > d_type (for y2038+ time support), for which it will be very important to
> > keep d_type and q_{type,flags} separate.
>
> Why? We'll just OR the bigtime flag in before writing to disk.
Ugh, fine, I'll rework the whole series yet again, since it doesn't look
like anyone else is going to have the time to review a 27 patch cleanup
series.
--D
>
> diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
> index ef9b8559ff6197..c48b77c223073e 100644
> --- a/fs/xfs/libxfs/xfs_dquot_buf.c
> +++ b/fs/xfs/libxfs/xfs_dquot_buf.c
> @@ -37,11 +37,8 @@ xfs_failaddr_t
> xfs_dquot_verify(
> struct xfs_mount *mp,
> struct xfs_disk_dquot *ddq,
> - xfs_dqid_t id,
> - xfs_dqtype_t type) /* used only during quotacheck */
> + xfs_dqid_t id)
> {
> - uint8_t ddq_type;
> -
> /*
> * We can encounter an uninitialized dquot buffer for 2 reasons:
> * 1. If we crash while deleting the quotainode(s), and those blks got
> @@ -64,13 +61,14 @@ xfs_dquot_verify(
>
> if (ddq->d_type & ~XFS_DQTYPE_ANY)
> return __this_address;
> - ddq_type = ddq->d_type & XFS_DQTYPE_REC_MASK;
> - if (type != XFS_DQTYPE_NONE && ddq_type != type)
> - return __this_address;
> - if (ddq_type != XFS_DQTYPE_USER &&
> - ddq_type != XFS_DQTYPE_PROJ &&
> - ddq_type != XFS_DQTYPE_GROUP)
> + switch (ddq->d_type & XFS_DQTYPE_REC_MASK) {
> + case XFS_DQTYPE_USER:
> + case XFS_DQTYPE_PROJ:
> + case XFS_DQTYPE_GROUP:
> + break;
> + default:
> return __this_address;
> + }
>
> if (id != -1 && id != be32_to_cpu(ddq->d_id))
> return __this_address;
> @@ -100,14 +98,12 @@ xfs_failaddr_t
> xfs_dqblk_verify(
> struct xfs_mount *mp,
> struct xfs_dqblk *dqb,
> - xfs_dqid_t id,
> - xfs_dqtype_t type) /* used only during quotacheck */
> + xfs_dqid_t id)
> {
> if (xfs_sb_version_hascrc(&mp->m_sb) &&
> !uuid_equal(&dqb->dd_uuid, &mp->m_sb.sb_meta_uuid))
> return __this_address;
> -
> - return xfs_dquot_verify(mp, &dqb->dd_diskdq, id, type);
> + return xfs_dquot_verify(mp, &dqb->dd_diskdq, id);
> }
>
> /*
> @@ -210,7 +206,7 @@ xfs_dquot_buf_verify(
> if (i == 0)
> id = be32_to_cpu(ddq->d_id);
>
> - fa = xfs_dqblk_verify(mp, &dqb[i], id + i, XFS_DQTYPE_NONE);
> + fa = xfs_dqblk_verify(mp, &dqb[i], id + i);
> if (fa) {
> if (!readahead)
> xfs_buf_verifier_error(bp, -EFSCORRUPTED,
> diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
> index e4178c804abf06..ec472131ea4b15 100644
> --- a/fs/xfs/libxfs/xfs_format.h
> +++ b/fs/xfs/libxfs/xfs_format.h
> @@ -1150,13 +1150,11 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
> #define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
> #define XFS_DQUOT_VERSION (uint8_t)0x01 /* latest version number */
>
> -#define XFS_DQTYPE_NONE 0
> #define XFS_DQTYPE_USER 0x01 /* user dquot record */
> #define XFS_DQTYPE_PROJ 0x02 /* project dquot record */
> #define XFS_DQTYPE_GROUP 0x04 /* group dquot record */
>
> #define XFS_DQTYPE_STRINGS \
> - { XFS_DQTYPE_NONE, "NONE" }, \
> { XFS_DQTYPE_USER, "USER" }, \
> { XFS_DQTYPE_PROJ, "PROJ" }, \
> { XFS_DQTYPE_GROUP, "GROUP" }
> diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
> index 6edd249fdef4ea..5e3d6b49981707 100644
> --- a/fs/xfs/libxfs/xfs_quota_defs.h
> +++ b/fs/xfs/libxfs/xfs_quota_defs.h
> @@ -129,9 +129,9 @@ typedef uint16_t xfs_qwarncnt_t;
> #define XFS_QMOPT_RESBLK_MASK (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
>
> extern xfs_failaddr_t xfs_dquot_verify(struct xfs_mount *mp,
> - struct xfs_disk_dquot *ddq, xfs_dqid_t id, xfs_dqtype_t type);
> + struct xfs_disk_dquot *ddq, xfs_dqid_t id);
> extern xfs_failaddr_t xfs_dqblk_verify(struct xfs_mount *mp,
> - struct xfs_dqblk *dqb, xfs_dqid_t id, xfs_dqtype_t type);
> + struct xfs_dqblk *dqb, xfs_dqid_t id);
> extern int xfs_calc_dquots_per_chunk(unsigned int nbblks);
> extern void xfs_dqblk_repair(struct xfs_mount *mp, struct xfs_dqblk *dqb,
> xfs_dqid_t id, xfs_dqtype_t type);
> diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
> index f045895f28ffb1..a8eace16fdae74 100644
> --- a/fs/xfs/scrub/quota.c
> +++ b/fs/xfs/scrub/quota.c
> @@ -31,7 +31,7 @@ xchk_quota_to_dqtype(
> return XFS_DQTYPE_PROJ;
> default:
> ASSERT(0);
> - return XFS_DQTYPE_NONE;
> + return 0;
> }
> }
>
> diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
> index c2f19d35e05dbd..e4f37c064497aa 100644
> --- a/fs/xfs/xfs_buf_item_recover.c
> +++ b/fs/xfs/xfs_buf_item_recover.c
> @@ -494,8 +494,7 @@ xlog_recover_do_reg_buffer(
> item->ri_buf[i].i_len, __func__);
> goto next;
> }
> - fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr,
> - -1, XFS_DQTYPE_NONE);
> + fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr, -1);
> if (fa) {
> xfs_alert(mp,
> "dquot corrupt at %pS trying to replay into block 0x%llx",
> diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
> index b5afb9fb8cd4fd..2df6238ed19abc 100644
> --- a/fs/xfs/xfs_dquot_item_recover.c
> +++ b/fs/xfs/xfs_dquot_item_recover.c
> @@ -108,7 +108,7 @@ xlog_recover_dquot_commit_pass2(
> */
> dq_f = item->ri_buf[0].i_addr;
> ASSERT(dq_f);
> - fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, XFS_DQTYPE_NONE);
> + fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id);
> if (fa) {
> xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
> dq_f->qlf_id, fa);
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index 96171f4406e978..716b91b582ff56 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -828,7 +828,6 @@ xfs_qm_reset_dqcounts(
> {
> struct xfs_dqblk *dqb;
> int j;
> - xfs_failaddr_t fa;
>
> trace_xfs_reset_dqcounts(bp, _RET_IP_);
>
> @@ -853,8 +852,8 @@ xfs_qm_reset_dqcounts(
> * find uninitialised dquot blks. See comment in
> * xfs_dquot_verify.
> */
> - fa = xfs_dqblk_verify(mp, &dqb[j], id + j, type);
> - if (fa)
> + if (xfs_dqblk_verify(mp, &dqb[j], id + j, type) ||
> + dqb[j].d_type != type)
> xfs_dqblk_repair(mp, &dqb[j], id + j, type);
>
> /*
^ permalink raw reply [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-15 18:38 ` Darrick J. Wong
@ 2020-07-15 18:39 ` Christoph Hellwig
2020-07-15 21:20 ` Darrick J. Wong
0 siblings, 1 reply; 47+ messages in thread
From: Christoph Hellwig @ 2020-07-15 18:39 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: Christoph Hellwig, linux-xfs
On Wed, Jul 15, 2020 at 11:38:38AM -0700, Darrick J. Wong wrote:
> On Wed, Jul 15, 2020 at 06:43:40PM +0100, Christoph Hellwig wrote:
> > On Tue, Jul 14, 2020 at 11:05:02AM -0700, Darrick J. Wong wrote:
> > > On Tue, Jul 14, 2020 at 08:57:56AM +0100, Christoph Hellwig wrote:
> > > > On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> > > > > From: Darrick J. Wong <darrick.wong@oracle.com>
> > > > >
> > > > > Create a new type (xfs_dqtype_t) to represent the type of an incore
> > > > > dquot. Break the type field out from the dq_flags field of the incore
> > > > > dquot.
> > > >
> > > > I don't understand why we need separate in-core vs on-disk values for
> > > > the type. Why not something like this on top of the whole series:
> > >
> > > I want to keep the ondisk d_type values separate from the incore q_type
> > > values because they don't describe exactly the same concepts:
> > >
> > > First, the incore qtype has a NONE value that we can pass to the dquot
> > > core verifier when we don't actually know if this is a user, group, or
> > > project dquot. This should never end up on disk.
> >
> > Which we can trivially verify. Or just get rid of NONE, which actually
> > cleans things up a fair bit (patch on top of my previous one below)
>
> Ok, I'll get rid of that usage.
>
> > > Second, xfs_dqtype_t is a (barely concealed) enumeration type for quota
> > > callers to tell us that they want to perform an action on behalf of
> > > user, group, or project quotas. The incore q_flags and the ondisk
> > > d_type contain internal state that should not be exposed to quota
> > > callers.
> >
> > I don't think that is an argument, as we do the same elsewhere.
> >
> > >
> > > I feel a need to reiterate that I'm about to start adding more flags to
> > > d_type (for y2038+ time support), for which it will be very important to
> > > keep d_type and q_{type,flags} separate.
> >
> > Why? We'll just OR the bigtime flag in before writing to disk.
>
> Ugh, fine, I'll rework the whole series yet again, since it doesn't look
> like anyone else is going to have the time to review a 27 patch cleanup
> series.
Let's just get your series in and I'll send an incremental patch
after the bigtime series..
^ permalink raw reply [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-15 18:39 ` Christoph Hellwig
@ 2020-07-15 21:20 ` Darrick J. Wong
2020-07-16 2:17 ` Darrick J. Wong
0 siblings, 1 reply; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-15 21:20 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-xfs
On Wed, Jul 15, 2020 at 07:39:48PM +0100, Christoph Hellwig wrote:
> On Wed, Jul 15, 2020 at 11:38:38AM -0700, Darrick J. Wong wrote:
> > On Wed, Jul 15, 2020 at 06:43:40PM +0100, Christoph Hellwig wrote:
> > > On Tue, Jul 14, 2020 at 11:05:02AM -0700, Darrick J. Wong wrote:
> > > > On Tue, Jul 14, 2020 at 08:57:56AM +0100, Christoph Hellwig wrote:
> > > > > On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> > > > > > From: Darrick J. Wong <darrick.wong@oracle.com>
> > > > > >
> > > > > > Create a new type (xfs_dqtype_t) to represent the type of an incore
> > > > > > dquot. Break the type field out from the dq_flags field of the incore
> > > > > > dquot.
> > > > >
> > > > > I don't understand why we need separate in-core vs on-disk values for
> > > > > the type. Why not something like this on top of the whole series:
> > > >
> > > > I want to keep the ondisk d_type values separate from the incore q_type
> > > > values because they don't describe exactly the same concepts:
> > > >
> > > > First, the incore qtype has a NONE value that we can pass to the dquot
> > > > core verifier when we don't actually know if this is a user, group, or
> > > > project dquot. This should never end up on disk.
> > >
> > > Which we can trivially verify. Or just get rid of NONE, which actually
> > > cleans things up a fair bit (patch on top of my previous one below)
> >
> > Ok, I'll get rid of that usage.
> >
> > > > Second, xfs_dqtype_t is a (barely concealed) enumeration type for quota
> > > > callers to tell us that they want to perform an action on behalf of
> > > > user, group, or project quotas. The incore q_flags and the ondisk
> > > > d_type contain internal state that should not be exposed to quota
> > > > callers.
> > >
> > > I don't think that is an argument, as we do the same elsewhere.
> > >
> > > >
> > > > I feel a need to reiterate that I'm about to start adding more flags to
> > > > d_type (for y2038+ time support), for which it will be very important to
> > > > keep d_type and q_{type,flags} separate.
> > >
> > > Why? We'll just OR the bigtime flag in before writing to disk.
> >
> > Ugh, fine, I'll rework the whole series yet again, since it doesn't look
> > like anyone else is going to have the time to review a 27 patch cleanup
> > series.
>
> Let's just get your series in and I'll send an incremental patch
> after the bigtime series..
Seeing as I already refactored yesterday to produce v4 and am now midway
through refactoring to produce v5 I just going to keep going with even
more ******* cleanups.
--D
^ permalink raw reply [flat|nested] 47+ messages in thread* Re: [PATCH 05/26] xfs: split the incore dquot type into a separate field
2020-07-15 21:20 ` Darrick J. Wong
@ 2020-07-16 2:17 ` Darrick J. Wong
0 siblings, 0 replies; 47+ messages in thread
From: Darrick J. Wong @ 2020-07-16 2:17 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-xfs
On Wed, Jul 15, 2020 at 02:20:32PM -0700, Darrick J. Wong wrote:
> On Wed, Jul 15, 2020 at 07:39:48PM +0100, Christoph Hellwig wrote:
> > On Wed, Jul 15, 2020 at 11:38:38AM -0700, Darrick J. Wong wrote:
> > > On Wed, Jul 15, 2020 at 06:43:40PM +0100, Christoph Hellwig wrote:
> > > > On Tue, Jul 14, 2020 at 11:05:02AM -0700, Darrick J. Wong wrote:
> > > > > On Tue, Jul 14, 2020 at 08:57:56AM +0100, Christoph Hellwig wrote:
> > > > > > On Mon, Jul 13, 2020 at 06:32:00PM -0700, Darrick J. Wong wrote:
> > > > > > > From: Darrick J. Wong <darrick.wong@oracle.com>
> > > > > > >
> > > > > > > Create a new type (xfs_dqtype_t) to represent the type of an incore
> > > > > > > dquot. Break the type field out from the dq_flags field of the incore
> > > > > > > dquot.
> > > > > >
> > > > > > I don't understand why we need separate in-core vs on-disk values for
> > > > > > the type. Why not something like this on top of the whole series:
> > > > >
> > > > > I want to keep the ondisk d_type values separate from the incore q_type
> > > > > values because they don't describe exactly the same concepts:
> > > > >
> > > > > First, the incore qtype has a NONE value that we can pass to the dquot
> > > > > core verifier when we don't actually know if this is a user, group, or
> > > > > project dquot. This should never end up on disk.
> > > >
> > > > Which we can trivially verify. Or just get rid of NONE, which actually
> > > > cleans things up a fair bit (patch on top of my previous one below)
> > >
> > > Ok, I'll get rid of that usage.
> > >
> > > > > Second, xfs_dqtype_t is a (barely concealed) enumeration type for quota
> > > > > callers to tell us that they want to perform an action on behalf of
> > > > > user, group, or project quotas. The incore q_flags and the ondisk
> > > > > d_type contain internal state that should not be exposed to quota
> > > > > callers.
> > > >
> > > > I don't think that is an argument, as we do the same elsewhere.
> > > >
> > > > >
> > > > > I feel a need to reiterate that I'm about to start adding more flags to
> > > > > d_type (for y2038+ time support), for which it will be very important to
> > > > > keep d_type and q_{type,flags} separate.
> > > >
> > > > Why? We'll just OR the bigtime flag in before writing to disk.
> > >
> > > Ugh, fine, I'll rework the whole series yet again, since it doesn't look
> > > like anyone else is going to have the time to review a 27 patch cleanup
> > > series.
> >
> > Let's just get your series in and I'll send an incremental patch
> > after the bigtime series..
>
> Seeing as I already refactored yesterday to produce v4 and am now midway
> through refactoring to produce v5 I just going to keep going with even
> more ******* cleanups.
To elaborate on that, I've split all the patches that /have/ been
reviewed into one branch, and all the flags cleanups into a second
branch. If that second branch passes testing I'll mail it out in the
morning.
--D
> --D
^ permalink raw reply [flat|nested] 47+ messages in thread