Loading...
Note: File does not exist in v3.5.6.
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2017 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_trans_resv.h"
11#include "xfs_mount.h"
12#include "xfs_btree.h"
13#include "xfs_bit.h"
14#include "xfs_log_format.h"
15#include "xfs_trans.h"
16#include "xfs_inode.h"
17#include "xfs_alloc.h"
18#include "xfs_bmap.h"
19#include "xfs_bmap_btree.h"
20#include "xfs_rmap.h"
21#include "xfs_rmap_btree.h"
22#include "scrub/scrub.h"
23#include "scrub/common.h"
24#include "scrub/btree.h"
25#include "xfs_ag.h"
26
27/* Set us up with an inode's bmap. */
28int
29xchk_setup_inode_bmap(
30 struct xfs_scrub *sc)
31{
32 int error;
33
34 error = xchk_get_inode(sc);
35 if (error)
36 goto out;
37
38 sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
39 xfs_ilock(sc->ip, sc->ilock_flags);
40
41 /*
42 * We don't want any ephemeral data fork updates sitting around
43 * while we inspect block mappings, so wait for directio to finish
44 * and flush dirty data if we have delalloc reservations.
45 */
46 if (S_ISREG(VFS_I(sc->ip)->i_mode) &&
47 sc->sm->sm_type == XFS_SCRUB_TYPE_BMBTD) {
48 struct address_space *mapping = VFS_I(sc->ip)->i_mapping;
49
50 inode_dio_wait(VFS_I(sc->ip));
51
52 /*
53 * Try to flush all incore state to disk before we examine the
54 * space mappings for the data fork. Leave accumulated errors
55 * in the mapping for the writer threads to consume.
56 *
57 * On ENOSPC or EIO writeback errors, we continue into the
58 * extent mapping checks because write failures do not
59 * necessarily imply anything about the correctness of the file
60 * metadata. The metadata and the file data could be on
61 * completely separate devices; a media failure might only
62 * affect a subset of the disk, etc. We can handle delalloc
63 * extents in the scrubber, so leaving them in memory is fine.
64 */
65 error = filemap_fdatawrite(mapping);
66 if (!error)
67 error = filemap_fdatawait_keep_errors(mapping);
68 if (error && (error != -ENOSPC && error != -EIO))
69 goto out;
70 }
71
72 /* Got the inode, lock it and we're ready to go. */
73 error = xchk_trans_alloc(sc, 0);
74 if (error)
75 goto out;
76 sc->ilock_flags |= XFS_ILOCK_EXCL;
77 xfs_ilock(sc->ip, XFS_ILOCK_EXCL);
78
79out:
80 /* scrub teardown will unlock and release the inode */
81 return error;
82}
83
84/*
85 * Inode fork block mapping (BMBT) scrubber.
86 * More complex than the others because we have to scrub
87 * all the extents regardless of whether or not the fork
88 * is in btree format.
89 */
90
91struct xchk_bmap_info {
92 struct xfs_scrub *sc;
93 struct xfs_iext_cursor icur;
94 xfs_fileoff_t lastoff;
95 bool is_rt;
96 bool is_shared;
97 bool was_loaded;
98 int whichfork;
99};
100
101/* Look for a corresponding rmap for this irec. */
102static inline bool
103xchk_bmap_get_rmap(
104 struct xchk_bmap_info *info,
105 struct xfs_bmbt_irec *irec,
106 xfs_agblock_t agbno,
107 uint64_t owner,
108 struct xfs_rmap_irec *rmap)
109{
110 xfs_fileoff_t offset;
111 unsigned int rflags = 0;
112 int has_rmap;
113 int error;
114
115 if (info->whichfork == XFS_ATTR_FORK)
116 rflags |= XFS_RMAP_ATTR_FORK;
117 if (irec->br_state == XFS_EXT_UNWRITTEN)
118 rflags |= XFS_RMAP_UNWRITTEN;
119
120 /*
121 * CoW staging extents are owned (on disk) by the refcountbt, so
122 * their rmaps do not have offsets.
123 */
124 if (info->whichfork == XFS_COW_FORK)
125 offset = 0;
126 else
127 offset = irec->br_startoff;
128
129 /*
130 * If the caller thinks this could be a shared bmbt extent (IOWs,
131 * any data fork extent of a reflink inode) then we have to use the
132 * range rmap lookup to make sure we get the correct owner/offset.
133 */
134 if (info->is_shared) {
135 error = xfs_rmap_lookup_le_range(info->sc->sa.rmap_cur, agbno,
136 owner, offset, rflags, rmap, &has_rmap);
137 } else {
138 error = xfs_rmap_lookup_le(info->sc->sa.rmap_cur, agbno,
139 owner, offset, rflags, rmap, &has_rmap);
140 }
141 if (!xchk_should_check_xref(info->sc, &error, &info->sc->sa.rmap_cur))
142 return false;
143
144 if (!has_rmap)
145 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
146 irec->br_startoff);
147 return has_rmap;
148}
149
150static inline bool
151xchk_bmap_has_prev(
152 struct xchk_bmap_info *info,
153 struct xfs_bmbt_irec *irec)
154{
155 struct xfs_bmbt_irec got;
156 struct xfs_ifork *ifp;
157
158 ifp = xfs_ifork_ptr(info->sc->ip, info->whichfork);
159
160 if (!xfs_iext_peek_prev_extent(ifp, &info->icur, &got))
161 return false;
162 if (got.br_startoff + got.br_blockcount != irec->br_startoff)
163 return false;
164 if (got.br_startblock + got.br_blockcount != irec->br_startblock)
165 return false;
166 if (got.br_state != irec->br_state)
167 return false;
168 return true;
169}
170
171static inline bool
172xchk_bmap_has_next(
173 struct xchk_bmap_info *info,
174 struct xfs_bmbt_irec *irec)
175{
176 struct xfs_bmbt_irec got;
177 struct xfs_ifork *ifp;
178
179 ifp = xfs_ifork_ptr(info->sc->ip, info->whichfork);
180
181 if (!xfs_iext_peek_next_extent(ifp, &info->icur, &got))
182 return false;
183 if (irec->br_startoff + irec->br_blockcount != got.br_startoff)
184 return false;
185 if (irec->br_startblock + irec->br_blockcount != got.br_startblock)
186 return false;
187 if (got.br_state != irec->br_state)
188 return false;
189 return true;
190}
191
192/* Make sure that we have rmapbt records for this extent. */
193STATIC void
194xchk_bmap_xref_rmap(
195 struct xchk_bmap_info *info,
196 struct xfs_bmbt_irec *irec,
197 xfs_agblock_t agbno)
198{
199 struct xfs_rmap_irec rmap;
200 unsigned long long rmap_end;
201 uint64_t owner;
202
203 if (!info->sc->sa.rmap_cur || xchk_skip_xref(info->sc->sm))
204 return;
205
206 if (info->whichfork == XFS_COW_FORK)
207 owner = XFS_RMAP_OWN_COW;
208 else
209 owner = info->sc->ip->i_ino;
210
211 /* Find the rmap record for this irec. */
212 if (!xchk_bmap_get_rmap(info, irec, agbno, owner, &rmap))
213 return;
214
215 /* Check the rmap. */
216 rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount;
217 if (rmap.rm_startblock > agbno ||
218 agbno + irec->br_blockcount > rmap_end)
219 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
220 irec->br_startoff);
221
222 /*
223 * Check the logical offsets if applicable. CoW staging extents
224 * don't track logical offsets since the mappings only exist in
225 * memory.
226 */
227 if (info->whichfork != XFS_COW_FORK) {
228 rmap_end = (unsigned long long)rmap.rm_offset +
229 rmap.rm_blockcount;
230 if (rmap.rm_offset > irec->br_startoff ||
231 irec->br_startoff + irec->br_blockcount > rmap_end)
232 xchk_fblock_xref_set_corrupt(info->sc,
233 info->whichfork, irec->br_startoff);
234 }
235
236 if (rmap.rm_owner != owner)
237 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
238 irec->br_startoff);
239
240 /*
241 * Check for discrepancies between the unwritten flag in the irec and
242 * the rmap. Note that the (in-memory) CoW fork distinguishes between
243 * unwritten and written extents, but we don't track that in the rmap
244 * records because the blocks are owned (on-disk) by the refcountbt,
245 * which doesn't track unwritten state.
246 */
247 if (owner != XFS_RMAP_OWN_COW &&
248 !!(irec->br_state == XFS_EXT_UNWRITTEN) !=
249 !!(rmap.rm_flags & XFS_RMAP_UNWRITTEN))
250 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
251 irec->br_startoff);
252
253 if (!!(info->whichfork == XFS_ATTR_FORK) !=
254 !!(rmap.rm_flags & XFS_RMAP_ATTR_FORK))
255 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
256 irec->br_startoff);
257 if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK)
258 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
259 irec->br_startoff);
260
261 /*
262 * If the rmap starts before this bmbt record, make sure there's a bmbt
263 * record for the previous offset that is contiguous with this mapping.
264 * Skip this for CoW fork extents because the refcount btree (and not
265 * the inode) is the ondisk owner for those extents.
266 */
267 if (info->whichfork != XFS_COW_FORK && rmap.rm_startblock < agbno &&
268 !xchk_bmap_has_prev(info, irec)) {
269 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
270 irec->br_startoff);
271 return;
272 }
273
274 /*
275 * If the rmap ends after this bmbt record, make sure there's a bmbt
276 * record for the next offset that is contiguous with this mapping.
277 * Skip this for CoW fork extents because the refcount btree (and not
278 * the inode) is the ondisk owner for those extents.
279 */
280 rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount;
281 if (info->whichfork != XFS_COW_FORK &&
282 rmap_end > agbno + irec->br_blockcount &&
283 !xchk_bmap_has_next(info, irec)) {
284 xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
285 irec->br_startoff);
286 return;
287 }
288}
289
290/* Cross-reference a single rtdev extent record. */
291STATIC void
292xchk_bmap_rt_iextent_xref(
293 struct xfs_inode *ip,
294 struct xchk_bmap_info *info,
295 struct xfs_bmbt_irec *irec)
296{
297 xchk_xref_is_used_rt_space(info->sc, irec->br_startblock,
298 irec->br_blockcount);
299}
300
301/* Cross-reference a single datadev extent record. */
302STATIC void
303xchk_bmap_iextent_xref(
304 struct xfs_inode *ip,
305 struct xchk_bmap_info *info,
306 struct xfs_bmbt_irec *irec)
307{
308 struct xfs_mount *mp = info->sc->mp;
309 xfs_agnumber_t agno;
310 xfs_agblock_t agbno;
311 xfs_extlen_t len;
312 int error;
313
314 agno = XFS_FSB_TO_AGNO(mp, irec->br_startblock);
315 agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock);
316 len = irec->br_blockcount;
317
318 error = xchk_ag_init_existing(info->sc, agno, &info->sc->sa);
319 if (!xchk_fblock_process_error(info->sc, info->whichfork,
320 irec->br_startoff, &error))
321 goto out_free;
322
323 xchk_xref_is_used_space(info->sc, agbno, len);
324 xchk_xref_is_not_inode_chunk(info->sc, agbno, len);
325 xchk_bmap_xref_rmap(info, irec, agbno);
326 switch (info->whichfork) {
327 case XFS_DATA_FORK:
328 if (xfs_is_reflink_inode(info->sc->ip))
329 break;
330 fallthrough;
331 case XFS_ATTR_FORK:
332 xchk_xref_is_not_shared(info->sc, agbno,
333 irec->br_blockcount);
334 break;
335 case XFS_COW_FORK:
336 xchk_xref_is_cow_staging(info->sc, agbno,
337 irec->br_blockcount);
338 xchk_xref_is_not_shared(info->sc, agbno,
339 irec->br_blockcount);
340 break;
341 }
342
343out_free:
344 xchk_ag_free(info->sc, &info->sc->sa);
345}
346
347/*
348 * Directories and attr forks should never have blocks that can't be addressed
349 * by a xfs_dablk_t.
350 */
351STATIC void
352xchk_bmap_dirattr_extent(
353 struct xfs_inode *ip,
354 struct xchk_bmap_info *info,
355 struct xfs_bmbt_irec *irec)
356{
357 struct xfs_mount *mp = ip->i_mount;
358 xfs_fileoff_t off;
359
360 if (!S_ISDIR(VFS_I(ip)->i_mode) && info->whichfork != XFS_ATTR_FORK)
361 return;
362
363 if (!xfs_verify_dablk(mp, irec->br_startoff))
364 xchk_fblock_set_corrupt(info->sc, info->whichfork,
365 irec->br_startoff);
366
367 off = irec->br_startoff + irec->br_blockcount - 1;
368 if (!xfs_verify_dablk(mp, off))
369 xchk_fblock_set_corrupt(info->sc, info->whichfork, off);
370}
371
372/* Scrub a single extent record. */
373STATIC void
374xchk_bmap_iextent(
375 struct xfs_inode *ip,
376 struct xchk_bmap_info *info,
377 struct xfs_bmbt_irec *irec)
378{
379 struct xfs_mount *mp = info->sc->mp;
380
381 /*
382 * Check for out-of-order extents. This record could have come
383 * from the incore list, for which there is no ordering check.
384 */
385 if (irec->br_startoff < info->lastoff)
386 xchk_fblock_set_corrupt(info->sc, info->whichfork,
387 irec->br_startoff);
388
389 if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
390 xchk_fblock_set_corrupt(info->sc, info->whichfork,
391 irec->br_startoff);
392
393 xchk_bmap_dirattr_extent(ip, info, irec);
394
395 /* There should never be a "hole" extent in either extent list. */
396 if (irec->br_startblock == HOLESTARTBLOCK)
397 xchk_fblock_set_corrupt(info->sc, info->whichfork,
398 irec->br_startoff);
399
400 /* Make sure the extent points to a valid place. */
401 if (irec->br_blockcount > XFS_MAX_BMBT_EXTLEN)
402 xchk_fblock_set_corrupt(info->sc, info->whichfork,
403 irec->br_startoff);
404 if (info->is_rt &&
405 !xfs_verify_rtext(mp, irec->br_startblock, irec->br_blockcount))
406 xchk_fblock_set_corrupt(info->sc, info->whichfork,
407 irec->br_startoff);
408 if (!info->is_rt &&
409 !xfs_verify_fsbext(mp, irec->br_startblock, irec->br_blockcount))
410 xchk_fblock_set_corrupt(info->sc, info->whichfork,
411 irec->br_startoff);
412
413 /* We don't allow unwritten extents on attr forks. */
414 if (irec->br_state == XFS_EXT_UNWRITTEN &&
415 info->whichfork == XFS_ATTR_FORK)
416 xchk_fblock_set_corrupt(info->sc, info->whichfork,
417 irec->br_startoff);
418
419 if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
420 return;
421
422 if (info->is_rt)
423 xchk_bmap_rt_iextent_xref(ip, info, irec);
424 else
425 xchk_bmap_iextent_xref(ip, info, irec);
426}
427
428/* Scrub a bmbt record. */
429STATIC int
430xchk_bmapbt_rec(
431 struct xchk_btree *bs,
432 const union xfs_btree_rec *rec)
433{
434 struct xfs_bmbt_irec irec;
435 struct xfs_bmbt_irec iext_irec;
436 struct xfs_iext_cursor icur;
437 struct xchk_bmap_info *info = bs->private;
438 struct xfs_inode *ip = bs->cur->bc_ino.ip;
439 struct xfs_buf *bp = NULL;
440 struct xfs_btree_block *block;
441 struct xfs_ifork *ifp = xfs_ifork_ptr(ip, info->whichfork);
442 uint64_t owner;
443 int i;
444
445 /*
446 * Check the owners of the btree blocks up to the level below
447 * the root since the verifiers don't do that.
448 */
449 if (xfs_has_crc(bs->cur->bc_mp) &&
450 bs->cur->bc_levels[0].ptr == 1) {
451 for (i = 0; i < bs->cur->bc_nlevels - 1; i++) {
452 block = xfs_btree_get_block(bs->cur, i, &bp);
453 owner = be64_to_cpu(block->bb_u.l.bb_owner);
454 if (owner != ip->i_ino)
455 xchk_fblock_set_corrupt(bs->sc,
456 info->whichfork, 0);
457 }
458 }
459
460 /*
461 * Check that the incore extent tree contains an extent that matches
462 * this one exactly. We validate those cached bmaps later, so we don't
463 * need to check them here. If the incore extent tree was just loaded
464 * from disk by the scrubber, we assume that its contents match what's
465 * on disk (we still hold the ILOCK) and skip the equivalence check.
466 */
467 if (!info->was_loaded)
468 return 0;
469
470 xfs_bmbt_disk_get_all(&rec->bmbt, &irec);
471 if (!xfs_iext_lookup_extent(ip, ifp, irec.br_startoff, &icur,
472 &iext_irec) ||
473 irec.br_startoff != iext_irec.br_startoff ||
474 irec.br_startblock != iext_irec.br_startblock ||
475 irec.br_blockcount != iext_irec.br_blockcount ||
476 irec.br_state != iext_irec.br_state)
477 xchk_fblock_set_corrupt(bs->sc, info->whichfork,
478 irec.br_startoff);
479 return 0;
480}
481
482/* Scan the btree records. */
483STATIC int
484xchk_bmap_btree(
485 struct xfs_scrub *sc,
486 int whichfork,
487 struct xchk_bmap_info *info)
488{
489 struct xfs_owner_info oinfo;
490 struct xfs_ifork *ifp = xfs_ifork_ptr(sc->ip, whichfork);
491 struct xfs_mount *mp = sc->mp;
492 struct xfs_inode *ip = sc->ip;
493 struct xfs_btree_cur *cur;
494 int error;
495
496 /* Load the incore bmap cache if it's not loaded. */
497 info->was_loaded = !xfs_need_iread_extents(ifp);
498
499 error = xfs_iread_extents(sc->tp, ip, whichfork);
500 if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
501 goto out;
502
503 /* Check the btree structure. */
504 cur = xfs_bmbt_init_cursor(mp, sc->tp, ip, whichfork);
505 xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
506 error = xchk_btree(sc, cur, xchk_bmapbt_rec, &oinfo, info);
507 xfs_btree_del_cursor(cur, error);
508out:
509 return error;
510}
511
512struct xchk_bmap_check_rmap_info {
513 struct xfs_scrub *sc;
514 int whichfork;
515 struct xfs_iext_cursor icur;
516};
517
518/* Can we find bmaps that fit this rmap? */
519STATIC int
520xchk_bmap_check_rmap(
521 struct xfs_btree_cur *cur,
522 const struct xfs_rmap_irec *rec,
523 void *priv)
524{
525 struct xfs_bmbt_irec irec;
526 struct xfs_rmap_irec check_rec;
527 struct xchk_bmap_check_rmap_info *sbcri = priv;
528 struct xfs_ifork *ifp;
529 struct xfs_scrub *sc = sbcri->sc;
530 bool have_map;
531
532 /* Is this even the right fork? */
533 if (rec->rm_owner != sc->ip->i_ino)
534 return 0;
535 if ((sbcri->whichfork == XFS_ATTR_FORK) ^
536 !!(rec->rm_flags & XFS_RMAP_ATTR_FORK))
537 return 0;
538 if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK)
539 return 0;
540
541 /* Now look up the bmbt record. */
542 ifp = xfs_ifork_ptr(sc->ip, sbcri->whichfork);
543 if (!ifp) {
544 xchk_fblock_set_corrupt(sc, sbcri->whichfork,
545 rec->rm_offset);
546 goto out;
547 }
548 have_map = xfs_iext_lookup_extent(sc->ip, ifp, rec->rm_offset,
549 &sbcri->icur, &irec);
550 if (!have_map)
551 xchk_fblock_set_corrupt(sc, sbcri->whichfork,
552 rec->rm_offset);
553 /*
554 * bmap extent record lengths are constrained to 2^21 blocks in length
555 * because of space constraints in the on-disk metadata structure.
556 * However, rmap extent record lengths are constrained only by AG
557 * length, so we have to loop through the bmbt to make sure that the
558 * entire rmap is covered by bmbt records.
559 */
560 check_rec = *rec;
561 while (have_map) {
562 if (irec.br_startoff != check_rec.rm_offset)
563 xchk_fblock_set_corrupt(sc, sbcri->whichfork,
564 check_rec.rm_offset);
565 if (irec.br_startblock != XFS_AGB_TO_FSB(sc->mp,
566 cur->bc_ag.pag->pag_agno,
567 check_rec.rm_startblock))
568 xchk_fblock_set_corrupt(sc, sbcri->whichfork,
569 check_rec.rm_offset);
570 if (irec.br_blockcount > check_rec.rm_blockcount)
571 xchk_fblock_set_corrupt(sc, sbcri->whichfork,
572 check_rec.rm_offset);
573 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
574 break;
575 check_rec.rm_startblock += irec.br_blockcount;
576 check_rec.rm_offset += irec.br_blockcount;
577 check_rec.rm_blockcount -= irec.br_blockcount;
578 if (check_rec.rm_blockcount == 0)
579 break;
580 have_map = xfs_iext_next_extent(ifp, &sbcri->icur, &irec);
581 if (!have_map)
582 xchk_fblock_set_corrupt(sc, sbcri->whichfork,
583 check_rec.rm_offset);
584 }
585
586out:
587 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
588 return -ECANCELED;
589 return 0;
590}
591
592/* Make sure each rmap has a corresponding bmbt entry. */
593STATIC int
594xchk_bmap_check_ag_rmaps(
595 struct xfs_scrub *sc,
596 int whichfork,
597 struct xfs_perag *pag)
598{
599 struct xchk_bmap_check_rmap_info sbcri;
600 struct xfs_btree_cur *cur;
601 struct xfs_buf *agf;
602 int error;
603
604 error = xfs_alloc_read_agf(pag, sc->tp, 0, &agf);
605 if (error)
606 return error;
607
608 cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf, pag);
609
610 sbcri.sc = sc;
611 sbcri.whichfork = whichfork;
612 error = xfs_rmap_query_all(cur, xchk_bmap_check_rmap, &sbcri);
613 if (error == -ECANCELED)
614 error = 0;
615
616 xfs_btree_del_cursor(cur, error);
617 xfs_trans_brelse(sc->tp, agf);
618 return error;
619}
620
621/* Make sure each rmap has a corresponding bmbt entry. */
622STATIC int
623xchk_bmap_check_rmaps(
624 struct xfs_scrub *sc,
625 int whichfork)
626{
627 struct xfs_ifork *ifp = xfs_ifork_ptr(sc->ip, whichfork);
628 struct xfs_perag *pag;
629 xfs_agnumber_t agno;
630 bool zero_size;
631 int error;
632
633 if (!xfs_has_rmapbt(sc->mp) ||
634 whichfork == XFS_COW_FORK ||
635 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
636 return 0;
637
638 /* Don't support realtime rmap checks yet. */
639 if (XFS_IS_REALTIME_INODE(sc->ip) && whichfork == XFS_DATA_FORK)
640 return 0;
641
642 ASSERT(xfs_ifork_ptr(sc->ip, whichfork) != NULL);
643
644 /*
645 * Only do this for complex maps that are in btree format, or for
646 * situations where we would seem to have a size but zero extents.
647 * The inode repair code can zap broken iforks, which means we have
648 * to flag this bmap as corrupt if there are rmaps that need to be
649 * reattached.
650 */
651
652 if (whichfork == XFS_DATA_FORK)
653 zero_size = i_size_read(VFS_I(sc->ip)) == 0;
654 else
655 zero_size = false;
656
657 if (ifp->if_format != XFS_DINODE_FMT_BTREE &&
658 (zero_size || ifp->if_nextents > 0))
659 return 0;
660
661 for_each_perag(sc->mp, agno, pag) {
662 error = xchk_bmap_check_ag_rmaps(sc, whichfork, pag);
663 if (error ||
664 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) {
665 xfs_perag_put(pag);
666 return error;
667 }
668 }
669
670 return 0;
671}
672
673/* Scrub a delalloc reservation from the incore extent map tree. */
674STATIC void
675xchk_bmap_iextent_delalloc(
676 struct xfs_inode *ip,
677 struct xchk_bmap_info *info,
678 struct xfs_bmbt_irec *irec)
679{
680 struct xfs_mount *mp = info->sc->mp;
681
682 /*
683 * Check for out-of-order extents. This record could have come
684 * from the incore list, for which there is no ordering check.
685 */
686 if (irec->br_startoff < info->lastoff)
687 xchk_fblock_set_corrupt(info->sc, info->whichfork,
688 irec->br_startoff);
689
690 if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
691 xchk_fblock_set_corrupt(info->sc, info->whichfork,
692 irec->br_startoff);
693
694 /* Make sure the extent points to a valid place. */
695 if (irec->br_blockcount > XFS_MAX_BMBT_EXTLEN)
696 xchk_fblock_set_corrupt(info->sc, info->whichfork,
697 irec->br_startoff);
698}
699
700/*
701 * Scrub an inode fork's block mappings.
702 *
703 * First we scan every record in every btree block, if applicable.
704 * Then we unconditionally scan the incore extent cache.
705 */
706STATIC int
707xchk_bmap(
708 struct xfs_scrub *sc,
709 int whichfork)
710{
711 struct xfs_bmbt_irec irec;
712 struct xchk_bmap_info info = { NULL };
713 struct xfs_mount *mp = sc->mp;
714 struct xfs_inode *ip = sc->ip;
715 struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
716 xfs_fileoff_t endoff;
717 int error = 0;
718
719 /* Non-existent forks can be ignored. */
720 if (!ifp)
721 goto out;
722
723 info.is_rt = whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip);
724 info.whichfork = whichfork;
725 info.is_shared = whichfork == XFS_DATA_FORK && xfs_is_reflink_inode(ip);
726 info.sc = sc;
727
728 switch (whichfork) {
729 case XFS_COW_FORK:
730 /* No CoW forks on non-reflink inodes/filesystems. */
731 if (!xfs_is_reflink_inode(ip)) {
732 xchk_ino_set_corrupt(sc, sc->ip->i_ino);
733 goto out;
734 }
735 break;
736 case XFS_ATTR_FORK:
737 if (!xfs_has_attr(mp) && !xfs_has_attr2(mp))
738 xchk_ino_set_corrupt(sc, sc->ip->i_ino);
739 break;
740 default:
741 ASSERT(whichfork == XFS_DATA_FORK);
742 break;
743 }
744
745 /* Check the fork values */
746 switch (ifp->if_format) {
747 case XFS_DINODE_FMT_UUID:
748 case XFS_DINODE_FMT_DEV:
749 case XFS_DINODE_FMT_LOCAL:
750 /* No mappings to check. */
751 if (whichfork == XFS_COW_FORK)
752 xchk_fblock_set_corrupt(sc, whichfork, 0);
753 goto out;
754 case XFS_DINODE_FMT_EXTENTS:
755 break;
756 case XFS_DINODE_FMT_BTREE:
757 if (whichfork == XFS_COW_FORK) {
758 xchk_fblock_set_corrupt(sc, whichfork, 0);
759 goto out;
760 }
761
762 error = xchk_bmap_btree(sc, whichfork, &info);
763 if (error)
764 goto out;
765 break;
766 default:
767 xchk_fblock_set_corrupt(sc, whichfork, 0);
768 goto out;
769 }
770
771 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
772 goto out;
773
774 /* Find the offset of the last extent in the mapping. */
775 error = xfs_bmap_last_offset(ip, &endoff, whichfork);
776 if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
777 goto out;
778
779 /* Scrub extent records. */
780 info.lastoff = 0;
781 ifp = xfs_ifork_ptr(ip, whichfork);
782 for_each_xfs_iext(ifp, &info.icur, &irec) {
783 if (xchk_should_terminate(sc, &error) ||
784 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
785 goto out;
786
787 if (irec.br_startoff >= endoff) {
788 xchk_fblock_set_corrupt(sc, whichfork,
789 irec.br_startoff);
790 goto out;
791 }
792
793 if (isnullstartblock(irec.br_startblock))
794 xchk_bmap_iextent_delalloc(ip, &info, &irec);
795 else
796 xchk_bmap_iextent(ip, &info, &irec);
797 info.lastoff = irec.br_startoff + irec.br_blockcount;
798 }
799
800 error = xchk_bmap_check_rmaps(sc, whichfork);
801 if (!xchk_fblock_xref_process_error(sc, whichfork, 0, &error))
802 goto out;
803out:
804 return error;
805}
806
807/* Scrub an inode's data fork. */
808int
809xchk_bmap_data(
810 struct xfs_scrub *sc)
811{
812 return xchk_bmap(sc, XFS_DATA_FORK);
813}
814
815/* Scrub an inode's attr fork. */
816int
817xchk_bmap_attr(
818 struct xfs_scrub *sc)
819{
820 return xchk_bmap(sc, XFS_ATTR_FORK);
821}
822
823/* Scrub an inode's CoW fork. */
824int
825xchk_bmap_cow(
826 struct xfs_scrub *sc)
827{
828 if (!xfs_is_reflink_inode(sc->ip))
829 return -ENOENT;
830
831 return xchk_bmap(sc, XFS_COW_FORK);
832}