bmap.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Copyright (C) 2017-2023 Oracle.  All Rights Reserved.
   4 * Author: Darrick J. Wong <djwong@kernel.org>
   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 "xfs_rtgroup.h"
  23#include "xfs_health.h"
  24#include "xfs_rtalloc.h"
  25#include "xfs_rtrmap_btree.h"
  26#include "scrub/scrub.h"
  27#include "scrub/common.h"
  28#include "scrub/btree.h"
  29#include "scrub/health.h"
  30#include "xfs_ag.h"
  31
  32/* Set us up with an inode's bmap. */
  33int
  34xchk_setup_inode_bmap(
  35	struct xfs_scrub	*sc)
  36{
  37	int			error;
  38
  39	if (xchk_need_intent_drain(sc))
  40		xchk_fsgates_enable(sc, XCHK_FSGATES_DRAIN);
  41
  42	error = xchk_iget_for_scrubbing(sc);
  43	if (error)
  44		goto out;
  45
  46	xchk_ilock(sc, XFS_IOLOCK_EXCL);
  47
  48	/*
  49	 * We don't want any ephemeral data/cow fork updates sitting around
  50	 * while we inspect block mappings, so wait for directio to finish
  51	 * and flush dirty data if we have delalloc reservations.
  52	 */
  53	if (S_ISREG(VFS_I(sc->ip)->i_mode) &&
  54	    sc->sm->sm_type != XFS_SCRUB_TYPE_BMBTA) {
  55		struct address_space	*mapping = VFS_I(sc->ip)->i_mapping;
  56		bool			is_repair = xchk_could_repair(sc);
  57
  58		xchk_ilock(sc, XFS_MMAPLOCK_EXCL);
  59
  60		/* Break all our leases, we're going to mess with things. */
  61		if (is_repair) {
  62			error = xfs_break_layouts(VFS_I(sc->ip),
  63					&sc->ilock_flags, BREAK_WRITE);
  64			if (error)
  65				goto out;
  66		}
  67
  68		inode_dio_wait(VFS_I(sc->ip));
  69
  70		/*
  71		 * Try to flush all incore state to disk before we examine the
  72		 * space mappings for the data fork.  Leave accumulated errors
  73		 * in the mapping for the writer threads to consume.
  74		 *
  75		 * On ENOSPC or EIO writeback errors, we continue into the
  76		 * extent mapping checks because write failures do not
  77		 * necessarily imply anything about the correctness of the file
  78		 * metadata.  The metadata and the file data could be on
  79		 * completely separate devices; a media failure might only
  80		 * affect a subset of the disk, etc.  We can handle delalloc
  81		 * extents in the scrubber, so leaving them in memory is fine.
  82		 */
  83		error = filemap_fdatawrite(mapping);
  84		if (!error)
  85			error = filemap_fdatawait_keep_errors(mapping);
  86		if (error && (error != -ENOSPC && error != -EIO))
  87			goto out;
  88
  89		/* Drop the page cache if we're repairing block mappings. */
  90		if (is_repair) {
  91			error = invalidate_inode_pages2(
  92					VFS_I(sc->ip)->i_mapping);
  93			if (error)
  94				goto out;
  95		}
  96
  97	}
  98
  99	/* Got the inode, lock it and we're ready to go. */
 100	error = xchk_trans_alloc(sc, 0);
 101	if (error)
 102		goto out;
 103
 104	error = xchk_ino_dqattach(sc);
 105	if (error)
 106		goto out;
 107
 108	xchk_ilock(sc, XFS_ILOCK_EXCL);
 109out:
 110	/* scrub teardown will unlock and release the inode */
 111	return error;
 112}
 113
 114/*
 115 * Inode fork block mapping (BMBT) scrubber.
 116 * More complex than the others because we have to scrub
 117 * all the extents regardless of whether or not the fork
 118 * is in btree format.
 119 */
 120
 121struct xchk_bmap_info {
 122	struct xfs_scrub	*sc;
 123
 124	/* Incore extent tree cursor */
 125	struct xfs_iext_cursor	icur;
 126
 127	/* Previous fork mapping that we examined */
 128	struct xfs_bmbt_irec	prev_rec;
 129
 130	/* Is this a realtime fork? */
 131	bool			is_rt;
 132
 133	/* May mappings point to shared space? */
 134	bool			is_shared;
 135
 136	/* Was the incore extent tree loaded? */
 137	bool			was_loaded;
 138
 139	/* Which inode fork are we checking? */
 140	int			whichfork;
 141};
 142
 143/* Look for a corresponding rmap for this irec. */
 144static inline bool
 145xchk_bmap_get_rmap(
 146	struct xchk_bmap_info	*info,
 147	struct xfs_bmbt_irec	*irec,
 148	xfs_agblock_t		bno,
 149	uint64_t		owner,
 150	struct xfs_rmap_irec	*rmap)
 151{
 152	struct xfs_btree_cur	**curp = &info->sc->sa.rmap_cur;
 153	xfs_fileoff_t		offset;
 154	unsigned int		rflags = 0;
 155	int			has_rmap;
 156	int			error;
 157
 158	if (xfs_ifork_is_realtime(info->sc->ip, info->whichfork))
 159		curp = &info->sc->sr.rmap_cur;
 160
 161	if (*curp == NULL)
 162		return false;
 163
 164	if (info->whichfork == XFS_ATTR_FORK)
 165		rflags |= XFS_RMAP_ATTR_FORK;
 166	if (irec->br_state == XFS_EXT_UNWRITTEN)
 167		rflags |= XFS_RMAP_UNWRITTEN;
 168
 169	/*
 170	 * CoW staging extents are owned (on disk) by the refcountbt, so
 171	 * their rmaps do not have offsets.
 172	 */
 173	if (info->whichfork == XFS_COW_FORK)
 174		offset = 0;
 175	else
 176		offset = irec->br_startoff;
 177
 178	/*
 179	 * If the caller thinks this could be a shared bmbt extent (IOWs,
 180	 * any data fork extent of a reflink inode) then we have to use the
 181	 * range rmap lookup to make sure we get the correct owner/offset.
 182	 */
 183	if (info->is_shared) {
 184		error = xfs_rmap_lookup_le_range(*curp, bno, owner, offset,
 185				rflags, rmap, &has_rmap);
 186	} else {
 187		error = xfs_rmap_lookup_le(*curp, bno, owner, offset,
 188				rflags, rmap, &has_rmap);
 189	}
 190	if (!xchk_should_check_xref(info->sc, &error, curp))
 191		return false;
 192
 193	if (!has_rmap)
 194		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 195			irec->br_startoff);
 196	return has_rmap;
 197}
 198
 199/* Make sure that we have rmapbt records for this data/attr fork extent. */
 200STATIC void
 201xchk_bmap_xref_rmap(
 202	struct xchk_bmap_info	*info,
 203	struct xfs_bmbt_irec	*irec,
 204	xfs_agblock_t		bno)
 205{
 206	struct xfs_rmap_irec	rmap;
 207	unsigned long long	rmap_end;
 208	uint64_t		owner = info->sc->ip->i_ino;
 209
 210	if (xchk_skip_xref(info->sc->sm))
 211		return;
 212
 213	/* Find the rmap record for this irec. */
 214	if (!xchk_bmap_get_rmap(info, irec, bno, owner, &rmap))
 215		return;
 216
 217	/*
 218	 * The rmap must be an exact match for this incore file mapping record,
 219	 * which may have arisen from multiple ondisk records.
 220	 */
 221	if (rmap.rm_startblock != bno)
 222		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 223				irec->br_startoff);
 224
 225	rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount;
 226	if (rmap_end != bno + irec->br_blockcount)
 227		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 228				irec->br_startoff);
 229
 230	/* Check the logical offsets. */
 231	if (rmap.rm_offset != irec->br_startoff)
 232		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 233				irec->br_startoff);
 234
 235	rmap_end = (unsigned long long)rmap.rm_offset + rmap.rm_blockcount;
 236	if (rmap_end != irec->br_startoff + irec->br_blockcount)
 237		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 238				irec->br_startoff);
 239
 240	/* Check the owner */
 241	if (rmap.rm_owner != owner)
 242		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 243				irec->br_startoff);
 244
 245	/*
 246	 * Check for discrepancies between the unwritten flag in the irec and
 247	 * the rmap.  Note that the (in-memory) CoW fork distinguishes between
 248	 * unwritten and written extents, but we don't track that in the rmap
 249	 * records because the blocks are owned (on-disk) by the refcountbt,
 250	 * which doesn't track unwritten state.
 251	 */
 252	if (!!(irec->br_state == XFS_EXT_UNWRITTEN) !=
 253	    !!(rmap.rm_flags & XFS_RMAP_UNWRITTEN))
 254		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 255				irec->br_startoff);
 256
 257	if (!!(info->whichfork == XFS_ATTR_FORK) !=
 258	    !!(rmap.rm_flags & XFS_RMAP_ATTR_FORK))
 259		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 260				irec->br_startoff);
 261	if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK)
 262		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 263				irec->br_startoff);
 264}
 265
 266/* Make sure that we have rmapbt records for this COW fork extent. */
 267STATIC void
 268xchk_bmap_xref_rmap_cow(
 269	struct xchk_bmap_info	*info,
 270	struct xfs_bmbt_irec	*irec,
 271	xfs_agblock_t		bno)
 272{
 273	struct xfs_rmap_irec	rmap;
 274	unsigned long long	rmap_end;
 275	uint64_t		owner = XFS_RMAP_OWN_COW;
 276
 277	if (!info->sc->sa.rmap_cur || xchk_skip_xref(info->sc->sm))
 278		return;
 279
 280	/* Find the rmap record for this irec. */
 281	if (!xchk_bmap_get_rmap(info, irec, bno, owner, &rmap))
 282		return;
 283
 284	/*
 285	 * CoW staging extents are owned by the refcount btree, so the rmap
 286	 * can start before and end after the physical space allocated to this
 287	 * mapping.  There are no offsets to check.
 288	 */
 289	if (rmap.rm_startblock > bno)
 290		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 291				irec->br_startoff);
 292
 293	rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount;
 294	if (rmap_end < bno + irec->br_blockcount)
 295		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 296				irec->br_startoff);
 297
 298	/* Check the owner */
 299	if (rmap.rm_owner != owner)
 300		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 301				irec->br_startoff);
 302
 303	/*
 304	 * No flags allowed.  Note that the (in-memory) CoW fork distinguishes
 305	 * between unwritten and written extents, but we don't track that in
 306	 * the rmap records because the blocks are owned (on-disk) by the
 307	 * refcountbt, which doesn't track unwritten state.
 308	 */
 309	if (rmap.rm_flags & XFS_RMAP_ATTR_FORK)
 310		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 311				irec->br_startoff);
 312	if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK)
 313		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 314				irec->br_startoff);
 315	if (rmap.rm_flags & XFS_RMAP_UNWRITTEN)
 316		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
 317				irec->br_startoff);
 318}
 319
 320/* Cross-reference a single rtdev extent record. */
 321STATIC void
 322xchk_bmap_rt_iextent_xref(
 323	struct xfs_inode	*ip,
 324	struct xchk_bmap_info	*info,
 325	struct xfs_bmbt_irec	*irec)
 326{
 327	struct xfs_owner_info	oinfo;
 328	xfs_rgblock_t		rgbno;
 329	int			error;
 330
 331	error = xchk_rtgroup_init_existing(info->sc,
 332			xfs_rtb_to_rgno(ip->i_mount, irec->br_startblock),
 333			&info->sc->sr);
 334	if (!xchk_fblock_process_error(info->sc, info->whichfork,
 335			irec->br_startoff, &error))
 336		return;
 337
 338	error = xchk_rtgroup_lock(info->sc, &info->sc->sr, XCHK_RTGLOCK_ALL);
 339	if (!xchk_fblock_process_error(info->sc, info->whichfork,
 340			irec->br_startoff, &error))
 341		goto out_free;
 342
 343	xchk_xref_is_used_rt_space(info->sc, irec->br_startblock,
 344			irec->br_blockcount);
 345
 346	if (!xfs_has_rtrmapbt(info->sc->mp))
 347		goto out_cur;
 348
 349	rgbno = xfs_rtb_to_rgbno(info->sc->mp, irec->br_startblock);
 350
 351	switch (info->whichfork) {
 352	case XFS_DATA_FORK:
 353		xchk_bmap_xref_rmap(info, irec, rgbno);
 354		if (!xfs_is_reflink_inode(info->sc->ip)) {
 355			xfs_rmap_ino_owner(&oinfo, info->sc->ip->i_ino,
 356					info->whichfork, irec->br_startoff);
 357			xchk_xref_is_only_rt_owned_by(info->sc, rgbno,
 358					irec->br_blockcount, &oinfo);
 359			xchk_xref_is_not_rt_shared(info->sc, rgbno,
 360					irec->br_blockcount);
 361		}
 362		xchk_xref_is_not_rt_cow_staging(info->sc, rgbno,
 363				irec->br_blockcount);
 364		break;
 365	case XFS_COW_FORK:
 366		xchk_bmap_xref_rmap_cow(info, irec, rgbno);
 367		xchk_xref_is_only_rt_owned_by(info->sc, rgbno,
 368				irec->br_blockcount, &XFS_RMAP_OINFO_COW);
 369		xchk_xref_is_rt_cow_staging(info->sc, rgbno,
 370				irec->br_blockcount);
 371		xchk_xref_is_not_rt_shared(info->sc, rgbno,
 372				irec->br_blockcount);
 373		break;
 374	}
 375out_cur:
 376	xchk_rtgroup_btcur_free(&info->sc->sr);
 377out_free:
 378	xchk_rtgroup_free(info->sc, &info->sc->sr);
 379}
 380
 381/* Cross-reference a single datadev extent record. */
 382STATIC void
 383xchk_bmap_iextent_xref(
 384	struct xfs_inode	*ip,
 385	struct xchk_bmap_info	*info,
 386	struct xfs_bmbt_irec	*irec)
 387{
 388	struct xfs_owner_info	oinfo;
 389	struct xfs_mount	*mp = info->sc->mp;
 390	xfs_agnumber_t		agno;
 391	xfs_agblock_t		agbno;
 392	xfs_extlen_t		len;
 393	int			error;
 394
 395	agno = XFS_FSB_TO_AGNO(mp, irec->br_startblock);
 396	agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock);
 397	len = irec->br_blockcount;
 398
 399	error = xchk_ag_init_existing(info->sc, agno, &info->sc->sa);
 400	if (!xchk_fblock_process_error(info->sc, info->whichfork,
 401			irec->br_startoff, &error))
 402		goto out_free;
 403
 404	xchk_xref_is_used_space(info->sc, agbno, len);
 405	xchk_xref_is_not_inode_chunk(info->sc, agbno, len);
 406	switch (info->whichfork) {
 407	case XFS_DATA_FORK:
 408		xchk_bmap_xref_rmap(info, irec, agbno);
 409		if (!xfs_is_reflink_inode(info->sc->ip)) {
 410			xfs_rmap_ino_owner(&oinfo, info->sc->ip->i_ino,
 411					info->whichfork, irec->br_startoff);
 412			xchk_xref_is_only_owned_by(info->sc, agbno,
 413					irec->br_blockcount, &oinfo);
 414			xchk_xref_is_not_shared(info->sc, agbno,
 415					irec->br_blockcount);
 416		}
 417		xchk_xref_is_not_cow_staging(info->sc, agbno,
 418				irec->br_blockcount);
 419		break;
 420	case XFS_ATTR_FORK:
 421		xchk_bmap_xref_rmap(info, irec, agbno);
 422		xfs_rmap_ino_owner(&oinfo, info->sc->ip->i_ino,
 423				info->whichfork, irec->br_startoff);
 424		xchk_xref_is_only_owned_by(info->sc, agbno, irec->br_blockcount,
 425				&oinfo);
 426		xchk_xref_is_not_shared(info->sc, agbno,
 427				irec->br_blockcount);
 428		xchk_xref_is_not_cow_staging(info->sc, agbno,
 429				irec->br_blockcount);
 430		break;
 431	case XFS_COW_FORK:
 432		xchk_bmap_xref_rmap_cow(info, irec, agbno);
 433		xchk_xref_is_only_owned_by(info->sc, agbno, irec->br_blockcount,
 434				&XFS_RMAP_OINFO_COW);
 435		xchk_xref_is_cow_staging(info->sc, agbno,
 436				irec->br_blockcount);
 437		xchk_xref_is_not_shared(info->sc, agbno,
 438				irec->br_blockcount);
 439		break;
 440	}
 441
 442out_free:
 443	xchk_ag_free(info->sc, &info->sc->sa);
 444}
 445
 446/*
 447 * Directories and attr forks should never have blocks that can't be addressed
 448 * by a xfs_dablk_t.
 449 */
 450STATIC void
 451xchk_bmap_dirattr_extent(
 452	struct xfs_inode	*ip,
 453	struct xchk_bmap_info	*info,
 454	struct xfs_bmbt_irec	*irec)
 455{
 456	struct xfs_mount	*mp = ip->i_mount;
 457	xfs_fileoff_t		off;
 458
 459	if (!S_ISDIR(VFS_I(ip)->i_mode) && info->whichfork != XFS_ATTR_FORK)
 460		return;
 461
 462	if (!xfs_verify_dablk(mp, irec->br_startoff))
 463		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 464				irec->br_startoff);
 465
 466	off = irec->br_startoff + irec->br_blockcount - 1;
 467	if (!xfs_verify_dablk(mp, off))
 468		xchk_fblock_set_corrupt(info->sc, info->whichfork, off);
 469}
 470
 471/* Scrub a single extent record. */
 472STATIC void
 473xchk_bmap_iextent(
 474	struct xfs_inode	*ip,
 475	struct xchk_bmap_info	*info,
 476	struct xfs_bmbt_irec	*irec)
 477{
 478	struct xfs_mount	*mp = info->sc->mp;
 479
 480	/*
 481	 * Check for out-of-order extents.  This record could have come
 482	 * from the incore list, for which there is no ordering check.
 483	 */
 484	if (irec->br_startoff < info->prev_rec.br_startoff +
 485				info->prev_rec.br_blockcount)
 486		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 487				irec->br_startoff);
 488
 489	if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
 490		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 491				irec->br_startoff);
 492
 493	xchk_bmap_dirattr_extent(ip, info, irec);
 494
 495	/* Make sure the extent points to a valid place. */
 496	if (info->is_rt &&
 497	    !xfs_verify_rtbext(mp, irec->br_startblock, irec->br_blockcount))
 498		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 499				irec->br_startoff);
 500	if (!info->is_rt &&
 501	    !xfs_verify_fsbext(mp, irec->br_startblock, irec->br_blockcount))
 502		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 503				irec->br_startoff);
 504
 505	/* We don't allow unwritten extents on attr forks. */
 506	if (irec->br_state == XFS_EXT_UNWRITTEN &&
 507	    info->whichfork == XFS_ATTR_FORK)
 508		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 509				irec->br_startoff);
 510
 511	if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 512		return;
 513
 514	if (info->is_rt)
 515		xchk_bmap_rt_iextent_xref(ip, info, irec);
 516	else
 517		xchk_bmap_iextent_xref(ip, info, irec);
 518}
 519
 520/* Scrub a bmbt record. */
 521STATIC int
 522xchk_bmapbt_rec(
 523	struct xchk_btree	*bs,
 524	const union xfs_btree_rec *rec)
 525{
 526	struct xfs_bmbt_irec	irec;
 527	struct xfs_bmbt_irec	iext_irec;
 528	struct xfs_iext_cursor	icur;
 529	struct xchk_bmap_info	*info = bs->private;
 530	struct xfs_inode	*ip = bs->cur->bc_ino.ip;
 531	struct xfs_buf		*bp = NULL;
 532	struct xfs_btree_block	*block;
 533	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, info->whichfork);
 534	uint64_t		owner;
 535	int			i;
 536
 537	/*
 538	 * Check the owners of the btree blocks up to the level below
 539	 * the root since the verifiers don't do that.
 540	 */
 541	if (xfs_has_crc(bs->cur->bc_mp) &&
 542	    bs->cur->bc_levels[0].ptr == 1) {
 543		for (i = 0; i < bs->cur->bc_nlevels - 1; i++) {
 544			block = xfs_btree_get_block(bs->cur, i, &bp);
 545			owner = be64_to_cpu(block->bb_u.l.bb_owner);
 546			if (owner != ip->i_ino)
 547				xchk_fblock_set_corrupt(bs->sc,
 548						info->whichfork, 0);
 549		}
 550	}
 551
 552	/*
 553	 * Check that the incore extent tree contains an extent that matches
 554	 * this one exactly.  We validate those cached bmaps later, so we don't
 555	 * need to check them here.  If the incore extent tree was just loaded
 556	 * from disk by the scrubber, we assume that its contents match what's
 557	 * on disk (we still hold the ILOCK) and skip the equivalence check.
 558	 */
 559	if (!info->was_loaded)
 560		return 0;
 561
 562	xfs_bmbt_disk_get_all(&rec->bmbt, &irec);
 563	if (xfs_bmap_validate_extent(ip, info->whichfork, &irec) != NULL) {
 564		xchk_fblock_set_corrupt(bs->sc, info->whichfork,
 565				irec.br_startoff);
 566		return 0;
 567	}
 568
 569	if (!xfs_iext_lookup_extent(ip, ifp, irec.br_startoff, &icur,
 570				&iext_irec) ||
 571	    irec.br_startoff != iext_irec.br_startoff ||
 572	    irec.br_startblock != iext_irec.br_startblock ||
 573	    irec.br_blockcount != iext_irec.br_blockcount ||
 574	    irec.br_state != iext_irec.br_state)
 575		xchk_fblock_set_corrupt(bs->sc, info->whichfork,
 576				irec.br_startoff);
 577	return 0;
 578}
 579
 580/* Scan the btree records. */
 581STATIC int
 582xchk_bmap_btree(
 583	struct xfs_scrub	*sc,
 584	int			whichfork,
 585	struct xchk_bmap_info	*info)
 586{
 587	struct xfs_owner_info	oinfo;
 588	struct xfs_ifork	*ifp = xfs_ifork_ptr(sc->ip, whichfork);
 589	struct xfs_mount	*mp = sc->mp;
 590	struct xfs_inode	*ip = sc->ip;
 591	struct xfs_btree_cur	*cur;
 592	int			error;
 593
 594	/* Load the incore bmap cache if it's not loaded. */
 595	info->was_loaded = !xfs_need_iread_extents(ifp);
 596
 597	error = xfs_iread_extents(sc->tp, ip, whichfork);
 598	if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
 599		goto out;
 600
 601	/* Check the btree structure. */
 602	cur = xfs_bmbt_init_cursor(mp, sc->tp, ip, whichfork);
 603	xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
 604	error = xchk_btree(sc, cur, xchk_bmapbt_rec, &oinfo, info);
 605	xfs_btree_del_cursor(cur, error);
 606out:
 607	return error;
 608}
 609
 610struct xchk_bmap_check_rmap_info {
 611	struct xfs_scrub	*sc;
 612	int			whichfork;
 613	struct xfs_iext_cursor	icur;
 614};
 615
 616/* Can we find bmaps that fit this rmap? */
 617STATIC int
 618xchk_bmap_check_rmap(
 619	struct xfs_btree_cur		*cur,
 620	const struct xfs_rmap_irec	*rec,
 621	void				*priv)
 622{
 623	struct xfs_bmbt_irec		irec;
 624	struct xfs_rmap_irec		check_rec;
 625	struct xchk_bmap_check_rmap_info	*sbcri = priv;
 626	struct xfs_ifork		*ifp;
 627	struct xfs_scrub		*sc = sbcri->sc;
 628	bool				have_map;
 629
 630	/* Is this even the right fork? */
 631	if (rec->rm_owner != sc->ip->i_ino)
 632		return 0;
 633	if ((sbcri->whichfork == XFS_ATTR_FORK) ^
 634	    !!(rec->rm_flags & XFS_RMAP_ATTR_FORK))
 635		return 0;
 636	if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK)
 637		return 0;
 638
 639	/* Now look up the bmbt record. */
 640	ifp = xfs_ifork_ptr(sc->ip, sbcri->whichfork);
 641	if (!ifp) {
 642		xchk_fblock_set_corrupt(sc, sbcri->whichfork,
 643				rec->rm_offset);
 644		goto out;
 645	}
 646	have_map = xfs_iext_lookup_extent(sc->ip, ifp, rec->rm_offset,
 647			&sbcri->icur, &irec);
 648	if (!have_map)
 649		xchk_fblock_set_corrupt(sc, sbcri->whichfork,
 650				rec->rm_offset);
 651	/*
 652	 * bmap extent record lengths are constrained to 2^21 blocks in length
 653	 * because of space constraints in the on-disk metadata structure.
 654	 * However, rmap extent record lengths are constrained only by AG
 655	 * length, so we have to loop through the bmbt to make sure that the
 656	 * entire rmap is covered by bmbt records.
 657	 */
 658	check_rec = *rec;
 659	while (have_map) {
 660		if (irec.br_startoff != check_rec.rm_offset)
 661			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
 662					check_rec.rm_offset);
 663		if (irec.br_startblock !=
 664		    xfs_gbno_to_fsb(cur->bc_group, check_rec.rm_startblock))
 665			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
 666					check_rec.rm_offset);
 667		if (irec.br_blockcount > check_rec.rm_blockcount)
 668			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
 669					check_rec.rm_offset);
 670		if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 671			break;
 672		check_rec.rm_startblock += irec.br_blockcount;
 673		check_rec.rm_offset += irec.br_blockcount;
 674		check_rec.rm_blockcount -= irec.br_blockcount;
 675		if (check_rec.rm_blockcount == 0)
 676			break;
 677		have_map = xfs_iext_next_extent(ifp, &sbcri->icur, &irec);
 678		if (!have_map)
 679			xchk_fblock_set_corrupt(sc, sbcri->whichfork,
 680					check_rec.rm_offset);
 681	}
 682
 683out:
 684	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 685		return -ECANCELED;
 686	return 0;
 687}
 688
 689/* Make sure each rmap has a corresponding bmbt entry. */
 690STATIC int
 691xchk_bmap_check_ag_rmaps(
 692	struct xfs_scrub		*sc,
 693	int				whichfork,
 694	struct xfs_perag		*pag)
 695{
 696	struct xchk_bmap_check_rmap_info	sbcri;
 697	struct xfs_btree_cur		*cur;
 698	struct xfs_buf			*agf;
 699	int				error;
 700
 701	error = xfs_alloc_read_agf(pag, sc->tp, 0, &agf);
 702	if (error)
 703		return error;
 704
 705	cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, agf, pag);
 706
 707	sbcri.sc = sc;
 708	sbcri.whichfork = whichfork;
 709	error = xfs_rmap_query_all(cur, xchk_bmap_check_rmap, &sbcri);
 710	if (error == -ECANCELED)
 711		error = 0;
 712
 713	xfs_btree_del_cursor(cur, error);
 714	xfs_trans_brelse(sc->tp, agf);
 715	return error;
 716}
 717
 718/* Make sure each rt rmap has a corresponding bmbt entry. */
 719STATIC int
 720xchk_bmap_check_rt_rmaps(
 721	struct xfs_scrub		*sc,
 722	struct xfs_rtgroup		*rtg)
 723{
 724	struct xchk_bmap_check_rmap_info sbcri;
 725	struct xfs_btree_cur		*cur;
 726	int				error;
 727
 728	xfs_rtgroup_lock(rtg, XFS_RTGLOCK_RMAP);
 729	cur = xfs_rtrmapbt_init_cursor(sc->tp, rtg);
 730
 731	sbcri.sc = sc;
 732	sbcri.whichfork = XFS_DATA_FORK;
 733	error = xfs_rmap_query_all(cur, xchk_bmap_check_rmap, &sbcri);
 734	if (error == -ECANCELED)
 735		error = 0;
 736
 737	xfs_btree_del_cursor(cur, error);
 738	xfs_rtgroup_unlock(rtg, XFS_RTGLOCK_RMAP);
 739	return error;
 740}
 741
 742/*
 743 * Decide if we want to scan the reverse mappings to determine if the attr
 744 * fork /really/ has zero space mappings.
 745 */
 746STATIC bool
 747xchk_bmap_check_empty_attrfork(
 748	struct xfs_inode	*ip)
 749{
 750	struct xfs_ifork	*ifp = &ip->i_af;
 751
 752	/*
 753	 * If the dinode repair found a bad attr fork, it will reset the fork
 754	 * to extents format with zero records and wait for the this scrubber
 755	 * to reconstruct the block mappings.  If the fork is not in this
 756	 * state, then the fork cannot have been zapped.
 757	 */
 758	if (ifp->if_format != XFS_DINODE_FMT_EXTENTS || ifp->if_nextents != 0)
 759		return false;
 760
 761	/*
 762	 * Files can have an attr fork in EXTENTS format with zero records for
 763	 * several reasons:
 764	 *
 765	 * a) an attr set created a fork but ran out of space
 766	 * b) attr replace deleted an old attr but failed during the set step
 767	 * c) the data fork was in btree format when all attrs were deleted, so
 768	 *    the fork was left in place
 769	 * d) the inode repair code zapped the fork
 770	 *
 771	 * Only in case (d) do we want to scan the rmapbt to see if we need to
 772	 * rebuild the attr fork.  The fork zap code clears all DAC permission
 773	 * bits and zeroes the uid and gid, so avoid the scan if any of those
 774	 * three conditions are not met.
 775	 */
 776	if ((VFS_I(ip)->i_mode & 0777) != 0)
 777		return false;
 778	if (!uid_eq(VFS_I(ip)->i_uid, GLOBAL_ROOT_UID))
 779		return false;
 780	if (!gid_eq(VFS_I(ip)->i_gid, GLOBAL_ROOT_GID))
 781		return false;
 782
 783	return true;
 784}
 785
 786/*
 787 * Decide if we want to scan the reverse mappings to determine if the data
 788 * fork /really/ has zero space mappings.
 789 */
 790STATIC bool
 791xchk_bmap_check_empty_datafork(
 792	struct xfs_inode	*ip)
 793{
 794	struct xfs_ifork	*ifp = &ip->i_df;
 795
 796	/*
 797	 * If the dinode repair found a bad data fork, it will reset the fork
 798	 * to extents format with zero records and wait for the this scrubber
 799	 * to reconstruct the block mappings.  If the fork is not in this
 800	 * state, then the fork cannot have been zapped.
 801	 */
 802	if (ifp->if_format != XFS_DINODE_FMT_EXTENTS || ifp->if_nextents != 0)
 803		return false;
 804
 805	/*
 806	 * If we encounter an empty data fork along with evidence that the fork
 807	 * might not really be empty, we need to scan the reverse mappings to
 808	 * decide if we're going to rebuild the fork.  Data forks with nonzero
 809	 * file size are scanned.
 810	 */
 811	return i_size_read(VFS_I(ip)) != 0;
 812}
 813
 814/*
 815 * Decide if we want to walk every rmap btree in the fs to make sure that each
 816 * rmap for this file fork has corresponding bmbt entries.
 817 */
 818static bool
 819xchk_bmap_want_check_rmaps(
 820	struct xchk_bmap_info	*info)
 821{
 822	struct xfs_scrub	*sc = info->sc;
 823
 824	if (!xfs_has_rmapbt(sc->mp))
 825		return false;
 826	if (info->whichfork == XFS_COW_FORK)
 827		return false;
 828	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
 829		return false;
 830
 831	if (info->whichfork == XFS_ATTR_FORK)
 832		return xchk_bmap_check_empty_attrfork(sc->ip);
 833
 834	return xchk_bmap_check_empty_datafork(sc->ip);
 835}
 836
 837/* Make sure each rmap has a corresponding bmbt entry. */
 838STATIC int
 839xchk_bmap_check_rmaps(
 840	struct xfs_scrub	*sc,
 841	int			whichfork)
 842{
 843	struct xfs_perag	*pag = NULL;
 844	int			error;
 845
 846	if (xfs_ifork_is_realtime(sc->ip, whichfork)) {
 847		struct xfs_rtgroup	*rtg = NULL;
 848
 849		while ((rtg = xfs_rtgroup_next(sc->mp, rtg))) {
 850			error = xchk_bmap_check_rt_rmaps(sc, rtg);
 851			if (error ||
 852			    (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) {
 853				xfs_rtgroup_rele(rtg);
 854				return error;
 855			}
 856		}
 857
 858		return 0;
 859	}
 860
 861	while ((pag = xfs_perag_next(sc->mp, pag))) {
 862		error = xchk_bmap_check_ag_rmaps(sc, whichfork, pag);
 863		if (error ||
 864		    (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) {
 865			xfs_perag_rele(pag);
 866			return error;
 867		}
 868	}
 869
 870	return 0;
 871}
 872
 873/* Scrub a delalloc reservation from the incore extent map tree. */
 874STATIC void
 875xchk_bmap_iextent_delalloc(
 876	struct xfs_inode	*ip,
 877	struct xchk_bmap_info	*info,
 878	struct xfs_bmbt_irec	*irec)
 879{
 880	struct xfs_mount	*mp = info->sc->mp;
 881
 882	/*
 883	 * Check for out-of-order extents.  This record could have come
 884	 * from the incore list, for which there is no ordering check.
 885	 */
 886	if (irec->br_startoff < info->prev_rec.br_startoff +
 887				info->prev_rec.br_blockcount)
 888		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 889				irec->br_startoff);
 890
 891	if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
 892		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 893				irec->br_startoff);
 894
 895	/* Make sure the extent points to a valid place. */
 896	if (irec->br_blockcount > XFS_MAX_BMBT_EXTLEN)
 897		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 898				irec->br_startoff);
 899}
 900
 901/* Decide if this individual fork mapping is ok. */
 902static bool
 903xchk_bmap_iext_mapping(
 904	struct xchk_bmap_info		*info,
 905	const struct xfs_bmbt_irec	*irec)
 906{
 907	/* There should never be a "hole" extent in either extent list. */
 908	if (irec->br_startblock == HOLESTARTBLOCK)
 909		return false;
 910	if (irec->br_blockcount > XFS_MAX_BMBT_EXTLEN)
 911		return false;
 912	return true;
 913}
 914
 915/* Are these two mappings contiguous with each other? */
 916static inline bool
 917xchk_are_bmaps_contiguous(
 918	const struct xchk_bmap_info	*info,
 919	const struct xfs_bmbt_irec	*b1,
 920	const struct xfs_bmbt_irec	*b2)
 921{
 922	struct xfs_mount		*mp = info->sc->mp;
 923
 924	/* Don't try to combine unallocated mappings. */
 925	if (!xfs_bmap_is_real_extent(b1))
 926		return false;
 927	if (!xfs_bmap_is_real_extent(b2))
 928		return false;
 929
 930	/* Does b2 come right after b1 in the logical and physical range? */
 931	if (b1->br_startoff + b1->br_blockcount != b2->br_startoff)
 932		return false;
 933	if (b1->br_startblock + b1->br_blockcount != b2->br_startblock)
 934		return false;
 935	if (b1->br_state != b2->br_state)
 936		return false;
 937
 938	/*
 939	 * Don't combine bmaps that would cross rtgroup boundaries.  This is a
 940	 * valid state, but if combined they will fail rtb extent checks.
 941	 */
 942	if (info->is_rt && xfs_has_rtgroups(mp)) {
 943		if (xfs_rtb_to_rgno(mp, b1->br_startblock) !=
 944		    xfs_rtb_to_rgno(mp, b2->br_startblock))
 945			return false;
 946	}
 947
 948	return true;
 949}
 950
 951/*
 952 * Walk the incore extent records, accumulating consecutive contiguous records
 953 * into a single incore mapping.  Returns true if @irec has been set to a
 954 * mapping or false if there are no more mappings.  Caller must ensure that
 955 * @info.icur is zeroed before the first call.
 956 */
 957static bool
 958xchk_bmap_iext_iter(
 959	struct xchk_bmap_info	*info,
 960	struct xfs_bmbt_irec	*irec)
 961{
 962	struct xfs_bmbt_irec	got;
 963	struct xfs_ifork	*ifp;
 964	unsigned int		nr = 0;
 965
 966	ifp = xfs_ifork_ptr(info->sc->ip, info->whichfork);
 967
 968	/* Advance to the next iextent record and check the mapping. */
 969	xfs_iext_next(ifp, &info->icur);
 970	if (!xfs_iext_get_extent(ifp, &info->icur, irec))
 971		return false;
 972
 973	if (!xchk_bmap_iext_mapping(info, irec)) {
 974		xchk_fblock_set_corrupt(info->sc, info->whichfork,
 975				irec->br_startoff);
 976		return false;
 977	}
 978	nr++;
 979
 980	/*
 981	 * Iterate subsequent iextent records and merge them with the one
 982	 * that we just read, if possible.
 983	 */
 984	while (xfs_iext_peek_next_extent(ifp, &info->icur, &got)) {
 985		if (!xchk_are_bmaps_contiguous(info, irec, &got))
 986			break;
 987
 988		if (!xchk_bmap_iext_mapping(info, &got)) {
 989			xchk_fblock_set_corrupt(info->sc, info->whichfork,
 990					got.br_startoff);
 991			return false;
 992		}
 993		nr++;
 994
 995		irec->br_blockcount += got.br_blockcount;
 996		xfs_iext_next(ifp, &info->icur);
 997	}
 998
 999	/*
1000	 * If the merged mapping could be expressed with fewer bmbt records
1001	 * than we actually found, notify the user that this fork could be
1002	 * optimized.  CoW forks only exist in memory so we ignore them.
1003	 */
1004	if (nr > 1 && info->whichfork != XFS_COW_FORK &&
1005	    howmany_64(irec->br_blockcount, XFS_MAX_BMBT_EXTLEN) < nr)
1006		xchk_ino_set_preen(info->sc, info->sc->ip->i_ino);
1007
1008	return true;
1009}
1010
1011/*
1012 * Scrub an inode fork's block mappings.
1013 *
1014 * First we scan every record in every btree block, if applicable.
1015 * Then we unconditionally scan the incore extent cache.
1016 */
1017STATIC int
1018xchk_bmap(
1019	struct xfs_scrub	*sc,
1020	int			whichfork)
1021{
1022	struct xfs_bmbt_irec	irec;
1023	struct xchk_bmap_info	info = { NULL };
1024	struct xfs_mount	*mp = sc->mp;
1025	struct xfs_inode	*ip = sc->ip;
1026	struct xfs_ifork	*ifp = xfs_ifork_ptr(ip, whichfork);
1027	xfs_fileoff_t		endoff;
1028	int			error = 0;
1029
1030	/* Non-existent forks can be ignored. */
1031	if (!ifp)
1032		return -ENOENT;
1033
1034	info.is_rt = xfs_ifork_is_realtime(ip, whichfork);
1035	info.whichfork = whichfork;
1036	info.is_shared = whichfork == XFS_DATA_FORK && xfs_is_reflink_inode(ip);
1037	info.sc = sc;
1038
1039	switch (whichfork) {
1040	case XFS_COW_FORK:
1041		/* No CoW forks filesystem doesn't support out of place writes */
1042		if (!xfs_has_reflink(mp) && !xfs_has_zoned(mp)) {
1043			xchk_ino_set_corrupt(sc, sc->ip->i_ino);
1044			return 0;
1045		}
1046		break;
1047	case XFS_ATTR_FORK:
1048		/*
1049		 * "attr" means that an attr fork was created at some point in
1050		 * the life of this filesystem.  "attr2" means that inodes have
1051		 * variable-sized data/attr fork areas.  Hence we only check
1052		 * attr here.
1053		 */
1054		if (!xfs_has_attr(mp))
1055			xchk_ino_set_corrupt(sc, sc->ip->i_ino);
1056		break;
1057	default:
1058		ASSERT(whichfork == XFS_DATA_FORK);
1059		break;
1060	}
1061
1062	/* Check the fork values */
1063	switch (ifp->if_format) {
1064	case XFS_DINODE_FMT_UUID:
1065	case XFS_DINODE_FMT_DEV:
1066	case XFS_DINODE_FMT_LOCAL:
1067	case XFS_DINODE_FMT_META_BTREE:
1068		/* No mappings to check. */
1069		if (whichfork == XFS_COW_FORK)
1070			xchk_fblock_set_corrupt(sc, whichfork, 0);
1071		return 0;
1072	case XFS_DINODE_FMT_EXTENTS:
1073		break;
1074	case XFS_DINODE_FMT_BTREE:
1075		if (whichfork == XFS_COW_FORK) {
1076			xchk_fblock_set_corrupt(sc, whichfork, 0);
1077			return 0;
1078		}
1079
1080		error = xchk_bmap_btree(sc, whichfork, &info);
1081		if (error)
1082			return error;
1083		break;
1084	default:
1085		xchk_fblock_set_corrupt(sc, whichfork, 0);
1086		return 0;
1087	}
1088
1089	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
1090		return 0;
1091
1092	/* Find the offset of the last extent in the mapping. */
1093	error = xfs_bmap_last_offset(ip, &endoff, whichfork);
1094	if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
1095		return error;
1096
1097	/*
1098	 * Scrub extent records.  We use a special iterator function here that
1099	 * combines adjacent mappings if they are logically and physically
1100	 * contiguous.   For large allocations that require multiple bmbt
1101	 * records, this reduces the number of cross-referencing calls, which
1102	 * reduces runtime.  Cross referencing with the rmap is simpler because
1103	 * the rmap must match the combined mapping exactly.
1104	 */
1105	while (xchk_bmap_iext_iter(&info, &irec)) {
1106		if (xchk_should_terminate(sc, &error) ||
1107		    (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
1108			return 0;
1109
1110		if (irec.br_startoff >= endoff) {
1111			xchk_fblock_set_corrupt(sc, whichfork,
1112					irec.br_startoff);
1113			return 0;
1114		}
1115
1116		if (isnullstartblock(irec.br_startblock))
1117			xchk_bmap_iextent_delalloc(ip, &info, &irec);
1118		else
1119			xchk_bmap_iextent(ip, &info, &irec);
1120		memcpy(&info.prev_rec, &irec, sizeof(struct xfs_bmbt_irec));
1121	}
1122
1123	if (xchk_bmap_want_check_rmaps(&info)) {
1124		error = xchk_bmap_check_rmaps(sc, whichfork);
1125		if (!xchk_fblock_xref_process_error(sc, whichfork, 0, &error))
1126			return error;
1127	}
1128
1129	return 0;
1130}
1131
1132/* Scrub an inode's data fork. */
1133int
1134xchk_bmap_data(
1135	struct xfs_scrub	*sc)
1136{
1137	int			error;
1138
1139	if (xchk_file_looks_zapped(sc, XFS_SICK_INO_BMBTD_ZAPPED)) {
1140		xchk_ino_set_corrupt(sc, sc->ip->i_ino);
1141		return 0;
1142	}
1143
1144	error = xchk_bmap(sc, XFS_DATA_FORK);
1145	if (error)
1146		return error;
1147
1148	/* If the data fork is clean, it is clearly not zapped. */
1149	xchk_mark_healthy_if_clean(sc, XFS_SICK_INO_BMBTD_ZAPPED);
1150	return 0;
1151}
1152
1153/* Scrub an inode's attr fork. */
1154int
1155xchk_bmap_attr(
1156	struct xfs_scrub	*sc)
1157{
1158	int			error;
1159
1160	/*
1161	 * If the attr fork has been zapped, it's possible that forkoff was
1162	 * reset to zero and hence sc->ip->i_afp is NULL.  We don't want the
1163	 * NULL ifp check in xchk_bmap to conclude that the attr fork is ok,
1164	 * so short circuit that logic by setting the corruption flag and
1165	 * returning immediately.
1166	 */
1167	if (xchk_file_looks_zapped(sc, XFS_SICK_INO_BMBTA_ZAPPED)) {
1168		xchk_ino_set_corrupt(sc, sc->ip->i_ino);
1169		return 0;
1170	}
1171
1172	error = xchk_bmap(sc, XFS_ATTR_FORK);
1173	if (error)
1174		return error;
1175
1176	/* If the attr fork is clean, it is clearly not zapped. */
1177	xchk_mark_healthy_if_clean(sc, XFS_SICK_INO_BMBTA_ZAPPED);
1178	return 0;
1179}
1180
1181/* Scrub an inode's CoW fork. */
1182int
1183xchk_bmap_cow(
1184	struct xfs_scrub	*sc)
1185{
1186	return xchk_bmap(sc, XFS_COW_FORK);
1187}