imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,12 +1,11 @@
 static void xfs_agf_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   if (!xfs_agf_verify(mp, bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) XFS_BUF_TO_AGF(bp)->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_AGF_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,15 +1,14 @@
 static void xfs_agfl_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   /*
    * There is no verification of non-crc AGFLs because mkfs does not
    * initialise the AGFL to zero or NULL. Hence the only valid part of the
    * AGFL is what the AGF says is active. We can't get to the AGF, so we
    * can't verify just those entries are valid.
    */
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_agfl_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void xfs_agfl_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   /* no verification of non-crc AGFLs */
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (!xfs_agfl_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (bip) XFS_BUF_TO_AGFL(bp)->agfl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_AGFL_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_attr3_leaf_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (xfs_sb_version_hascrc(&mp->m_sb) && !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_attr3_leaf_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void xfs_attr3_leaf_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
   if (!xfs_attr3_leaf_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,35 +1,33 @@
 static void xfs_attr3_rmt_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   int blksize = mp->m_attr_geo->blksize;
   char *ptr;
   int len;
   xfs_daddr_t bno;
   /* no verification of non-crc buffers */
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   ptr = bp->b_addr;
   bno = bp->b_bn;
   len = BBTOB(bp->b_length);
   ASSERT(len >= blksize);
   while (len > 0) {
     struct xfs_attr3_rmt_hdr *rmt = (struct xfs_attr3_rmt_hdr *)ptr;
     if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-      xfs_buf_ioerror(bp, -EFSCORRUPTED);
-      xfs_verifier_error(bp);
+      xfs_verifier_error(bp, -EFSCORRUPTED);
       return;
     }
     /*
      * Ensure we aren't writing bogus LSNs to disk. See
      * xfs_attr3_rmt_hdr_set() for the explanation.
      */
     if (rmt->rm_lsn != cpu_to_be64(NULLCOMMITLSN)) {
-      xfs_buf_ioerror(bp, -EFSCORRUPTED);
-      xfs_verifier_error(bp);
+      xfs_verifier_error(bp, -EFSCORRUPTED);
       return;
     }
     xfs_update_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF);
     len -= blksize;
     ptr += blksize;
     bno += BTOBB(blksize);
   }
   ASSERT(len == 0);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,10 +1,7 @@
 static void xfs_bmbt_read_verify(struct xfs_buf *bp) {
   if (!xfs_btree_lblock_verify_crc(bp))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_bmbt_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) {
-    trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_verifier_error(bp);
-  }
+    xfs_verifier_error(bp, -EFSCORRUPTED);
+  if (bp->b_error) trace_xfs_btree_corrupt(bp, _RET_IP_);
 }<sep>@@
expression bp;
statement S;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
-
       if (bp->b_error)
- {
		S
-               xfs_verifier_error(bp);
- }
--- initial
+++ final
@@ -1,9 +1,8 @@
 static void xfs_bmbt_write_verify(struct xfs_buf *bp) {
   if (!xfs_bmbt_verify(bp)) {
     trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   xfs_btree_lblock_calc_crc(bp);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void xfs_da3_node_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
   if (!xfs_da3_node_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_DA3_NODE_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_dir3_block_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (xfs_sb_version_hascrc(&mp->m_sb) && !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_dir3_block_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void xfs_dir3_block_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
   if (!xfs_dir3_block_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_dir3_data_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (xfs_sb_version_hascrc(&mp->m_sb) && !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_dir3_data_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,19 +1,16 @@
 static void xfs_dir3_data_reada_verify(struct xfs_buf *bp) {
   struct xfs_dir2_data_hdr *hdr = bp->b_addr;
   switch (hdr->magic) {
   case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
   case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
     bp->b_ops = &xfs_dir3_block_buf_ops;
     bp->b_ops->verify_read(bp);
     return;
   case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
   case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
     bp->b_ops = &xfs_dir3_data_buf_ops;
     bp->b_ops->verify_read(bp);
     return;
-  default:
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
-    break;
+  default: xfs_verifier_error(bp, -EFSCORRUPTED); break;
   }
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void xfs_dir3_data_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
   if (!xfs_dir3_data_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void __read_verify(struct xfs_buf *bp, uint16_t magic) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (xfs_sb_version_hascrc(&mp->m_sb) && !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_dir3_leaf_verify(bp, magic))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void __write_verify(struct xfs_buf *bp, uint16_t magic) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
   if (!xfs_dir3_leaf_verify(bp, magic)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_DIR3_LEAF_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,15 +1,14 @@
 static int __xfs_dir3_free_read(struct xfs_trans *tp, struct xfs_inode *dp, xfs_dablk_t fbno, xfs_daddr_t mappedbno, struct xfs_buf **bpp) {
   int err;
   err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, XFS_DATA_FORK, &xfs_dir3_free_buf_ops);
   if (err || !*bpp) return err;
   /* Check things that we can't do in the verifier. */
   if (!xfs_dir3_free_header_check(dp, fbno, *bpp)) {
-    xfs_buf_ioerror(*bpp, -EFSCORRUPTED);
-    xfs_verifier_error(*bpp);
+    xfs_verifier_error(*bpp, -EFSCORRUPTED);
     xfs_trans_brelse(tp, *bpp);
     return -EFSCORRUPTED;
   }
   /* try read returns without an error or *bpp if it lands in a hole */
   if (tp) xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_FREE_BUF);
   return 0;
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_dir3_free_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (xfs_sb_version_hascrc(&mp->m_sb) && !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_dir3_free_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,13 +1,12 @@
 static void xfs_dir3_free_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
   if (!xfs_dir3_free_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_DIR3_FREE_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_dquot_buf_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (!xfs_dquot_buf_verify_crc(mp, bp))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_dquot_buf_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (!xfs_dquot_buf_verify(mp, bp, XFS_QMOPT_DOWARN)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,10 +1,7 @@
 static void xfs_inobt_read_verify(struct xfs_buf *bp) {
   if (!xfs_btree_sblock_verify_crc(bp))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_inobt_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) {
-    trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_verifier_error(bp);
-  }
+    xfs_verifier_error(bp, -EFSCORRUPTED);
+  if (bp->b_error) trace_xfs_btree_corrupt(bp, _RET_IP_);
 }<sep>@@
expression bp;
statement S;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
-
       if (bp->b_error)
- {
		S
-               xfs_verifier_error(bp);
- }
--- initial
+++ final
@@ -1,9 +1,8 @@
 static void xfs_inobt_write_verify(struct xfs_buf *bp) {
   if (!xfs_inobt_verify(bp)) {
     trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   xfs_btree_sblock_calc_crc(bp);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,8 +1,7 @@
 static void xfs_agi_read_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   if (xfs_sb_version_hascrc(&mp->m_sb) && !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp, XFS_ERRTAG_IALLOC_READ_AGI))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
 }<sep>@@
expression bp;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
-
-       if (bp->b_error)
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
--- initial
+++ final
@@ -1,12 +1,11 @@
 static void xfs_agi_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   if (!xfs_agi_verify(bp)) {
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) XFS_BUF_TO_AGI(bp)->agi_lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_AGI_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,28 +1,27 @@
 static void xfs_inode_buf_verify(struct xfs_buf *bp, bool readahead) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   int i;
   int ni;
   /*
    * Validate the magic number and version of every inode in the buffer
    */
   ni = XFS_BB_TO_FSB(mp, bp->b_length) * mp->m_sb.sb_inopblock;
   for (i = 0; i < ni; i++) {
     int di_ok;
     xfs_dinode_t *dip;
     dip = xfs_buf_offset(bp, (i << mp->m_sb.sb_inodelog));
     di_ok = dip->di_magic == cpu_to_be16(XFS_DINODE_MAGIC) && xfs_dinode_good_version(mp, dip->di_version);
     if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP))) {
       if (readahead) {
         bp->b_flags &= ~XBF_DONE;
         xfs_buf_ioerror(bp, -EIO);
         return;
       }
-      xfs_buf_ioerror(bp, -EFSCORRUPTED);
-      xfs_verifier_error(bp);
+      xfs_verifier_error(bp, -EFSCORRUPTED);
 #ifdef DEBUG
       xfs_alert(mp, "bad inode magic/vsn daddr %lld #%d (magic=%x)", (unsigned long long)bp->b_bn, i, be16_to_cpu(dip->di_magic));
 #endif
     }
   }
   xfs_inobp_check(mp, bp);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,10 +1,7 @@
 STATIC void xfs_refcountbt_read_verify(struct xfs_buf *bp) {
   if (!xfs_btree_sblock_verify_crc(bp))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_refcountbt_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) {
-    trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_verifier_error(bp);
-  }
+    xfs_verifier_error(bp, -EFSCORRUPTED);
+  if (bp->b_error) trace_xfs_btree_corrupt(bp, _RET_IP_);
 }<sep>@@
expression bp;
statement S;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
-
       if (bp->b_error)
- {
		S
-               xfs_verifier_error(bp);
- }
--- initial
+++ final
@@ -1,9 +1,8 @@
 STATIC void xfs_refcountbt_write_verify(struct xfs_buf *bp) {
   if (!xfs_refcountbt_verify(bp)) {
     trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   xfs_btree_sblock_calc_crc(bp);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,10 +1,7 @@
 static void xfs_rmapbt_read_verify(struct xfs_buf *bp) {
   if (!xfs_btree_sblock_verify_crc(bp))
-    xfs_buf_ioerror(bp, -EFSBADCRC);
+    xfs_verifier_error(bp, -EFSBADCRC);
   else if (!xfs_rmapbt_verify(bp))
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-  if (bp->b_error) {
-    trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_verifier_error(bp);
-  }
+    xfs_verifier_error(bp, -EFSCORRUPTED);
+  if (bp->b_error) trace_xfs_btree_corrupt(bp, _RET_IP_);
 }<sep>@@
expression bp;
statement S;
@@

	if (...)
-               xfs_buf_ioerror(bp, -EFSBADCRC);
+               xfs_verifier_error(bp, -EFSBADCRC);
        else if (...)
-               xfs_buf_ioerror(bp, -EFSCORRUPTED);
+               xfs_verifier_error(bp, -EFSCORRUPTED);
-
       if (bp->b_error)
- {
		S
-               xfs_verifier_error(bp);
- }
--- initial
+++ final
@@ -1,9 +1,8 @@
 static void xfs_rmapbt_write_verify(struct xfs_buf *bp) {
   if (!xfs_rmapbt_verify(bp)) {
     trace_xfs_btree_corrupt(bp, _RET_IP_);
-    xfs_buf_ioerror(bp, -EFSCORRUPTED);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, -EFSCORRUPTED);
     return;
   }
   xfs_btree_sblock_calc_crc(bp);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);
--- initial
+++ final
@@ -1,14 +1,13 @@
 static void xfs_sb_write_verify(struct xfs_buf *bp) {
   struct xfs_mount *mp = bp->b_target->bt_mount;
   struct xfs_buf_log_item *bip = bp->b_fspriv;
   int error;
   error = xfs_sb_verify(bp, false);
   if (error) {
-    xfs_buf_ioerror(bp, error);
-    xfs_verifier_error(bp);
+    xfs_verifier_error(bp, error);
     return;
   }
   if (!xfs_sb_version_hascrc(&mp->m_sb)) return;
   if (bip) XFS_BUF_TO_SBP(bp)->sb_lsn = cpu_to_be64(bip->bli_item.li_lsn);
   xfs_buf_update_cksum(bp, XFS_SB_CRC_OFF);
 }<sep>@@
expression bp,e;
@@

-               xfs_buf_ioerror(bp, e);
-               xfs_verifier_error(bp);
+               xfs_verifier_error(bp, e);