}
        ASSERT(vp->v_fbhv == NULL);
 
-       VN_LOCK(vp);
-       vp->v_flag &= (VRECLM|VWAIT);
-       VN_UNLOCK(vp, 0);
-
        vp->v_fbhv = NULL;
 
 #ifdef XFS_VNODE_TRACE
        return 0;
 }
 
-STATIC void
-vn_wakeup(
-       struct vnode    *vp)
-{
-       VN_LOCK(vp);
-       if (vp->v_flag & VWAIT)
-               sv_broadcast(vptosync(vp));
-       vp->v_flag &= ~(VRECLM|VWAIT|VMODIFIED);
-       VN_UNLOCK(vp, 0);
-}
-
-int
-vn_wait(
-       struct vnode    *vp)
-{
-       VN_LOCK(vp);
-       if (vp->v_flag & (VINACT | VRECLM)) {
-               vp->v_flag |= VWAIT;
-               sv_wait(vptosync(vp), PINOD, &vp->v_lock, 0);
-               return 1;
-       }
-       VN_UNLOCK(vp, 0);
-       return 0;
-}
-
 struct vnode *
 vn_initialize(
        struct inode    *inode)
 {
        vn_trace_entry(vp, "vn_purge", (inst_t *)__return_address);
 
-again:
        /*
         * Check whether vp has already been reclaimed since our caller
         * sampled its version while holding a filesystem cache lock that
                return;
        }
 
-       /*
-        * If vp is being reclaimed or inactivated, wait until it is inert,
-        * then proceed.  Can't assume that vnode is actually reclaimed
-        * just because the reclaimed flag is asserted -- a vn_alloc
-        * reclaim can fail.
-        */
-       if (vp->v_flag & (VINACT | VRECLM)) {
-               ASSERT(vn_count(vp) == 0);
-               vp->v_flag |= VWAIT;
-               sv_wait(vptosync(vp), PINOD, &vp->v_lock, 0);
-               goto again;
-       }
-
        /*
         * Another process could have raced in and gotten this vnode...
         */
        }
 
        XFS_STATS_DEC(vn_active);
-       vp->v_flag |= VRECLM;
        VN_UNLOCK(vp, 0);
 
        /*
         */
        if (vn_reclaim(vp) != 0)
                panic("vn_purge: cannot reclaim");
-
-       /*
-        * Wakeup anyone waiting for vp to be reclaimed.
-        */
-       vn_wakeup(vp);
 }
 
 /*
         * return.
         */
        if (!vcnt) {
-               /*
-                * As soon as we turn this on, noone can find us in vn_get
-                * until we turn off VINACT or VRECLM
-                */
-               vp->v_flag |= VINACT;
                VN_UNLOCK(vp, 0);
 
                /*
                        VOP_INACTIVE(vp, NULL, cache);
 
                VN_LOCK(vp);
-               if (vp->v_flag & VWAIT)
-                       sv_broadcast(vptosync(vp));
-
-               vp->v_flag &= ~(VINACT|VWAIT|VRECLM|VMODIFIED);
+               vp->v_flag &= ~VMODIFIED;
        }
 
        VN_UNLOCK(vp, 0);
 
 /*
  * Vnode flags.
  */
-#define VINACT                0x1      /* vnode is being inactivated   */
-#define VRECLM                0x2      /* vnode is being reclaimed     */
-#define VWAIT                 0x4      /* waiting for VINACT/VRECLM to end */
 #define VMODIFIED             0x8      /* XFS inode state possibly differs */
                                        /* to the Linux inode state.    */
 
        (VN_ISREG(vp) && ((mode) & (VSGID|(VEXEC>>3))) == VSGID)
 
 extern void    vn_init(void);
-extern int     vn_wait(struct vnode *);
 extern vnode_t *vn_initialize(struct inode *);
 
 /*
 
        vnode_t         *vp = NULL;
        int             error;
 
-retry:
        XFS_STATS_INC(xs_ig_attempts);
 
        if ((inode = iget_locked(XFS_MTOVFS(mp)->vfs_super, ino))) {
                                iput(inode);
                        }
                } else {
-                       /* These are true if the inode is in inactive or
-                        * reclaim. The linux inode is about to go away,
-                        * wait for that path to finish, and try again.
-                        */
-                       if (vp->v_flag & (VINACT | VRECLM)) {
-                               vn_wait(vp);
-                               iput(inode);
-                               goto retry;
-                       }
-
                        if (is_bad_inode(inode)) {
                                iput(inode);
                                return EIO;