Mon Mar 6 10:07:52 2017 UTC ()

Change vrecycle() and vgone() to lock with LK_RETRY.  If this node is
a layerfs node the lower node(s) may already be reclaimed.


(hannken)

diff -r1.75 -r1.76 src/sys/kern/vfs_vnode.c

--- src/sys/kern/vfs_vnode.c 2017/02/17 08:30:00	1.75
+++ src/sys/kern/vfs_vnode.c 2017/03/06 10:07:52	1.76

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_vnode.c,v 1.75 2017/02/17 08:30:00 hannken Exp $	*/
+/*	$NetBSD: vfs_vnode.c,v 1.76 2017/03/06 10:07:52 hannken Exp $	*/
 /*-
  * Copyright (c) 1997-2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -146,27 +146,27 @@
  * Note on v_usecount and its locking
+ *
  *	At nearly all points it is known that v_usecount could be zero,
  *	the vnode_t::v_interlock will be held.  To change v_usecount away
  *	from zero, the interlock must be held.  To change from a non-zero
  *	value to zero, again the interlock must be held.
+ *
  *	Changing the usecount from a non-zero value to a non-zero value can
  *	safely be done using atomic operations, without the interlock held.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_vnode.c,v 1.75 2017/02/17 08:30:00 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_vnode.c,v 1.76 2017/03/06 10:07:52 hannken Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/hash.h>
 #include <sys/kauth.h>
 #include <sys/kmem.h>
 #include <sys/kthread.h>
 #include <sys/module.h>
 @@ -909,27 +909,27 @@ vrecycle(vnode_t *vp)
 		return true;
+	}
 	/* Prevent further references until the vnode is locked. */
 	VSTATE_CHANGE(vp, VS_ACTIVE, VS_BLOCKED);
 	mutex_exit(vp->v_interlock);
 	/*
 	 * On a leaf file system this lock will always succeed as we hold
 	 * the last reference and prevent further references.
 	 * On layered file systems waiting for the lock would open a can of
 	 * deadlocks as the lower vnodes may have other active references.
 	 */
-	error = vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT);
+	error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_NOWAIT);
 	mutex_enter(vp->v_interlock);
 	VSTATE_CHANGE(vp, VS_BLOCKED, VS_ACTIVE);
 	if (error) {
 		mutex_exit(vp->v_interlock);
 		return false;
+	}
 	KASSERT(vp->v_usecount == 1);
 	vcache_reclaim(vp);
 	vrelel(vp, 0);
 @@ -968,33 +968,32 @@ vrevoke(vnode_t *vp)
 	while (spec_node_lookup_by_dev(type, dev, &vq) == 0) {
 		vgone(vq);
+	}
+}
 /*
  * Eliminate all activity associated with a vnode in preparation for
  * reuse.  Drops a reference from the vnode.
  */
 void
 vgone(vnode_t *vp)
+{
-	if (vn_lock(vp, LK_EXCLUSIVE) != 0) {
+	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 		VSTATE_ASSERT(vp, VS_RECLAIMED);
 		vrele(vp);
 	mutex_enter(vp->v_interlock);
-	vcache_reclaim(vp);
+	VSTATE_WAIT_STABLE(vp);
 	if (VSTATE_GET(vp) == VS_ACTIVE)
 		vcache_reclaim(vp);
 	VSTATE_ASSERT(vp, VS_RECLAIMED);
 	vrelel(vp, 0);
+}
 static inline uint32_t
 vcache_hash(const struct vcache_key *key)
+{
 	uint32_t hash = HASH32_BUF_INIT;
 	hash = hash32_buf(&key->vk_mount, sizeof(struct mount *), hash);
 	hash = hash32_buf(key->vk_key, key->vk_key_len, hash);
 	return hash;
+}