 @@ -4862,1586 +4862,1586 @@ zfs_inactive(vnode_t *vp, cred_t *cr, ca
+	}
 	rw_exit(&zfsvfs->z_teardown_inactive_lock);
+}
 #ifdef __FreeBSD__
 CTASSERT(sizeof(struct zfid_short) <= sizeof(struct fid));
 CTASSERT(sizeof(struct zfid_long) <= sizeof(struct fid));
 #endif
 /*ARGSUSED*/
 static int
 zfs_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
+{
 	znode_t		*zp = VTOZ(vp);
 	zfsvfs_t	*zfsvfs = zp->z_zfsvfs;
 	uint32_t	gen;
 	uint64_t	gen64;
 	uint64_t	object = zp->z_id;
 	zfid_short_t	*zfid;
 	int		size, i, error;
 	ZFS_ENTER(zfsvfs);
 	ZFS_VERIFY_ZP(zp);
 	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs),
 	    &gen64, sizeof (uint64_t))) != 0) {
 		ZFS_EXIT(zfsvfs);
 		return (error);
+	}
 	gen = (uint32_t)gen64;
 	size = (zfsvfs->z_parent != zfsvfs) ? LONG_FID_LEN : SHORT_FID_LEN;
 #ifdef illumos
 	if (fidp->fid_len < size) {
 		fidp->fid_len = size;
 		ZFS_EXIT(zfsvfs);
 		return (SET_ERROR(ENOSPC));
+	}
 #else
 	fidp->fid_len = size;
 #endif
 	zfid = (zfid_short_t *)fidp;
 	zfid->zf_len = size;
 	for (i = 0; i < sizeof (zfid->zf_object); i++)
 		zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
 	/* Must have a non-zero generation number to distinguish from .zfs */
 	if (gen == 0)
 		gen = 1;
 	for (i = 0; i < sizeof (zfid->zf_gen); i++)
 		zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));
 	if (size == LONG_FID_LEN) {
 		uint64_t	objsetid = dmu_objset_id(zfsvfs->z_os);
 		zfid_long_t	*zlfid;
 		zlfid = (zfid_long_t *)fidp;
 		for (i = 0; i < sizeof (zlfid->zf_setid); i++)
 			zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i));
 		/* XXX - this should be the generation number for the objset */
 		for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
 			zlfid->zf_setgen[i] = 0;
+	}
 	ZFS_EXIT(zfsvfs);
 	return (0);
+}
 static int
 zfs_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
     caller_context_t *ct)
+{
 	znode_t		*zp, *xzp;
 	zfsvfs_t	*zfsvfs;
 	int		error;
 	switch (cmd) {
 	case _PC_LINK_MAX:
 		*valp = INT_MAX;
 		return (0);
 	case _PC_FILESIZEBITS:
 		*valp = 64;
 		return (0);
 #ifdef illumos
 	case _PC_XATTR_EXISTS:
 		zp = VTOZ(vp);
 		zfsvfs = zp->z_zfsvfs;
 		ZFS_ENTER(zfsvfs);
 		ZFS_VERIFY_ZP(zp);
 		*valp = 0;
 		error = zfs_dirent_lookup(zp, "", &xzp,
 		    ZXATTR | ZEXISTS | ZSHARED);
 		if (error == 0) {
 			if (!zfs_dirempty(xzp))
 				*valp = 1;
 			vrele(ZTOV(xzp));
 		} else if (error == ENOENT) {
 			/*
 			 * If there aren't extended attributes, it's the
 			 * same as having zero of them.
 			 */
 			error = 0;
+		}
 		ZFS_EXIT(zfsvfs);
 		return (error);
 	case _PC_SATTR_ENABLED:
 	case _PC_SATTR_EXISTS:
 		*valp = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) &&
 		    (vp->v_type == VREG || vp->v_type == VDIR);
 		return (0);
 	case _PC_ACCESS_FILTERING:
 		*valp = vfs_has_feature(vp->v_vfsp, VFSFT_ACCESS_FILTER) &&
 		    vp->v_type == VDIR;
 		return (0);
 	case _PC_ACL_ENABLED:
 		*valp = _ACL_ACE_ENABLED;
 		return (0);
 #endif	/* illumos */
 	case _PC_MIN_HOLE_SIZE:
 		*valp = (int)SPA_MINBLOCKSIZE;
 		return (0);
 #ifdef illumos
 	case _PC_TIMESTAMP_RESOLUTION:
 		/* nanosecond timestamp resolution */
 		*valp = 1L;
 		return (0);
 #endif
 	case _PC_ACL_EXTENDED:
 		*valp = 0;
 		return (0);
 #ifndef __NetBSD__
 	case _PC_ACL_NFS4:
 		*valp = 1;
 		return (0);
 	case _PC_ACL_PATH_MAX:
 		*valp = ACL_MAX_ENTRIES;
 		return (0);
 #endif
 	default:
 		return (EOPNOTSUPP);
+	}
+}
 /*ARGSUSED*/
 static int
 zfs_getsecattr(vnode_t *vp, vsecattr_t *vsecp, int flag, cred_t *cr,
     caller_context_t *ct)
+{
 	znode_t *zp = VTOZ(vp);
 	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
 	int error;
 	boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
 	ZFS_ENTER(zfsvfs);
 	ZFS_VERIFY_ZP(zp);
 	error = zfs_getacl(zp, vsecp, skipaclchk, cr);
 	ZFS_EXIT(zfsvfs);
 	return (error);
+}
 /*ARGSUSED*/
 int
 zfs_setsecattr(vnode_t *vp, vsecattr_t *vsecp, int flag, cred_t *cr,
     caller_context_t *ct)
+{
 	znode_t *zp = VTOZ(vp);
 	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
 	int error;
 	boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
 	zilog_t	*zilog = zfsvfs->z_log;
 	ZFS_ENTER(zfsvfs);
 	ZFS_VERIFY_ZP(zp);
 	error = zfs_setacl(zp, vsecp, skipaclchk, cr);
 	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
 		zil_commit(zilog, 0);
 	ZFS_EXIT(zfsvfs);
 	return (error);
+}
 static int
 ioflags(int ioflags)
+{
 	int flags = 0;
 	if (ioflags & IO_APPEND)
 		flags |= FAPPEND;
 	if (ioflags & IO_NDELAY)
 		flags |= FNONBLOCK;
 	if (ioflags & IO_SYNC)
 		flags |= (FSYNC | FDSYNC | FRSYNC);
 	return (flags);
+}
 #ifdef __NetBSD__
 static int
 zfs_netbsd_open(void *v)
+{
 	struct vop_open_args *ap = v;
 	return (zfs_open(&ap->a_vp, ap->a_mode, ap->a_cred, NULL));
+}
 static int
 zfs_netbsd_close(void *v)
+{
 	struct vop_close_args *ap = v;
 	return (zfs_close(ap->a_vp, ap->a_fflag, 0, 0, ap->a_cred, NULL));
+}
 static int
 zfs_netbsd_ioctl(void *v)
+{
 	struct vop_ioctl_args *ap = v;
 	return (zfs_ioctl(ap->a_vp, ap->a_command, (intptr_t)ap->a_data,
 		ap->a_fflag, ap->a_cred, NULL, NULL));
+}
 static int
 zfs_netbsd_read(void *v)
+{
 	struct vop_read_args *ap = v;
 	vnode_t *vp = ap->a_vp;
 	znode_t *zp = VTOZ(vp);
 	switch (vp->v_type) {
 	case VBLK:
 	case VCHR:
 		ZFS_ACCESSTIME_STAMP(zp->z_zfsvfs, zp);
 		return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
 	case VFIFO:
 		ZFS_ACCESSTIME_STAMP(zp->z_zfsvfs, zp);
 		return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
+	}
 	return (zfs_read(vp, ap->a_uio, ioflags(ap->a_ioflag), ap->a_cred, NULL));
+}
 static int
 zfs_netbsd_write(void *v)
+{
 	struct vop_write_args *ap = v;
 	vnode_t *vp = ap->a_vp;
 	znode_t *zp = VTOZ(vp);
 	struct uio *uio = ap->a_uio;
 	off_t osize = zp->z_size;
 	int error, resid;
 	switch (vp->v_type) {
 	case VBLK:
 	case VCHR:
 		GOP_MARKUPDATE(vp, GOP_UPDATE_MODIFIED);
 		return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
 	case VFIFO:
 		GOP_MARKUPDATE(vp, GOP_UPDATE_MODIFIED);
 		return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
+	}
 	resid = uio->uio_resid;
 	error = zfs_write(vp, uio, ioflags(ap->a_ioflag), ap->a_cred, NULL);
 	if (resid > uio->uio_resid)
 		VN_KNOTE(vp, NOTE_WRITE |
 		    (zp->z_size > osize ? NOTE_EXTEND : 0));
 	return error;
+}
 static int
 zfs_netbsd_access(void *v)
+{
 	struct vop_access_args /* {
 		struct vnode *a_vp;
 		int a_mode;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	int mode = ap->a_mode;
 	mode_t zfs_mode = 0;
 	kauth_cred_t cred = ap->a_cred;
 	int error;
 	/*
 	 * XXX This is really random, especially the left shift by six,
 	 * and it exists only because of randomness in zfs_unix_to_v4
 	 * and zfs_zaccess_rwx in zfs_acl.c.
 	 */
 	if (mode & VREAD)
 		zfs_mode |= S_IROTH;
 	if (mode & VWRITE)
 		zfs_mode |= S_IWOTH;
 	if (mode & VEXEC)
 		zfs_mode |= S_IXOTH;
 	zfs_mode <<= 6;
 	KASSERT(VOP_ISLOCKED(vp));
 	error = zfs_access(vp, zfs_mode, 0, cred, NULL);
 	/* We expect EACCES as common error. */
 	if (error == EPERM)
 		error = EACCES;
 	return (error);
+}
 static int
 zfs_netbsd_lookup(void *v)
+{
 	struct vop_lookup_v2_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode **vpp = ap->a_vpp;
 	struct componentname *cnp = ap->a_cnp;
 	char *nm, short_nm[31];
 	int error;
 	int iswhiteout;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	*vpp = NULL;
 	/*
 	 * Do an access check before the cache lookup.  zfs_lookup does
 	 * an access check too, but it's too scary to contemplate
 	 * injecting our namecache stuff into zfs internals.
+	 *
 	 * XXX Is this the correct access check?
 	 */
 	if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred)) != 0)
 		goto out;
 	/*
 	 * Check the namecache before entering zfs_lookup.
 	 * cache_lookup does the locking dance for us.
 	 */
 	if (cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
 	    cnp->cn_nameiop, cnp->cn_flags, &iswhiteout, vpp)) {
 		if (iswhiteout) {
 			cnp->cn_flags |= ISWHITEOUT;
+		}
 		return *vpp == NULL ? ENOENT : 0;
+	}
 	/*
 	 * zfs_lookup wants a null-terminated component name, but namei
 	 * gives us a pointer into the full pathname.
 	 */
 	ASSERT(cnp->cn_namelen < PATH_MAX - 1);
 	if (cnp->cn_namelen + 1 > sizeof(short_nm))
 		nm = PNBUF_GET();
 	else
 		nm = short_nm;
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	error = zfs_lookup(dvp, nm, vpp, 0, cnp, cnp->cn_nameiop, cnp->cn_cred);
 	if (nm != short_nm)
 		PNBUF_PUT(nm);
 	/*
 	 * Translate errors to match our namei insanity.  Also, if the
 	 * caller wants to create an entry here, it's apparently our
 	 * responsibility as lookup to make sure that's permissible.
 	 * Go figure.
 	 */
 	if (cnp->cn_flags & ISLASTCN) {
 		switch (cnp->cn_nameiop) {
 		case CREATE:
 		case RENAME:
 			if (error == ENOENT) {
 				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
 				if (error)
 					break;
 				error = EJUSTRETURN;
 				break;
+			}
 			break;
 		case DELETE:
 			if (error == 0) {
 				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
 				if (error) {
 					VN_RELE(*vpp);
 					*vpp = NULL;
+				}
+			}
 			break;
+		}
+	}
 	if (error) {
 		KASSERT(*vpp == NULL);
 		goto out;
+	}
 	KASSERT(*vpp != NULL);
 	if ((cnp->cn_namelen == 1) && (cnp->cn_nameptr[0] == '.')) {
 		KASSERT(!(cnp->cn_flags & ISDOTDOT));
 		KASSERT(dvp == *vpp);
 	} else if ((cnp->cn_namelen == 2) &&
 	    (cnp->cn_nameptr[0] == '.') &&
 	    (cnp->cn_nameptr[1] == '.')) {
 		KASSERT(cnp->cn_flags & ISDOTDOT);
 	} else {
 		KASSERT(!(cnp->cn_flags & ISDOTDOT));
+	}
 out:
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	/*
 	 * Insert name into cache if appropriate.
 	 */
 	if (error == 0 || (error == ENOENT && cnp->cn_nameiop != CREATE))
 		cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen,
 		    cnp->cn_flags);
 	return (error);
+}
 static int
 zfs_netbsd_create(void *v)
+{
 	struct vop_create_v3_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode **vpp = ap->a_vpp;
 	struct componentname *cnp = ap->a_cnp;
 	struct vattr *vap = ap->a_vap;
 	char *nm;
 	int mode;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	vattr_init_mask(vap);
 	mode = vap->va_mode & ALLPERMS;
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	/* XXX !EXCL is wrong here...  */
 	error = zfs_create(dvp, nm, vap, !EXCL, mode, vpp, cnp->cn_cred, NULL);
 	PNBUF_PUT(nm);
 	KASSERT((error == 0) == (*vpp != NULL));
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	if (error == 0)
 		VN_KNOTE(dvp, NOTE_WRITE);
 	if (*vpp != NULL)
 		VOP_UNLOCK(*vpp, 0);
 	return (error);
+}
 static int
 zfs_netbsd_mknod(void *v)
+{
 	struct vop_mknod_v3_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode **vpp = ap->a_vpp;
 	struct componentname *cnp = ap->a_cnp;
 	struct vattr *vap = ap->a_vap;
 	char *nm;
 	int mode;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	vattr_init_mask(vap);
 	mode = vap->va_mode & ALLPERMS;
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	/* XXX !EXCL is wrong here...  */
 	error = zfs_create(dvp, nm, vap, !EXCL, mode, vpp, cnp->cn_cred, NULL);
 	PNBUF_PUT(nm);
 	KASSERT((error == 0) == (*vpp != NULL));
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	if (error == 0)
 		VN_KNOTE(dvp, NOTE_WRITE);
 	if (*vpp != NULL)
 		VOP_UNLOCK(*vpp, 0);
 	return (error);
+}
 static int
 zfs_netbsd_remove(void *v)
+{
 	struct vop_remove_v2_args /* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode *vp = ap->a_vp;
 	struct componentname *cnp = ap->a_cnp;
 	char *nm;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	error = zfs_remove(dvp, vp, nm, cnp->cn_cred);
 	PNBUF_PUT(nm);
 	if (error == 0) {
 		VN_KNOTE(vp, NOTE_DELETE);
 		VN_KNOTE(dvp, NOTE_WRITE);
+	}
 	vput(vp);
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	return (error);
+}
 static int
 zfs_netbsd_mkdir(void *v)
+{
 	struct vop_mkdir_v3_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode **vpp = ap->a_vpp;
 	struct componentname *cnp = ap->a_cnp;
 	struct vattr *vap = ap->a_vap;
 	char *nm;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	vattr_init_mask(vap);
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	error = zfs_mkdir(dvp, nm, vap, vpp, cnp->cn_cred);
 	PNBUF_PUT(nm);
 	KASSERT((error == 0) == (*vpp != NULL));
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	if (error == 0)
 		VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
 	if (*vpp != NULL)
 		VOP_UNLOCK(*vpp, 0);
 	return (error);
+}
 static int
 zfs_netbsd_rmdir(void *v)
+{
 	struct vop_rmdir_v2_args /* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode *vp = ap->a_vp;
 	struct componentname *cnp = ap->a_cnp;
 	char *nm;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	error = zfs_rmdir(dvp, vp, nm, cnp->cn_cred);
 	PNBUF_PUT(nm);
 	if (error == 0) {
 		VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
 		VN_KNOTE(vp, NOTE_DELETE);
+	}
 	vput(vp);
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	return error;
+}
 static int
 zfs_netbsd_readdir(void *v)
+{
 	struct vop_readdir_args *ap = v;
 	return (zfs_readdir(ap->a_vp, ap->a_uio, ap->a_cred, ap->a_eofflag,
 		ap->a_ncookies, ap->a_cookies));
+}
 static int
 zfs_netbsd_fsync(void *v)
+{
 	struct vop_fsync_args *ap = v;
 	return (zfs_fsync(ap->a_vp, ap->a_flags, ap->a_cred, NULL));
+}
 static int
 zfs_spec_fsync(void *v)
+{
 	struct vop_fsync_args *ap = v;
 	int error;
 	error = spec_fsync(v);
 	if (error)
 		return error;
 	return (zfs_fsync(ap->a_vp, ap->a_flags, ap->a_cred, NULL));
+}
 static int
 zfs_netbsd_getattr(void *v)
+{
 	struct vop_getattr_args *ap = v;
 	vattr_t *vap = ap->a_vap;
 	xvattr_t xvap;
 	u_long fflags = 0;
 	int error;
 	xva_init(&xvap);
 	xvap.xva_vattr = *vap;
 	xvap.xva_vattr.va_mask |= AT_XVATTR;
 	/* Convert chflags into ZFS-type flags. */
 	/* XXX: what about SF_SETTABLE?. */
 	XVA_SET_REQ(&xvap, XAT_IMMUTABLE);
 	XVA_SET_REQ(&xvap, XAT_APPENDONLY);
 	XVA_SET_REQ(&xvap, XAT_NOUNLINK);
 	XVA_SET_REQ(&xvap, XAT_NODUMP);
 	error = zfs_getattr(ap->a_vp, (vattr_t *)&xvap, 0, ap->a_cred, NULL);
 	if (error != 0)
 		return (error);
 	/* Convert ZFS xattr into chflags. */
 #define	FLAG_CHECK(fflag, xflag, xfield)	do {			\
 	if (XVA_ISSET_RTN(&xvap, (xflag)) && (xfield) != 0)		\
 		fflags |= (fflag);					\
 } while (0)
 	FLAG_CHECK(SF_IMMUTABLE, XAT_IMMUTABLE,
 	    xvap.xva_xoptattrs.xoa_immutable);
 	FLAG_CHECK(SF_APPEND, XAT_APPENDONLY,
 	    xvap.xva_xoptattrs.xoa_appendonly);
 	FLAG_CHECK(SF_NOUNLINK, XAT_NOUNLINK,
 	    xvap.xva_xoptattrs.xoa_nounlink);
 	FLAG_CHECK(UF_NODUMP, XAT_NODUMP,
 	    xvap.xva_xoptattrs.xoa_nodump);
 #undef	FLAG_CHECK
 	*vap = xvap.xva_vattr;
 	vap->va_flags = fflags;
 	return (0);
+}
 static int
 zfs_netbsd_setattr(void *v)
+{
 	struct vop_setattr_args *ap = v;
 	vnode_t *vp = ap->a_vp;
 	vattr_t *vap = ap->a_vap;
 	cred_t *cred = ap->a_cred;
 	znode_t *zp = VTOZ(vp);
 	xvattr_t xvap;
 	kauth_action_t action;
 	u_long fflags, sfflags = 0;
 	uint64_t zflags;
 	int error, flags = 0;
 	bool changing_sysflags;
 	vattr_init_mask(vap);
 	vap->va_mask &= ~AT_NOSET;
 	if (ISSET(vap->va_vaflags, VA_UTIMES_NULL))
 		flags |= ATTR_UTIME;
 	xva_init(&xvap);
 	xvap.xva_vattr = *vap;
 	zflags = VTOZ(vp)->z_pflags;
 	/* Ignore size changes on device nodes. */
 	if (vp->v_type == VBLK || vp->v_type == VCHR)
 		xvap.xva_vattr.va_mask &= ~AT_SIZE;
 	if (vap->va_flags != VNOVAL) {
 		int error;
 		fflags = vap->va_flags;
 		if ((fflags & ~(SF_IMMUTABLE|SF_APPEND|SF_NOUNLINK|UF_NODUMP)) != 0)
 			return (EOPNOTSUPP);
 #define	FLAG_CHANGE(fflag, zflag, xflag, xfield)	do {		\
 	if (((fflags & (fflag)) && !(zflags & (zflag))) ||		\
 	    ((zflags & (zflag)) && !(fflags & (fflag)))) {		\
 		XVA_SET_REQ(&xvap, (xflag));				\
 		(xfield) = ((fflags & (fflag)) != 0);			\
 		if (((fflag) & SF_SETTABLE) != 0)			\
 			sfflags |= (fflag);				\
 	}								\
 } while (0)
 		/* Convert chflags into ZFS-type flags. */
 		/* XXX: what about SF_SETTABLE?. */
 		FLAG_CHANGE(SF_IMMUTABLE, ZFS_IMMUTABLE, XAT_IMMUTABLE,
 		    xvap.xva_xoptattrs.xoa_immutable);
 		FLAG_CHANGE(SF_APPEND, ZFS_APPENDONLY, XAT_APPENDONLY,
 		    xvap.xva_xoptattrs.xoa_appendonly);
 		FLAG_CHANGE(SF_NOUNLINK, ZFS_NOUNLINK, XAT_NOUNLINK,
 		    xvap.xva_xoptattrs.xoa_nounlink);
 		FLAG_CHANGE(UF_NODUMP, ZFS_NODUMP, XAT_NODUMP,
 		    xvap.xva_xoptattrs.xoa_nodump);
 #undef	FLAG_CHANGE
 		action = KAUTH_VNODE_WRITE_FLAGS;
 		changing_sysflags = false;
 		if (zflags & (ZFS_IMMUTABLE|ZFS_APPENDONLY|ZFS_NOUNLINK)) {
 			action |= KAUTH_VNODE_HAS_SYSFLAGS;
+		}
 		if (sfflags != 0) {
 			action |= KAUTH_VNODE_WRITE_SYSFLAGS;
 			changing_sysflags = true;
+		}
 		error = kauth_authorize_vnode(cred, action, vp, NULL,
 		    genfs_can_chflags(cred, vp->v_type, zp->z_uid,
 		    changing_sysflags));
 		if (error)
 			return error;
+	}
 	if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL ||
 	    vap->va_birthtime.tv_sec != VNOVAL) {
 		error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
 		     NULL, genfs_can_chtimes(vp, vap->va_vaflags, zp->z_uid,
 		     cred));
 		if (error)
 			return error;
+	}
 	error = zfs_setattr(vp, (vattr_t *)&xvap, flags, cred, NULL);
 	if (error == 0)
 		VN_KNOTE(vp, NOTE_ATTRIB);
 	return error;
+}
 static int
 zfs_netbsd_rename(void *v)
+{
 	struct vop_rename_args  /* {
 		struct vnode *a_fdvp;
 		struct vnode *a_fvp;
 		struct componentname *a_fcnp;
 		struct vnode *a_tdvp;
 		struct vnode *a_tvp;
 		struct componentname *a_tcnp;
 	} */ *ap = v;
 	vnode_t *fdvp = ap->a_fdvp;
 	vnode_t *fvp = ap->a_fvp;
 	struct componentname *fcnp = ap->a_fcnp;
 	vnode_t *tdvp = ap->a_tdvp;
 	vnode_t *tvp = ap->a_tvp;
 	struct componentname *tcnp = ap->a_tcnp;
 	kauth_cred_t cred;
 	int error;
 	KASSERT(VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE);
 	KASSERT(tvp == NULL || VOP_ISLOCKED(tvp) == LK_EXCLUSIVE);
 	KASSERT(fdvp->v_type == VDIR);
 	KASSERT(tdvp->v_type == VDIR);
 	cred = fcnp->cn_cred;
 	/*
 	 * XXX Want a better equality test.  `tcnp->cn_cred == cred'
 	 * hoses p2k because puffs transmits the creds separately and
 	 * allocates distinct but equivalent structures for them.
 	 */
 	KASSERT(kauth_cred_uidmatch(cred, tcnp->cn_cred));
 	/*
 	 * Drop the insane locks.
 	 */
 	VOP_UNLOCK(tdvp, 0);
 	if (tvp != NULL && tvp != tdvp)
 		VOP_UNLOCK(tvp, 0);
 	/*
 	 * Release the source and target nodes; zfs_rename will look
 	 * them up again once the locking situation is sane.
 	 */
 	VN_RELE(fvp);
 	if (tvp != NULL)
 		VN_RELE(tvp);
 	fvp = NULL;
 	tvp = NULL;
 	/*
 	 * Do the rename ZFSly.
 	 */
 	error = zfs_rename(fdvp, &fvp, fcnp, tdvp, &tvp, tcnp, cred);
 	/*
 	 * Release the directories now too, because the VOP_RENAME
 	 * protocol is insane.
 	 */
 	VN_RELE(fdvp);
 	VN_RELE(tdvp);
 	if (fvp != NULL)
 		VN_RELE(fvp);
 	if (tvp != NULL)
 		VN_RELE(tvp);
 	return (error);
+}
 static int
 zfs_netbsd_symlink(void *v)
+{
 	struct vop_symlink_v3_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 		char *a_target;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode **vpp = ap->a_vpp;
 	struct componentname *cnp = ap->a_cnp;
 	struct vattr *vap = ap->a_vap;
 	char *target = ap->a_target;
 	char *nm;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	vap->va_type = VLNK;	/* Netbsd: Syscall only sets va_mode. */
 	vattr_init_mask(vap);
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	error = zfs_symlink(dvp, vpp, nm, vap, target, cnp->cn_cred, 0);
 	PNBUF_PUT(nm);
 	if (error == 0)
 		VN_KNOTE(ap->a_dvp, NOTE_WRITE);
 	KASSERT((error == 0) == (*vpp != NULL));
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	if (*vpp != NULL)
 		VOP_UNLOCK(*vpp, 0);
 	return (error);
+}
 static int
 zfs_netbsd_readlink(void *v)
+{
 	struct vop_readlink_args *ap = v;
 	return (zfs_readlink(ap->a_vp, ap->a_uio, ap->a_cred, NULL));
+}
 static int
 zfs_netbsd_link(void *v)
+{
 	struct vop_link_v2_args /* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *dvp = ap->a_dvp;
 	struct vnode *vp = ap->a_vp;
 	struct componentname *cnp = ap->a_cnp;
 	char *nm;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE);
 	/* ZFS wants a null-terminated name. */
 	nm = PNBUF_GET();
 	(void)strlcpy(nm, cnp->cn_nameptr, cnp->cn_namelen + 1);
 	vn_lock(vp, LK_EXCLUSIVE);
 	error = zfs_link(dvp, vp, nm, cnp->cn_cred,
 	    NULL, 0);
 	PNBUF_PUT(nm);
 	if (error == 0) {
 		VN_KNOTE(vp, NOTE_LINK);
 		VN_KNOTE(dvp, NOTE_WRITE);
+	}
 	VOP_UNLOCK(vp, 0);
 	return error;
+}
 static int
 zfs_netbsd_inactive(void *v)
+{
 	struct vop_inactive_v2_args *ap = v;
 	vnode_t *vp = ap->a_vp;
 	znode_t	*zp = VTOZ(vp);
 	/*
 	 * NetBSD: nothing to do here, other than indicate if the
 	 * vnode should be reclaimed.  No need to lock, if we race
 	 * vrele() will call us again.
 	 */
 	*ap->a_recycle = (zp->z_unlinked != 0);
 	return (0);
+}
 static int
 zfs_netbsd_reclaim(void *v)
+{
 	struct vop_reclaim_v2_args /* {
 		struct vnode *a_vp;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	znode_t	*zp;
 	zfsvfs_t *zfsvfs;
 	int error;
 	VOP_UNLOCK(vp, 0);
 	zp = VTOZ(vp);
 	zfsvfs = zp->z_zfsvfs;
 	KASSERTMSG(!vn_has_cached_data(vp), "vp %p", vp);
 	rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_READER);
 	/*
 	 * Process a deferred atime update.
 	 */
 	if (zp->z_atime_dirty && zp->z_unlinked == 0 && zp->z_sa_hdl != NULL) {
 		dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);
 		dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
 		zfs_sa_upgrade_txholds(tx, zp);
 		error = dmu_tx_assign(tx, TXG_WAIT);
 		if (error) {
 			dmu_tx_abort(tx);
 		} else {
 			(void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zfsvfs),
 			    (void *)&zp->z_atime, sizeof (zp->z_atime), tx);
 			zp->z_atime_dirty = 0;
 			dmu_tx_commit(tx);
+		}
-	if (zfsvfs->z_log)
+		if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
-		zil_commit(zfsvfs->z_log, zp->z_id);
+			zil_commit(zfsvfs->z_log, zp->z_id);
+	}
 	if (zp->z_sa_hdl == NULL)
 		zfs_znode_free(zp);
 	else
 		zfs_zinactive(zp);
 	rw_exit(&zfsvfs->z_teardown_inactive_lock);
 	return 0;
+}
 static int
 zfs_netbsd_fid(void *v)
+{
 	struct vop_fid_args *ap = v;
 	return (zfs_fid(ap->a_vp, (void *)ap->a_fid, NULL));
+}
 static int
 zfs_netbsd_pathconf(void *v)
+{
 	struct vop_pathconf_args *ap = v;
 	ulong_t val;
 	int error;
 	error = zfs_pathconf(ap->a_vp, ap->a_name, &val, curthread->l_cred, NULL);
 	if (error == 0)
 		*ap->a_retval = val;
 	else if (error == EOPNOTSUPP) {
 		switch (ap->a_name) {
 		case _PC_NAME_MAX:
 			*ap->a_retval = NAME_MAX;
 			return (0);
 		case _PC_PATH_MAX:
 			*ap->a_retval = PATH_MAX;
 			return (0);
 		case _PC_LINK_MAX:
 			*ap->a_retval = LINK_MAX;
 			return (0);
 		case _PC_MAX_CANON:
 			*ap->a_retval = MAX_CANON;
 			return (0);
 		case _PC_MAX_INPUT:
 			*ap->a_retval = MAX_INPUT;
 			return (0);
 		case _PC_PIPE_BUF:
 			*ap->a_retval = PIPE_BUF;
 			return (0);
 		case _PC_CHOWN_RESTRICTED:
 			*ap->a_retval = 1;
 			return (0);
 		case _PC_NO_TRUNC:
 			*ap->a_retval = 1;
 			return (0);
 		case _PC_VDISABLE:
 			*ap->a_retval = _POSIX_VDISABLE;
 			return (0);
 		default:
 			return (EINVAL);
+		}
 		/* NOTREACHED */
+	}
 	return (error);
+}
 static int
 zfs_netbsd_advlock(void *v)
+{
 	struct vop_advlock_args /* {
 		struct vnode *a_vp;
 		void *a_id;
 		int a_op;
 		struct flock *a_fl;
 		int a_flags;
 	} */ *ap = v;
 	struct vnode *vp;
 	struct znode *zp;
 	struct zfsvfs *zfsvfs;
 	int error;
 	vp = ap->a_vp;
 	zp = VTOZ(vp);
 	zfsvfs = zp->z_zfsvfs;
 	ZFS_ENTER(zfsvfs);
 	ZFS_VERIFY_ZP(zp);
 	error = lf_advlock(ap, &zp->z_lockf, zp->z_size);
 	ZFS_EXIT(zfsvfs);
 	return error;
+}
 static int
 zfs_netbsd_getpages(void *v)
+{
 	struct vop_getpages_args /* {
 		struct vnode *a_vp;
 		voff_t a_offset;
 		struct vm_page **a_m;
 		int *a_count;
 		int a_centeridx;
 		vm_prot_t a_access_type;
 		int a_advice;
 		int a_flags;
 	} */ * const ap = v;
 	vnode_t *const vp = ap->a_vp;
 	off_t offset = ap->a_offset + (ap->a_centeridx << PAGE_SHIFT);
 	const int flags = ap->a_flags;
 	const bool async = (flags & PGO_SYNCIO) == 0;
 	const bool memwrite = (ap->a_access_type & VM_PROT_WRITE) != 0;
 	struct uvm_object * const uobj = &vp->v_uobj;
 	krwlock_t * const rw = uobj->vmobjlock;
 	znode_t *zp = VTOZ(vp);
 	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
 	vfs_t *mp;
 	struct vm_page *pg;
 	caddr_t va;
 	int npages, found, err = 0;
 	if (flags & PGO_LOCKED) {
 		*ap->a_count = 0;
 		ap->a_m[ap->a_centeridx] = NULL;
 		return EBUSY;
+	}
 	rw_exit(rw);
 	if (async) {
 		return 0;
+	}
 	if (*ap->a_count != 1) {
 		return EBUSY;
+	}
 	mp = vp->v_mount;
 	fstrans_start(mp);
 	if (vp->v_mount != mp) {
 		fstrans_done(mp);
 		return ENOENT;
+	}
 	ZFS_ENTER(zfsvfs);
 	ZFS_VERIFY_ZP(zp);
 	rw_enter(rw, RW_WRITER);
 	if (offset >= vp->v_size) {
 		rw_exit(rw);
 		ZFS_EXIT(zfsvfs);
 		fstrans_done(mp);
 		return EINVAL;
+	}
 	npages = 1;
 	pg = NULL;
 	uvn_findpages(uobj, offset, &npages, &pg, NULL, UFP_ALL);
 	if (pg->flags & PG_FAKE) {
 		rw_exit(rw);
 		va = zfs_map_page(pg, S_WRITE);
 		err = dmu_read(zfsvfs->z_os, zp->z_id, offset, PAGE_SIZE,
 		    va, DMU_READ_PREFETCH);
 		zfs_unmap_page(pg, va);
 		rw_enter(rw, RW_WRITER);
 		pg->flags &= ~(PG_FAKE);
+	}
 	if (memwrite) {
 		if (uvm_pagegetdirty(pg) == UVM_PAGE_STATUS_CLEAN) {
 			/* For write faults, start dirtiness tracking. */
 			uvm_pagemarkdirty(pg, UVM_PAGE_STATUS_UNKNOWN);
+		}
 		mutex_enter(vp->v_interlock);
 		if ((vp->v_iflag & VI_ONWORKLST) == 0) {
 			vn_syncer_add_to_worklist(vp, filedelay);
+		}
 		if ((vp->v_iflag & (VI_WRMAP|VI_WRMAPDIRTY)) == VI_WRMAP) {
 			vp->v_iflag |= VI_WRMAPDIRTY;
+		}
 		mutex_exit(vp->v_interlock);
+	}
 	rw_exit(rw);
 	ap->a_m[ap->a_centeridx] = pg;
 	ZFS_EXIT(zfsvfs);
 	fstrans_done(mp);
 	return (err);
+}
 static int
 zfs_putapage(vnode_t *vp, page_t **pp, int count, int flags)
+{
 	znode_t		*zp = VTOZ(vp);
 	zfsvfs_t	*zfsvfs = zp->z_zfsvfs;
 	dmu_tx_t	*tx;
 	voff_t		off, koff;
 	voff_t		len, klen;
 	int		err;
 	bool async = (flags & PGO_SYNCIO) == 0;
 	bool *cleanedp;
 	struct uvm_object *uobj = &vp->v_uobj;
 	krwlock_t *rw = uobj->vmobjlock;
 	if (zp->z_sa_hdl == NULL) {
 		err = 0;
 		goto out_unbusy;
+	}
 	off = pp[0]->offset;
 	len = count * PAGESIZE;
 	KASSERT(off + len <= round_page(zp->z_size));
 	if (zfs_owner_overquota(zfsvfs, zp, B_FALSE) ||
 	    zfs_owner_overquota(zfsvfs, zp, B_TRUE)) {
 		err = SET_ERROR(EDQUOT);
 		goto out;
+	}
 	tx = dmu_tx_create(zfsvfs->z_os);
 	dmu_tx_hold_write(tx, zp->z_id, off, len);
 	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
 	zfs_sa_upgrade_txholds(tx, zp);
 	err = dmu_tx_assign(tx, TXG_WAIT);
 	if (err != 0) {
 		dmu_tx_abort(tx);
 		goto out;
+	}
 	if (zp->z_blksz <= PAGESIZE) {
 		KASSERTMSG(count == 1, "vp %p pp %p count %d", vp, pp, count);
 		caddr_t va = zfs_map_page(*pp, S_READ);
 		ASSERT3U(len, <=, PAGESIZE);
 		dmu_write(zfsvfs->z_os, zp->z_id, off, len, va, tx);
 		zfs_unmap_page(*pp, va);
 	} else {
 		err = dmu_write_pages(zfsvfs->z_os, zp->z_id, off, len, pp, tx);
+	}
 	cleanedp = tsd_get(zfs_putpage_key);
 	*cleanedp = true;
 	if (err == 0) {
 		uint64_t mtime[2], ctime[2];
 		sa_bulk_attr_t bulk[3];
 		int count = 0;
 		SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
 		    &mtime, 16);
 		SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
 		    &ctime, 16);
 		SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
 		    &zp->z_pflags, 8);
 		zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime,
 		    B_TRUE);
 		err = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
 		ASSERT0(err);
 		zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, off, len, 0);
+	}
 	dmu_tx_commit(tx);
 out_unbusy:
 	rw_enter(rw, RW_WRITER);
 	uvm_page_unbusy(pp, count);
 	rw_exit(rw);
 out:
 	return (err);
+}
 static void
 zfs_netbsd_gop_markupdate(vnode_t *vp, int flags)
+{
 	znode_t		*zp = VTOZ(vp);
 	zfsvfs_t	*zfsvfs = zp->z_zfsvfs;
 	dmu_tx_t	*tx;
 	sa_bulk_attr_t	bulk[2];
 	uint64_t	mtime[2], ctime[2];
 	int		count = 0, err;
 	KASSERT(flags == GOP_UPDATE_MODIFIED);
 	tx = dmu_tx_create(zfsvfs->z_os);
 	err = dmu_tx_assign(tx, TXG_WAIT);
 	if (err != 0) {
 		dmu_tx_abort(tx);
 		return;
+	}
 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);
 	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
 	dmu_tx_commit(tx);
+}
 static int
 zfs_netbsd_putpages(void *v)
+{
 	struct vop_putpages_args /* {
 		struct vnode *a_vp;
 		voff_t a_offlo;
 		voff_t a_offhi;
 		int a_flags;
 	} */ * const ap = v;
 	struct vnode *vp = ap->a_vp;
 	voff_t offlo = ap->a_offlo;
 	voff_t offhi = ap->a_offhi;
 	int flags = ap->a_flags;
 	znode_t *zp = VTOZ(vp);
 	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
 	rl_t *rl = NULL;
 	uint64_t len;
 	int error;
 	bool cleaned = false;
 	bool async = (flags & PGO_SYNCIO) == 0;
 	bool cleaning = (flags & PGO_CLEANIT) != 0;
 	if (cleaning) {
 		ASSERT((offlo & PAGE_MASK) == 0 && (offhi & PAGE_MASK) == 0);
 		ASSERT(offlo < offhi || offhi == 0);
 		if (offhi == 0)
 			len = UINT64_MAX;
 		else
 			len = offhi - offlo;
 		rw_exit(vp->v_uobj.vmobjlock);
 		if (curlwp == uvm.pagedaemon_lwp) {
 			error = fstrans_start_nowait(vp->v_mount);
 			if (error)
 				return error;
 		} else {
 			vfs_t *mp = vp->v_mount;
 			fstrans_start(mp);
 			if (vp->v_mount != mp) {
 				fstrans_done(mp);
 				ASSERT(!vn_has_cached_data(vp));
 				return 0;
+			}
+		}
 		/*
 		 * Cannot use ZFS_ENTER() here as it returns with error
 		 * if z_unmounted.  The next statement is equivalent.
 		 */
 		rrm_enter(&zfsvfs->z_teardown_lock, RW_READER, FTAG);
 		rl = zfs_range_lock(zp, offlo, len, RL_WRITER);
 		rw_enter(vp->v_uobj.vmobjlock, RW_WRITER);
 		tsd_set(zfs_putpage_key, &cleaned);
+	}
 	error = genfs_putpages(v);
 	if (cleaning) {
 		tsd_set(zfs_putpage_key, NULL);
 		zfs_range_unlock(rl);
 		/*
 		 * Only zil_commit() if we cleaned something.  This avoids
 		 * deadlock if we're called from zfs_netbsd_setsize().
 		 */
 		if (cleaned)
 		if (!async || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
 			zil_commit(zfsvfs->z_log, zp->z_id);
 		ZFS_EXIT(zfsvfs);
 		fstrans_done(vp->v_mount);
+	}
 	return error;
+}
 /*
  * Restrict the putpages range to the ZFS block containing the offset.
  */
 static void
 zfs_netbsd_gop_putrange(struct vnode *vp, off_t off, off_t *lop, off_t *hip)
+{
 	znode_t *zp = VTOZ(vp);
 	*lop = trunc_page(rounddown2(off, zp->z_blksz));
 	*hip = round_page(*lop + zp->z_blksz);
+}
 void
 zfs_netbsd_setsize(vnode_t *vp, off_t size)
+{
 	struct uvm_object *uobj = &vp->v_uobj;
 	krwlock_t *rw = uobj->vmobjlock;
 	page_t *pg;
 	int count, pgoff;
 	caddr_t va;
 	off_t tsize;
 	uvm_vnp_setsize(vp, size);
 	if (!vn_has_cached_data(vp))
 		return;
 	tsize = trunc_page(size);
 	if (tsize == size)
 		return;
 	/*
 	 * If there's a partial page, we need to zero the tail.
 	 */
 	rw_enter(rw, RW_WRITER);
 	count = 1;
 	pg = NULL;
 	if (uvn_findpages(uobj, tsize, &count, &pg, NULL, UFP_NOALLOC)) {
 		va = zfs_map_page(pg, S_WRITE);
 		pgoff = size - tsize;
 		memset(va + pgoff, 0, PAGESIZE - pgoff);
 		zfs_unmap_page(pg, va);
 		uvm_page_unbusy(&pg, 1);
+	}
 	rw_exit(rw);
+}
 static int
 zfs_netbsd_print(void *v)
+{
 	struct vop_print_args /* {
 		struct vnode	*a_vp;
 	} */ *ap = v;
 	vnode_t	*vp;
 	znode_t	*zp;
 	vp = ap->a_vp;
 	zp = VTOZ(vp);
 	printf("\tino %" PRIu64 " size %" PRIu64 "\n",
 	       zp->z_id, zp->z_size);
 	return 0;
+}
 const struct genfs_ops zfs_genfsops = {
         .gop_write = zfs_putapage,
 	.gop_markupdate = zfs_netbsd_gop_markupdate,
 	.gop_putrange = zfs_netbsd_gop_putrange,
 };
 #define	zfs_netbsd_lock		genfs_lock
 #define	zfs_netbsd_unlock	genfs_unlock
 #define	zfs_netbsd_islocked	genfs_islocked
 #define zfs_netbsd_seek		genfs_seek
 #define zfs_netbsd_mmap		genfs_mmap
 #define zfs_netbsd_fcntl	genfs_fcntl
 int (**zfs_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc zfs_vnodeop_entries[] = {
 	{ &vop_default_desc,		vn_default_error },
 	{ &vop_lookup_desc,		zfs_netbsd_lookup },
 	{ &vop_create_desc,		zfs_netbsd_create },
 	{ &vop_mknod_desc,		zfs_netbsd_mknod },
 	{ &vop_open_desc,		zfs_netbsd_open },
 	{ &vop_close_desc,		zfs_netbsd_close },
 	{ &vop_access_desc,		zfs_netbsd_access },
 	{ &vop_getattr_desc,		zfs_netbsd_getattr },
 	{ &vop_setattr_desc,		zfs_netbsd_setattr },
 	{ &vop_read_desc,		zfs_netbsd_read },
 	{ &vop_write_desc,		zfs_netbsd_write },
 	{ &vop_ioctl_desc,		zfs_netbsd_ioctl },
 	{ &vop_poll_desc,		genfs_poll },
 	{ &vop_kqfilter_desc,		genfs_kqfilter },
 	{ &vop_revoke_desc,		genfs_revoke },
 	{ &vop_fsync_desc,		zfs_netbsd_fsync },
 	{ &vop_remove_desc,		zfs_netbsd_remove },
 	{ &vop_link_desc,		zfs_netbsd_link },
 	{ &vop_lock_desc,		zfs_netbsd_lock },
 	{ &vop_unlock_desc,		zfs_netbsd_unlock },
 	{ &vop_rename_desc,		zfs_netbsd_rename },
 	{ &vop_mkdir_desc,		zfs_netbsd_mkdir },
 	{ &vop_rmdir_desc,		zfs_netbsd_rmdir },
 	{ &vop_symlink_desc,		zfs_netbsd_symlink },
 	{ &vop_readdir_desc,		zfs_netbsd_readdir },
 	{ &vop_readlink_desc,		zfs_netbsd_readlink },
 	{ &vop_inactive_desc,		zfs_netbsd_inactive },
 	{ &vop_reclaim_desc,		zfs_netbsd_reclaim },
 	{ &vop_pathconf_desc,		zfs_netbsd_pathconf },
 	{ &vop_seek_desc,		zfs_netbsd_seek },
 	{ &vop_getpages_desc,		zfs_netbsd_getpages },
 	{ &vop_putpages_desc,		zfs_netbsd_putpages },
 	{ &vop_mmap_desc,		zfs_netbsd_mmap },
 	{ &vop_islocked_desc,		zfs_netbsd_islocked },
 	{ &vop_advlock_desc,		zfs_netbsd_advlock },
 	{ &vop_print_desc,		zfs_netbsd_print },
 	{ &vop_fcntl_desc,		zfs_netbsd_fcntl },
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc zfs_vnodeop_opv_desc =
 	{ &zfs_vnodeop_p, zfs_vnodeop_entries };
 int (**zfs_specop_p)(void *);
 const struct vnodeopv_entry_desc zfs_specop_entries[] = {
 	{ &vop_default_desc,		vn_default_error },
 	{ &vop_lookup_desc,		spec_lookup },
 	{ &vop_create_desc,		spec_create },
 	{ &vop_mknod_desc,		spec_mknod },
 	{ &vop_open_desc,		spec_open },
 	{ &vop_close_desc,		spec_close },
 	{ &vop_access_desc,		zfs_netbsd_access },
 	{ &vop_getattr_desc,		zfs_netbsd_getattr },
 	{ &vop_setattr_desc,		zfs_netbsd_setattr },
 	{ &vop_read_desc,		/**/zfs_netbsd_read },
 	{ &vop_write_desc,		/**/zfs_netbsd_write },
 	{ &vop_ioctl_desc,		spec_ioctl },
 	{ &vop_poll_desc,		spec_poll },
 	{ &vop_kqfilter_desc,		spec_kqfilter },
 	{ &vop_revoke_desc,		spec_revoke },
 	{ &vop_fsync_desc,		zfs_spec_fsync },
 	{ &vop_remove_desc,		spec_remove },
 	{ &vop_link_desc,		spec_link },
 	{ &vop_lock_desc,		zfs_netbsd_lock },
 	{ &vop_unlock_desc,		zfs_netbsd_unlock },
 	{ &vop_rename_desc,		spec_rename },
 	{ &vop_mkdir_desc,		spec_mkdir },
 	{ &vop_rmdir_desc,		spec_rmdir },
 	{ &vop_symlink_desc,		spec_symlink },
 	{ &vop_readdir_desc,		spec_readdir },
 	{ &vop_readlink_desc,		spec_readlink },
 	{ &vop_inactive_desc,		zfs_netbsd_inactive },
 	{ &vop_reclaim_desc,		zfs_netbsd_reclaim },
 	{ &vop_pathconf_desc,		spec_pathconf },
 	{ &vop_seek_desc,		spec_seek },
 	{ &vop_getpages_desc,		spec_getpages },
 	{ &vop_putpages_desc,		spec_putpages },
 	{ &vop_mmap_desc,		spec_mmap },
 	{ &vop_islocked_desc,		zfs_netbsd_islocked },
 	{ &vop_advlock_desc,		spec_advlock },
 	{ &vop_strategy_desc,		spec_strategy },
 	{ &vop_bwrite_desc,		spec_bwrite },
 	{ &vop_print_desc,		zfs_netbsd_print },
 	{ &vop_fcntl_desc,		zfs_netbsd_fcntl },
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc zfs_specop_opv_desc =
 	{ &zfs_specop_p, zfs_specop_entries };
 int (**zfs_fifoop_p)(void *);
 const struct vnodeopv_entry_desc zfs_fifoop_entries[] = {
 	{ &vop_default_desc,		vn_default_error },
 	{ &vop_lookup_desc,		vn_fifo_bypass },
 	{ &vop_create_desc,		vn_fifo_bypass },
 	{ &vop_mknod_desc,		vn_fifo_bypass },
 	{ &vop_open_desc,		vn_fifo_bypass },
 	{ &vop_close_desc,		vn_fifo_bypass },
 	{ &vop_access_desc,		zfs_netbsd_access },
 	{ &vop_getattr_desc,		zfs_netbsd_getattr },
 	{ &vop_setattr_desc,		zfs_netbsd_setattr },
 	{ &vop_read_desc,		/**/zfs_netbsd_read },
 	{ &vop_write_desc,		/**/zfs_netbsd_write },
 	{ &vop_ioctl_desc,		vn_fifo_bypass },
 	{ &vop_poll_desc,		vn_fifo_bypass },
 	{ &vop_kqfilter_desc,		vn_fifo_bypass },
 	{ &vop_revoke_desc,		vn_fifo_bypass },
 	{ &vop_fsync_desc,		zfs_netbsd_fsync },
 	{ &vop_remove_desc,		vn_fifo_bypass },
 	{ &vop_link_desc,		vn_fifo_bypass },
 	{ &vop_lock_desc,		zfs_netbsd_lock },
 	{ &vop_unlock_desc,		zfs_netbsd_unlock },
 	{ &vop_rename_desc,		vn_fifo_bypass },
 	{ &vop_mkdir_desc,		vn_fifo_bypass },
 	{ &vop_rmdir_desc,		vn_fifo_bypass },
 	{ &vop_symlink_desc,		vn_fifo_bypass },
 	{ &vop_readdir_desc,		vn_fifo_bypass },
 	{ &vop_readlink_desc,		vn_fifo_bypass },
 	{ &vop_inactive_desc,		zfs_netbsd_inactive },
 	{ &vop_reclaim_desc,		zfs_netbsd_reclaim },
 	{ &vop_pathconf_desc,		vn_fifo_bypass },
 	{ &vop_seek_desc,		vn_fifo_bypass },
 	{ &vop_putpages_desc,		vn_fifo_bypass },
 	{ &vop_mmap_desc,		vn_fifo_bypass },
 	{ &vop_islocked_desc,		zfs_netbsd_islocked },
 	{ &vop_advlock_desc,		vn_fifo_bypass },
 	{ &vop_print_desc,		zfs_netbsd_print },
 	{ &vop_fcntl_desc,		zfs_netbsd_fcntl },
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc zfs_fifoop_opv_desc =
 	{ &zfs_fifoop_p, zfs_fifoop_entries };
 #endif /* __NetBSD__ */