Attachment #228714 for bug #258208




	zfs_refcount_destroy(&rrl->rr_linked_rcount);
}

static int
rrw_enter_read_impl(rrwlock_t *rrl, boolean_t prio, void *tag, boolean_t try)
{
	mutex_enter(&rrl->rr_lock);
#if !defined(DEBUG) && defined(_KERNEL)

	    !rrl->rr_track_all) {
		rrl->rr_anon_rcount.rc_count++;
		mutex_exit(&rrl->rr_lock);
		return (1);
	}
	DTRACE_PROBE(zfs__rrwfastpath__rdmiss);
#endif


	while (rrl->rr_writer != NULL || (rrl->rr_writer_wanted &&
	    zfs_refcount_is_zero(&rrl->rr_anon_rcount) && !prio &&
	    rrn_find(rrl) == NULL)) {
		if (try) {
			mutex_exit(&rrl->rr_lock);
			return (0);
		} else
			cv_wait(&rrl->rr_cv, &rrl->rr_lock);
	}

	if (rrl->rr_writer_wanted || rrl->rr_track_all) {
		/* may or may not be a re-entrant enter */

	}
	ASSERT(rrl->rr_writer == NULL);
	mutex_exit(&rrl->rr_lock);
	return (1);
}

void
rrw_enter_read(rrwlock_t *rrl, void *tag)
{
	(void)rrw_enter_read_impl(rrl, B_FALSE, tag, B_FALSE);
}

/*

void
rrw_enter_read_prio(rrwlock_t *rrl, void *tag)
{
	(void)rrw_enter_read_impl(rrl, B_TRUE, tag, B_FALSE);
}



		rrw_enter_write(rrl);
}

int
rrw_tryenter(rrwlock_t *rrl, krw_t rw, void *tag)
{
	ASSERT(rw == RW_READER);
	return (rrw_enter_read_impl(rrl, B_FALSE, tag, B_TRUE));
}

void
rrw_exit(rrwlock_t *rrl, void *tag)
{

 */
#define	RRM_TD_LOCK()	(((uint32_t)(uintptr_t)(curthread)) % RRM_NUM_LOCKS)

int
rrm_tryenter(rrmlock_t *rrl, krw_t rw, void *tag)
{
	return (rrw_tryenter(&rrl->locks[RRM_TD_LOCK()], rw, tag));
}

void
rrm_enter_read(rrmlock_t *rrl, void *tag)
{

Lines 53-59 typedef struct reference { Link Here

(-)b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/refcount.h (+4 lines)
53	} reference_t;	53	} reference_t;
54		54
55	typedef struct refcount {	55	typedef struct refcount {
		56	#ifndef _KERNEL
56	kmutex_t rc_mtx;	57	kmutex_t rc_mtx;
		58	#else
		59	struct mtx rc_mtx;
		60	#endif
57	boolean_t rc_tracked;	61	boolean_t rc_tracked;
58	list_t rc_list;	62	list_t rc_list;
59	list_t rc_removed;	63	list_t rc_removed;

Lines 51-57 extern "C" { Link Here

(-)b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/rrwlock.h (+6 lines)
51	* - rr_writer_wanted: a writer wants the lock	51	* - rr_writer_wanted: a writer wants the lock
52	*/	52	*/
53	typedef struct rrwlock {	53	typedef struct rrwlock {
		54	#ifndef _KERNEL
54	kmutex_t rr_lock;	55	kmutex_t rr_lock;
		56	#else
		57	struct mtx rr_lock;
		58	#endif
55	kcondvar_t rr_cv;	59	kcondvar_t rr_cv;
56	kthread_t *rr_writer;	60	kthread_t *rr_writer;
57	zfs_refcount_t rr_anon_rcount;	61	zfs_refcount_t rr_anon_rcount;
Lines 71-76 void rrw_enter(rrwlock_t rrl, krw_t rw, void tag); Link Here
71	void rrw_enter_read(rrwlock_t rrl, void tag);	75	void rrw_enter_read(rrwlock_t rrl, void tag);
72	void rrw_enter_read_prio(rrwlock_t rrl, void tag);	76	void rrw_enter_read_prio(rrwlock_t rrl, void tag);
73	void rrw_enter_write(rrwlock_t *rrl);	77	void rrw_enter_write(rrwlock_t *rrl);
		78	int rrw_tryenter(rrwlock_t rrl, krw_t rw, void tag);
74	void rrw_exit(rrwlock_t rrl, void tag);	79	void rrw_exit(rrwlock_t rrl, void tag);
75	boolean_t rrw_held(rrwlock_t *rrl, krw_t rw);	80	boolean_t rrw_held(rrwlock_t *rrl, krw_t rw);
76	void rrw_tsd_destroy(void *arg);	81	void rrw_tsd_destroy(void *arg);
Lines 97-102 void rrm_destroy(rrmlock_t *rrl); Link Here
97	void rrm_enter(rrmlock_t rrl, krw_t rw, void tag);	102	void rrm_enter(rrmlock_t rrl, krw_t rw, void tag);
98	void rrm_enter_read(rrmlock_t rrl, void tag);	103	void rrm_enter_read(rrmlock_t rrl, void tag);
99	void rrm_enter_write(rrmlock_t *rrl);	104	void rrm_enter_write(rrmlock_t *rrl);
		105	int rrm_tryenter(rrmlock_t rrl, krw_t rw, void tag);
100	void rrm_exit(rrmlock_t rrl, void tag);	106	void rrm_exit(rrmlock_t rrl, void tag);
101	boolean_t rrm_held(rrmlock_t *rrl, krw_t rw);	107	boolean_t rrm_held(rrmlock_t *rrl, krw_t rw);
102		108




		zil_close(zfsvfs->z_log);
		zfsvfs->z_log = NULL;
	}

	ZFS_WLOCK_TEARDOWN_INACTIVE(zfsvfs);

	/*
	 * If we are not unmounting (ie: online recv) and someone already
	 * unmounted this file system while we were doing the switcheroo,
	 * or a reopen of z_os failed then just bail out now.
	 */
	if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
		ZFS_WUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
		rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
		return (SET_ERROR(EIO));
	}

	 */
	if (unmounting) {
		zfsvfs->z_unmounted = B_TRUE;
		ZFS_WUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
		rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
	}


	znode_t *zp;

	ASSERT(RRM_WRITE_HELD(&zfsvfs->z_teardown_lock));
	ASSERT(ZFS_TEARDOWN_INACTIVE_WLOCKED(zfsvfs));

	/*
	 * We already own this, so just update the objset_t, as the one we


bail:
	/* release the VOPs */
	ZFS_WUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);

	if (err) {




	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	int error;

	ZFS_RLOCK_TEARDOWN_INACTIVE(zfsvfs);
	if (zp->z_sa_hdl == NULL) {
		/*
		 * The fs has been unmounted, or we did a
		 * suspend/resume and this file no longer exists.
		 */
		ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
		vrecycle(vp);
		return;
	}

		/*
		 * Fast path to recycle a vnode of a removed file.
		 */
		ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
		vrecycle(vp);
		return;
	}

			dmu_tx_commit(tx);
		}
	}
	ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
}



{
	vnode_t	*vp = ap->a_vp;
	znode_t	*zp = VTOZ(vp);
	zfsvfs_t *zfsvfs;

	ASSERT(zp != NULL);
	zfsvfs = zp->z_zfsvfs;

	/*
	 * z_teardown_inactive_lock protects from a race with
	 * zfs_znode_dmu_fini in zfsvfs_teardown during
	 * force unmount.
	 */
	ZFS_RLOCK_TEARDOWN_INACTIVE(zfsvfs);
	if (zp->z_sa_hdl == NULL)
		zfs_znode_free(zp);
	else
		zfs_zinactive(zp);
	ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);

	vp->v_data = NULL;

	/*
	 * Drop z_teardown_lock acquired in zfs_freebsd_lock,
	 * because zfs_freebsd_unlock won't be called on this vnode.
	 */
	lockmgr_assert(vp->v_vnlock, KA_XLOCKED | KA_NOTRECURSED);
	rrm_exit(&zfsvfs->z_teardown_lock, vp);

	return (0);
}


	return (error);
}

int
zfs_freebsd_lock(ap)
zfs_lock(ap)
	struct vop_lock1_args /* {
		struct vnode *a_vp;
		int a_flags;

		int line;
	} */ *ap;
{
	struct vnode *vp = ap->a_vp;
	zfsvfs_t *zfsvfs;
	int error;
	int op;

	op = ap->a_flags & LK_TYPE_MASK;
	if (op == LK_UPGRADE) {
		/*
		 * Failure to upgrade means losing shared lock.
		 * We drop z_teardown_lock now and re-acquire it
		 * if the upgrade is successful.
		 */
		ASSERT(VTOZ(vp) != NULL && VTOZ(vp)->z_zfsvfs != NULL);
		zfsvfs = VTOZ(vp)->z_zfsvfs;
		rrm_exit(&zfsvfs->z_teardown_lock, vp);
	}
	error = vop_lock(ap);
	if (op == LK_DOWNGRADE) {
		ASSERT(error == 0);
		return (error);
	}
	if (op == LK_TRYUPGRADE)
		return (error);
	ASSERT(op == LK_SHARED || op == LK_EXCLUSIVE || op == LK_UPGRADE);
	if (error != 0 || VN_IS_DOOMED(vp))
		return (error);
	ASSERT(VTOZ(vp) != NULL && VTOZ(vp)->z_zfsvfs != NULL);
	zfsvfs = VTOZ(vp)->z_zfsvfs;

	/*
	 * zfsvfs_teardown -> zil_close -> zil_commit ->
	 * zfs_get_data -> zfs_zget -> zfs_znode_alloc
	 */
	if (!RRM_WRITE_HELD(&zfsvfs->z_teardown_lock)) {
		if ((ap->a_flags & LK_NOWAIT) == 0) {
#ifdef DIAGNOSTIC
			if (vp->v_mount != NULL && (VTOZ(vp)->z_pflags & ZFS_XATTR) == 0)
				ASSERT(!RRM_LOCK_HELD(&zp->z_zfsvfs->z_teardown_lock));
#endif
			rrm_enter(&zfsvfs->z_teardown_lock, RW_READER, vp);
		} else if (!rrm_tryenter(&zfsvfs->z_teardown_lock, RW_READER,
		    vp)) {
			(void)lockmgr_unlock(&vp->v_lock);
			return (EBUSY);
		}
	}
	return (0);
}

int
zfs_freebsd_unlock(ap)
	struct vop_unlock_args /* {
		struct vnode *a_vp;
		int a_flags;
	} */ *ap;
{
	struct vnode *vp = ap->a_vp;
	zfsvfs_t *zfsvfs = VTOZ(vp)->z_zfsvfs;
	int error;

	error = vop_unlock(ap);
	if (!RRM_WRITE_HELD(&zfsvfs->z_teardown_lock))
		rrm_exit(&zfsvfs->z_teardown_lock, vp);
	return (error);
}

struct vop_vector zfs_vnodeops;
struct vop_vector zfs_fifoops;

	.vop_getpages =		zfs_freebsd_getpages,
	.vop_putpages =		zfs_freebsd_putpages,
	.vop_vptocnp =		zfs_vptocnp,
	.vop_lock1 =		zfs_freebsd_lock,
	.vop_unlock =		zfs_freebsd_unlock,
#else
	.vop_lock1 =		vop_lock,
#endif
	.vop_unlock =		vop_unlock,
	.vop_islocked =		vop_islocked,
};
VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);

	.vop_getacl =		zfs_freebsd_getacl,
	.vop_setacl =		zfs_freebsd_setacl,
	.vop_aclcheck =		zfs_freebsd_aclcheck,
	.vop_lock1 =		zfs_freebsd_lock,
	.vop_unlock =		zfs_freebsd_unlock,
};
VFS_VOP_VECTOR_REGISTER(zfs_fifoops);


	.vop_reclaim =		zfs_freebsd_reclaim,
	.vop_fid =		zfs_freebsd_fid,
	.vop_pathconf =		zfs_freebsd_pathconf,
	.vop_lock1 =		zfs_freebsd_lock,
	.vop_unlock =		zfs_freebsd_unlock,
};
VFS_VOP_VECTOR_REGISTER(zfs_shareops);

Lines 679-685 zfs_znode_dmu_fini(znode_t *zp) Link Here

(-)b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_znode.c (-1 / +1 lines)
679	{	679	{
680	ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zp->z_zfsvfs, zp->z_id)) \|\|	680	ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zp->z_zfsvfs, zp->z_id)) \|\|
681	zp->z_unlinked \|\|	681	zp->z_unlinked \|\|
682	ZFS_TEARDOWN_INACTIVE_WLOCKED(zp->z_zfsvfs));	682	RRM_WRITE_HELD(&zp->z_zfsvfs->z_teardown_lock));
683		683
684	sa_handle_destroy(zp->z_sa_hdl);	684	sa_handle_destroy(zp->z_sa_hdl);
685	zp->z_sa_hdl = NULL;	685	zp->z_sa_hdl = NULL;

Return to bug 258208

Lines 159-166 rrw_destroy(rrwlock_t *rrl) Link Here

(-)b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/rrwlock.c (-7 / +26 lines)
159	zfs_refcount_destroy(&rrl->rr_linked_rcount);	159	zfs_refcount_destroy(&rrl->rr_linked_rcount);
160	}	160	}
161		161
162	static void	162	static int
163	rrw_enter_read_impl(rrwlock_t rrl, boolean_t prio, void tag)	163	rrw_enter_read_impl(rrwlock_t rrl, boolean_t prio, void tag, boolean_t try)
164	{	164	{
165	mutex_enter(&rrl->rr_lock);	165	mutex_enter(&rrl->rr_lock);
166	#if !defined(DEBUG) && defined(_KERNEL)	166	#if !defined(DEBUG) && defined(_KERNEL)
Lines 168-174 rrw_enter_read_impl(rrwlock_t rrl, boolean_t prio, void tag) Link Here
168	!rrl->rr_track_all) {	168	!rrl->rr_track_all) {
169	rrl->rr_anon_rcount.rc_count++;	169	rrl->rr_anon_rcount.rc_count++;
170	mutex_exit(&rrl->rr_lock);	170	mutex_exit(&rrl->rr_lock);
171	return;	171	return (1);
172	}	172	}
173	DTRACE_PROBE(zfs__rrwfastpath__rdmiss);	173	DTRACE_PROBE(zfs__rrwfastpath__rdmiss);
174	#endif	174	#endif
Lines 177-184 rrw_enter_read_impl(rrwlock_t rrl, boolean_t prio, void tag) Link Here
177		177
178	while (rrl->rr_writer != NULL \|\| (rrl->rr_writer_wanted &&	178	while (rrl->rr_writer != NULL \|\| (rrl->rr_writer_wanted &&
179	zfs_refcount_is_zero(&rrl->rr_anon_rcount) && !prio &&	179	zfs_refcount_is_zero(&rrl->rr_anon_rcount) && !prio &&
180	rrn_find(rrl) == NULL))	180	rrn_find(rrl) == NULL)) {
181	cv_wait(&rrl->rr_cv, &rrl->rr_lock);	181	if (try) {
		182	mutex_exit(&rrl->rr_lock);
		183	return (0);
		184	} else
		185	cv_wait(&rrl->rr_cv, &rrl->rr_lock);
		186	}
182		187
183	if (rrl->rr_writer_wanted \|\| rrl->rr_track_all) {	188	if (rrl->rr_writer_wanted \|\| rrl->rr_track_all) {
184	/* may or may not be a re-entrant enter */	189	/* may or may not be a re-entrant enter */
Lines 189-200 rrw_enter_read_impl(rrwlock_t rrl, boolean_t prio, void tag) Link Here
189	}	194	}
190	ASSERT(rrl->rr_writer == NULL);	195	ASSERT(rrl->rr_writer == NULL);
191	mutex_exit(&rrl->rr_lock);	196	mutex_exit(&rrl->rr_lock);
		197	return (1);
192	}	198	}
193		199
194	void	200	void
195	rrw_enter_read(rrwlock_t rrl, void tag)	201	rrw_enter_read(rrwlock_t rrl, void tag)
196	{	202	{
197	rrw_enter_read_impl(rrl, B_FALSE, tag);	203	(void)rrw_enter_read_impl(rrl, B_FALSE, tag, B_FALSE);
198	}	204	}
199		205
200	/*	206	/*
Lines 206-212 rrw_enter_read(rrwlock_t rrl, void tag) Link Here
206	void	212	void
207	rrw_enter_read_prio(rrwlock_t rrl, void tag)	213	rrw_enter_read_prio(rrwlock_t rrl, void tag)
208	{	214	{
209	rrw_enter_read_impl(rrl, B_TRUE, tag);	215	(void)rrw_enter_read_impl(rrl, B_TRUE, tag, B_FALSE);
210	}	216	}
211		217
212		218
Lines 236-241 rrw_enter(rrwlock_t rrl, krw_t rw, void tag) Link Here
236	rrw_enter_write(rrl);	242	rrw_enter_write(rrl);
237	}	243	}
238		244
		245	int
		246	rrw_tryenter(rrwlock_t rrl, krw_t rw, void tag)
		247	{
		248	ASSERT(rw == RW_READER);
		249	return (rrw_enter_read_impl(rrl, B_FALSE, tag, B_TRUE));
		250	}
		251
239	void	252	void
240	rrw_exit(rrwlock_t rrl, void tag)	253	rrw_exit(rrwlock_t rrl, void tag)
241	{	254	{
Lines 357-362 rrm_enter(rrmlock_t rrl, krw_t rw, void tag) Link Here
357	*/	370	*/
358	#define RRM_TD_LOCK() (((uint32_t)(uintptr_t)(curthread)) % RRM_NUM_LOCKS)	371	#define RRM_TD_LOCK() (((uint32_t)(uintptr_t)(curthread)) % RRM_NUM_LOCKS)
359		372
		373	int
		374	rrm_tryenter(rrmlock_t rrl, krw_t rw, void tag)
		375	{
		376	return (rrw_tryenter(&rrl->locks[RRM_TD_LOCK()], rw, tag));
		377	}
		378
360	void	379	void
361	rrm_enter_read(rrmlock_t rrl, void tag)	380	rrm_enter_read(rrmlock_t rrl, void tag)
362	{	381	{

Lines 2073-2088 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting) Link Here

(-)b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vfsops.c (-7 lines)
2073	zil_close(zfsvfs->z_log);	2073	zil_close(zfsvfs->z_log);
2074	zfsvfs->z_log = NULL;	2074	zfsvfs->z_log = NULL;
2075	}	2075	}
2076
2077	ZFS_WLOCK_TEARDOWN_INACTIVE(zfsvfs);
2078
2079	/*	2076	/*
2080	* If we are not unmounting (ie: online recv) and someone already	2077	* If we are not unmounting (ie: online recv) and someone already
2081	* unmounted this file system while we were doing the switcheroo,	2078	* unmounted this file system while we were doing the switcheroo,
2082	* or a reopen of z_os failed then just bail out now.	2079	* or a reopen of z_os failed then just bail out now.
2083	*/	2080	*/
2084	if (!unmounting && (zfsvfs->z_unmounted \|\| zfsvfs->z_os == NULL)) {	2081	if (!unmounting && (zfsvfs->z_unmounted \|\| zfsvfs->z_os == NULL)) {
2085	ZFS_WUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
2086	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);	2082	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2087	return (SET_ERROR(EIO));	2083	return (SET_ERROR(EIO));
2088	}	2084	}
Lines 2110-2116 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting) Link Here
2110	*/	2106	*/
2111	if (unmounting) {	2107	if (unmounting) {
2112	zfsvfs->z_unmounted = B_TRUE;	2108	zfsvfs->z_unmounted = B_TRUE;
2113	ZFS_WUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
2114	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);	2109	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2115	}	2110	}
2116		2111
Lines 2456-2462 zfs_resume_fs(zfsvfs_t zfsvfs, dsl_dataset_t ds) Link Here
2456	znode_t *zp;	2451	znode_t *zp;
2457		2452
2458	ASSERT(RRM_WRITE_HELD(&zfsvfs->z_teardown_lock));	2453	ASSERT(RRM_WRITE_HELD(&zfsvfs->z_teardown_lock));
2459	ASSERT(ZFS_TEARDOWN_INACTIVE_WLOCKED(zfsvfs));
2460		2454
2461	/*	2455	/*
2462	* We already own this, so just update the objset_t, as the one we	2456	* We already own this, so just update the objset_t, as the one we
Lines 2490-2496 zfs_resume_fs(zfsvfs_t zfsvfs, dsl_dataset_t ds) Link Here
2490		2484
2491	bail:	2485	bail:
2492	/* release the VOPs */	2486	/* release the VOPs */
2493	ZFS_WUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
2494	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);	2487	rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2495		2488
2496	if (err) {	2489	if (err) {

Lines 4270-4282 zfs_inactive(vnode_t vp, cred_t cr, caller_context_t *ct) Link Here

(-)b/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c (-33 / +80 lines)
4270	zfsvfs_t *zfsvfs = zp->z_zfsvfs;	4270	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
4271	int error;	4271	int error;
4272		4272
4273	ZFS_RLOCK_TEARDOWN_INACTIVE(zfsvfs);
4274	if (zp->z_sa_hdl == NULL) {	4273	if (zp->z_sa_hdl == NULL) {
4275	/*	4274	/*
4276	* The fs has been unmounted, or we did a	4275	* The fs has been unmounted, or we did a
4277	* suspend/resume and this file no longer exists.	4276	* suspend/resume and this file no longer exists.
4278	*/	4277	*/
4279	ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
4280	vrecycle(vp);	4278	vrecycle(vp);
4281	return;	4279	return;
4282	}	4280	}
Lines 4285-4291 zfs_inactive(vnode_t vp, cred_t cr, caller_context_t *ct) Link Here
4285	/*	4283	/*
4286	* Fast path to recycle a vnode of a removed file.	4284	* Fast path to recycle a vnode of a removed file.
4287	*/	4285	*/
4288	ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
4289	vrecycle(vp);	4286	vrecycle(vp);
4290	return;	4287	return;
4291	}	4288	}
Lines 4305-4311 zfs_inactive(vnode_t vp, cred_t cr, caller_context_t *ct) Link Here
4305	dmu_tx_commit(tx);	4302	dmu_tx_commit(tx);
4306	}	4303	}
4307	}	4304	}
4308	ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
4309	}	4305	}
4310		4306
4311		4307
Lines 5416-5438 zfs_freebsd_reclaim(ap) Link Here
5416	{	5412	{
5417	vnode_t *vp = ap->a_vp;	5413	vnode_t *vp = ap->a_vp;
5418	znode_t *zp = VTOZ(vp);	5414	znode_t *zp = VTOZ(vp);
5419	zfsvfs_t *zfsvfs = zp->z_zfsvfs;	5415	zfsvfs_t *zfsvfs;
5420		5416
5421	ASSERT(zp != NULL);	5417	ASSERT(zp != NULL);
		5418	zfsvfs = zp->z_zfsvfs;
5422		5419
5423	/*
5424	* z_teardown_inactive_lock protects from a race with
5425	* zfs_znode_dmu_fini in zfsvfs_teardown during
5426	* force unmount.
5427	*/
5428	ZFS_RLOCK_TEARDOWN_INACTIVE(zfsvfs);
5429	if (zp->z_sa_hdl == NULL)	5420	if (zp->z_sa_hdl == NULL)
5430	zfs_znode_free(zp);	5421	zfs_znode_free(zp);
5431	else	5422	else
5432	zfs_zinactive(zp);	5423	zfs_zinactive(zp);
5433	ZFS_RUNLOCK_TEARDOWN_INACTIVE(zfsvfs);
5434		5424
5435	vp->v_data = NULL;	5425	vp->v_data = NULL;
		5426
		5427	/*
		5428	* Drop z_teardown_lock acquired in zfs_freebsd_lock,
		5429	* because zfs_freebsd_unlock won't be called on this vnode.
		5430	*/
		5431	lockmgr_assert(vp->v_vnlock, KA_XLOCKED \| KA_NOTRECURSED);
		5432	rrm_exit(&zfsvfs->z_teardown_lock, vp);
		5433
5436	return (0);	5434	return (0);
5437	}	5435	}
5438		5436
Lines 6010-6018 zfs_vptocnp(struct vop_vptocnp_args *ap) Link Here
6010	return (error);	6008	return (error);
6011	}	6009	}
6012		6010
6013	#ifdef DIAGNOSTIC	6011	int
6014	static int	6012	zfs_freebsd_lock(ap)
6015	zfs_lock(ap)
6016	struct vop_lock1_args /* {	6013	struct vop_lock1_args /* {
6017	struct vnode *a_vp;	6014	struct vnode *a_vp;
6018	int a_flags;	6015	int a_flags;
Lines 6020-6040 zfs_lock(ap) Link Here
6020	int line;	6017	int line;
6021	} / ap;	6018	} / ap;
6022	{	6019	{
6023	vnode_t *vp;	6020	struct vnode *vp = ap->a_vp;
6024	znode_t *zp;	6021	zfsvfs_t *zfsvfs;
6025	int err;	6022	int error;
		6023	int op;
6026		6024
6027	err = vop_lock(ap);	6025	op = ap->a_flags & LK_TYPE_MASK;
6028	if (err == 0 && (ap->a_flags & LK_NOWAIT) == 0) {	6026	if (op == LK_UPGRADE) {
6029	vp = ap->a_vp;	6027	/*
6030	zp = vp->v_data;	6028	* Failure to upgrade means losing shared lock.
6031	if (vp->v_mount != NULL && !VN_IS_DOOMED(vp) &&	6029	* We drop z_teardown_lock now and re-acquire it
6032	zp != NULL && (zp->z_pflags & ZFS_XATTR) == 0)	6030	* if the upgrade is successful.
6033	VERIFY(!RRM_LOCK_HELD(&zp->z_zfsvfs->z_teardown_lock));	6031	*/
		6032	ASSERT(VTOZ(vp) != NULL && VTOZ(vp)->z_zfsvfs != NULL);
		6033	zfsvfs = VTOZ(vp)->z_zfsvfs;
		6034	rrm_exit(&zfsvfs->z_teardown_lock, vp);
6034	}	6035	}
6035	return (err);	6036	error = vop_lock(ap);
6036	}	6037	if (op == LK_DOWNGRADE) {
		6038	ASSERT(error == 0);
		6039	return (error);
		6040	}
		6041	if (op == LK_TRYUPGRADE)
		6042	return (error);
		6043	ASSERT(op == LK_SHARED \|\| op == LK_EXCLUSIVE \|\| op == LK_UPGRADE);
		6044	if (error != 0 \|\| VN_IS_DOOMED(vp))
		6045	return (error);
		6046	ASSERT(VTOZ(vp) != NULL && VTOZ(vp)->z_zfsvfs != NULL);
		6047	zfsvfs = VTOZ(vp)->z_zfsvfs;
		6048
		6049	/*
		6050	* zfsvfs_teardown -> zil_close -> zil_commit ->
		6051	* zfs_get_data -> zfs_zget -> zfs_znode_alloc
		6052	*/
		6053	if (!RRM_WRITE_HELD(&zfsvfs->z_teardown_lock)) {
		6054	if ((ap->a_flags & LK_NOWAIT) == 0) {
		6055	#ifdef DIAGNOSTIC
		6056	if (vp->v_mount != NULL && (VTOZ(vp)->z_pflags & ZFS_XATTR) == 0)
		6057	ASSERT(!RRM_LOCK_HELD(&zp->z_zfsvfs->z_teardown_lock));
6037	#endif	6058	#endif
		6059	rrm_enter(&zfsvfs->z_teardown_lock, RW_READER, vp);
		6060	} else if (!rrm_tryenter(&zfsvfs->z_teardown_lock, RW_READER,
		6061	vp)) {
		6062	(void)lockmgr_unlock(&vp->v_lock);
		6063	return (EBUSY);
		6064	}
		6065	}
		6066	return (0);
		6067	}
		6068
		6069	int
		6070	zfs_freebsd_unlock(ap)
		6071	struct vop_unlock_args /* {
		6072	struct vnode *a_vp;
		6073	int a_flags;
		6074	} / ap;
		6075	{
		6076	struct vnode *vp = ap->a_vp;
		6077	zfsvfs_t *zfsvfs = VTOZ(vp)->z_zfsvfs;
		6078	int error;
		6079
		6080	error = vop_unlock(ap);
		6081	if (!RRM_WRITE_HELD(&zfsvfs->z_teardown_lock))
		6082	rrm_exit(&zfsvfs->z_teardown_lock, vp);
		6083	return (error);
		6084	}
6038		6085
6039	struct vop_vector zfs_vnodeops;	6086	struct vop_vector zfs_vnodeops;
6040	struct vop_vector zfs_fifoops;	6087	struct vop_vector zfs_fifoops;
Lines 6081-6092 struct vop_vector zfs_vnodeops = { Link Here
6081	.vop_getpages = zfs_freebsd_getpages,	6128	.vop_getpages = zfs_freebsd_getpages,
6082	.vop_putpages = zfs_freebsd_putpages,	6129	.vop_putpages = zfs_freebsd_putpages,
6083	.vop_vptocnp = zfs_vptocnp,	6130	.vop_vptocnp = zfs_vptocnp,
6084	#ifdef DIAGNOSTIC	6131	.vop_lock1 = zfs_freebsd_lock,
6085	.vop_lock1 = zfs_lock,	6132	.vop_unlock = zfs_freebsd_unlock,
6086	#else
6087	.vop_lock1 = vop_lock,
6088	#endif
6089	.vop_unlock = vop_unlock,
6090	.vop_islocked = vop_islocked,	6133	.vop_islocked = vop_islocked,
6091	};	6134	};
6092	VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);	6135	VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);
Lines 6106-6111 struct vop_vector zfs_fifoops = { Link Here
6106	.vop_getacl = zfs_freebsd_getacl,	6149	.vop_getacl = zfs_freebsd_getacl,
6107	.vop_setacl = zfs_freebsd_setacl,	6150	.vop_setacl = zfs_freebsd_setacl,
6108	.vop_aclcheck = zfs_freebsd_aclcheck,	6151	.vop_aclcheck = zfs_freebsd_aclcheck,
		6152	.vop_lock1 = zfs_freebsd_lock,
		6153	.vop_unlock = zfs_freebsd_unlock,
6109	};	6154	};
6110	VFS_VOP_VECTOR_REGISTER(zfs_fifoops);	6155	VFS_VOP_VECTOR_REGISTER(zfs_fifoops);
6111		6156
Lines 6120-6124 struct vop_vector zfs_shareops = { Link Here
6120	.vop_reclaim = zfs_freebsd_reclaim,	6165	.vop_reclaim = zfs_freebsd_reclaim,
6121	.vop_fid = zfs_freebsd_fid,	6166	.vop_fid = zfs_freebsd_fid,
6122	.vop_pathconf = zfs_freebsd_pathconf,	6167	.vop_pathconf = zfs_freebsd_pathconf,
		6168	.vop_lock1 = zfs_freebsd_lock,
		6169	.vop_unlock = zfs_freebsd_unlock,
6123	};	6170	};
6124	VFS_VOP_VECTOR_REGISTER(zfs_shareops);	6171	VFS_VOP_VECTOR_REGISTER(zfs_shareops);