kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/fs/xfs/scrub/quota.c
..
..
@@ -9,37 +9,26 @@
9
9
 #include "xfs_format.h"
10
10
 #include "xfs_trans_resv.h"
11
11
 #include "xfs_mount.h"
12
-#include "xfs_defer.h"
13
-#include "xfs_btree.h"
14
-#include "xfs_bit.h"
15
12
 #include "xfs_log_format.h"
16
13
 #include "xfs_trans.h"
17
-#include "xfs_sb.h"
18
14
 #include "xfs_inode.h"
19
-#include "xfs_inode_fork.h"
20
-#include "xfs_alloc.h"
21
-#include "xfs_bmap.h"
22
15
 #include "xfs_quota.h"
23
16
 #include "xfs_qm.h"
24
-#include "xfs_dquot.h"
25
-#include "xfs_dquot_item.h"
26
-#include "scrub/xfs_scrub.h"
27
17
 #include "scrub/scrub.h"
28
18
 #include "scrub/common.h"
29
-#include "scrub/trace.h"
30
19
 
31
20
 /* Convert a scrub type code to a DQ flag, or return 0 if error. */
32
-static inline uint
21
+static inline xfs_dqtype_t
33
22
 xchk_quota_to_dqtype(
34
23
 	struct xfs_scrub	*sc)
35
24
 {
36
25
 	switch (sc->sm->sm_type) {
37
26
 	case XFS_SCRUB_TYPE_UQUOTA:
38
-		return XFS_DQ_USER;
27
+		return XFS_DQTYPE_USER;
39
28
 	case XFS_SCRUB_TYPE_GQUOTA:
40
-		return XFS_DQ_GROUP;
29
+		return XFS_DQTYPE_GROUP;
41
30
 	case XFS_SCRUB_TYPE_PQUOTA:
42
-		return XFS_DQ_PROJ;
31
+		return XFS_DQTYPE_PROJ;
43
32
 	default:
44
33
 		return 0;
45
34
 	}
..
..
@@ -51,7 +40,7 @@
51
40
 	struct xfs_scrub	*sc,
52
41
 	struct xfs_inode	*ip)
53
42
 {
54
-	uint			dqtype;
43
+	xfs_dqtype_t		dqtype;
55
44
 	int			error;
56
45
 
57
46
 	if (!XFS_IS_QUOTA_RUNNING(sc->mp) || !XFS_IS_QUOTA_ON(sc->mp))
..
..
@@ -60,7 +49,7 @@
60
49
 	dqtype = xchk_quota_to_dqtype(sc);
61
50
 	if (dqtype == 0)
62
51
 		return -EINVAL;
63
-	sc->has_quotaofflock = true;
52
+	sc->flags |= XCHK_HAS_QUOTAOFFLOCK;
64
53
 	mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock);
65
54
 	if (!xfs_this_quota_on(sc->mp, dqtype))
66
55
 		return -ENOENT;
..
..
@@ -84,52 +73,29 @@
84
73
 STATIC int
85
74
 xchk_quota_item(
86
75
 	struct xfs_dquot	*dq,
87
-	uint			dqtype,
76
+	xfs_dqtype_t		dqtype,
88
77
 	void			*priv)
89
78
 {
90
79
 	struct xchk_quota_info	*sqi = priv;
91
80
 	struct xfs_scrub	*sc = sqi->sc;
92
81
 	struct xfs_mount	*mp = sc->mp;
93
-	struct xfs_disk_dquot	*d = &dq->q_core;
94
82
 	struct xfs_quotainfo	*qi = mp->m_quotainfo;
95
83
 	xfs_fileoff_t		offset;
96
-	unsigned long long	bsoft;
97
-	unsigned long long	isoft;
98
-	unsigned long long	rsoft;
99
-	unsigned long long	bhard;
100
-	unsigned long long	ihard;
101
-	unsigned long long	rhard;
102
-	unsigned long long	bcount;
103
-	unsigned long long	icount;
104
-	unsigned long long	rcount;
105
84
 	xfs_ino_t		fs_icount;
106
-	xfs_dqid_t		id = be32_to_cpu(d->d_id);
85
+	int			error = 0;
86
+
87
+	if (xchk_should_terminate(sc, &error))
88
+		return error;
107
89
 
108
90
 	/*
109
91
 	 * Except for the root dquot, the actual dquot we got must either have
110
92
 	 * the same or higher id as we saw before.
111
93
 	 */
112
-	offset = id / qi->qi_dqperchunk;
113
-	if (id && id <= sqi->last_id)
94
+	offset = dq->q_id / qi->qi_dqperchunk;
95
+	if (dq->q_id && dq->q_id <= sqi->last_id)
114
96
 		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
115
97
 
116
-	sqi->last_id = id;
117
-
118
-	/* Did we get the dquot type we wanted? */
119
-	if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
120
-		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
121
-
122
-	if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
123
-		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
124
-
125
-	/* Check the limits. */
126
-	bhard = be64_to_cpu(d->d_blk_hardlimit);
127
-	ihard = be64_to_cpu(d->d_ino_hardlimit);
128
-	rhard = be64_to_cpu(d->d_rtb_hardlimit);
129
-
130
-	bsoft = be64_to_cpu(d->d_blk_softlimit);
131
-	isoft = be64_to_cpu(d->d_ino_softlimit);
132
-	rsoft = be64_to_cpu(d->d_rtb_softlimit);
98
+	sqi->last_id = dq->q_id;
133
99
 
134
100
 	/*
135
101
 	 * Warn if the hard limits are larger than the fs.
..
..
@@ -139,25 +105,22 @@
139
105
 	 * Complain about corruption if the soft limit is greater than
140
106
 	 * the hard limit.
141
107
 	 */
142
-	if (bhard > mp->m_sb.sb_dblocks)
108
+	if (dq->q_blk.hardlimit > mp->m_sb.sb_dblocks)
143
109
 		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
144
-	if (bsoft > bhard)
110
+	if (dq->q_blk.softlimit > dq->q_blk.hardlimit)
145
111
 		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
146
112
 
147
-	if (ihard > mp->m_maxicount)
113
+	if (dq->q_ino.hardlimit > M_IGEO(mp)->maxicount)
148
114
 		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
149
-	if (isoft > ihard)
115
+	if (dq->q_ino.softlimit > dq->q_ino.hardlimit)
150
116
 		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
151
117
 
152
-	if (rhard > mp->m_sb.sb_rblocks)
118
+	if (dq->q_rtb.hardlimit > mp->m_sb.sb_rblocks)
153
119
 		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
154
-	if (rsoft > rhard)
120
+	if (dq->q_rtb.softlimit > dq->q_rtb.hardlimit)
155
121
 		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
156
122
 
157
123
 	/* Check the resource counts. */
158
-	bcount = be64_to_cpu(d->d_bcount);
159
-	icount = be64_to_cpu(d->d_icount);
160
-	rcount = be64_to_cpu(d->d_rtbcount);
161
124
 	fs_icount = percpu_counter_sum(&mp->m_icount);
162
125
 
163
126
 	/*
..
..
@@ -166,15 +129,15 @@
166
129
 	 * if there are no quota limits.
167
130
 	 */
168
131
 	if (xfs_sb_version_hasreflink(&mp->m_sb)) {
169
-		if (mp->m_sb.sb_dblocks < bcount)
132
+		if (mp->m_sb.sb_dblocks < dq->q_blk.count)
170
133
 			xchk_fblock_set_warning(sc, XFS_DATA_FORK,
171
134
 					offset);
172
135
 	} else {
173
-		if (mp->m_sb.sb_dblocks < bcount)
136
+		if (mp->m_sb.sb_dblocks < dq->q_blk.count)
174
137
 			xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
175
138
 					offset);
176
139
 	}
177
-	if (icount > fs_icount || rcount > mp->m_sb.sb_rblocks)
140
+	if (dq->q_ino.count > fs_icount || dq->q_rtb.count > mp->m_sb.sb_rblocks)
178
141
 		xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
179
142
 
180
143
 	/*
..
..
@@ -182,12 +145,24 @@
182
145
 	 * lower limit than the actual usage.  However, we flag it for
183
146
 	 * admin review.
184
147
 	 */
185
-	if (id != 0 && bhard != 0 && bcount > bhard)
148
+	if (dq->q_id == 0)
149
+		goto out;
150
+
151
+	if (dq->q_blk.hardlimit != 0 &&
152
+	    dq->q_blk.count > dq->q_blk.hardlimit)
186
153
 		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
187
-	if (id != 0 && ihard != 0 && icount > ihard)
154
+
155
+	if (dq->q_ino.hardlimit != 0 &&
156
+	    dq->q_ino.count > dq->q_ino.hardlimit)
188
157
 		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
189
-	if (id != 0 && rhard != 0 && rcount > rhard)
158
+
159
+	if (dq->q_rtb.hardlimit != 0 &&
160
+	    dq->q_rtb.count > dq->q_rtb.hardlimit)
190
161
 		xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
162
+
163
+out:
164
+	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
165
+		return -EFSCORRUPTED;
191
166
 
192
167
 	return 0;
193
168
 }
..
..
@@ -239,7 +214,7 @@
239
214
 	struct xchk_quota_info	sqi;
240
215
 	struct xfs_mount	*mp = sc->mp;
241
216
 	struct xfs_quotainfo	*qi = mp->m_quotainfo;
242
-	uint			dqtype;
217
+	xfs_dqtype_t		dqtype;
243
218
 	int			error = 0;
244
219
 
245
220
 	dqtype = xchk_quota_to_dqtype(sc);