Commit a349e4c6 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-5.10-fixes-7' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull xfs fixes from Darrick Wong:
 "The critical fixes are for a crash that someone reported in the xattr
  code on 32-bit arm last week; and a revert of the rmap key comparison
  change from last week as it was totally wrong. I need a vacation. :(

  Summary:

   - Fix various deficiencies in online fsck's metadata checking code

   - Fix an integer casting bug in the xattr code on 32-bit systems

   - Fix a hang in an inode walk when the inode index is corrupt

   - Fix error codes being dropped when initializing per-AG structures

   - Fix nowait directio writes that partially succeed but return EAGAIN

   - Revert last week's rmap comparison patch because it was wrong"

* tag 'xfs-5.10-fixes-7' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux:
  xfs: revert "xfs: fix rmap key and record comparison functions"
  xfs: don't allow NOWAIT DIO across extent boundaries
  xfs: return corresponding errcode if xfs_initialize_perag() fail
  xfs: ensure inobt record walks always make forward progress
  xfs: fix forkoff miscalculation related to XFS_LITINO(mp)
  xfs: directory scrub should check the null bestfree entries too
  xfs: strengthen rmap record flags checking
  xfs: fix the minrecs logic when dealing with inode root child blocks
parents ba911108 eb840907

fs/xfs/libxfs/xfs_attr_leaf.c

+7 −1
Original line number Diff line number Diff line
@@ -515,7 +515,7 @@ xfs_attr_copy_value( 
 *========================================================================*/



/*

 * Query whether the requested number of additional bytes of extended

 * Query whether the total requested number of attr fork bytes of extended

 * attribute space will be able to fit inline.

 *

 * Returns zero if not, else the di_forkoff fork offset to be used in the
@@ -535,6 +535,12 @@ xfs_attr_shortform_bytesfit( 
	int			maxforkoff;

	int			offset;



	/*

	 * Check if the new size could fit at all first:

	 */

	if (bytes > XFS_LITINO(mp))

		return 0;



	/* rounded down */

	offset = (XFS_LITINO(mp) - bytes) >> 3;

fs/xfs/libxfs/xfs_rmap_btree.c

+8 −8
Original line number Diff line number Diff line
@@ -243,8 +243,8 @@ xfs_rmapbt_key_diff( 
	else if (y > x)

		return -1;



	x = be64_to_cpu(kp->rm_offset);

	y = xfs_rmap_irec_offset_pack(rec);

	x = XFS_RMAP_OFF(be64_to_cpu(kp->rm_offset));

	y = rec->rm_offset;

	if (x > y)

		return 1;

	else if (y > x)
@@ -275,8 +275,8 @@ xfs_rmapbt_diff_two_keys( 
	else if (y > x)

		return -1;



	x = be64_to_cpu(kp1->rm_offset);

	y = be64_to_cpu(kp2->rm_offset);

	x = XFS_RMAP_OFF(be64_to_cpu(kp1->rm_offset));

	y = XFS_RMAP_OFF(be64_to_cpu(kp2->rm_offset));

	if (x > y)

		return 1;

	else if (y > x)
@@ -390,8 +390,8 @@ xfs_rmapbt_keys_inorder( 
		return 1;

	else if (a > b)

		return 0;

	a = be64_to_cpu(k1->rmap.rm_offset);

	b = be64_to_cpu(k2->rmap.rm_offset);

	a = XFS_RMAP_OFF(be64_to_cpu(k1->rmap.rm_offset));

	b = XFS_RMAP_OFF(be64_to_cpu(k2->rmap.rm_offset));

	if (a <= b)

		return 1;

	return 0;
@@ -420,8 +420,8 @@ xfs_rmapbt_recs_inorder( 
		return 1;

	else if (a > b)

		return 0;

	a = be64_to_cpu(r1->rmap.rm_offset);

	b = be64_to_cpu(r2->rmap.rm_offset);

	a = XFS_RMAP_OFF(be64_to_cpu(r1->rmap.rm_offset));

	b = XFS_RMAP_OFF(be64_to_cpu(r2->rmap.rm_offset));

	if (a <= b)

		return 1;

	return 0;

fs/xfs/scrub/bmap.c

+4 −4
Original line number Diff line number Diff line
@@ -218,13 +218,13 @@ xchk_bmap_xref_rmap( 
	 * which doesn't track unwritten state.

	 */

	if (owner != XFS_RMAP_OWN_COW &&

	    irec->br_state == XFS_EXT_UNWRITTEN &&

	    !(rmap.rm_flags & XFS_RMAP_UNWRITTEN))

	    !!(irec->br_state == XFS_EXT_UNWRITTEN) !=

	    !!(rmap.rm_flags & XFS_RMAP_UNWRITTEN))

		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,

				irec->br_startoff);



	if (info->whichfork == XFS_ATTR_FORK &&

	    !(rmap.rm_flags & XFS_RMAP_ATTR_FORK))

	if (!!(info->whichfork == XFS_ATTR_FORK) !=

	    !!(rmap.rm_flags & XFS_RMAP_ATTR_FORK))

		xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,

				irec->br_startoff);

	if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK)

fs/xfs/scrub/btree.c

+27 −18
Original line number Diff line number Diff line
@@ -452,32 +452,41 @@ xchk_btree_check_minrecs( 
	int			level,

	struct xfs_btree_block	*block)

{

	unsigned int		numrecs;

	int			ok_level;



	numrecs = be16_to_cpu(block->bb_numrecs);

	struct xfs_btree_cur	*cur = bs->cur;

	unsigned int		root_level = cur->bc_nlevels - 1;

	unsigned int		numrecs = be16_to_cpu(block->bb_numrecs);



	/* More records than minrecs means the block is ok. */

	if (numrecs >= bs->cur->bc_ops->get_minrecs(bs->cur, level))

	if (numrecs >= cur->bc_ops->get_minrecs(cur, level))

		return;



	/*

	 * Certain btree blocks /can/ have fewer than minrecs records.  Any

	 * level greater than or equal to the level of the highest dedicated

	 * btree block are allowed to violate this constraint.

	 *

	 * For a btree rooted in a block, the btree root can have fewer than

	 * minrecs records.  If the btree is rooted in an inode and does not

	 * store records in the root, the direct children of the root and the

	 * root itself can have fewer than minrecs records.

	 * For btrees rooted in the inode, it's possible that the root block

	 * contents spilled into a regular ondisk block because there wasn't

	 * enough space in the inode root.  The number of records in that

	 * child block might be less than the standard minrecs, but that's ok

	 * provided that there's only one direct child of the root.

	 */

	ok_level = bs->cur->bc_nlevels - 1;

	if (bs->cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)

		ok_level--;

	if (level >= ok_level)

	if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&

	    level == cur->bc_nlevels - 2) {

		struct xfs_btree_block	*root_block;

		struct xfs_buf		*root_bp;

		int			root_maxrecs;



		root_block = xfs_btree_get_block(cur, root_level, &root_bp);

		root_maxrecs = cur->bc_ops->get_dmaxrecs(cur, root_level);

		if (be16_to_cpu(root_block->bb_numrecs) != 1 ||

		    numrecs <= root_maxrecs)

			xchk_btree_set_corrupt(bs->sc, cur, level);

		return;

	}



	xchk_btree_set_corrupt(bs->sc, bs->cur, level);

	/*

	 * Otherwise, only the root level is allowed to have fewer than minrecs

	 * records or keyptrs.

	 */

	if (level < root_level)

		xchk_btree_set_corrupt(bs->sc, cur, level);

}



/*

fs/xfs/scrub/dir.c

+17 −4
Original line number Diff line number Diff line
@@ -558,13 +558,26 @@ xchk_directory_leaf1_bestfree( 
	/* Check all the bestfree entries. */

	for (i = 0; i < bestcount; i++, bestp++) {

		best = be16_to_cpu(*bestp);

		if (best == NULLDATAOFF)

			continue;

		error = xfs_dir3_data_read(sc->tp, sc->ip,

				i * args->geo->fsbcount, 0, &dbp);

				xfs_dir2_db_to_da(args->geo, i),

				XFS_DABUF_MAP_HOLE_OK,

				&dbp);

		if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk,

				&error))

			break;



		if (!dbp) {

			if (best != NULLDATAOFF) {

				xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,

						lblk);

				break;

			}

			continue;

		}



		if (best == NULLDATAOFF)

			xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);

		else

			xchk_directory_check_freesp(sc, lblk, dbp, best);

		xfs_trans_brelse(sc->tp, dbp);

		if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)

CRA Git | Maintained and supported by SUSTech CRA and CCSE