?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'xtensa-20180225' of git://github.com/jcmvbkbc/linux-xtensa
[cris-mirror.git] / fs / xfs / scrub / agheader.c
blobfd975524f4603387e28078d13b175b5df2443021
1 /*
2 * Copyright (C) 2017 Oracle. All Rights Reserved.
3 *
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it would be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20 #include "xfs.h"
21 #include "xfs_fs.h"
22 #include "xfs_shared.h"
23 #include "xfs_format.h"
24 #include "xfs_trans_resv.h"
25 #include "xfs_mount.h"
26 #include "xfs_defer.h"
27 #include "xfs_btree.h"
28 #include "xfs_bit.h"
29 #include "xfs_log_format.h"
30 #include "xfs_trans.h"
31 #include "xfs_sb.h"
32 #include "xfs_inode.h"
33 #include "xfs_alloc.h"
34 #include "xfs_ialloc.h"
35 #include "xfs_rmap.h"
36 #include "scrub/xfs_scrub.h"
37 #include "scrub/scrub.h"
38 #include "scrub/common.h"
39 #include "scrub/trace.h"
40
41 /*
42 * Walk all the blocks in the AGFL. The fn function can return any negative
43 * error code or XFS_BTREE_QUERY_RANGE_ABORT.
44 */
45 int
46 xfs_scrub_walk_agfl(
47 struct xfs_scrub_context *sc,
48 int (*fn)(struct xfs_scrub_context *,
49 xfs_agblock_t bno, void *),
50 void *priv)
51 {
52 struct xfs_agf *agf;
53 __be32 *agfl_bno;
54 struct xfs_mount *mp = sc->mp;
55 unsigned int flfirst;
56 unsigned int fllast;
57 int i;
58 int error;
59
60 agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
61 agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, sc->sa.agfl_bp);
62 flfirst = be32_to_cpu(agf->agf_flfirst);
63 fllast = be32_to_cpu(agf->agf_fllast);
64
65 /* Nothing to walk in an empty AGFL. */
66 if (agf->agf_flcount == cpu_to_be32(0))
67 return 0;
68
69 /* first to last is a consecutive list. */
70 if (fllast >= flfirst) {
71 for (i = flfirst; i <= fllast; i++) {
72 error = fn(sc, be32_to_cpu(agfl_bno[i]), priv);
73 if (error)
74 return error;
75 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
76 return error;
77 }
78
79 return 0;
80 }
81
82 /* first to the end */
83 for (i = flfirst; i < XFS_AGFL_SIZE(mp); i++) {
84 error = fn(sc, be32_to_cpu(agfl_bno[i]), priv);
85 if (error)
86 return error;
87 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
88 return error;
89 }
90
91 /* the start to last. */
92 for (i = 0; i <= fllast; i++) {
93 error = fn(sc, be32_to_cpu(agfl_bno[i]), priv);
94 if (error)
95 return error;
96 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
97 return error;
98 }
99
100 return 0;
101 }
102
103 /* Superblock */
104
105 /* Cross-reference with the other btrees. */
106 STATIC void
107 xfs_scrub_superblock_xref(
108 struct xfs_scrub_context *sc,
109 struct xfs_buf *bp)
110 {
111 struct xfs_owner_info oinfo;
112 struct xfs_mount *mp = sc->mp;
113 xfs_agnumber_t agno = sc->sm->sm_agno;
114 xfs_agblock_t agbno;
115 int error;
116
117 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
118 return;
119
120 agbno = XFS_SB_BLOCK(mp);
121
122 error = xfs_scrub_ag_init(sc, agno, &sc->sa);
123 if (!xfs_scrub_xref_process_error(sc, agno, agbno, &error))
124 return;
125
126 xfs_scrub_xref_is_used_space(sc, agbno, 1);
127 xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
128 xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
129 xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
130 xfs_scrub_xref_is_not_shared(sc, agbno, 1);
131
132 /* scrub teardown will take care of sc->sa for us */
133 }
134
135 /*
136 * Scrub the filesystem superblock.
137 *
138 * Note: We do /not/ attempt to check AG 0's superblock. Mount is
139 * responsible for validating all the geometry information in sb 0, so
140 * if the filesystem is capable of initiating online scrub, then clearly
141 * sb 0 is ok and we can use its information to check everything else.
142 */
143 int
144 xfs_scrub_superblock(
145 struct xfs_scrub_context *sc)
146 {
147 struct xfs_mount *mp = sc->mp;
148 struct xfs_buf *bp;
149 struct xfs_dsb *sb;
150 xfs_agnumber_t agno;
151 uint32_t v2_ok;
152 __be32 features_mask;
153 int error;
154 __be16 vernum_mask;
155
156 agno = sc->sm->sm_agno;
157 if (agno == 0)
158 return 0;
159
160 error = xfs_trans_read_buf(mp, sc->tp, mp->m_ddev_targp,
161 XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
162 XFS_FSS_TO_BB(mp, 1), 0, &bp, &xfs_sb_buf_ops);
163 /*
164 * The superblock verifier can return several different error codes
165 * if it thinks the superblock doesn't look right. For a mount these
166 * would all get bounced back to userspace, but if we're here then the
167 * fs mounted successfully, which means that this secondary superblock
168 * is simply incorrect. Treat all these codes the same way we treat
169 * any corruption.
170 */
171 switch (error) {
172 case -EINVAL: /* also -EWRONGFS */
173 case -ENOSYS:
174 case -EFBIG:
175 error = -EFSCORRUPTED;
176 default:
177 break;
178 }
179 if (!xfs_scrub_process_error(sc, agno, XFS_SB_BLOCK(mp), &error))
180 return error;
181
182 sb = XFS_BUF_TO_SBP(bp);
183
184 /*
185 * Verify the geometries match. Fields that are permanently
186 * set by mkfs are checked; fields that can be updated later
187 * (and are not propagated to backup superblocks) are preen
188 * checked.
189 */
190 if (sb->sb_blocksize != cpu_to_be32(mp->m_sb.sb_blocksize))
191 xfs_scrub_block_set_corrupt(sc, bp);
192
193 if (sb->sb_dblocks != cpu_to_be64(mp->m_sb.sb_dblocks))
194 xfs_scrub_block_set_corrupt(sc, bp);
195
196 if (sb->sb_rblocks != cpu_to_be64(mp->m_sb.sb_rblocks))
197 xfs_scrub_block_set_corrupt(sc, bp);
198
199 if (sb->sb_rextents != cpu_to_be64(mp->m_sb.sb_rextents))
200 xfs_scrub_block_set_corrupt(sc, bp);
201
202 if (!uuid_equal(&sb->sb_uuid, &mp->m_sb.sb_uuid))
203 xfs_scrub_block_set_preen(sc, bp);
204
205 if (sb->sb_logstart != cpu_to_be64(mp->m_sb.sb_logstart))
206 xfs_scrub_block_set_corrupt(sc, bp);
207
208 if (sb->sb_rootino != cpu_to_be64(mp->m_sb.sb_rootino))
209 xfs_scrub_block_set_preen(sc, bp);
210
211 if (sb->sb_rbmino != cpu_to_be64(mp->m_sb.sb_rbmino))
212 xfs_scrub_block_set_preen(sc, bp);
213
214 if (sb->sb_rsumino != cpu_to_be64(mp->m_sb.sb_rsumino))
215 xfs_scrub_block_set_preen(sc, bp);
216
217 if (sb->sb_rextsize != cpu_to_be32(mp->m_sb.sb_rextsize))
218 xfs_scrub_block_set_corrupt(sc, bp);
219
220 if (sb->sb_agblocks != cpu_to_be32(mp->m_sb.sb_agblocks))
221 xfs_scrub_block_set_corrupt(sc, bp);
222
223 if (sb->sb_agcount != cpu_to_be32(mp->m_sb.sb_agcount))
224 xfs_scrub_block_set_corrupt(sc, bp);
225
226 if (sb->sb_rbmblocks != cpu_to_be32(mp->m_sb.sb_rbmblocks))
227 xfs_scrub_block_set_corrupt(sc, bp);
228
229 if (sb->sb_logblocks != cpu_to_be32(mp->m_sb.sb_logblocks))
230 xfs_scrub_block_set_corrupt(sc, bp);
231
232 /* Check sb_versionnum bits that are set at mkfs time. */
233 vernum_mask = cpu_to_be16(~XFS_SB_VERSION_OKBITS |
234 XFS_SB_VERSION_NUMBITS |
235 XFS_SB_VERSION_ALIGNBIT |
236 XFS_SB_VERSION_DALIGNBIT |
237 XFS_SB_VERSION_SHAREDBIT |
238 XFS_SB_VERSION_LOGV2BIT |
239 XFS_SB_VERSION_SECTORBIT |
240 XFS_SB_VERSION_EXTFLGBIT |
241 XFS_SB_VERSION_DIRV2BIT);
242 if ((sb->sb_versionnum & vernum_mask) !=
243 (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask))
244 xfs_scrub_block_set_corrupt(sc, bp);
245
246 /* Check sb_versionnum bits that can be set after mkfs time. */
247 vernum_mask = cpu_to_be16(XFS_SB_VERSION_ATTRBIT |
248 XFS_SB_VERSION_NLINKBIT |
249 XFS_SB_VERSION_QUOTABIT);
250 if ((sb->sb_versionnum & vernum_mask) !=
251 (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask))
252 xfs_scrub_block_set_preen(sc, bp);
253
254 if (sb->sb_sectsize != cpu_to_be16(mp->m_sb.sb_sectsize))
255 xfs_scrub_block_set_corrupt(sc, bp);
256
257 if (sb->sb_inodesize != cpu_to_be16(mp->m_sb.sb_inodesize))
258 xfs_scrub_block_set_corrupt(sc, bp);
259
260 if (sb->sb_inopblock != cpu_to_be16(mp->m_sb.sb_inopblock))
261 xfs_scrub_block_set_corrupt(sc, bp);
262
263 if (memcmp(sb->sb_fname, mp->m_sb.sb_fname, sizeof(sb->sb_fname)))
264 xfs_scrub_block_set_preen(sc, bp);
265
266 if (sb->sb_blocklog != mp->m_sb.sb_blocklog)
267 xfs_scrub_block_set_corrupt(sc, bp);
268
269 if (sb->sb_sectlog != mp->m_sb.sb_sectlog)
270 xfs_scrub_block_set_corrupt(sc, bp);
271
272 if (sb->sb_inodelog != mp->m_sb.sb_inodelog)
273 xfs_scrub_block_set_corrupt(sc, bp);
274
275 if (sb->sb_inopblog != mp->m_sb.sb_inopblog)
276 xfs_scrub_block_set_corrupt(sc, bp);
277
278 if (sb->sb_agblklog != mp->m_sb.sb_agblklog)
279 xfs_scrub_block_set_corrupt(sc, bp);
280
281 if (sb->sb_rextslog != mp->m_sb.sb_rextslog)
282 xfs_scrub_block_set_corrupt(sc, bp);
283
284 if (sb->sb_imax_pct != mp->m_sb.sb_imax_pct)
285 xfs_scrub_block_set_preen(sc, bp);
286
287 /*
288 * Skip the summary counters since we track them in memory anyway.
289 * sb_icount, sb_ifree, sb_fdblocks, sb_frexents
290 */
291
292 if (sb->sb_uquotino != cpu_to_be64(mp->m_sb.sb_uquotino))
293 xfs_scrub_block_set_preen(sc, bp);
294
295 if (sb->sb_gquotino != cpu_to_be64(mp->m_sb.sb_gquotino))
296 xfs_scrub_block_set_preen(sc, bp);
297
298 /*
299 * Skip the quota flags since repair will force quotacheck.
300 * sb_qflags
301 */
302
303 if (sb->sb_flags != mp->m_sb.sb_flags)
304 xfs_scrub_block_set_corrupt(sc, bp);
305
306 if (sb->sb_shared_vn != mp->m_sb.sb_shared_vn)
307 xfs_scrub_block_set_corrupt(sc, bp);
308
309 if (sb->sb_inoalignmt != cpu_to_be32(mp->m_sb.sb_inoalignmt))
310 xfs_scrub_block_set_corrupt(sc, bp);
311
312 if (sb->sb_unit != cpu_to_be32(mp->m_sb.sb_unit))
313 xfs_scrub_block_set_preen(sc, bp);
314
315 if (sb->sb_width != cpu_to_be32(mp->m_sb.sb_width))
316 xfs_scrub_block_set_preen(sc, bp);
317
318 if (sb->sb_dirblklog != mp->m_sb.sb_dirblklog)
319 xfs_scrub_block_set_corrupt(sc, bp);
320
321 if (sb->sb_logsectlog != mp->m_sb.sb_logsectlog)
322 xfs_scrub_block_set_corrupt(sc, bp);
323
324 if (sb->sb_logsectsize != cpu_to_be16(mp->m_sb.sb_logsectsize))
325 xfs_scrub_block_set_corrupt(sc, bp);
326
327 if (sb->sb_logsunit != cpu_to_be32(mp->m_sb.sb_logsunit))
328 xfs_scrub_block_set_corrupt(sc, bp);
329
330 /* Do we see any invalid bits in sb_features2? */
331 if (!xfs_sb_version_hasmorebits(&mp->m_sb)) {
332 if (sb->sb_features2 != 0)
333 xfs_scrub_block_set_corrupt(sc, bp);
334 } else {
335 v2_ok = XFS_SB_VERSION2_OKBITS;
336 if (XFS_SB_VERSION_NUM(&mp->m_sb) >= XFS_SB_VERSION_5)
337 v2_ok |= XFS_SB_VERSION2_CRCBIT;
338
339 if (!!(sb->sb_features2 & cpu_to_be32(~v2_ok)))
340 xfs_scrub_block_set_corrupt(sc, bp);
341
342 if (sb->sb_features2 != sb->sb_bad_features2)
343 xfs_scrub_block_set_preen(sc, bp);
344 }
345
346 /* Check sb_features2 flags that are set at mkfs time. */
347 features_mask = cpu_to_be32(XFS_SB_VERSION2_LAZYSBCOUNTBIT |
348 XFS_SB_VERSION2_PROJID32BIT |
349 XFS_SB_VERSION2_CRCBIT |
350 XFS_SB_VERSION2_FTYPE);
351 if ((sb->sb_features2 & features_mask) !=
352 (cpu_to_be32(mp->m_sb.sb_features2) & features_mask))
353 xfs_scrub_block_set_corrupt(sc, bp);
354
355 /* Check sb_features2 flags that can be set after mkfs time. */
356 features_mask = cpu_to_be32(XFS_SB_VERSION2_ATTR2BIT);
357 if ((sb->sb_features2 & features_mask) !=
358 (cpu_to_be32(mp->m_sb.sb_features2) & features_mask))
359 xfs_scrub_block_set_corrupt(sc, bp);
360
361 if (!xfs_sb_version_hascrc(&mp->m_sb)) {
362 /* all v5 fields must be zero */
363 if (memchr_inv(&sb->sb_features_compat, 0,
364 sizeof(struct xfs_dsb) -
365 offsetof(struct xfs_dsb, sb_features_compat)))
366 xfs_scrub_block_set_corrupt(sc, bp);
367 } else {
368 /* Check compat flags; all are set at mkfs time. */
369 features_mask = cpu_to_be32(XFS_SB_FEAT_COMPAT_UNKNOWN);
370 if ((sb->sb_features_compat & features_mask) !=
371 (cpu_to_be32(mp->m_sb.sb_features_compat) & features_mask))
372 xfs_scrub_block_set_corrupt(sc, bp);
373
374 /* Check ro compat flags; all are set at mkfs time. */
375 features_mask = cpu_to_be32(XFS_SB_FEAT_RO_COMPAT_UNKNOWN |
376 XFS_SB_FEAT_RO_COMPAT_FINOBT |
377 XFS_SB_FEAT_RO_COMPAT_RMAPBT |
378 XFS_SB_FEAT_RO_COMPAT_REFLINK);
379 if ((sb->sb_features_ro_compat & features_mask) !=
380 (cpu_to_be32(mp->m_sb.sb_features_ro_compat) &
381 features_mask))
382 xfs_scrub_block_set_corrupt(sc, bp);
383
384 /* Check incompat flags; all are set at mkfs time. */
385 features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_UNKNOWN |
386 XFS_SB_FEAT_INCOMPAT_FTYPE |
387 XFS_SB_FEAT_INCOMPAT_SPINODES |
388 XFS_SB_FEAT_INCOMPAT_META_UUID);
389 if ((sb->sb_features_incompat & features_mask) !=
390 (cpu_to_be32(mp->m_sb.sb_features_incompat) &
391 features_mask))
392 xfs_scrub_block_set_corrupt(sc, bp);
393
394 /* Check log incompat flags; all are set at mkfs time. */
395 features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN);
396 if ((sb->sb_features_log_incompat & features_mask) !=
397 (cpu_to_be32(mp->m_sb.sb_features_log_incompat) &
398 features_mask))
399 xfs_scrub_block_set_corrupt(sc, bp);
400
401 /* Don't care about sb_crc */
402
403 if (sb->sb_spino_align != cpu_to_be32(mp->m_sb.sb_spino_align))
404 xfs_scrub_block_set_corrupt(sc, bp);
405
406 if (sb->sb_pquotino != cpu_to_be64(mp->m_sb.sb_pquotino))
407 xfs_scrub_block_set_preen(sc, bp);
408
409 /* Don't care about sb_lsn */
410 }
411
412 if (xfs_sb_version_hasmetauuid(&mp->m_sb)) {
413 /* The metadata UUID must be the same for all supers */
414 if (!uuid_equal(&sb->sb_meta_uuid, &mp->m_sb.sb_meta_uuid))
415 xfs_scrub_block_set_corrupt(sc, bp);
416 }
417
418 /* Everything else must be zero. */
419 if (memchr_inv(sb + 1, 0,
420 BBTOB(bp->b_length) - sizeof(struct xfs_dsb)))
421 xfs_scrub_block_set_corrupt(sc, bp);
422
423 xfs_scrub_superblock_xref(sc, bp);
424
425 return error;
426 }
427
428 /* AGF */
429
430 /* Tally freespace record lengths. */
431 STATIC int
432 xfs_scrub_agf_record_bno_lengths(
433 struct xfs_btree_cur *cur,
434 struct xfs_alloc_rec_incore *rec,
435 void *priv)
436 {
437 xfs_extlen_t *blocks = priv;
438
439 (*blocks) += rec->ar_blockcount;
440 return 0;
441 }
442
443 /* Check agf_freeblks */
444 static inline void
445 xfs_scrub_agf_xref_freeblks(
446 struct xfs_scrub_context *sc)
447 {
448 struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
449 xfs_extlen_t blocks = 0;
450 int error;
451
452 if (!sc->sa.bno_cur)
453 return;
454
455 error = xfs_alloc_query_all(sc->sa.bno_cur,
456 xfs_scrub_agf_record_bno_lengths, &blocks);
457 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
458 return;
459 if (blocks != be32_to_cpu(agf->agf_freeblks))
460 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
461 }
462
463 /* Cross reference the AGF with the cntbt (freespace by length btree) */
464 static inline void
465 xfs_scrub_agf_xref_cntbt(
466 struct xfs_scrub_context *sc)
467 {
468 struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
469 xfs_agblock_t agbno;
470 xfs_extlen_t blocks;
471 int have;
472 int error;
473
474 if (!sc->sa.cnt_cur)
475 return;
476
477 /* Any freespace at all? */
478 error = xfs_alloc_lookup_le(sc->sa.cnt_cur, 0, -1U, &have);
479 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.cnt_cur))
480 return;
481 if (!have) {
482 if (agf->agf_freeblks != be32_to_cpu(0))
483 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
484 return;
485 }
486
487 /* Check agf_longest */
488 error = xfs_alloc_get_rec(sc->sa.cnt_cur, &agbno, &blocks, &have);
489 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.cnt_cur))
490 return;
491 if (!have || blocks != be32_to_cpu(agf->agf_longest))
492 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
493 }
494
495 /* Check the btree block counts in the AGF against the btrees. */
496 STATIC void
497 xfs_scrub_agf_xref_btreeblks(
498 struct xfs_scrub_context *sc)
499 {
500 struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
501 struct xfs_mount *mp = sc->mp;
502 xfs_agblock_t blocks;
503 xfs_agblock_t btreeblks;
504 int error;
505
506 /* Check agf_rmap_blocks; set up for agf_btreeblks check */
507 if (sc->sa.rmap_cur) {
508 error = xfs_btree_count_blocks(sc->sa.rmap_cur, &blocks);
509 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
510 return;
511 btreeblks = blocks - 1;
512 if (blocks != be32_to_cpu(agf->agf_rmap_blocks))
513 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
514 } else {
515 btreeblks = 0;
516 }
517
518 /*
519 * No rmap cursor; we can't xref if we have the rmapbt feature.
520 * We also can't do it if we're missing the free space btree cursors.
521 */
522 if ((xfs_sb_version_hasrmapbt(&mp->m_sb) && !sc->sa.rmap_cur) ||
523 !sc->sa.bno_cur || !sc->sa.cnt_cur)
524 return;
525
526 /* Check agf_btreeblks */
527 error = xfs_btree_count_blocks(sc->sa.bno_cur, &blocks);
528 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
529 return;
530 btreeblks += blocks - 1;
531
532 error = xfs_btree_count_blocks(sc->sa.cnt_cur, &blocks);
533 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.cnt_cur))
534 return;
535 btreeblks += blocks - 1;
536
537 if (btreeblks != be32_to_cpu(agf->agf_btreeblks))
538 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
539 }
540
541 /* Check agf_refcount_blocks against tree size */
542 static inline void
543 xfs_scrub_agf_xref_refcblks(
544 struct xfs_scrub_context *sc)
545 {
546 struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
547 xfs_agblock_t blocks;
548 int error;
549
550 if (!sc->sa.refc_cur)
551 return;
552
553 error = xfs_btree_count_blocks(sc->sa.refc_cur, &blocks);
554 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.refc_cur))
555 return;
556 if (blocks != be32_to_cpu(agf->agf_refcount_blocks))
557 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
558 }
559
560 /* Cross-reference with the other btrees. */
561 STATIC void
562 xfs_scrub_agf_xref(
563 struct xfs_scrub_context *sc)
564 {
565 struct xfs_owner_info oinfo;
566 struct xfs_mount *mp = sc->mp;
567 xfs_agblock_t agbno;
568 int error;
569
570 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
571 return;
572
573 agbno = XFS_AGF_BLOCK(mp);
574
575 error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
576 if (error)
577 return;
578
579 xfs_scrub_xref_is_used_space(sc, agbno, 1);
580 xfs_scrub_agf_xref_freeblks(sc);
581 xfs_scrub_agf_xref_cntbt(sc);
582 xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
583 xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
584 xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
585 xfs_scrub_agf_xref_btreeblks(sc);
586 xfs_scrub_xref_is_not_shared(sc, agbno, 1);
587 xfs_scrub_agf_xref_refcblks(sc);
588
589 /* scrub teardown will take care of sc->sa for us */
590 }
591
592 /* Scrub the AGF. */
593 int
594 xfs_scrub_agf(
595 struct xfs_scrub_context *sc)
596 {
597 struct xfs_mount *mp = sc->mp;
598 struct xfs_agf *agf;
599 xfs_agnumber_t agno;
600 xfs_agblock_t agbno;
601 xfs_agblock_t eoag;
602 xfs_agblock_t agfl_first;
603 xfs_agblock_t agfl_last;
604 xfs_agblock_t agfl_count;
605 xfs_agblock_t fl_count;
606 int level;
607 int error = 0;
608
609 agno = sc->sa.agno = sc->sm->sm_agno;
610 error = xfs_scrub_ag_read_headers(sc, agno, &sc->sa.agi_bp,
611 &sc->sa.agf_bp, &sc->sa.agfl_bp);
612 if (!xfs_scrub_process_error(sc, agno, XFS_AGF_BLOCK(sc->mp), &error))
613 goto out;
614 xfs_scrub_buffer_recheck(sc, sc->sa.agf_bp);
615
616 agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
617
618 /* Check the AG length */
619 eoag = be32_to_cpu(agf->agf_length);
620 if (eoag != xfs_ag_block_count(mp, agno))
621 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
622
623 /* Check the AGF btree roots and levels */
624 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]);
625 if (!xfs_verify_agbno(mp, agno, agbno))
626 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
627
628 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]);
629 if (!xfs_verify_agbno(mp, agno, agbno))
630 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
631
632 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]);
633 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
634 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
635
636 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]);
637 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
638 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
639
640 if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
641 agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_RMAP]);
642 if (!xfs_verify_agbno(mp, agno, agbno))
643 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
644
645 level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]);
646 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
647 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
648 }
649
650 if (xfs_sb_version_hasreflink(&mp->m_sb)) {
651 agbno = be32_to_cpu(agf->agf_refcount_root);
652 if (!xfs_verify_agbno(mp, agno, agbno))
653 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
654
655 level = be32_to_cpu(agf->agf_refcount_level);
656 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
657 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
658 }
659
660 /* Check the AGFL counters */
661 agfl_first = be32_to_cpu(agf->agf_flfirst);
662 agfl_last = be32_to_cpu(agf->agf_fllast);
663 agfl_count = be32_to_cpu(agf->agf_flcount);
664 if (agfl_last > agfl_first)
665 fl_count = agfl_last - agfl_first + 1;
666 else
667 fl_count = XFS_AGFL_SIZE(mp) - agfl_first + agfl_last + 1;
668 if (agfl_count != 0 && fl_count != agfl_count)
669 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
670
671 xfs_scrub_agf_xref(sc);
672 out:
673 return error;
674 }
675
676 /* AGFL */
677
678 struct xfs_scrub_agfl_info {
679 struct xfs_owner_info oinfo;
680 unsigned int sz_entries;
681 unsigned int nr_entries;
682 xfs_agblock_t *entries;
683 };
684
685 /* Cross-reference with the other btrees. */
686 STATIC void
687 xfs_scrub_agfl_block_xref(
688 struct xfs_scrub_context *sc,
689 xfs_agblock_t agbno,
690 struct xfs_owner_info *oinfo)
691 {
692 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
693 return;
694
695 xfs_scrub_xref_is_used_space(sc, agbno, 1);
696 xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
697 xfs_scrub_xref_is_owned_by(sc, agbno, 1, oinfo);
698 xfs_scrub_xref_is_not_shared(sc, agbno, 1);
699 }
700
701 /* Scrub an AGFL block. */
702 STATIC int
703 xfs_scrub_agfl_block(
704 struct xfs_scrub_context *sc,
705 xfs_agblock_t agbno,
706 void *priv)
707 {
708 struct xfs_mount *mp = sc->mp;
709 struct xfs_scrub_agfl_info *sai = priv;
710 xfs_agnumber_t agno = sc->sa.agno;
711
712 if (xfs_verify_agbno(mp, agno, agbno) &&
713 sai->nr_entries < sai->sz_entries)
714 sai->entries[sai->nr_entries++] = agbno;
715 else
716 xfs_scrub_block_set_corrupt(sc, sc->sa.agfl_bp);
717
718 xfs_scrub_agfl_block_xref(sc, agbno, priv);
719
720 return 0;
721 }
722
723 static int
724 xfs_scrub_agblock_cmp(
725 const void *pa,
726 const void *pb)
727 {
728 const xfs_agblock_t *a = pa;
729 const xfs_agblock_t *b = pb;
730
731 return (int)*a - (int)*b;
732 }
733
734 /* Cross-reference with the other btrees. */
735 STATIC void
736 xfs_scrub_agfl_xref(
737 struct xfs_scrub_context *sc)
738 {
739 struct xfs_owner_info oinfo;
740 struct xfs_mount *mp = sc->mp;
741 xfs_agblock_t agbno;
742 int error;
743
744 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
745 return;
746
747 agbno = XFS_AGFL_BLOCK(mp);
748
749 error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
750 if (error)
751 return;
752
753 xfs_scrub_xref_is_used_space(sc, agbno, 1);
754 xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
755 xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
756 xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
757 xfs_scrub_xref_is_not_shared(sc, agbno, 1);
758
759 /*
760 * Scrub teardown will take care of sc->sa for us. Leave sc->sa
761 * active so that the agfl block xref can use it too.
762 */
763 }
764
765 /* Scrub the AGFL. */
766 int
767 xfs_scrub_agfl(
768 struct xfs_scrub_context *sc)
769 {
770 struct xfs_scrub_agfl_info sai = { 0 };
771 struct xfs_agf *agf;
772 xfs_agnumber_t agno;
773 unsigned int agflcount;
774 unsigned int i;
775 int error;
776
777 agno = sc->sa.agno = sc->sm->sm_agno;
778 error = xfs_scrub_ag_read_headers(sc, agno, &sc->sa.agi_bp,
779 &sc->sa.agf_bp, &sc->sa.agfl_bp);
780 if (!xfs_scrub_process_error(sc, agno, XFS_AGFL_BLOCK(sc->mp), &error))
781 goto out;
782 if (!sc->sa.agf_bp)
783 return -EFSCORRUPTED;
784 xfs_scrub_buffer_recheck(sc, sc->sa.agfl_bp);
785
786 xfs_scrub_agfl_xref(sc);
787
788 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
789 goto out;
790
791 /* Allocate buffer to ensure uniqueness of AGFL entries. */
792 agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
793 agflcount = be32_to_cpu(agf->agf_flcount);
794 if (agflcount > XFS_AGFL_SIZE(sc->mp)) {
795 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
796 goto out;
797 }
798 sai.sz_entries = agflcount;
799 sai.entries = kmem_zalloc(sizeof(xfs_agblock_t) * agflcount, KM_NOFS);
800 if (!sai.entries) {
801 error = -ENOMEM;
802 goto out;
803 }
804
805 /* Check the blocks in the AGFL. */
806 xfs_rmap_ag_owner(&sai.oinfo, XFS_RMAP_OWN_AG);
807 error = xfs_scrub_walk_agfl(sc, xfs_scrub_agfl_block, &sai);
808 if (error)
809 goto out_free;
810
811 if (agflcount != sai.nr_entries) {
812 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
813 goto out_free;
814 }
815
816 /* Sort entries, check for duplicates. */
817 sort(sai.entries, sai.nr_entries, sizeof(sai.entries[0]),
818 xfs_scrub_agblock_cmp, NULL);
819 for (i = 1; i < sai.nr_entries; i++) {
820 if (sai.entries[i] == sai.entries[i - 1]) {
821 xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
822 break;
823 }
824 }
825
826 out_free:
827 kmem_free(sai.entries);
828 out:
829 return error;
830 }
831
832 /* AGI */
833
834 /* Check agi_count/agi_freecount */
835 static inline void
836 xfs_scrub_agi_xref_icounts(
837 struct xfs_scrub_context *sc)
838 {
839 struct xfs_agi *agi = XFS_BUF_TO_AGI(sc->sa.agi_bp);
840 xfs_agino_t icount;
841 xfs_agino_t freecount;
842 int error;
843
844 if (!sc->sa.ino_cur)
845 return;
846
847 error = xfs_ialloc_count_inodes(sc->sa.ino_cur, &icount, &freecount);
848 if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.ino_cur))
849 return;
850 if (be32_to_cpu(agi->agi_count) != icount ||
851 be32_to_cpu(agi->agi_freecount) != freecount)
852 xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agi_bp);
853 }
854
855 /* Cross-reference with the other btrees. */
856 STATIC void
857 xfs_scrub_agi_xref(
858 struct xfs_scrub_context *sc)
859 {
860 struct xfs_owner_info oinfo;
861 struct xfs_mount *mp = sc->mp;
862 xfs_agblock_t agbno;
863 int error;
864
865 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
866 return;
867
868 agbno = XFS_AGI_BLOCK(mp);
869
870 error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
871 if (error)
872 return;
873
874 xfs_scrub_xref_is_used_space(sc, agbno, 1);
875 xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
876 xfs_scrub_agi_xref_icounts(sc);
877 xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
878 xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
879 xfs_scrub_xref_is_not_shared(sc, agbno, 1);
880
881 /* scrub teardown will take care of sc->sa for us */
882 }
883
884 /* Scrub the AGI. */
885 int
886 xfs_scrub_agi(
887 struct xfs_scrub_context *sc)
888 {
889 struct xfs_mount *mp = sc->mp;
890 struct xfs_agi *agi;
891 xfs_agnumber_t agno;
892 xfs_agblock_t agbno;
893 xfs_agblock_t eoag;
894 xfs_agino_t agino;
895 xfs_agino_t first_agino;
896 xfs_agino_t last_agino;
897 xfs_agino_t icount;
898 int i;
899 int level;
900 int error = 0;
901
902 agno = sc->sa.agno = sc->sm->sm_agno;
903 error = xfs_scrub_ag_read_headers(sc, agno, &sc->sa.agi_bp,
904 &sc->sa.agf_bp, &sc->sa.agfl_bp);
905 if (!xfs_scrub_process_error(sc, agno, XFS_AGI_BLOCK(sc->mp), &error))
906 goto out;
907 xfs_scrub_buffer_recheck(sc, sc->sa.agi_bp);
908
909 agi = XFS_BUF_TO_AGI(sc->sa.agi_bp);
910
911 /* Check the AG length */
912 eoag = be32_to_cpu(agi->agi_length);
913 if (eoag != xfs_ag_block_count(mp, agno))
914 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
915
916 /* Check btree roots and levels */
917 agbno = be32_to_cpu(agi->agi_root);
918 if (!xfs_verify_agbno(mp, agno, agbno))
919 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
920
921 level = be32_to_cpu(agi->agi_level);
922 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
923 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
924
925 if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
926 agbno = be32_to_cpu(agi->agi_free_root);
927 if (!xfs_verify_agbno(mp, agno, agbno))
928 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
929
930 level = be32_to_cpu(agi->agi_free_level);
931 if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
932 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
933 }
934
935 /* Check inode counters */
936 xfs_ialloc_agino_range(mp, agno, &first_agino, &last_agino);
937 icount = be32_to_cpu(agi->agi_count);
938 if (icount > last_agino - first_agino + 1 ||
939 icount < be32_to_cpu(agi->agi_freecount))
940 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
941
942 /* Check inode pointers */
943 agino = be32_to_cpu(agi->agi_newino);
944 if (agino != NULLAGINO && !xfs_verify_agino(mp, agno, agino))
945 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
946
947 agino = be32_to_cpu(agi->agi_dirino);
948 if (agino != NULLAGINO && !xfs_verify_agino(mp, agno, agino))
949 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
950
951 /* Check unlinked inode buckets */
952 for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) {
953 agino = be32_to_cpu(agi->agi_unlinked[i]);
954 if (agino == NULLAGINO)
955 continue;
956 if (!xfs_verify_agino(mp, agno, agino))
957 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
958 }
959
960 if (agi->agi_pad32 != cpu_to_be32(0))
961 xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
962
963 xfs_scrub_agi_xref(sc);
964 out:
965 return error;
966 }
CRIS linux kernel tree