* [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot
@ 2020-07-05 22:12 Darrick J. Wong
2020-07-05 22:12 ` [PATCH 01/22] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
` (21 more replies)
0 siblings, 22 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:12 UTC (permalink / raw)
To: darrick.wong
Cc: Christoph Hellwig, Brian Foster, Chandan Babu R, Allison Collins,
Dave Chinner, linux-xfs
Hi all,
This series replaces q_core (the ondisk quota structure) in the incore
dquot structure with a quota resource control structure containing the
count, reservation, limits, timers, and warnings. Each dquot gets three
of these resource control structures (blocks, inodes, rt blocks).
Doing this enables us to remove a whole lot of noisy endian conversions
in the quota code, and enables us to refactor a bunch of open-coded
logic to pass around pointers to quota resource control structs.
Note that these cleanups are a prerequisite for the bigtime patchset, as
it depends on incore quota timers being time64_t to take advantage of
the 64-bit time functions in the kernel with fewer places to trip over
the ondisk format.
In v2 we do some more work cleaning up the d_flags/dq_flags mess,
finally add the dquot cluster size to the ondisk format declarations
(because the cluster size actually /does/ affect that), shorten some of
the long names from v1, and fix quota warning count having been broken
for years.
If you're going to start using this mess, you probably ought to just
pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy!
Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=remove-quota-qcore
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=remove-quota-qcore
---
fs/xfs/libxfs/xfs_dquot_buf.c | 15 +-
fs/xfs/libxfs/xfs_format.h | 28 +++
fs/xfs/libxfs/xfs_quota_defs.h | 6 -
fs/xfs/scrub/quota.c | 69 +++-----
fs/xfs/xfs_dquot.c | 289 +++++++++++++++++++---------------
fs/xfs/xfs_dquot.h | 54 +++++-
fs/xfs/xfs_dquot_item.c | 8 +
fs/xfs/xfs_dquot_item_recover.c | 4
fs/xfs/xfs_iomap.c | 6 -
fs/xfs/xfs_qm.c | 113 +++++++------
fs/xfs/xfs_qm.h | 51 ++----
fs/xfs/xfs_qm_bhv.c | 20 +-
fs/xfs/xfs_qm_syscalls.c | 231 ++++++++++++++-------------
fs/xfs/xfs_quotaops.c | 12 +
fs/xfs/xfs_trace.h | 160 +++++++++++++++++--
fs/xfs/xfs_trans_dquot.c | 330 ++++++++++++++++++++-------------------
16 files changed, 798 insertions(+), 598 deletions(-)
^ permalink raw reply [flat|nested] 27+ messages in thread
* [PATCH 01/22] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
@ 2020-07-05 22:12 ` Darrick J. Wong
2020-07-05 22:12 ` [PATCH 02/22] xfs: fix inode quota reservation checks Darrick J. Wong
` (20 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:12 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] 27+ messages in thread
* [PATCH 02/22] xfs: fix inode quota reservation checks
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
2020-07-05 22:12 ` [PATCH 01/22] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
@ 2020-07-05 22:12 ` Darrick J. Wong
2020-07-05 22:12 ` [PATCH 03/22] xfs: validate ondisk/incore dquot flags Darrick J. Wong
` (19 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:12 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] 27+ messages in thread
* [PATCH 03/22] xfs: validate ondisk/incore dquot flags
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
2020-07-05 22:12 ` [PATCH 01/22] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
2020-07-05 22:12 ` [PATCH 02/22] xfs: fix inode quota reservation checks Darrick J. Wong
@ 2020-07-05 22:12 ` Darrick J. Wong
2020-07-09 13:40 ` Christoph Hellwig
2020-07-05 22:13 ` [PATCH 04/22] xfs: split " Darrick J. Wong
` (18 subsequent siblings)
21 siblings, 1 reply; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:12 UTC (permalink / raw)
To: darrick.wong; +Cc: 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>
---
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 d5b7f03e93c8..5bd963c774f8 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] 27+ messages in thread
* [PATCH 04/22] xfs: split dquot flags
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (2 preceding siblings ...)
2020-07-05 22:12 ` [PATCH 03/22] xfs: validate ondisk/incore dquot flags Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-09 13:46 ` Christoph Hellwig
2020-07-05 22:13 ` [PATCH 05/22] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
` (17 subsequent siblings)
21 siblings, 1 reply; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 UTC (permalink / raw)
To: darrick.wong; +Cc: linux-xfs
From: Darrick J. Wong <darrick.wong@oracle.com>
Split the dquot flags space between incore dquots (XFS_DQ_*) and ondisk
dquots (XFS_DQFLAG_*).
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_dquot_buf.c | 15 ++++++++++-----
fs/xfs/libxfs/xfs_format.h | 12 +++++++++++-
fs/xfs/libxfs/xfs_quota_defs.h | 6 +++---
fs/xfs/xfs_dquot.c | 4 ++--
fs/xfs/xfs_dquot_item_recover.c | 4 ++--
fs/xfs/xfs_qm.c | 21 ++++++++++++---------
6 files changed, 40 insertions(+), 22 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index bedc1e752b60..3d8abfaf8bcf 100644
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -40,6 +40,8 @@ xfs_dquot_verify(
xfs_dqid_t id,
uint type) /* used only during quotacheck */
{
+ unsigned int dtype;
+
/*
* 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,14 @@ xfs_dquot_verify(
if (ddq->d_version != XFS_DQUOT_VERSION)
return __this_address;
- if (type && ddq->d_flags != type)
+ if (ddq->d_flags & ~XFS_DDQFEAT_ANY)
return __this_address;
- if (ddq->d_flags != XFS_DQ_USER &&
- ddq->d_flags != XFS_DQ_PROJ &&
- ddq->d_flags != XFS_DQ_GROUP)
+ dtype = ddq->d_flags & XFS_DDQFEAT_TYPE_MASK;
+ if (type && dtype != type)
+ return __this_address;
+ if (dtype != XFS_DDQFEAT_USER &&
+ dtype != XFS_DDQFEAT_PROJ &&
+ dtype != XFS_DDQFEAT_GROUP)
return __this_address;
if (id != -1 && id != be32_to_cpu(ddq->d_id))
@@ -123,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_flags = type & XFS_DDQFEAT_TYPE_MASK;
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 c74249063250..fcd270194e47 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1150,6 +1150,16 @@ 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_DDQFEAT_USER 0x01 /* user dquot record */
+#define XFS_DDQFEAT_PROJ 0x02 /* project dquot record */
+#define XFS_DDQFEAT_GROUP 0x04 /* group dquot record */
+
+#define XFS_DDQFEAT_TYPE_MASK (XFS_DDQFEAT_USER | \
+ XFS_DDQFEAT_PROJ | \
+ XFS_DDQFEAT_GROUP)
+
+#define XFS_DDQFEAT_ANY (XFS_DDQFEAT_TYPE_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
@@ -1159,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_flags; /* XFS_DDQFEAT_* */
__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 56d9dd787e7b..396c10369771 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;
/*
* 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_DQ_USER XFS_DDQFEAT_USER /* a user quota */
+#define XFS_DQ_PROJ XFS_DDQFEAT_PROJ /* a project quota */
+#define XFS_DQ_GROUP XFS_DDQFEAT_GROUP /* a group quota */
#define XFS_DQ_DIRTY 0x0008 /* dquot is dirty */
#define XFS_DQ_FREEING 0x0010 /* dquot is being torn down */
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 5bd963c774f8..883573927416 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_flags = type & XFS_DDQFEAT_TYPE_MASK;
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),
@@ -536,7 +536,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_DDQFEAT_TYPE_MASK) != 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",
diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index 3400be4c88f0..edb4bd88f1a3 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_flags & XFS_DDQFEAT_TYPE_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_flags & XFS_DDQFEAT_TYPE_MASK;
ASSERT(type);
if (log->l_quotaoffs_flag & type)
return 0;
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 938023dd8ce5..bd807f740eb9 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -826,13 +826,16 @@ xfs_qm_qino_alloc(
return error;
}
-
+/*
+ * Reset the dquot counters. type should be one of the ondisk quota type flags
+ * (XFS_DQUOT_{USER,GROUP,PROJECT}.
+ */
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,
+ unsigned int type)
{
struct xfs_dqblk *dqb;
int j;
@@ -869,7 +872,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 = type & XFS_DDQFEAT_TYPE_MASK;
ddq->d_bcount = 0;
ddq->d_icount = 0;
ddq->d_rtbcount = 0;
@@ -907,11 +910,11 @@ xfs_qm_reset_dqcounts_all(
{
struct xfs_buf *bp;
int error;
- int type;
+ unsigned int 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_DDQFEAT_USER :
+ (flags & XFS_QMOPT_PQUOTA ? XFS_DDQFEAT_PROJ : XFS_DDQFEAT_GROUP);
error = 0;
/*
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 05/22] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (3 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 04/22] xfs: split " Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-09 13:47 ` Christoph Hellwig
2020-07-05 22:13 ` [PATCH 06/22] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
` (16 subsequent siblings)
21 siblings, 1 reply; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 UTC (permalink / raw)
To: darrick.wong; +Cc: 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>
---
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 fcd270194e47..d6615103db0c 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 7b0e771fcbce..2c8ca9df23af 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] 27+ messages in thread
* [PATCH 06/22] xfs: stop using q_core.d_flags in the quota code
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (4 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 05/22] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 07/22] xfs: stop using q_core.d_id " Darrick J. Wong
` (15 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 UTC (permalink / raw)
To: darrick.wong; +Cc: 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>
---
fs/xfs/scrub/quota.c | 4 ----
fs/xfs/xfs_dquot.c | 35 +++++++++++++++++++++++++++++++++--
fs/xfs/xfs_dquot.h | 2 ++
fs/xfs/xfs_dquot_item.c | 6 ++++--
fs/xfs/xfs_qm.c | 4 ++--
fs/xfs/xfs_qm.h | 2 +-
fs/xfs/xfs_qm_syscalls.c | 9 +++------
7 files changed, 45 insertions(+), 17 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 905a34558361..710659d3fa28 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -108,10 +108,6 @@ xchk_quota_item(
sqi->last_id = id;
- /* Did we get the dquot type we wanted? */
- if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
- 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_dquot.c b/fs/xfs/xfs_dquot.c
index 883573927416..8c1a6ab9b2e0 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -561,6 +561,16 @@ 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));
+ ddqp->d_flags = dqp->dq_flags & XFS_DDQFEAT_TYPE_MASK;
+}
+
/* Allocate and initialize the dquot buffer for this in-core dquot. */
static int
xfs_qm_dqread_alloc(
@@ -1108,6 +1118,19 @@ xfs_qm_dqflush_done(
xfs_dqfunlock(dqp);
}
+/* Check incore dquot for errors before we flush. */
+static xfs_failaddr_t
+xfs_qm_dqflush_check(
+ struct xfs_dquot *dqp)
+{
+ unsigned int type = dqp->dq_flags & XFS_DQ_ALLTYPES;
+
+ if (type != XFS_DQ_USER && type != XFS_DQ_GROUP && type != XFS_DQ_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.
@@ -1166,8 +1189,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 71e36c85e20b..1b1a4261a580 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -144,6 +144,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)->dq_flags & XFS_DQ_DIRTY)
#define XFS_QM_ISUDQ(dqp) ((dqp)->dq_flags & XFS_DQ_USER)
diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c
index 349c92d26570..ff0ab65cf413 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));
}
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index bd807f740eb9..16399413fbc9 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -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->dq_flags),
be32_to_cpu(dqp->q_core.d_id));
qi->qi_dquots--;
@@ -1601,7 +1601,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->dq_flags),
be32_to_cpu(dqp->q_core.d_id));
qi->qi_dquots--;
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 2c8ca9df23af..43cc01fa4b4d 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -74,7 +74,7 @@ xfs_dquot_tree(
struct xfs_quotainfo *qi,
int type)
{
- switch (type) {
+ switch (type & XFS_DQ_ALLTYPES) {
case XFS_DQ_USER:
return &qi->qi_uquota_tree;
case XFS_DQ_GROUP:
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 7effd7a28136..8cbb65f01bf1 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -644,12 +644,9 @@ 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->dq_flags & XFS_DQ_USER)) ||
+ (!XFS_IS_GQUOTA_ENFORCED(mp) && (dqp->dq_flags & XFS_DQ_GROUP)) ||
+ (!XFS_IS_PQUOTA_ENFORCED(mp) && (dqp->dq_flags & XFS_DQ_PROJ))) {
dst->d_spc_timer = 0;
dst->d_ino_timer = 0;
dst->d_rt_spc_timer = 0;
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 07/22] xfs: stop using q_core.d_id in the quota code
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (5 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 06/22] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 08/22] xfs: use a per-resource struct for incore dquot data Darrick J. Wong
` (14 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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 | 25 +++++++++++--------------
fs/xfs/xfs_dquot.h | 5 +++--
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, 43 insertions(+), 44 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 710659d3fa28..9a271f115882 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -92,7 +92,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))
@@ -102,11 +101,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);
@@ -171,13 +170,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 8c1a6ab9b2e0..2af8869a3d01 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, xfs_dquot_type(dq));
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, xfs_dquot_type(dq));
#ifdef DEBUG
@@ -366,7 +366,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),
+ xfs_qm_init_dquot_blk(tp, mp, dqp->q_id,
dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
xfs_buf_set_ref(bp, XFS_DQUOT_REF);
@@ -479,7 +479,7 @@ xfs_dquot_alloc(
dqp = kmem_zone_zalloc(xfs_qm_dqzone, 0);
dqp->dq_flags = 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);
@@ -537,10 +537,10 @@ xfs_dquot_from_disk(
* Everything else was checked by the dquot buffer verifier.
*/
if ((ddqp->d_flags & XFS_DDQFEAT_TYPE_MASK) != dqp->dq_flags ||
- 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;
}
@@ -1179,11 +1179,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;
@@ -1192,7 +1191,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;
@@ -1265,8 +1264,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 {
@@ -1334,9 +1332,8 @@ xfs_qm_dqiterate(
return error;
error = iter_fn(dq, dqtype, priv);
- id = be32_to_cpu(dq->q_core.d_id);
+ id = dq->q_id + 1;
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 1b1a4261a580..5ea1f1515979 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -31,12 +31,13 @@ enum {
* The incore dquot structure
*/
struct xfs_dquot {
- uint dq_flags;
struct list_head q_lru;
struct xfs_mount *q_mount;
+ xfs_dqid_t q_id;
+ uint dq_flags;
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 ff0ab65cf413..378d919997f1 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 16399413fbc9..3e1dfbbd1f48 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->dq_flags),
- be32_to_cpu(dqp->q_core.d_id));
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->dq_flags), dqp->q_id);
qi->qi_dquots--;
/*
@@ -1115,7 +1114,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);
}
@@ -1601,8 +1600,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->dq_flags),
- be32_to_cpu(dqp->q_core.d_id));
+ radix_tree_delete(xfs_dquot_tree(qi, dqp->dq_flags), dqp->q_id);
qi->qi_dquots--;
mutex_unlock(&qi->qi_tree_lock);
@@ -1826,7 +1824,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
@@ -1839,7 +1837,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);
@@ -1848,7 +1846,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);
@@ -1932,21 +1930,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 8cbb65f01bf1..90a11e7daf92 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_DQ_USER) ||
(XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
(XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_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 2c5df8315351..78d9dbc7614d 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -876,7 +876,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->flags = dqp->dq_flags;
__entry->nrefs = dqp->q_nrefs;
__entry->res_bcount = dqp->q_res_bcount;
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index ed0ce8b301b4..a2656ec6ea76 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);
}
@@ -558,8 +558,7 @@ xfs_quota_warn(
else
qtype = GRPQUOTA;
- 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);
}
@@ -618,8 +617,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] 27+ messages in thread
* [PATCH 08/22] xfs: use a per-resource struct for incore dquot data
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (6 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 07/22] xfs: stop using q_core.d_id " Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 09/22] xfs: stop using q_core limits in the quota code Darrick J. Wong
` (13 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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 2af8869a3d01..9d3afb4ba9e4 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -552,9 +552,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 5ea1f1515979..cb20df1e774f 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
*/
@@ -40,14 +45,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];
@@ -138,7 +142,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 b9a8c3798e08..f60a6e44363b 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(
struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
/* 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 3e1dfbbd1f48..fe0a8240c7c6 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1099,14 +1099,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 fc2fa418919f..94b2b4b0fc17 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 90a11e7daf92..56fe80395679 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 78d9dbc7614d..71567ed367f2 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -879,7 +879,7 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->id = dqp->q_id;
__entry->flags = dqp->dq_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 a2656ec6ea76..8c02430ea165 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)
@@ -602,7 +602,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);
@@ -614,7 +614,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 &&
@@ -645,7 +645,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;
@@ -675,11 +675,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,
@@ -700,9 +700,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] 27+ messages in thread
* [PATCH 09/22] xfs: stop using q_core limits in the quota code
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (7 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 08/22] xfs: use a per-resource struct for incore dquot data Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 10/22] xfs: stop using q_core counters " Darrick J. Wong
` (12 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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 | 135 ++++++++++++++++++++++++++--------------------
fs/xfs/xfs_dquot.h | 6 ++
fs/xfs/xfs_qm.c | 14 ++---
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, 138 insertions(+), 141 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 9a271f115882..1a1c6996fc69 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -82,12 +82,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;
@@ -110,15 +104,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
@@ -127,19 +112,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. */
@@ -173,13 +158,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 9d3afb4ba9e4..f763421b2212 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, xfs_dquot_type(dq));
- 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, xfs_dquot_type(dq));
#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;
}
}
@@ -291,8 +275,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);
@@ -547,6 +531,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
@@ -569,6 +559,12 @@ xfs_dquot_to_disk(
{
memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
ddqp->d_flags = dqp->dq_flags & XFS_DDQFEAT_TYPE_MASK;
+ 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. */
@@ -1123,11 +1119,30 @@ static xfs_failaddr_t
xfs_qm_dqflush_check(
struct xfs_dquot *dqp)
{
+ struct xfs_disk_dquot *ddq = &dqp->q_core;
unsigned int type = dqp->dq_flags & XFS_DQ_ALLTYPES;
if (type != XFS_DQ_USER && type != XFS_DQ_GROUP && type != XFS_DQ_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 cb20df1e774f..edb49788c476 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;
};
/*
@@ -142,7 +146,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 fe0a8240c7c6..6aa834da00fd 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -550,26 +550,24 @@ xfs_qm_set_defquota(
{
struct xfs_dquot *dqp;
struct xfs_def_quota *defq;
- struct xfs_disk_dquot *ddqp;
int error;
error = xfs_qm_dqget_uncached(mp, 0, type, &dqp);
if (error)
return;
- ddqp = &dqp->q_core;
defq = xfs_get_defquota(qinf, xfs_dquot_type(dqp));
/*
* 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 43cc01fa4b4d..d972457a5491 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 94b2b4b0fc17..0993217e5ac8 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 56fe80395679..ab596d389e3e 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 71567ed367f2..7f744a37dc0e 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -882,14 +882,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 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 8c02430ea165..6d7c0a0b7b1b 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -593,10 +593,10 @@ xfs_trans_dqresv(
defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
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);
@@ -605,10 +605,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);
@@ -649,10 +649,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] 27+ messages in thread
* [PATCH 10/22] xfs: stop using q_core counters in the quota code
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (8 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 09/22] xfs: stop using q_core limits in the quota code Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 11/22] xfs: stop using q_core warning " Darrick J. Wong
` (11 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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 1a1c6996fc69..2fc2625feca0 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -82,9 +82,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;
@@ -128,9 +125,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);
/*
@@ -139,15 +133,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);
/*
@@ -159,15 +153,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 f763421b2212..c75ac3188fa4 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;
}
}
@@ -538,13 +538,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);
@@ -565,6 +569,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. */
@@ -1128,18 +1136,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 edb49788c476..23e05b0d7567 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 6aa834da00fd..3ff66c347811 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1096,14 +1096,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 d972457a5491..78d9b2e6d085 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 7f744a37dc0e..851f97dfe9e3 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -880,8 +880,8 @@ DECLARE_EVENT_CLASS(xfs_dquot_class,
__entry->flags = dqp->dq_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 6d7c0a0b7b1b..b36d747989a7 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);
}
}
}
@@ -675,7 +667,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)
@@ -700,9 +692,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] 27+ messages in thread
* [PATCH 11/22] xfs: stop using q_core warning counters in the quota code
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (9 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 10/22] xfs: stop using q_core counters " Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 12/22] xfs: stop using q_core timers " Darrick J. Wong
` (10 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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 c75ac3188fa4..3942ef6f1e94 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 ||
@@ -542,6 +542,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.
@@ -573,6 +577,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 23e05b0d7567..5840bc54b772 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 3ff66c347811..fabc0e6062f2 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -616,12 +616,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 ab596d389e3e..5d3bccdbd3bf 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 b36d747989a7..21ed8eda3c80 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -592,7 +592,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 {
@@ -604,7 +604,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;
}
@@ -639,7 +639,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] 27+ messages in thread
* [PATCH 12/22] xfs: stop using q_core timers in the quota code
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (10 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 11/22] xfs: stop using q_core warning " Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 13/22] xfs: remove qcore from incore dquots Darrick J. Wong
` (9 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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 | 40 +++++++++++++++++++++++-----------------
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(+), 39 deletions(-)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 3942ef6f1e94..6738e33102a2 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;
}
}
}
@@ -546,6 +545,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.
@@ -581,6 +584,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. */
@@ -1135,7 +1142,6 @@ static xfs_failaddr_t
xfs_qm_dqflush_check(
struct xfs_dquot *dqp)
{
- struct xfs_disk_dquot *ddq = &dqp->q_core;
unsigned int type = dqp->dq_flags & XFS_DQ_ALLTYPES;
if (type != XFS_DQ_USER && type != XFS_DQ_GROUP && type != XFS_DQ_PROJ)
@@ -1145,15 +1151,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 5840bc54b772..414bae537b1d 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 fabc0e6062f2..54b8d270843b 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -579,7 +579,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;
@@ -603,19 +602,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 5d3bccdbd3bf..1b2b70b1660f 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 21ed8eda3c80..28b59a4069a3 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -591,7 +591,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;
@@ -603,7 +603,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;
@@ -638,7 +638,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] 27+ messages in thread
* [PATCH 13/22] xfs: remove qcore from incore dquots
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (11 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 12/22] xfs: stop using q_core timers " Darrick J. Wong
@ 2020-07-05 22:13 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 14/22] xfs: refactor default quota limits by resource Darrick J. Wong
` (8 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:13 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/scrub/quota.c | 4 ----
fs/xfs/xfs_dquot.c | 35 ++++++++++++-----------------------
fs/xfs/xfs_dquot.h | 1 -
3 files changed, 12 insertions(+), 28 deletions(-)
diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 2fc2625feca0..f4aad5b00188 100644
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -79,7 +79,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;
@@ -98,9 +97,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 6738e33102a2..1d96b254539b 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -529,7 +529,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);
@@ -568,8 +567,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_flags = dqp->dq_flags & XFS_DDQFEAT_TYPE_MASK;
+ 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);
@@ -1181,8 +1185,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;
@@ -1206,22 +1209,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",
@@ -1231,7 +1218,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.
@@ -1251,8 +1240,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 414bae537b1d..62b0fc6e0133 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -71,7 +71,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] 27+ messages in thread
* [PATCH 14/22] xfs: refactor default quota limits by resource
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (12 preceding siblings ...)
2020-07-05 22:13 ` [PATCH 13/22] xfs: remove qcore from incore dquots Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 15/22] xfs: remove unnecessary arguments from quota adjust functions Darrick J. Wong
` (7 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 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 1d96b254539b..78dafaca6fee 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, xfs_dquot_type(dq));
- 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 54b8d270843b..e2b218ffc7c8 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -562,12 +562,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);
}
@@ -584,12 +584,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.
@@ -608,17 +608,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 78d9b2e6d085..9b21279f9b3f 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 1b2b70b1660f..791b6ae27b6c 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 bf809b77a316..7a8c6de21b85 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 28b59a4069a3..4eee634f40d1 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -587,25 +587,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;
}
@@ -640,13 +640,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] 27+ messages in thread
* [PATCH 15/22] xfs: remove unnecessary arguments from quota adjust functions
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (13 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 14/22] xfs: refactor default quota limits by resource Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 16/22] xfs: refactor quota exceeded test Darrick J. Wong
` (6 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 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 78dafaca6fee..3c3f2ab5ebd3 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 62b0fc6e0133..e37b4bebc1ea 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -181,10 +181,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, uint type);
int xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
uint type, bool can_alloc,
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index e2b218ffc7c8..9b715719e7fc 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1110,8 +1110,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->dq_flags |= XFS_DQ_DIRTY;
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 791b6ae27b6c..580546f3ab40 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->dq_flags |= XFS_DQ_DIRTY;
xfs_trans_log_dquot(tp, dqp);
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 4eee634f40d1..130d97871a3d 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->dq_flags |= XFS_DQ_DIRTY;
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 16/22] xfs: refactor quota exceeded test
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (14 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 15/22] xfs: remove unnecessary arguments from quota adjust functions Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 17/22] xfs: refactor xfs_qm_scall_setqlim Darrick J. Wong
` (5 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 UTC (permalink / raw)
To: darrick.wong; +Cc: Chandan Babu R, 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>
---
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 3c3f2ab5ebd3..44734584f8fb 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, xfs_dquot_type(dq));
-#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] 27+ messages in thread
* [PATCH 17/22] xfs: refactor xfs_qm_scall_setqlim
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (15 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 16/22] xfs: refactor quota exceeded test Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 18/22] xfs: refactor xfs_trans_dqresv Darrick J. Wong
` (4 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 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 580546f3ab40..2e3e36b5eaad 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] 27+ messages in thread
* [PATCH 18/22] xfs: refactor xfs_trans_dqresv
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (16 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 17/22] xfs: refactor xfs_qm_scall_setqlim Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 19/22] xfs: refactor xfs_trans_apply_dquot_deltas Darrick J. Wong
` (3 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 UTC (permalink / raw)
To: darrick.wong; +Cc: Chandan Babu R, Allison Collins, 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>
---
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 130d97871a3d..7f847cfba885 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -554,6 +554,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
@@ -569,99 +621,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, xfs_dquot_type(dqp));
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);
- }
}
}
@@ -669,9 +673,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] 27+ messages in thread
* [PATCH 19/22] xfs: refactor xfs_trans_apply_dquot_deltas
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (17 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 18/22] xfs: refactor xfs_trans_dqresv Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 20/22] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits Darrick J. Wong
` (2 subsequent siblings)
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 UTC (permalink / raw)
To: darrick.wong; +Cc: Allison Collins, 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>
---
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 7f847cfba885..4439fe04f928 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] 27+ messages in thread
* [PATCH 20/22] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (18 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 19/22] xfs: refactor xfs_trans_apply_dquot_deltas Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 21/22] xfs: actually bump warning counts when we send warnings Darrick J. Wong
2020-07-05 22:14 ` [PATCH 22/22] xfs: add more dquot tracepoints Darrick J. Wong
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 UTC (permalink / raw)
To: darrick.wong; +Cc: 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>
---
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 44734584f8fb..710119538a6a 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, xfs_dquot_type(dq));
- 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] 27+ messages in thread
* [PATCH 21/22] xfs: actually bump warning counts when we send warnings
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (19 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 20/22] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
2020-07-05 22:14 ` [PATCH 22/22] xfs: add more dquot tracepoints Darrick J. Wong
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 UTC (permalink / raw)
To: darrick.wong; +Cc: 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>
---
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 4439fe04f928..1c3385f7f273 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -589,6 +589,7 @@ xfs_dqresv_check(
return QUOTA_NL_ISOFTLONGWARN;
}
+ res->warnings++;
return QUOTA_NL_ISOFTWARN;
}
^ permalink raw reply related [flat|nested] 27+ messages in thread
* [PATCH 22/22] xfs: add more dquot tracepoints
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
` (20 preceding siblings ...)
2020-07-05 22:14 ` [PATCH 21/22] xfs: actually bump warning counts when we send warnings Darrick J. Wong
@ 2020-07-05 22:14 ` Darrick J. Wong
21 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-05 22:14 UTC (permalink / raw)
To: darrick.wong; +Cc: Allison Collins, 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>
---
fs/xfs/xfs_trace.h | 140 +++++++++++++++++++++++++++++++++++++++++++++-
fs/xfs/xfs_trans_dquot.c | 21 +++++++
2 files changed, 159 insertions(+), 2 deletions(-)
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 851f97dfe9e3..35b9dfd3984f 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" }, \
@@ -867,37 +868,59 @@ 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->flags = dqp->dq_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 flags %s nrefs %u res_bc 0x%llx "
+ TP_printk("dev %d:%d id 0x%x 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,
__print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
__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)
@@ -928,6 +951,119 @@ 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(unsigned int, dqflags)
+ __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->dqflags = dqp->dq_flags;
+ __entry->dqid = dqp->q_id;
+ __entry->field = field;
+ __entry->delta = delta;
+ ),
+ TP_printk("dev %d:%d dquot %s id 0x%x %s delta %lld",
+ MAJOR(__entry->dev), MINOR(__entry->dev),
+ __print_flags(__entry->dqflags, "|", XFS_DQ_FLAGS),
+ __entry->dqid,
+ __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(unsigned int, dqflags)
+ __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->dqflags = qtrx->qt_dquot->dq_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 %s id 0x%x "
+ "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),
+ __print_flags(__entry->dqflags, "|", XFS_DQ_FLAGS),
+ __entry->dqid,
+
+ __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 1c3385f7f273..f523b1a3b3ae 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] 27+ messages in thread
* Re: [PATCH 03/22] xfs: validate ondisk/incore dquot flags
2020-07-05 22:12 ` [PATCH 03/22] xfs: validate ondisk/incore dquot flags Darrick J. Wong
@ 2020-07-09 13:40 ` Christoph Hellwig
0 siblings, 0 replies; 27+ messages in thread
From: Christoph Hellwig @ 2020-07-09 13:40 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Sun, Jul 05, 2020 at 03:12:53PM -0700, 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.
>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Looks good,
Reviewed-by: Christoph Hellwig <hch@lst.de>
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 04/22] xfs: split dquot flags
2020-07-05 22:13 ` [PATCH 04/22] xfs: split " Darrick J. Wong
@ 2020-07-09 13:46 ` Christoph Hellwig
2020-07-09 23:37 ` Darrick J. Wong
0 siblings, 1 reply; 27+ messages in thread
From: Christoph Hellwig @ 2020-07-09 13:46 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Sun, Jul 05, 2020 at 03:13:00PM -0700, Darrick J. Wong wrote:
> + dtype = ddq->d_flags & XFS_DDQFEAT_TYPE_MASK;
> + if (type && dtype != type)
> + return __this_address;
> + if (dtype != XFS_DDQFEAT_USER &&
> + dtype != XFS_DDQFEAT_PROJ &&
> + dtype != XFS_DDQFEAT_GROUP)
> return __this_address;
Why not use hweight here?
> if (id != -1 && id != be32_to_cpu(ddq->d_id))
> @@ -123,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_flags = type & XFS_DDQFEAT_TYPE_MASK;
And this still mixes up the on-disk and in-memory flags. I think they
really need to be separated and kept entirely separate.
e.g. rename the d_flags field to d_type in both the on-disk and
in-core inode, rename the values to XFS_DQTYPE_*, and then have a
separate u8 d_flags just in the in-core inode for just the in-core
values.
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 05/22] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format
2020-07-05 22:13 ` [PATCH 05/22] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
@ 2020-07-09 13:47 ` Christoph Hellwig
0 siblings, 0 replies; 27+ messages in thread
From: Christoph Hellwig @ 2020-07-09 13:47 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs
On Sun, Jul 05, 2020 at 03:13:06PM -0700, Darrick J. 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.
Looks good:
Reviewed-by: Christoph Hellwig <hch@lst.de>
^ permalink raw reply [flat|nested] 27+ messages in thread
* Re: [PATCH 04/22] xfs: split dquot flags
2020-07-09 13:46 ` Christoph Hellwig
@ 2020-07-09 23:37 ` Darrick J. Wong
0 siblings, 0 replies; 27+ messages in thread
From: Darrick J. Wong @ 2020-07-09 23:37 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: linux-xfs
On Thu, Jul 09, 2020 at 02:46:09PM +0100, Christoph Hellwig wrote:
> On Sun, Jul 05, 2020 at 03:13:00PM -0700, Darrick J. Wong wrote:
> > + dtype = ddq->d_flags & XFS_DDQFEAT_TYPE_MASK;
> > + if (type && dtype != type)
> > + return __this_address;
> > + if (dtype != XFS_DDQFEAT_USER &&
> > + dtype != XFS_DDQFEAT_PROJ &&
> > + dtype != XFS_DDQFEAT_GROUP)
> > return __this_address;
>
> Why not use hweight here?
>
> > if (id != -1 && id != be32_to_cpu(ddq->d_id))
> > @@ -123,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_flags = type & XFS_DDQFEAT_TYPE_MASK;
>
> And this still mixes up the on-disk and in-memory flags. I think they
> really need to be separated and kept entirely separate.
>
> e.g. rename the d_flags field to d_type in both the on-disk and
> in-core inode, rename the values to XFS_DQTYPE_*, and then have a
> separate u8 d_flags just in the in-core inode for just the in-core
> values.
Rrrgh, fine, this is going to cause a lot of hell refactoring the whole
series a fourth time, but here I go...
--D
^ permalink raw reply [flat|nested] 27+ messages in thread
end of thread, other threads:[~2020-07-09 23:40 UTC | newest]
Thread overview: 27+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-07-05 22:12 [PATCH v2 00/22] xfs: remove xfs_disk_quot from incore dquot Darrick J. Wong
2020-07-05 22:12 ` [PATCH 01/22] xfs: clear XFS_DQ_FREEING if we can't lock the dquot buffer to flush Darrick J. Wong
2020-07-05 22:12 ` [PATCH 02/22] xfs: fix inode quota reservation checks Darrick J. Wong
2020-07-05 22:12 ` [PATCH 03/22] xfs: validate ondisk/incore dquot flags Darrick J. Wong
2020-07-09 13:40 ` Christoph Hellwig
2020-07-05 22:13 ` [PATCH 04/22] xfs: split " Darrick J. Wong
2020-07-09 13:46 ` Christoph Hellwig
2020-07-09 23:37 ` Darrick J. Wong
2020-07-05 22:13 ` [PATCH 05/22] xfs: make XFS_DQUOT_CLUSTER_SIZE_FSB part of the ondisk format Darrick J. Wong
2020-07-09 13:47 ` Christoph Hellwig
2020-07-05 22:13 ` [PATCH 06/22] xfs: stop using q_core.d_flags in the quota code Darrick J. Wong
2020-07-05 22:13 ` [PATCH 07/22] xfs: stop using q_core.d_id " Darrick J. Wong
2020-07-05 22:13 ` [PATCH 08/22] xfs: use a per-resource struct for incore dquot data Darrick J. Wong
2020-07-05 22:13 ` [PATCH 09/22] xfs: stop using q_core limits in the quota code Darrick J. Wong
2020-07-05 22:13 ` [PATCH 10/22] xfs: stop using q_core counters " Darrick J. Wong
2020-07-05 22:13 ` [PATCH 11/22] xfs: stop using q_core warning " Darrick J. Wong
2020-07-05 22:13 ` [PATCH 12/22] xfs: stop using q_core timers " Darrick J. Wong
2020-07-05 22:13 ` [PATCH 13/22] xfs: remove qcore from incore dquots Darrick J. Wong
2020-07-05 22:14 ` [PATCH 14/22] xfs: refactor default quota limits by resource Darrick J. Wong
2020-07-05 22:14 ` [PATCH 15/22] xfs: remove unnecessary arguments from quota adjust functions Darrick J. Wong
2020-07-05 22:14 ` [PATCH 16/22] xfs: refactor quota exceeded test Darrick J. Wong
2020-07-05 22:14 ` [PATCH 17/22] xfs: refactor xfs_qm_scall_setqlim Darrick J. Wong
2020-07-05 22:14 ` [PATCH 18/22] xfs: refactor xfs_trans_dqresv Darrick J. Wong
2020-07-05 22:14 ` [PATCH 19/22] xfs: refactor xfs_trans_apply_dquot_deltas Darrick J. Wong
2020-07-05 22:14 ` [PATCH 20/22] xfs: assume the default quota limits are always set in xfs_qm_adjust_dqlimits Darrick J. Wong
2020-07-05 22:14 ` [PATCH 21/22] xfs: actually bump warning counts when we send warnings Darrick J. Wong
2020-07-05 22:14 ` [PATCH 22/22] xfs: add more dquot tracepoints Darrick J. Wong
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).