bmap.c revision 38c26bfd
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	xfs_fileoff_t		lastoff;
94	bool			is_rt;
95	bool			is_shared;
96	bool			was_loaded;
97	int			whichfork;
98};
99
100/* Look for a corresponding rmap for this irec. */
101static inline bool
102xchk_bmap_get_rmap(
103	struct xchk_bmap_info	*info,
104	struct xfs_bmbt_irec	*irec,
105	xfs_agblock_t		agbno,
106	uint64_t		owner,
107	struct xfs_rmap_irec	*rmap)
108{
109	xfs_fileoff_t		offset;
110	unsigned int		rflags = 0;
111	int			has_rmap;
112	int			error;
113
114	if (info->whichfork == XFS_ATTR_FORK)
115		rflags |= XFS_RMAP_ATTR_FORK;
116	if (irec->br_state == XFS_EXT_UNWRITTEN)
117		rflags |= XFS_RMAP_UNWRITTEN;
118
119	/*
120	 * CoW staging extents are owned (on disk) by the refcountbt, so
121	 * their rmaps do not have offsets.
122	 */
123	if (info->whichfork == XFS_COW_FORK)
124		offset = 0;
125	else
126		offset = irec->br_startoff;
127
128	/*
129	 * If the caller thinks this could be a shared bmbt extent (IOWs,
130	 * any data fork extent of a reflink inode) then we have to use the
131	 * range rmap lookup to make sure we get the correct owner/offset.
132	 */
133	if (info->is_shared) {
134		error = xfs_rmap_lookup_le_range(info->sc->sa.rmap_cur, agbno,
135				owner, offset, rflags, rmap, &has_rmap);
136		if (!xchk_should_check_xref(info->sc, &error,
137				&info->sc->sa.rmap_cur))
138			return false;
139		goto out;
140	}
141
142	/*
143	 * Otherwise, use the (faster) regular lookup.
144	 */
145	error = xfs_rmap_lookup_le(info->sc->sa.rmap_cur, agbno, 0, owner,
146			offset, rflags, &has_rmap);
147	if (!xchk_should_check_xref(info->sc, &error,
148			&info->sc->sa.rmap_cur))
149		return false;
150	if (!has_rmap)
151		goto out;
152
153	error = xfs_rmap_get_rec(info->sc->sa.rmap_cur, rmap, &has_rmap);
154	if (!xchk_should_check_xref(info->sc, &error,
155			&info->sc->sa.rmap_cur))
156		return false;
157
158out:
159	if (!has_rmap)
160		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
161			irec->br_startoff);
162	return has_rmap;
163}
164
165/* Make sure that we have rmapbt records for this extent. */
166STATIC void
167xchk_bmap_xref_rmap(
168	struct xchk_bmap_info	*info,
169	struct xfs_bmbt_irec	*irec,
170	xfs_agblock_t		agbno)
171{
172	struct xfs_rmap_irec	rmap;
173	unsigned long long	rmap_end;
174	uint64_t		owner;
175
176	if (!info->sc->sa.rmap_cur || xchk_skip_xref(info->sc->sm))
177		return;
178
179	if (info->whichfork == XFS_COW_FORK)
180		owner = XFS_RMAP_OWN_COW;
181	else
182		owner = info->sc->ip->i_ino;
183
184	/* Find the rmap record for this irec. */
185	if (!xchk_bmap_get_rmap(info, irec, agbno, owner, &rmap))
186		return;
187
188	/* Check the rmap. */
189	rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount;
190	if (rmap.rm_startblock > agbno ||
191	    agbno + irec->br_blockcount > rmap_end)
192		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
193				irec->br_startoff);
194
195	/*
196	 * Check the logical offsets if applicable.  CoW staging extents
197	 * don't track logical offsets since the mappings only exist in
198	 * memory.
199	 */
200	if (info->whichfork != XFS_COW_FORK) {
201		rmap_end = (unsigned long long)rmap.rm_offset +
202				rmap.rm_blockcount;
203		if (rmap.rm_offset > irec->br_startoff ||
204		    irec->br_startoff + irec->br_blockcount > rmap_end)
205			xchk_fblock_xref_set_corrupt(info->sc,
206					info->whichfork, irec->br_startoff);
207	}
208
209	if (rmap.rm_owner != owner)
210		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
211				irec->br_startoff);
212
213	/*
214	 * Check for discrepancies between the unwritten flag in the irec and
215	 * the rmap.  Note that the (in-memory) CoW fork distinguishes between
216	 * unwritten and written extents, but we don't track that in the rmap
217	 * records because the blocks are owned (on-disk) by the refcountbt,
218	 * which doesn't track unwritten state.
219	 */
220	if (owner != XFS_RMAP_OWN_COW &&
221	    !!(irec->br_state == XFS_EXT_UNWRITTEN) !=
222	    !!(rmap.rm_flags & XFS_RMAP_UNWRITTEN))
223		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
224				irec->br_startoff);
225
226	if (!!(info->whichfork == XFS_ATTR_FORK) !=
227	    !!(rmap.rm_flags & XFS_RMAP_ATTR_FORK))
228		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
229				irec->br_startoff);
230	if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK)
231		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
232				irec->br_startoff);
233}
234
235/* Cross-reference a single rtdev extent record. */
236STATIC void
237xchk_bmap_rt_iextent_xref(
238	struct xfs_inode	*ip,
239	struct xchk_bmap_info	*info,
240	struct xfs_bmbt_irec	*irec)
241{
242	xchk_xref_is_used_rt_space(info->sc, irec->br_startblock,
243			irec->br_blockcount);
244}
245
246/* Cross-reference a single datadev extent record. */
247STATIC void
248xchk_bmap_iextent_xref(
249	struct xfs_inode	*ip,
250	struct xchk_bmap_info	*info,
251	struct xfs_bmbt_irec	*irec)
252{
253	struct xfs_mount	*mp = info->sc->mp;
254	xfs_agnumber_t		agno;
255	xfs_agblock_t		agbno;
256	xfs_extlen_t		len;
257	int			error;
258
259	agno = XFS_FSB_TO_AGNO(mp, irec->br_startblock);
260	agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock);
261	len = irec->br_blockcount;
262
263	error = xchk_ag_init_existing(info->sc, agno, &info->sc->sa);
264	if (!xchk_fblock_process_error(info->sc, info->whichfork,
265			irec->br_startoff, &error))
266		return;
267
268	xchk_xref_is_used_space(info->sc, agbno, len);
269	xchk_xref_is_not_inode_chunk(info->sc, agbno, len);
270	xchk_bmap_xref_rmap(info, irec, agbno);
271	switch (info->whichfork) {
272	case XFS_DATA_FORK:
273		if (xfs_is_reflink_inode(info->sc->ip))
274			break;
275		fallthrough;
276	case XFS_ATTR_FORK:
277		xchk_xref_is_not_shared(info->sc, agbno,
278				irec->br_blockcount);
279		break;
280	case XFS_COW_FORK:
281		xchk_xref_is_cow_staging(info->sc, agbno,
282				irec->br_blockcount);
283		break;
284	}
285
286	xchk_ag_free(info->sc, &info->sc->sa);
287}
288
289/*
290 * Directories and attr forks should never have blocks that can't be addressed
291 * by a xfs_dablk_t.
292 */
293STATIC void
294xchk_bmap_dirattr_extent(
295	struct xfs_inode	*ip,
296	struct xchk_bmap_info	*info,
297	struct xfs_bmbt_irec	*irec)
298{
299	struct xfs_mount	*mp = ip->i_mount;
300	xfs_fileoff_t		off;
301
302	if (!S_ISDIR(VFS_I(ip)->i_mode) && info->whichfork != XFS_ATTR_FORK)
303		return;
304
305	if (!xfs_verify_dablk(mp, irec->br_startoff))
306		xchk_fblock_set_corrupt(info->sc, info->whichfork,
307				irec->br_startoff);
308
309	off = irec->br_startoff + irec->br_blockcount - 1;
310	if (!xfs_verify_dablk(mp, off))
311		xchk_fblock_set_corrupt(info->sc, info->whichfork, off);
312}
313
314/* Scrub a single extent record. */
315STATIC int
316xchk_bmap_iextent(
317	struct xfs_inode	*ip,
318	struct xchk_bmap_info	*info,
319	struct xfs_bmbt_irec	*irec)
320{
321	struct xfs_mount	*mp = info->sc->mp;
322	int			error = 0;
323
324	/*
325	 * Check for out-of-order extents.  This record could have come
326	 * from the incore list, for which there is no ordering check.
327	 */
328	if (irec->br_startoff < info->lastoff)
329		xchk_fblock_set_corrupt(info->sc, info->whichfork,
330				irec->br_startoff);
331
332	if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
333		xchk_fblock_set_corrupt(info->sc, info->whichfork,
334				irec->br_startoff);
335
336	xchk_bmap_dirattr_extent(ip, info, irec);
337
338	/* There should never be a "hole" extent in either extent list. */
339	if (irec->br_startblock == HOLESTARTBLOCK)
340		xchk_fblock_set_corrupt(info->sc, info->whichfork,
341				irec->br_startoff);
342
343	/*
344	 * Check for delalloc extents.  We never iterate the ones in the
345	 * in-core extent scan, and we should never see these in the bmbt.
346	 */
347	if (isnullstartblock(irec->br_startblock))
348		xchk_fblock_set_corrupt(info->sc, info->whichfork,
349				irec->br_startoff);
350
351	/* Make sure the extent points to a valid place. */
352	if (irec->br_blockcount > MAXEXTLEN)
353		xchk_fblock_set_corrupt(info->sc, info->whichfork,
354				irec->br_startoff);
355	if (info->is_rt &&
356	    !xfs_verify_rtext(mp, irec->br_startblock, irec->br_blockcount))
357		xchk_fblock_set_corrupt(info->sc, info->whichfork,
358				irec->br_startoff);
359	if (!info->is_rt &&
360	    !xfs_verify_fsbext(mp, irec->br_startblock, irec->br_blockcount))
361		xchk_fblock_set_corrupt(info->sc, info->whichfork,
362				irec->br_startoff);
363
364	/* We don't allow unwritten extents on attr forks. */
365	if (irec->br_state == XFS_EXT_UNWRITTEN &&
366	    info->whichfork == XFS_ATTR_FORK)
367		xchk_fblock_set_corrupt(info->sc, info->whichfork,
368				irec->br_startoff);
369
370	if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
371		return 0;
372
373	if (info->is_rt)
374		xchk_bmap_rt_iextent_xref(ip, info, irec);
375	else
376		xchk_bmap_iextent_xref(ip, info, irec);
377
378	info->lastoff = irec->br_startoff + irec->br_blockcount;
379	return error;
380}
381
382/* Scrub a bmbt record. */
383STATIC int
384xchk_bmapbt_rec(
385	struct xchk_btree	*bs,
386	const union xfs_btree_rec *rec)
387{
388	struct xfs_bmbt_irec	irec;
389	struct xfs_bmbt_irec	iext_irec;
390	struct xfs_iext_cursor	icur;
391	struct xchk_bmap_info	*info = bs->private;
392	struct xfs_inode	*ip = bs->cur->bc_ino.ip;
393	struct xfs_buf		*bp = NULL;
394	struct xfs_btree_block	*block;
395	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, info->whichfork);
396	uint64_t		owner;
397	int			i;
398
399	/*
400	 * Check the owners of the btree blocks up to the level below
401	 * the root since the verifiers don't do that.
402	 */
403	if (xfs_has_crc(bs->cur->bc_mp) &&
404	    bs->cur->bc_ptrs[0] == 1) {
405		for (i = 0; i < bs->cur->bc_nlevels - 1; i++) {
406			block = xfs_btree_get_block(bs->cur, i, &bp);
407			owner = be64_to_cpu(block->bb_u.l.bb_owner);
408			if (owner != ip->i_ino)
409				xchk_fblock_set_corrupt(bs->sc,
410						info->whichfork, 0);
411		}
412	}
413
414	/*
415	 * Check that the incore extent tree contains an extent that matches
416	 * this one exactly.  We validate those cached bmaps later, so we don't
417	 * need to check them here.  If the incore extent tree was just loaded
418	 * from disk by the scrubber, we assume that its contents match what's
419	 * on disk (we still hold the ILOCK) and skip the equivalence check.
420	 */
421	if (!info->was_loaded)
422		return 0;
423
424	xfs_bmbt_disk_get_all(&rec->bmbt, &irec);
425	if (!xfs_iext_lookup_extent(ip, ifp, irec.br_startoff, &icur,
426				&iext_irec) ||
427	    irec.br_startoff != iext_irec.br_startoff ||
428	    irec.br_startblock != iext_irec.br_startblock ||
429	    irec.br_blockcount != iext_irec.br_blockcount ||
430	    irec.br_state != iext_irec.br_state)
431		xchk_fblock_set_corrupt(bs->sc, info->whichfork,
432				irec.br_startoff);
433	return 0;
434}
435
436/* Scan the btree records. */
437STATIC int
438xchk_bmap_btree(
439	struct xfs_scrub	*sc,
440	int			whichfork,
441	struct xchk_bmap_info	*info)
442{
443	struct xfs_owner_info	oinfo;
444	struct xfs_ifork	*ifp = XFS_IFORK_PTR(sc->ip, whichfork);
445	struct xfs_mount	*mp = sc->mp;
446	struct xfs_inode	*ip = sc->ip;
447	struct xfs_btree_cur	*cur;
448	int			error;
449
450	/* Load the incore bmap cache if it's not loaded. */
451	info->was_loaded = !xfs_need_iread_extents(ifp);
452
453	error = xfs_iread_extents(sc->tp, ip, whichfork);
454	if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
455		goto out;
456
457	/* Check the btree structure. */
458	cur = xfs_bmbt_init_cursor(mp, sc->tp, ip, whichfork);
459	xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
460	error = xchk_btree(sc, cur, xchk_bmapbt_rec, &oinfo, info);
461	xfs_btree_del_cursor(cur, error);
462out:
463	return error;
464}
465
466struct xchk_bmap_check_rmap_info {
467	struct xfs_scrub	*sc;
468	int			whichfork;
469	struct xfs_iext_cursor	icur;
470};
471
472/* Can we find bmaps that fit this rmap? */
473STATIC int
474xchk_bmap_check_rmap(
475	struct xfs_btree_cur		*cur,
476	const struct xfs_rmap_irec	*rec,
477	void				*priv)
478{
479	struct xfs_bmbt_irec		irec;
480	struct xfs_rmap_irec		check_rec;
481	struct xchk_bmap_check_rmap_info	*sbcri = priv;
482	struct xfs_ifork		*ifp;
483	struct xfs_scrub		*sc = sbcri->sc;
484	bool				have_map;
485
486	/* Is this even the right fork? */
487	if (rec->rm_owner != sc->ip->i_ino)
488		return 0;
489	if ((sbcri->whichfork == XFS_ATTR_FORK) ^
490	    !!(rec->rm_flags & XFS_RMAP_ATTR_FORK))
491		return 0;
492	if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK)
493		return 0;
494
495	/* Now look up the bmbt record. */
496	ifp = XFS_IFORK_PTR(sc->ip, sbcri->whichfork);
497	if (!ifp) {
498		xchk_fblock_set_corrupt(sc, sbcri->whichfork,
499				rec->rm_offset);
500		goto out;
501	}
502	have_map = xfs_iext_lookup_extent(sc->ip, ifp, rec->rm_offset,
503			&sbcri->icur, &irec);
504	if (!have_map)
505		xchk_fblock_set_corrupt(sc, sbcri->whichfork,
506				rec->rm_offset);
507	/*
508	 * bmap extent record lengths are constrained to 2^21 blocks in length
509	 * because of space constraints in the on-disk metadata structure.
510	 * However, rmap extent record lengths are constrained only by AG
511	 * length, so we have to loop through the bmbt to make sure that the
512	 * entire rmap is covered by bmbt records.
513	 */
514	check_rec = *rec;
515	while (have_map) {
516		if (irec.br_startoff != check_rec.rm_offset)
517			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
518					check_rec.rm_offset);
519		if (irec.br_startblock != XFS_AGB_TO_FSB(sc->mp,
520				cur->bc_ag.pag->pag_agno,
521				check_rec.rm_startblock))
522			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
523					check_rec.rm_offset);
524		if (irec.br_blockcount > check_rec.rm_blockcount)
525			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
526					check_rec.rm_offset);
527		if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
528			break;
529		check_rec.rm_startblock += irec.br_blockcount;
530		check_rec.rm_offset += irec.br_blockcount;
531		check_rec.rm_blockcount -= irec.br_blockcount;
532		if (check_rec.rm_blockcount == 0)
533			break;
534		have_map = xfs_iext_next_extent(ifp, &sbcri->icur, &irec);
535		if (!have_map)
536			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
537					check_rec.rm_offset);
538	}
539
540out:
541	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
542		return -ECANCELED;
543	return 0;
544}
545
546/* Make sure each rmap has a corresponding bmbt entry. */
547STATIC int
548xchk_bmap_check_ag_rmaps(
549	struct xfs_scrub		*sc,
550	int				whichfork,
551	struct xfs_perag		*pag)
552{
553	struct xchk_bmap_check_rmap_info	sbcri;
554	struct xfs_btree_cur		*cur;
555	struct xfs_buf			*agf;
556	int				error;
557
558	error = xfs_alloc_read_agf(sc->mp, sc->tp, pag->pag_agno, 0, &agf);
559	if (error)
560		return error;
561
562	cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf, pag);
563
564	sbcri.sc = sc;
565	sbcri.whichfork = whichfork;
566	error = xfs_rmap_query_all(cur, xchk_bmap_check_rmap, &sbcri);
567	if (error == -ECANCELED)
568		error = 0;
569
570	xfs_btree_del_cursor(cur, error);
571	xfs_trans_brelse(sc->tp, agf);
572	return error;
573}
574
575/* Make sure each rmap has a corresponding bmbt entry. */
576STATIC int
577xchk_bmap_check_rmaps(
578	struct xfs_scrub	*sc,
579	int			whichfork)
580{
581	struct xfs_ifork	*ifp = XFS_IFORK_PTR(sc->ip, whichfork);
582	struct xfs_perag	*pag;
583	xfs_agnumber_t		agno;
584	bool			zero_size;
585	int			error;
586
587	if (!xfs_has_rmapbt(sc->mp) ||
588	    whichfork == XFS_COW_FORK ||
589	    (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
590		return 0;
591
592	/* Don't support realtime rmap checks yet. */
593	if (XFS_IS_REALTIME_INODE(sc->ip) && whichfork == XFS_DATA_FORK)
594		return 0;
595
596	ASSERT(XFS_IFORK_PTR(sc->ip, whichfork) != NULL);
597
598	/*
599	 * Only do this for complex maps that are in btree format, or for
600	 * situations where we would seem to have a size but zero extents.
601	 * The inode repair code can zap broken iforks, which means we have
602	 * to flag this bmap as corrupt if there are rmaps that need to be
603	 * reattached.
604	 */
605
606	if (whichfork == XFS_DATA_FORK)
607		zero_size = i_size_read(VFS_I(sc->ip)) == 0;
608	else
609		zero_size = false;
610
611	if (ifp->if_format != XFS_DINODE_FMT_BTREE &&
612	    (zero_size || ifp->if_nextents > 0))
613		return 0;
614
615	for_each_perag(sc->mp, agno, pag) {
616		error = xchk_bmap_check_ag_rmaps(sc, whichfork, pag);
617		if (error)
618			break;
619		if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
620			break;
621	}
622	if (pag)
623		xfs_perag_put(pag);
624	return error;
625}
626
627/*
628 * Scrub an inode fork's block mappings.
629 *
630 * First we scan every record in every btree block, if applicable.
631 * Then we unconditionally scan the incore extent cache.
632 */
633STATIC int
634xchk_bmap(
635	struct xfs_scrub	*sc,
636	int			whichfork)
637{
638	struct xfs_bmbt_irec	irec;
639	struct xchk_bmap_info	info = { NULL };
640	struct xfs_mount	*mp = sc->mp;
641	struct xfs_inode	*ip = sc->ip;
642	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
643	xfs_fileoff_t		endoff;
644	struct xfs_iext_cursor	icur;
645	int			error = 0;
646
647	/* Non-existent forks can be ignored. */
648	if (!ifp)
649		goto out;
650
651	info.is_rt = whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip);
652	info.whichfork = whichfork;
653	info.is_shared = whichfork == XFS_DATA_FORK && xfs_is_reflink_inode(ip);
654	info.sc = sc;
655
656	switch (whichfork) {
657	case XFS_COW_FORK:
658		/* No CoW forks on non-reflink inodes/filesystems. */
659		if (!xfs_is_reflink_inode(ip)) {
660			xchk_ino_set_corrupt(sc, sc->ip->i_ino);
661			goto out;
662		}
663		break;
664	case XFS_ATTR_FORK:
665		if (!xfs_sb_version_hasattr(&mp->m_sb) &&
666		    !xfs_sb_version_hasattr2(&mp->m_sb))
667			xchk_ino_set_corrupt(sc, sc->ip->i_ino);
668		break;
669	default:
670		ASSERT(whichfork == XFS_DATA_FORK);
671		break;
672	}
673
674	/* Check the fork values */
675	switch (ifp->if_format) {
676	case XFS_DINODE_FMT_UUID:
677	case XFS_DINODE_FMT_DEV:
678	case XFS_DINODE_FMT_LOCAL:
679		/* No mappings to check. */
680		goto out;
681	case XFS_DINODE_FMT_EXTENTS:
682		break;
683	case XFS_DINODE_FMT_BTREE:
684		if (whichfork == XFS_COW_FORK) {
685			xchk_fblock_set_corrupt(sc, whichfork, 0);
686			goto out;
687		}
688
689		error = xchk_bmap_btree(sc, whichfork, &info);
690		if (error)
691			goto out;
692		break;
693	default:
694		xchk_fblock_set_corrupt(sc, whichfork, 0);
695		goto out;
696	}
697
698	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
699		goto out;
700
701	/* Find the offset of the last extent in the mapping. */
702	error = xfs_bmap_last_offset(ip, &endoff, whichfork);
703	if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
704		goto out;
705
706	/* Scrub extent records. */
707	info.lastoff = 0;
708	ifp = XFS_IFORK_PTR(ip, whichfork);
709	for_each_xfs_iext(ifp, &icur, &irec) {
710		if (xchk_should_terminate(sc, &error) ||
711		    (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
712			goto out;
713		if (isnullstartblock(irec.br_startblock))
714			continue;
715		if (irec.br_startoff >= endoff) {
716			xchk_fblock_set_corrupt(sc, whichfork,
717					irec.br_startoff);
718			goto out;
719		}
720		error = xchk_bmap_iextent(ip, &info, &irec);
721		if (error)
722			goto out;
723	}
724
725	error = xchk_bmap_check_rmaps(sc, whichfork);
726	if (!xchk_fblock_xref_process_error(sc, whichfork, 0, &error))
727		goto out;
728out:
729	return error;
730}
731
732/* Scrub an inode's data fork. */
733int
734xchk_bmap_data(
735	struct xfs_scrub	*sc)
736{
737	return xchk_bmap(sc, XFS_DATA_FORK);
738}
739
740/* Scrub an inode's attr fork. */
741int
742xchk_bmap_attr(
743	struct xfs_scrub	*sc)
744{
745	return xchk_bmap(sc, XFS_ATTR_FORK);
746}
747
748/* Scrub an inode's CoW fork. */
749int
750xchk_bmap_cow(
751	struct xfs_scrub	*sc)
752{
753	if (!xfs_is_reflink_inode(sc->ip))
754		return -ENOENT;
755
756	return xchk_bmap(sc, XFS_COW_FORK);
757}
758