Attachment #228813 for bug #258208

Lines 140-146 struct zfsvfs { Link Here

(-)b/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_vfsops_os.h (-2 / +2 lines)
140	#define ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, tag) \	140	#define ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, tag) \
141	rms_wlock(&(zfsvfs)->z_teardown_lock)	141	rms_wlock(&(zfsvfs)->z_teardown_lock)
142		142
143	#define ZFS_TEARDOWN_EXIT_WRITE(zfsvfs) \	143	#define ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, tag) \
144	rms_wunlock(&(zfsvfs)->z_teardown_lock)	144	rms_wunlock(&(zfsvfs)->z_teardown_lock)
145		145
146	#define ZFS_TEARDOWN_EXIT(zfsvfs, tag) \	146	#define ZFS_TEARDOWN_EXIT(zfsvfs, tag) \
Lines 173-179 struct zfsvfs { Link Here
173	#define ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, tag) \	173	#define ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, tag) \
174	rrm_enter(&(zfsvfs)->z_teardown_lock, RW_WRITER, tag)	174	rrm_enter(&(zfsvfs)->z_teardown_lock, RW_WRITER, tag)
175		175
176	#define ZFS_TEARDOWN_EXIT_WRITE(zfsvfs) \	176	#define ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, tag) \
177	rrm_exit(&(zfsvfs)->z_teardown_lock, tag)	177	rrm_exit(&(zfsvfs)->z_teardown_lock, tag)
178		178
179	#define ZFS_TEARDOWN_EXIT(zfsvfs, tag) \	179	#define ZFS_TEARDOWN_EXIT(zfsvfs, tag) \




		ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
		zfs_unregister_callbacks(zfsvfs);
		error = zfs_register_callbacks(vfsp);
		ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
		goto out;
	}


	 */
	if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
		ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
		ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
		return (SET_ERROR(EIO));
	}


	if (unmounting) {
		zfsvfs->z_unmounted = B_TRUE;
		ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
		ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
	}

	/*

		 */
		ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
		zfsvfs->z_unmounted = B_TRUE;
		ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
	}

	/*

bail:
	/* release the VOPs */
	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);

	if (err) {
		/*


	/* release the VOPs */
	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);

	/*
	 * Try to force unmount this file system.




}
#endif

static int
zfs_freebsd_lock(struct vop_lock1_args *ap)
{
	zfsvfs_t *zfsvfs;
	struct vnode *vp;
	int error, flags, type;

	vp = ap->a_vp;
	flags = ap->a_flags & LK_EATTR_MASK;
	type = ap->a_flags & LK_TYPE_MASK;
	zfsvfs = VTOZ(vp)->z_zfsvfs;

	KASSERT(type != LK_RELEASE && type != LK_DRAIN && type != LK_EXCLOTHER,
	    ("%s: invalid operation type %#x", __func__, type));

	if (type == LK_UPGRADE)
		ZFS_TEARDOWN_EXIT_READ(zfsvfs, NULL);

	error = vop_lock(ap);
	if (error != 0)
		return (error);

	if (!ZFS_TEARDOWN_WRITE_HELD(zfsvfs)) {
		switch (type) {
		case LK_DOWNGRADE:
			break;
		case LK_EXCLUSIVE:
		case LK_SHARED:
		case LK_UPGRADE:
			if ((flags & LK_NOWAIT) == 0) {
				ZFS_TEARDOWN_ENTER_READ(zfsvfs, NULL);
				break;
			}
			/* FALLTHROUGH */
		case LK_TRYUPGRADE:
			if (!ZFS_TEARDOWN_TRY_ENTER_READ(zfsvfs)) {
				/* XXXMJ coupled to vop_unlock impl */
				lockmgr_unlock(&vp->v_lock);
				return (EBUSY);
			}
			break;
		}
	}

	return (0);
}

/* XXXMJ can't release teardown lock before vnode lock */
static int
zfs_freebsd_unlock(struct vop_unlock_args *ap)
{
	zfsvfs_t *zfsvfs;
	struct vnode *vp;
	int error;

	vp = ap->a_vp;
	zfsvfs = VTOZ(ap->a_vp)->z_zfsvfs;
	error = vop_unlock(ap);
	if (!ZFS_TEARDOWN_WRITE_HELD(zfsvfs))
		ZFS_TEARDOWN_EXIT_READ(zfsvfs, NULL);
	return (error);
}

static int
zfs_freebsd_islocked(struct vop_islocked_args *ap)
{
	struct vnode *vp;
	int status;

	vp = ap->a_vp;
	status = vop_islocked(ap);
	if (status != 0)
		VNASSERT(ZFS_TEARDOWN_HELD(VTOZ(vp)->z_zfsvfs), vp,
		    ("teardown lock not held"));
	return (status);
}

struct vop_vector zfs_vnodeops;
struct vop_vector zfs_fifoops;
struct vop_vector zfs_shareops;

	.vop_putpages =		zfs_freebsd_putpages,
	.vop_vptocnp =		zfs_vptocnp,
#if __FreeBSD_version >= 1300064
	.vop_lock1 =		zfs_freebsd_lock,
	.vop_unlock =		zfs_freebsd_unlock,
	.vop_islocked =		zfs_freebsd_islocked,
#endif
};
VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);

Return to bug 258208

Lines 1405-1411 zfs_mount(vfs_t *vfsp) Link Here

(-)b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vfsops.c (-6 / +6 lines)
1405	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);	1405	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
1406	zfs_unregister_callbacks(zfsvfs);	1406	zfs_unregister_callbacks(zfsvfs);
1407	error = zfs_register_callbacks(vfsp);	1407	error = zfs_register_callbacks(vfsp);
1408	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);	1408	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
1409	goto out;	1409	goto out;
1410	}	1410	}
1411		1411
Lines 1587-1593 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting) Link Here
1587	*/	1587	*/
1588	if (!unmounting && (zfsvfs->z_unmounted \|\| zfsvfs->z_os == NULL)) {	1588	if (!unmounting && (zfsvfs->z_unmounted \|\| zfsvfs->z_os == NULL)) {
1589	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);	1589	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
1590	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);	1590	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
1591	return (SET_ERROR(EIO));	1591	return (SET_ERROR(EIO));
1592	}	1592	}
1593		1593
Lines 1615-1621 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting) Link Here
1615	if (unmounting) {	1615	if (unmounting) {
1616	zfsvfs->z_unmounted = B_TRUE;	1616	zfsvfs->z_unmounted = B_TRUE;
1617	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);	1617	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
1618	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);	1618	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
1619	}	1619	}
1620		1620
1621	/*	1621	/*
Lines 1677-1683 zfs_umount(vfs_t *vfsp, int fflag) Link Here
1677	*/	1677	*/
1678	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);	1678	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
1679	zfsvfs->z_unmounted = B_TRUE;	1679	zfsvfs->z_unmounted = B_TRUE;
1680	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);	1680	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
1681	}	1681	}
1682		1682
1683	/*	1683	/*
Lines 1976-1982 zfs_resume_fs(zfsvfs_t zfsvfs, dsl_dataset_t ds) Link Here
1976	bail:	1976	bail:
1977	/* release the VOPs */	1977	/* release the VOPs */
1978	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);	1978	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
1979	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);	1979	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
1980		1980
1981	if (err) {	1981	if (err) {
1982	/*	1982	/*
Lines 2109-2115 zfs_end_fs(zfsvfs_t zfsvfs, dsl_dataset_t ds) Link Here
2109		2109
2110	/* release the VOPs */	2110	/* release the VOPs */
2111	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);	2111	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
2112	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);	2112	ZFS_TEARDOWN_EXIT_WRITE(zfsvfs, FTAG);
2113		2113
2114	/*	2114	/*
2115	* Try to force unmount this file system.	2115	* Try to force unmount this file system.

Lines 6110-6115 zfs_deallocate(struct vop_deallocate_args *ap) Link Here

(-)b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c (-3 / +80 lines)
6110	}	6110	}
6111	#endif	6111	#endif
6112		6112
		6113	static int
		6114	zfs_freebsd_lock(struct vop_lock1_args *ap)
		6115	{
		6116	zfsvfs_t *zfsvfs;
		6117	struct vnode *vp;
		6118	int error, flags, type;
		6119
		6120	vp = ap->a_vp;
		6121	flags = ap->a_flags & LK_EATTR_MASK;
		6122	type = ap->a_flags & LK_TYPE_MASK;
		6123	zfsvfs = VTOZ(vp)->z_zfsvfs;
		6124
		6125	KASSERT(type != LK_RELEASE && type != LK_DRAIN && type != LK_EXCLOTHER,
		6126	("%s: invalid operation type %#x", __func__, type));
		6127
		6128	if (type == LK_UPGRADE)
		6129	ZFS_TEARDOWN_EXIT_READ(zfsvfs, NULL);
		6130
		6131	error = vop_lock(ap);
		6132	if (error != 0)
		6133	return (error);
		6134
		6135	if (!ZFS_TEARDOWN_WRITE_HELD(zfsvfs)) {
		6136	switch (type) {
		6137	case LK_DOWNGRADE:
		6138	break;
		6139	case LK_EXCLUSIVE:
		6140	case LK_SHARED:
		6141	case LK_UPGRADE:
		6142	if ((flags & LK_NOWAIT) == 0) {
		6143	ZFS_TEARDOWN_ENTER_READ(zfsvfs, NULL);
		6144	break;
		6145	}
		6146	/* FALLTHROUGH */
		6147	case LK_TRYUPGRADE:
		6148	if (!ZFS_TEARDOWN_TRY_ENTER_READ(zfsvfs)) {
		6149	/* XXXMJ coupled to vop_unlock impl */
		6150	lockmgr_unlock(&vp->v_lock);
		6151	return (EBUSY);
		6152	}
		6153	break;
		6154	}
		6155	}
		6156
		6157	return (0);
		6158	}
		6159
		6160	/* XXXMJ can't release teardown lock before vnode lock */
		6161	static int
		6162	zfs_freebsd_unlock(struct vop_unlock_args *ap)
		6163	{
		6164	zfsvfs_t *zfsvfs;
		6165	struct vnode *vp;
		6166	int error;
		6167
		6168	vp = ap->a_vp;
		6169	zfsvfs = VTOZ(ap->a_vp)->z_zfsvfs;
		6170	error = vop_unlock(ap);
		6171	if (!ZFS_TEARDOWN_WRITE_HELD(zfsvfs))
		6172	ZFS_TEARDOWN_EXIT_READ(zfsvfs, NULL);
		6173	return (error);
		6174	}
		6175
		6176	static int
6177	zfs_freebsd_islocked(struct vop_islocked_args *ap)
6178	{
6179	struct vnode *vp;
6180	int status;
6181
6182	vp = ap->a_vp;
6183	status = vop_islocked(ap);
6184	if (status != 0)
6185	VNASSERT(ZFS_TEARDOWN_HELD(VTOZ(vp)->z_zfsvfs), vp,
6186	("teardown lock not held"));
6187	return (status);
6188	}
6189
6113	struct vop_vector zfs_vnodeops;	6190	struct vop_vector zfs_vnodeops;
6114	struct vop_vector zfs_fifoops;	6191	struct vop_vector zfs_fifoops;
6115	struct vop_vector zfs_shareops;	6192	struct vop_vector zfs_shareops;
Lines 6166-6174 struct vop_vector zfs_vnodeops = { Link Here
6166	.vop_putpages = zfs_freebsd_putpages,	6243	.vop_putpages = zfs_freebsd_putpages,
6167	.vop_vptocnp = zfs_vptocnp,	6244	.vop_vptocnp = zfs_vptocnp,
6168	#if __FreeBSD_version >= 1300064	6245	#if __FreeBSD_version >= 1300064
6169	.vop_lock1 = vop_lock,	6246	.vop_lock1 = zfs_freebsd_lock,
6170	.vop_unlock = vop_unlock,	6247	.vop_unlock = zfs_freebsd_unlock,
6171	.vop_islocked = vop_islocked,	6248	.vop_islocked = zfs_freebsd_islocked,
6172	#endif	6249	#endif
6173	};	6250	};
6174	VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);	6251	VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);