--- initial
+++ final
@@ -1,103 +1,103 @@
 STATIC int xchk_parent_validate(struct xfs_scrub *sc, xfs_ino_t dnum, bool *try_again) {
   struct xfs_mount *mp = sc->mp;
   struct xfs_inode *dp = NULL;
   xfs_nlink_t expected_nlink;
   xfs_nlink_t nlink;
   int error = 0;
   *try_again = false;
   if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) goto out;
   /* '..' must not point to ourselves. */
   if (sc->ip->i_ino == dnum) {
     xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
     goto out;
   }
   /*
    * If we're an unlinked directory, the parent /won't/ have a link
    * to us.  Otherwise, it should have one link.
    */
   expected_nlink = VFS_I(sc->ip)->i_nlink == 0 ? 0 : 1;
   /*
    * Grab this parent inode.  We release the inode before we
    * cancel the scrub transaction.  Since we're don't know a
    * priori that releasing the inode won't trigger eofblocks
    * cleanup (which allocates what would be a nested transaction)
    * if the parent pointer erroneously points to a file, we
    * can't use DONTCACHE here because DONTCACHE inodes can trigger
    * immediate inactive cleanup of the inode.
    *
    * If _iget returns -EINVAL then the parent inode number is garbage
    * and the directory is corrupt.  If the _iget returns -EFSCORRUPTED
    * or -EFSBADCRC then the parent is corrupt which is a cross
    * referencing error.  Any other error is an operational error.
    */
   error = xfs_iget(mp, sc->tp, dnum, XFS_IGET_UNTRUSTED, 0, &dp);
   if (error == -EINVAL) {
     error = -EFSCORRUPTED;
     xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error);
     goto out;
   }
   if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error)) goto out;
   if (dp == sc->ip || !S_ISDIR(VFS_I(dp)->i_mode)) {
     xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
     goto out_rele;
   }
   /*
    * We prefer to keep the inode locked while we lock and search
    * its alleged parent for a forward reference.  If we can grab
    * the iolock, validate the pointers and we're done.  We must
    * use nowait here to avoid an ABBA deadlock on the parent and
    * the child inodes.
    */
   if (xfs_ilock_nowait(dp, XFS_IOLOCK_SHARED)) {
     error = xchk_parent_count_parent_dentries(sc, dp, &nlink);
     if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error)) goto out_unlock;
     if (nlink != expected_nlink) xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
     goto out_unlock;
   }
   /*
    * The game changes if we get here.  We failed to lock the parent,
    * so we're going to try to verify both pointers while only holding
    * one lock so as to avoid deadlocking with something that's actually
    * trying to traverse down the directory tree.
    */
   xfs_iunlock(sc->ip, sc->ilock_flags);
   sc->ilock_flags = 0;
   error = xchk_ilock_inverted(dp, XFS_IOLOCK_SHARED);
   if (error) goto out_rele;
   /* Go looking for our dentry. */
   error = xchk_parent_count_parent_dentries(sc, dp, &nlink);
   if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error)) goto out_unlock;
   /* Drop the parent lock, relock this inode. */
   xfs_iunlock(dp, XFS_IOLOCK_SHARED);
   error = xchk_ilock_inverted(sc->ip, XFS_IOLOCK_EXCL);
   if (error) goto out_rele;
   sc->ilock_flags = XFS_IOLOCK_EXCL;
   /*
    * If we're an unlinked directory, the parent /won't/ have a link
    * to us.  Otherwise, it should have one link.  We have to re-set
    * it here because we dropped the lock on sc->ip.
    */
   expected_nlink = VFS_I(sc->ip)->i_nlink == 0 ? 0 : 1;
   /* Look up '..' to see if the inode changed. */
   error = xfs_dir_lookup(sc->tp, sc->ip, &xfs_name_dotdot, &dnum, NULL);
   if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error)) goto out_rele;
   /* Drat, parent changed.  Try again! */
   if (dnum != dp->i_ino) {
-    iput(VFS_I(dp));
+    xfs_irele(dp);
     *try_again = true;
     return 0;
   }
-  iput(VFS_I(dp));
+  xfs_irele(dp);
   /*
    * '..' didn't change, so check that there was only one entry
    * for us in the parent.
    */
   if (nlink != expected_nlink) xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
   return error;
 out_unlock:
   xfs_iunlock(dp, XFS_IOLOCK_SHARED);
 out_rele:
-  iput(VFS_I(dp));
+  xfs_irele(dp);
 out:
   return error;
 }<sep>@@
expression dp;
@@
-               iput(VFS_I(dp));
+               xfs_irele(dp);