Merge branch 'xfs-verifier-cleanup' into for-next (49ae4b97) · Commits · e / devices / android_kernel_fairphone_FP5

fs/xfs/xfs_ag.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -89,6 +89,8 @@ typedef struct xfs_agf {
		/* structure must be padded to 64 bit alignment */
		} xfs_agf_t;

		#define XFS_AGF_CRC_OFF offsetof(struct xfs_agf, agf_crc)

		#define XFS_AGF_MAGICNUM 0x00000001
		#define XFS_AGF_VERSIONNUM 0x00000002
		#define XFS_AGF_SEQNO 0x00000004
		@@ -167,6 +169,8 @@ typedef struct xfs_agi {
		/* structure must be padded to 64 bit alignment */
		} xfs_agi_t;

		#define XFS_AGI_CRC_OFF offsetof(struct xfs_agi, agi_crc)

		#define XFS_AGI_MAGICNUM 0x00000001
		#define XFS_AGI_VERSIONNUM 0x00000002
		#define XFS_AGI_SEQNO 0x00000004
		@@ -222,6 +226,8 @@ typedef struct xfs_agfl {
		__be32 agfl_bno[]; /* actually XFS_AGFL_SIZE(mp) */
		} xfs_agfl_t;

		#define XFS_AGFL_CRC_OFF offsetof(struct xfs_agfl, agfl_crc)

		/*
		* tags for inode radix tree
		*/

fs/xfs/xfs_alloc.c

+19 −26

Original line number	Diff line number	Diff line
		@@ -474,7 +474,6 @@ xfs_agfl_read_verify(
		struct xfs_buf *bp)
		{
		struct xfs_mount *mp = bp->b_target->bt_mount;
		int agfl_ok = 1;

		/*
		* There is no verification of non-crc AGFLs because mkfs does not
		@@ -485,15 +484,13 @@ xfs_agfl_read_verify(
		if (!xfs_sb_version_hascrc(&mp->m_sb))
		return;

		agfl_ok = xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
		offsetof(struct xfs_agfl, agfl_crc));

		agfl_ok = agfl_ok && xfs_agfl_verify(bp);

		if (!agfl_ok) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
		xfs_buf_ioerror(bp, EFSBADCRC);
		else if (!xfs_agfl_verify(bp))
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		}

		if (bp->b_error)
		xfs_verifier_error(bp);
		}

		static void
		@@ -508,16 +505,15 @@ xfs_agfl_write_verify(
		return;

		if (!xfs_agfl_verify(bp)) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		}

		if (bip)
		XFS_BUF_TO_AGFL(bp)->agfl_lsn = cpu_to_be64(bip->bli_item.li_lsn);

		xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length),
		offsetof(struct xfs_agfl, agfl_crc));
		xfs_buf_update_cksum(bp, XFS_AGFL_CRC_OFF);
		}

		const struct xfs_buf_ops xfs_agfl_buf_ops = {
		@@ -2238,19 +2234,17 @@ xfs_agf_read_verify(
		struct xfs_buf *bp)
		{
		struct xfs_mount *mp = bp->b_target->bt_mount;
		int agf_ok = 1;

		if (xfs_sb_version_hascrc(&mp->m_sb))
		agf_ok = xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
		offsetof(struct xfs_agf, agf_crc));

		agf_ok = agf_ok && xfs_agf_verify(mp, bp);

		if (unlikely(XFS_TEST_ERROR(!agf_ok, mp, XFS_ERRTAG_ALLOC_READ_AGF,
		XFS_RANDOM_ALLOC_READ_AGF))) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		if (xfs_sb_version_hascrc(&mp->m_sb) &&
		!xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))
		xfs_buf_ioerror(bp, EFSBADCRC);
		else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp,
		XFS_ERRTAG_ALLOC_READ_AGF,
		XFS_RANDOM_ALLOC_READ_AGF))
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		}

		if (bp->b_error)
		xfs_verifier_error(bp);
		}

		static void
		@@ -2261,8 +2255,8 @@ xfs_agf_write_verify(
		struct xfs_buf_log_item *bip = bp->b_fspriv;

		if (!xfs_agf_verify(mp, bp)) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		}

		@@ -2272,8 +2266,7 @@ xfs_agf_write_verify(
		if (bip)
		XFS_BUF_TO_AGF(bp)->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn);

		xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length),
		offsetof(struct xfs_agf, agf_crc));
		xfs_buf_update_cksum(bp, XFS_AGF_CRC_OFF);
		}

		const struct xfs_buf_ops xfs_agf_buf_ops = {

fs/xfs/xfs_alloc_btree.c

+9 −7

Original line number	Diff line number	Diff line
		@@ -355,12 +355,14 @@ static void
		xfs_allocbt_read_verify(
		struct xfs_buf *bp)
		{
		if (!(xfs_btree_sblock_verify_crc(bp) &&
		xfs_allocbt_verify(bp))) {
		trace_xfs_btree_corrupt(bp, _RET_IP_);
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW,
		bp->b_target->bt_mount, bp->b_addr);
		if (!xfs_btree_sblock_verify_crc(bp))
		xfs_buf_ioerror(bp, EFSBADCRC);
		else if (!xfs_allocbt_verify(bp))
		xfs_buf_ioerror(bp, EFSCORRUPTED);

		if (bp->b_error) {
		trace_xfs_btree_corrupt(bp, _RET_IP_);
		xfs_verifier_error(bp);
		}
		}

		@@ -370,9 +372,9 @@ xfs_allocbt_write_verify(
		{
		if (!xfs_allocbt_verify(bp)) {
		trace_xfs_btree_corrupt(bp, _RET_IP_);
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW,
		bp->b_target->bt_mount, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		}
		xfs_btree_sblock_calc_crc(bp);

fs/xfs/xfs_attr_leaf.c

+9 −8

Original line number	Diff line number	Diff line
		@@ -213,8 +213,8 @@ xfs_attr3_leaf_write_verify(
		struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;

		if (!xfs_attr3_leaf_verify(bp)) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		}

		@@ -224,7 +224,7 @@ xfs_attr3_leaf_write_verify(
		if (bip)
		hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);

		xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_ATTR3_LEAF_CRC_OFF);
		xfs_buf_update_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF);
		}

		/*
		@@ -239,13 +239,14 @@ xfs_attr3_leaf_read_verify(
		{
		struct xfs_mount *mp = bp->b_target->bt_mount;

		if ((xfs_sb_version_hascrc(&mp->m_sb) &&
		!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
		XFS_ATTR3_LEAF_CRC_OFF)) \|\|
		!xfs_attr3_leaf_verify(bp)) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		if (xfs_sb_version_hascrc(&mp->m_sb) &&
		!xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
		xfs_buf_ioerror(bp, EFSBADCRC);
		else if (!xfs_attr3_leaf_verify(bp))
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		}

		if (bp->b_error)
		xfs_verifier_error(bp);
		}

		const struct xfs_buf_ops xfs_attr3_leaf_buf_ops = {

fs/xfs/xfs_attr_remote.c

+6 −9

Original line number	Diff line number	Diff line
		@@ -125,7 +125,6 @@ xfs_attr3_rmt_read_verify(
		struct xfs_mount *mp = bp->b_target->bt_mount;
		char *ptr;
		int len;
		bool corrupt = false;
		xfs_daddr_t bno;

		/* no verification of non-crc buffers */
		@@ -140,11 +139,11 @@ xfs_attr3_rmt_read_verify(
		while (len > 0) {
		if (!xfs_verify_cksum(ptr, XFS_LBSIZE(mp),
		XFS_ATTR3_RMT_CRC_OFF)) {
		corrupt = true;
		xfs_buf_ioerror(bp, EFSBADCRC);
		break;
		}
		if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) {
		corrupt = true;
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		break;
		}
		len -= XFS_LBSIZE(mp);
		@@ -152,10 +151,9 @@ xfs_attr3_rmt_read_verify(
		bno += mp->m_bsize;
		}

		if (corrupt) {
		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		} else
		if (bp->b_error)
		xfs_verifier_error(bp);
		else
		ASSERT(len == 0);
		}

		@@ -180,9 +178,8 @@ xfs_attr3_rmt_write_verify(

		while (len > 0) {
		if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) {
		XFS_CORRUPTION_ERROR(__func__,
		XFS_ERRLEVEL_LOW, mp, bp->b_addr);
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		}
		if (bip) {