imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,21 +1,21 @@
 static void hauppauge_eeprom(struct saa7134_dev *dev, u8 *eeprom_data) {
   struct tveeprom tv;
-  tveeprom_hauppauge_analog(&dev->i2c_client, &tv, eeprom_data);
+  tveeprom_hauppauge_analog(&tv, eeprom_data);
   /* Make sure we support the board model */
   switch (tv.model) {
   case 67019: /* WinTV-HVR1110 (Retail, IR Blaster, hybrid, FM, SVid/Comp, 3.5mm audio in) */
   case 67109: /* WinTV-HVR1000 (Retail, IR Receive, analog, no FM, SVid/Comp, 3.5mm audio in) */
   case 67201: /* WinTV-HVR1150 (Retail, IR Receive, hybrid, FM, SVid/Comp, 3.5mm audio in) */
   case 67301: /* WinTV-HVR1000 (Retail, IR Receive, analog, no FM, SVid/Comp, 3.5mm audio in) */
   case 67209: /* WinTV-HVR1110 (Retail, IR Receive, hybrid, FM, SVid/Comp, 3.5mm audio in) */
   case 67559: /* WinTV-HVR1110 (OEM, no IR, hybrid, FM, SVid/Comp, RCA aud) */
   case 67569: /* WinTV-HVR1110 (OEM, no IR, hybrid, FM) */
   case 67579: /* WinTV-HVR1110 (OEM, no IR, hybrid, no FM) */
   case 67589: /* WinTV-HVR1110 (OEM, no IR, hybrid, no FM, SVid/Comp, RCA aud) */
   case 67599: /* WinTV-HVR1110 (OEM, no IR, hybrid, no FM, SVid/Comp, RCA aud) */
   case 67651: /* WinTV-HVR1150 (OEM, no IR, hybrid, FM, SVid/Comp, RCA aud) */
   case 67659: /* WinTV-HVR1110 (OEM, no IR, hybrid, FM, SVid/Comp, RCA aud) */ break;
   default: pr_warn("%s: warning: unknown hauppauge model #%d\n", dev->name, tv.model); break;
   }
   pr_info("%s: hauppauge eeprom: model=%d\n", dev->name, tv.model);
 }<sep>@@
expression e1,e2,e3;
@@
tveeprom_hauppauge_analog(
- e1,
  e2,e3)
--- initial
+++ final
@@ -1,50 +1,50 @@
 static void hauppauge_eeprom(struct saa7164_dev *dev, u8 *eeprom_data) {
   struct tveeprom tv;
   /* TODO: Assumption: eeprom on bus 0 */
-  tveeprom_hauppauge_analog(&dev->i2c_bus[0].i2c_client, &tv, eeprom_data);
+  tveeprom_hauppauge_analog(&tv, eeprom_data);
   /* Make sure we support the board model */
   switch (tv.model) {
   case 88001:
     /* Development board - Limit circulation */
     /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
      * ATSC/QAM (TDA18271/S5H1411) and basic analog, no IR, FM */
   case 88021:
     /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
      * ATSC/QAM (TDA18271/S5H1411) and basic analog, MCE CIR, FM */
     break;
   case 88041:
     /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
      * ATSC/QAM (TDA18271/S5H1411) and basic analog, no IR, FM */
     break;
   case 88061:
     /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
      * ATSC/QAM (TDA18271/S5H1411) and basic analog, FM */
     break;
   case 89519:
   case 89609:
     /* WinTV-HVR2200 (PCIe, Retail, full-height)
      * DVB-T (TDA18271/TDA10048) and basic analog, no IR */
     break;
   case 89619:
     /* WinTV-HVR2200 (PCIe, Retail, half-height)
      * DVB-T (TDA18271/TDA10048) and basic analog, no IR */
     break;
   case 151009:
     /* First production board rev B2I6 */
     /* WinTV-HVR2205 (PCIe, Retail, full-height bracket)
      * DVB-T/T2/C (SI2157/SI2168) and basic analog, FM */
     break;
   case 151609:
     /* First production board rev B2I6 */
     /* WinTV-HVR2205 (PCIe, Retail, half-height bracket)
      * DVB-T/T2/C (SI2157/SI2168) and basic analog, FM */
     break;
   case 151061:
     /* First production board rev B1I6 */
     /* WinTV-HVR2255 (PCIe, Retail, full-height bracket)
      * ATSC/QAM (SI2157/LGDT3306) and basic analog, FM */
     break;
   default: printk(KERN_ERR "%s: Warning: Unknown Hauppauge model #%d\n", dev->name, tv.model); break;
   }
   printk(KERN_INFO "%s: Hauppauge eeprom: model=%d\n", dev->name, tv.model);
 }<sep>@@
expression e1,e2,e3;
@@
tveeprom_hauppauge_analog(
- e1,
  e2,e3)
--- initial
+++ final
@@ -1,18 +1,18 @@
 bool xfs_ag_resv_critical(struct xfs_perag *pag, enum xfs_ag_resv_type type) {
   xfs_extlen_t avail;
   xfs_extlen_t orig;
   switch (type) {
   case XFS_AG_RESV_METADATA:
     avail = pag->pagf_freeblks - pag->pag_agfl_resv.ar_reserved;
     orig = pag->pag_meta_resv.ar_asked;
     break;
   case XFS_AG_RESV_AGFL:
     avail = pag->pagf_freeblks + pag->pagf_flcount - pag->pag_meta_resv.ar_reserved;
     orig = pag->pag_agfl_resv.ar_asked;
     break;
   default: ASSERT(0); return false;
   }
   trace_xfs_ag_resv_critical(pag, type, avail);
   /* Critically low if less than 10% or max btree height remains. */
-  return XFS_TEST_ERROR(avail < orig / 10 || avail < XFS_BTREE_MAXLEVELS, pag->pag_mount, XFS_ERRTAG_AG_RESV_CRITICAL, XFS_RANDOM_AG_RESV_CRITICAL);
+  return XFS_TEST_ERROR(avail < orig / 10 || avail < XFS_BTREE_MAXLEVELS, pag->pag_mount, XFS_ERRTAG_AG_RESV_CRITICAL);
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,8 +1,8 @@
 static void xfs_agf_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_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))
+  else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp, XFS_ERRTAG_ALLOC_READ_AGF))
     xfs_buf_ioerror(bp, -EFSCORRUPTED);
   if (bp->b_error) xfs_verifier_error(bp);
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,28 +1,28 @@
 int                                           /* error */
 xfs_free_extent(struct xfs_trans *tp,         /* transaction pointer */
                 xfs_fsblock_t bno,            /* starting block number of extent */
                 xfs_extlen_t len,             /* length of extent */
                 struct xfs_owner_info *oinfo, /* extent owner */
                 enum xfs_ag_resv_type type)   /* block reservation type */
 {
   struct xfs_mount *mp = tp->t_mountp;
   struct xfs_buf *agbp;
   xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, bno);
   xfs_agblock_t agbno = XFS_FSB_TO_AGBNO(mp, bno);
   int error;
   ASSERT(len != 0);
   ASSERT(type != XFS_AG_RESV_AGFL);
-  if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_FREE_EXTENT, XFS_RANDOM_FREE_EXTENT)) return -EIO;
+  if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_FREE_EXTENT)) return -EIO;
   error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
   if (error) return error;
   XFS_WANT_CORRUPTED_GOTO(mp, agbno < mp->m_sb.sb_agblocks, err);
   /* validate the extent size is legal now we have the agf locked */
   XFS_WANT_CORRUPTED_GOTO(mp, agbno + len <= be32_to_cpu(XFS_BUF_TO_AGF(agbp)->agf_length), err);
   error = xfs_free_ag_extent(tp, agbp, agno, agbno, len, oinfo, type);
   if (error) goto err;
   xfs_extent_busy_insert(tp, agno, agbno, len, 0);
   return 0;
 err:
   xfs_trans_brelse(tp, agbp);
   return error;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,16 +1,16 @@
 int xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_defer_ops *dfops, struct xfs_inode *ip, enum xfs_bmap_intent_type type, int whichfork, xfs_fileoff_t startoff, xfs_fsblock_t startblock, xfs_filblks_t *blockcount, xfs_exntst_t state) {
   xfs_fsblock_t firstfsb;
   int error = 0;
   trace_xfs_bmap_deferred(tp->t_mountp, XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type, XFS_FSB_TO_AGBNO(tp->t_mountp, startblock), ip->i_ino, whichfork, startoff, *blockcount, state);
   if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK)) return -EFSCORRUPTED;
-  if (XFS_TEST_ERROR(false, tp->t_mountp, XFS_ERRTAG_BMAP_FINISH_ONE, XFS_RANDOM_BMAP_FINISH_ONE)) return -EIO;
+  if (XFS_TEST_ERROR(false, tp->t_mountp, XFS_ERRTAG_BMAP_FINISH_ONE)) return -EIO;
   switch (type) {
   case XFS_BMAP_MAP:
     error = xfs_bmapi_remap(tp, ip, startoff, *blockcount, startblock, dfops);
     *blockcount = 0;
     break;
   case XFS_BMAP_UNMAP: error = __xfs_bunmapi(tp, ip, startoff, blockcount, XFS_BMAPI_REMAP, 1, &firstfsb, dfops); break;
   default: ASSERT(0); error = -EFSCORRUPTED;
   }
   return error;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,63 +1,63 @@
 int xfs_bmapi_read(struct xfs_inode *ip, xfs_fileoff_t bno, xfs_filblks_t len, struct xfs_bmbt_irec *mval, int *nmap, int flags) {
   struct xfs_mount *mp = ip->i_mount;
   struct xfs_ifork *ifp;
   struct xfs_bmbt_irec got;
   xfs_fileoff_t obno;
   xfs_fileoff_t end;
   xfs_extnum_t idx;
   int error;
   bool eof = false;
   int n = 0;
   int whichfork = xfs_bmapi_whichfork(flags);
   ASSERT(*nmap >= 1);
   ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_ENTIRE | XFS_BMAPI_IGSTATE | XFS_BMAPI_COWFORK)));
   ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
-  if (unlikely(XFS_TEST_ERROR((XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
+  if (unlikely(XFS_TEST_ERROR((XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), mp, XFS_ERRTAG_BMAPIFORMAT))) {
     XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
     return -EFSCORRUPTED;
   }
   if (XFS_FORCED_SHUTDOWN(mp)) return -EIO;
   XFS_STATS_INC(mp, xs_blk_mapr);
   ifp = XFS_IFORK_PTR(ip, whichfork);
   /* No CoW fork?  Return a hole. */
   if (whichfork == XFS_COW_FORK && !ifp) {
     mval->br_startoff = bno;
     mval->br_startblock = HOLESTARTBLOCK;
     mval->br_blockcount = len;
     mval->br_state = XFS_EXT_NORM;
     *nmap = 1;
     return 0;
   }
   if (!(ifp->if_flags & XFS_IFEXTENTS)) {
     error = xfs_iread_extents(NULL, ip, whichfork);
     if (error) return error;
   }
   if (!xfs_iext_lookup_extent(ip, ifp, bno, &idx, &got)) eof = true;
   end = bno + len;
   obno = bno;
   while (bno < end && n < *nmap) {
     /* Reading past eof, act as though there's a hole up to end. */
     if (eof) got.br_startoff = end;
     if (got.br_startoff > bno) {
       /* Reading in a hole.  */
       mval->br_startoff = bno;
       mval->br_startblock = HOLESTARTBLOCK;
       mval->br_blockcount = XFS_FILBLKS_MIN(len, got.br_startoff - bno);
       mval->br_state = XFS_EXT_NORM;
       bno += mval->br_blockcount;
       len -= mval->br_blockcount;
       mval++;
       n++;
       continue;
     }
     /* set up the extent map to return. */
     xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
     xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
     /* If we're done, stop now. */
     if (bno >= end || n >= *nmap) break;
     /* Else go on to the next record. */
     if (!xfs_iext_get_extent(ifp, ++idx, &got)) eof = true;
   }
   *nmap = n;
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,53 +1,53 @@
 static int xfs_bmapi_remap(struct xfs_trans *tp, struct xfs_inode *ip, xfs_fileoff_t bno, xfs_filblks_t len, xfs_fsblock_t startblock, struct xfs_defer_ops *dfops) {
   struct xfs_mount *mp = ip->i_mount;
   struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
   struct xfs_btree_cur *cur = NULL;
   xfs_fsblock_t firstblock = NULLFSBLOCK;
   struct xfs_bmbt_irec got;
   xfs_extnum_t idx;
   int logflags = 0, error;
   ASSERT(len > 0);
   ASSERT(len <= (xfs_filblks_t)MAXEXTLEN);
   ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-  if (unlikely(XFS_TEST_ERROR((XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS && XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE), mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
+  if (unlikely(XFS_TEST_ERROR((XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS && XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE), mp, XFS_ERRTAG_BMAPIFORMAT))) {
     XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp);
     return -EFSCORRUPTED;
   }
   if (XFS_FORCED_SHUTDOWN(mp)) return -EIO;
   if (!(ifp->if_flags & XFS_IFEXTENTS)) {
     error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
     if (error) return error;
   }
   if (xfs_iext_lookup_extent(ip, ifp, bno, &idx, &got)) {
     /* make sure we only reflink into a hole. */
     ASSERT(got.br_startoff > bno);
     ASSERT(got.br_startoff - bno >= len);
   }
   ip->i_d.di_nblocks += len;
   xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
   if (ifp->if_flags & XFS_IFBROOT) {
     cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
     cur->bc_private.b.firstblock = firstblock;
     cur->bc_private.b.dfops = dfops;
     cur->bc_private.b.flags = 0;
   }
   got.br_startoff = bno;
   got.br_startblock = startblock;
   got.br_blockcount = len;
   got.br_state = XFS_EXT_NORM;
   error = xfs_bmap_add_extent_hole_real(tp, ip, XFS_DATA_FORK, &idx, &cur, &got, &firstblock, dfops, &logflags);
   if (error) goto error0;
   if (xfs_bmap_wants_extents(ip, XFS_DATA_FORK)) {
     int tmp_logflags = 0;
     error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags, XFS_DATA_FORK);
     logflags |= tmp_logflags;
   }
 error0:
   if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS)
     logflags &= ~XFS_ILOG_DEXT;
   else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE)
     logflags &= ~XFS_ILOG_DBROOT;
   if (logflags) xfs_trans_log_inode(tp, ip, logflags);
   if (cur) { xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); }
   return error;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,21 +1,21 @@
 STATIC int                                            /* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lblock(struct xfs_btree_cur *cur,     /* btree cursor */
                        struct xfs_btree_block *block, /* btree long form block pointer */
                        int level,                     /* level of the btree block */
                        struct xfs_buf *bp)            /* buffer for block, if any */
 {
   int lblock_ok = 1;    /* block passes checks */
   struct xfs_mount *mp; /* file system mount point */
   xfs_btnum_t btnum = cur->bc_btnum;
   int crc;
   mp = cur->bc_mp;
   crc = xfs_sb_version_hascrc(&mp->m_sb);
   if (crc) { lblock_ok = lblock_ok && uuid_equal(&block->bb_u.l.bb_uuid, &mp->m_sb.sb_meta_uuid) && block->bb_u.l.bb_blkno == cpu_to_be64(bp ? bp->b_bn : XFS_BUF_DADDR_NULL); }
   lblock_ok = lblock_ok && be32_to_cpu(block->bb_magic) == xfs_btree_magic(crc, btnum) && be16_to_cpu(block->bb_level) == level && be16_to_cpu(block->bb_numrecs) <= cur->bc_ops->get_maxrecs(cur, level) && block->bb_u.l.bb_leftsib && (block->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK) || XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_leftsib))) && block->bb_u.l.bb_rightsib && (block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK) || XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_rightsib)));
-  if (unlikely(XFS_TEST_ERROR(!lblock_ok, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK, XFS_RANDOM_BTREE_CHECK_LBLOCK))) {
+  if (unlikely(XFS_TEST_ERROR(!lblock_ok, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK))) {
     if (bp) trace_xfs_btree_corrupt(bp, _RET_IP_);
     XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
     return -EFSCORRUPTED;
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,27 +1,27 @@
 STATIC int                                            /* error (0 or EFSCORRUPTED) */
 xfs_btree_check_sblock(struct xfs_btree_cur *cur,     /* btree cursor */
                        struct xfs_btree_block *block, /* btree short form block pointer */
                        int level,                     /* level of the btree block */
                        struct xfs_buf *bp)            /* buffer containing block */
 {
   struct xfs_mount *mp; /* file system mount point */
   struct xfs_buf *agbp; /* buffer for ag. freespace struct */
   struct xfs_agf *agf;  /* ag. freespace structure */
   xfs_agblock_t agflen; /* native ag. freespace length */
   int sblock_ok = 1;    /* block passes checks */
   xfs_btnum_t btnum = cur->bc_btnum;
   int crc;
   mp = cur->bc_mp;
   crc = xfs_sb_version_hascrc(&mp->m_sb);
   agbp = cur->bc_private.a.agbp;
   agf = XFS_BUF_TO_AGF(agbp);
   agflen = be32_to_cpu(agf->agf_length);
   if (crc) { sblock_ok = sblock_ok && uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_meta_uuid) && block->bb_u.s.bb_blkno == cpu_to_be64(bp ? bp->b_bn : XFS_BUF_DADDR_NULL); }
   sblock_ok = sblock_ok && be32_to_cpu(block->bb_magic) == xfs_btree_magic(crc, btnum) && be16_to_cpu(block->bb_level) == level && be16_to_cpu(block->bb_numrecs) <= cur->bc_ops->get_maxrecs(cur, level) && (block->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) || be32_to_cpu(block->bb_u.s.bb_leftsib) < agflen) && block->bb_u.s.bb_leftsib && (block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK) || be32_to_cpu(block->bb_u.s.bb_rightsib) < agflen) && block->bb_u.s.bb_rightsib;
-  if (unlikely(XFS_TEST_ERROR(!sblock_ok, mp, XFS_ERRTAG_BTREE_CHECK_SBLOCK, XFS_RANDOM_BTREE_CHECK_SBLOCK))) {
+  if (unlikely(XFS_TEST_ERROR(!sblock_ok, mp, XFS_ERRTAG_BTREE_CHECK_SBLOCK))) {
     if (bp) trace_xfs_btree_corrupt(bp, _RET_IP_);
     XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
     return -EFSCORRUPTED;
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,18 +1,18 @@
 int xfs_dir_ino_validate(xfs_mount_t *mp, xfs_ino_t ino) {
   xfs_agblock_t agblkno;
   xfs_agino_t agino;
   xfs_agnumber_t agno;
   int ino_ok;
   int ioff;
   agno = XFS_INO_TO_AGNO(mp, ino);
   agblkno = XFS_INO_TO_AGBNO(mp, ino);
   ioff = XFS_INO_TO_OFFSET(mp, ino);
   agino = XFS_OFFBNO_TO_AGINO(mp, agblkno, ioff);
   ino_ok = agno < mp->m_sb.sb_agcount && agblkno < mp->m_sb.sb_agblocks && agblkno != 0 && ioff < (1 << mp->m_sb.sb_inopblog) && XFS_AGINO_TO_INO(mp, agno, agino) == ino;
-  if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE, XFS_RANDOM_DIR_INO_VALIDATE))) {
+  if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE))) {
     xfs_warn(mp, "Invalid inode number 0x%Lx", (unsigned long long)ino);
     XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
     return -EFSCORRUPTED;
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,8 +1,8 @@
 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);
-  else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp, XFS_ERRTAG_IALLOC_READ_AGI, XFS_RANDOM_IALLOC_READ_AGI))
+  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);
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,28 +1,28 @@
 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, XFS_RANDOM_ITOBP_INOTOBP))) {
+    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);
 #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 e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )
--- initial
+++ final
@@ -1,34 +1,34 @@
 static void xlog_iodone(xfs_buf_t *bp) {
   struct xlog_in_core *iclog = bp->b_fspriv;
   struct xlog *l = iclog->ic_log;
   int aborted = 0;
   /*
    * Race to shutdown the filesystem if we see an error or the iclog is in
    * IOABORT state. The IOABORT state is only set in DEBUG mode to inject
    * CRC errors into log recovery.
    */
-  if (XFS_TEST_ERROR(bp->b_error, l->l_mp, XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR) || iclog->ic_state & XLOG_STATE_IOABORT) {
+  if (XFS_TEST_ERROR(bp->b_error, l->l_mp, XFS_ERRTAG_IODONE_IOERR) || iclog->ic_state & XLOG_STATE_IOABORT) {
     if (iclog->ic_state & XLOG_STATE_IOABORT) iclog->ic_state &= ~XLOG_STATE_IOABORT;
     xfs_buf_ioerror_alert(bp, __func__);
     xfs_buf_stale(bp);
     xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
     /*
      * This flag will be propagated to the trans-committed
      * callback routines to let them know that the log-commit
      * didn't succeed.
      */
     aborted = XFS_LI_ABORTED;
   } else if (iclog->ic_state & XLOG_STATE_IOERROR) {
     aborted = XFS_LI_ABORTED;
   }
   /* log I/O is always issued ASYNC */
   ASSERT(bp->b_flags & XBF_ASYNC);
   xlog_state_done_syncing(iclog, aborted);
   /*
    * drop the buffer lock now that we are done. Nothing references
    * the buffer after this, so an unmount waiting on this lock can now
    * tear it down safely. As such, it is unsafe to reference the buffer
    * (bp) after the unlock as we could race with it being freed.
    */
   xfs_buf_unlock(bp);
 }<sep>@@
expression e1,e2,e3,e4;
@@
XFS_TEST_ERROR(e1,e2,e3
-                      ,e4
   )