X-Git-Url: https://git.camperquake.de/gitweb.cgi?a=blobdiff_plain;f=module%2Fzfs%2Fzfs_replay.c;fp=module%2Fzfs%2Fzfs_replay.c;h=f02d5add317788b8fd6cb77bbdf7364a1f90934e;hb=633e8030b3582f3579a457a803c1382fc81f56e5;hp=2c258948b3fdf7ec00d8c9368f53cdd558266f8e;hpb=3c4988c83e4f278cd6c8076f6cdb8e4858d05840;p=zfs.git

diff --git a/module/zfs/zfs_replay.c b/module/zfs/zfs_replay.c
index 2c25894..f02d5ad 100644
--- a/module/zfs/zfs_replay.c
+++ b/module/zfs/zfs_replay.c
@@ -22,8 +22,6 @@
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  */
 
-#ifdef HAVE_ZPL
-
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -56,26 +54,24 @@
  */
 
 static void
-zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode,
-	uint64_t uid, uint64_t gid, uint64_t rdev, uint64_t nodeid)
+zfs_init_iattr(struct iattr *attr, uint64_t mask, uint64_t mode,
+	uint64_t uid, uint64_t gid)
 {
-	bzero(vap, sizeof (*vap));
-	vap->va_mask = (uint_t)mask;
-	vap->va_type = IFTOVT(mode);
-	vap->va_mode = mode & MODEMASK;
-	vap->va_uid = (uid_t)(IS_EPHEMERAL(uid)) ? -1 : uid;
-	vap->va_gid = (gid_t)(IS_EPHEMERAL(gid)) ? -1 : gid;
-	vap->va_rdev = zfs_cmpldev(rdev);
-	vap->va_nodeid = nodeid;
+	memset(attr, 0, sizeof(*attr));
+	attr->ia_valid = (uint_t)mask;
+	attr->ia_mode = mode;
+	attr->ia_uid = (uid_t)(IS_EPHEMERAL(uid)) ? -1 : uid;
+	attr->ia_gid = (gid_t)(IS_EPHEMERAL(gid)) ? -1 : gid;
 }
 
 /* ARGSUSED */
 static int
-zfs_replay_error(zfsvfs_t *zfsvfs, lr_t *lr, boolean_t byteswap)
+zfs_replay_error(zfs_sb_t *zsb, lr_t *lr, boolean_t byteswap)
 {
 	return (ENOTSUP);
 }
 
+#ifdef HAVE_XVATTR
 static void
 zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap)
 {
@@ -136,6 +132,7 @@ zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap)
 	if (XVA_ISSET_REQ(xvap, XAT_SPARSE))
 		xoap->xoa_sparse = ((*attrs & XAT0_SPARSE) != 0);
 }
+#endif /* HAVE_XVATTR */
 
 static int
 zfs_replay_domain_cnt(uint64_t uid, uint64_t gid)
@@ -264,16 +261,17 @@ zfs_replay_swap_attrs(lr_attr_t *lrattr)
  * as option FUID information.
  */
 static int
-zfs_replay_create_acl(zfsvfs_t *zfsvfs,
-    lr_acl_create_t *lracl, boolean_t byteswap)
+zfs_replay_create_acl(zfs_sb_t *zsb, lr_acl_create_t *lracl, boolean_t byteswap)
 {
 	char *name = NULL;		/* location determined later */
 	lr_create_t *lr = (lr_create_t *)lracl;
 	znode_t *dzp;
-	vnode_t *vp = NULL;
+	struct inode *ip = NULL;
+#ifdef HAVE_XVATTR
 	xvattr_t xva;
-	int vflg = 0;
 	vsecattr_t vsec = { 0 };
+#endif /* HAVE_XVATTR */
+	int vflg = 0;
 	lr_attr_t *lrattr;
 	void *aclstart;
 	void *fuidstart;
@@ -301,12 +299,13 @@ zfs_replay_create_acl(zfsvfs_t *zfsvfs,
 		}
 	}
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_doid, &dzp)) != 0)
 		return (error);
 
+#ifdef HAVE_XVATTR
 	xva_init(&xva);
-	zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID,
-	    lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid);
+	zfs_init_iattr(&xva.xva_vattr, ATTR_MODE | ATTR_UID | ATTR_GID,
+	    lr->lr_mode, lr->lr_uid, lr->lr_gid, /*lr->lr_rdev, lr->lr_foid*/);
 
 	/*
 	 * All forms of zfs create (create, mkdir, mkxattrdir, symlink)
@@ -317,8 +316,9 @@ zfs_replay_create_acl(zfsvfs_t *zfsvfs,
 	 */
 	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
 	xva.xva_vattr.va_nblocks = lr->lr_gen;
+#endif /* HAVE_XVATTR */
 
-	error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL);
+	error = dmu_object_info(zsb->z_os, lr->lr_foid, NULL);
 	if (error != ENOENT)
 		goto bail;
 
@@ -329,11 +329,12 @@ zfs_replay_create_acl(zfsvfs_t *zfsvfs,
 		aclstart = (caddr_t)(lracl + 1);
 		fuidstart = (caddr_t)aclstart +
 		    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
-		zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
+		zsb->z_fuid_replay = zfs_replay_fuids(fuidstart,
 		    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
 		    lr->lr_uid, lr->lr_gid);
 		/*FALLTHROUGH*/
 	case TX_CREATE_ACL_ATTR:
+#ifdef HAVE_XVATTR
 		if (name == NULL) {
 			lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
 			xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
@@ -345,27 +346,29 @@ zfs_replay_create_acl(zfsvfs_t *zfsvfs,
 		vsec.vsa_aclcnt = lracl->lr_aclcnt;
 		vsec.vsa_aclentsz = lracl->lr_acl_bytes;
 		vsec.vsa_aclflags = lracl->lr_acl_flags;
-		if (zfsvfs->z_fuid_replay == NULL) {
+		if (zsb->z_fuid_replay == NULL) {
 			fuidstart = (caddr_t)(lracl + 1) + xvatlen +
 			    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
-			zfsvfs->z_fuid_replay =
+			zsb->z_fuid_replay =
 			    zfs_replay_fuids(fuidstart,
 			    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
 			    lr->lr_uid, lr->lr_gid);
 		}
 
-		error = zfs_create(ZTOV(dzp), name, &xva.xva_vattr,
-		    0, 0, &vp, kcred, vflg, NULL, &vsec);
+		error = zfs_create(ZTOI(dzp), name, &xva.xva_vattr,
+		    0, 0, &ip, kcred, vflg, NULL, &vsec);
+#endif /* HAVE_XVATTR */
 		break;
 	case TX_MKDIR_ACL:
 		aclstart = (caddr_t)(lracl + 1);
 		fuidstart = (caddr_t)aclstart +
 		    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
-		zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
+		zsb->z_fuid_replay = zfs_replay_fuids(fuidstart,
 		    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
 		    lr->lr_uid, lr->lr_gid);
 		/*FALLTHROUGH*/
 	case TX_MKDIR_ACL_ATTR:
+#ifdef HAVE_XVATTR
 		if (name == NULL) {
 			lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
 			xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
@@ -376,47 +379,50 @@ zfs_replay_create_acl(zfsvfs_t *zfsvfs,
 		vsec.vsa_aclcnt = lracl->lr_aclcnt;
 		vsec.vsa_aclentsz = lracl->lr_acl_bytes;
 		vsec.vsa_aclflags = lracl->lr_acl_flags;
-		if (zfsvfs->z_fuid_replay == NULL) {
+		if (zsb->z_fuid_replay == NULL) {
 			fuidstart = (caddr_t)(lracl + 1) + xvatlen +
 			    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
-			zfsvfs->z_fuid_replay =
+			zsb->z_fuid_replay =
 			    zfs_replay_fuids(fuidstart,
 			    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
 			    lr->lr_uid, lr->lr_gid);
 		}
-		error = zfs_mkdir(ZTOV(dzp), name, &xva.xva_vattr,
-		    &vp, kcred, NULL, vflg, &vsec);
+		error = zfs_mkdir(ZTOI(dzp), name, &xva.xva_vattr,
+		    &ip, kcred, NULL, vflg, &vsec);
+#endif /* HAVE_XVATTR */
 		break;
 	default:
 		error = ENOTSUP;
 	}
 
 bail:
-	if (error == 0 && vp != NULL)
-		VN_RELE(vp);
+	if (error == 0 && ip != NULL)
+		iput(ip);
 
-	VN_RELE(ZTOV(dzp));
+	iput(ZTOI(dzp));
 
-	if (zfsvfs->z_fuid_replay)
-		zfs_fuid_info_free(zfsvfs->z_fuid_replay);
-	zfsvfs->z_fuid_replay = NULL;
+	if (zsb->z_fuid_replay)
+		zfs_fuid_info_free(zsb->z_fuid_replay);
+	zsb->z_fuid_replay = NULL;
 
 	return (error);
 }
 
 static int
-zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
+zfs_replay_create(zfs_sb_t *zsb, lr_create_t *lr, boolean_t byteswap)
 {
 	char *name = NULL;		/* location determined later */
 	char *link;			/* symlink content follows name */
 	znode_t *dzp;
-	vnode_t *vp = NULL;
+	struct inode *ip = NULL;
 	xvattr_t xva;
 	int vflg = 0;
+#ifdef HAVE_XVATTR
 	size_t lrsize = sizeof (lr_create_t);
 	lr_attr_t *lrattr;
-	void *start;
 	size_t xvatlen;
+#endif /* HAVE_XVATTR */
+	void *start;
 	uint64_t txtype;
 	int error;
 
@@ -428,12 +434,13 @@ zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
 	}
 
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_doid, &dzp)) != 0)
 		return (error);
 
+#ifdef HAVE_XVATTR
 	xva_init(&xva);
-	zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID,
-	    lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid);
+	zfs_init_iattr(&xva.xva_vattr, ATTR_MODE | ATTR_UID | ATTR_GID,
+	    lr->lr_mode, lr->lr_uid, lr->lr_gid, /*lr->lr_rdev, lr->lr_foid*/);
 
 	/*
 	 * All forms of zfs create (create, mkdir, mkxattrdir, symlink)
@@ -444,8 +451,9 @@ zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
 	 */
 	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
 	xva.xva_vattr.va_nblocks = lr->lr_gen;
+#endif /* HAVE_XVATTR */
 
-	error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL);
+	error = dmu_object_info(zsb->z_os, lr->lr_foid, NULL);
 	if (error != ENOENT)
 		goto out;
 
@@ -462,75 +470,79 @@ zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
 	    (int)lr->lr_common.lrc_txtype != TX_MKDIR_ATTR &&
 	    (int)lr->lr_common.lrc_txtype != TX_CREATE_ATTR) {
 		start = (lr + 1);
-		zfsvfs->z_fuid_replay =
+		zsb->z_fuid_replay =
 		    zfs_replay_fuid_domain(start, &start,
 		    lr->lr_uid, lr->lr_gid);
 	}
 
 	switch (txtype) {
 	case TX_CREATE_ATTR:
+#ifdef HAVE_XVATTR
 		lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
 		xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
 		zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
 		start = (caddr_t)(lr + 1) + xvatlen;
-		zfsvfs->z_fuid_replay =
+		zsb->z_fuid_replay =
 		    zfs_replay_fuid_domain(start, &start,
 		    lr->lr_uid, lr->lr_gid);
 		name = (char *)start;
+#endif /* HAVE_XVATTR */
 
 		/*FALLTHROUGH*/
 	case TX_CREATE:
 		if (name == NULL)
 			name = (char *)start;
 
-		error = zfs_create(ZTOV(dzp), name, &xva.xva_vattr,
-		    0, 0, &vp, kcred, vflg, NULL, NULL);
+		error = zfs_create(ZTOI(dzp), name, &xva.xva_vattr,
+		    0, 0, &ip, kcred, vflg, NULL);
 		break;
 	case TX_MKDIR_ATTR:
+#ifdef HAVE_XVATTR
 		lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
 		xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
 		zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
 		start = (caddr_t)(lr + 1) + xvatlen;
-		zfsvfs->z_fuid_replay =
+		zsb->z_fuid_replay =
 		    zfs_replay_fuid_domain(start, &start,
 		    lr->lr_uid, lr->lr_gid);
 		name = (char *)start;
+#endif /* HAVE_XVATTR */
 
 		/*FALLTHROUGH*/
 	case TX_MKDIR:
 		if (name == NULL)
 			name = (char *)(lr + 1);
 
-		error = zfs_mkdir(ZTOV(dzp), name, &xva.xva_vattr,
-		    &vp, kcred, NULL, vflg, NULL);
+		error = zfs_mkdir(ZTOI(dzp), name, &xva.xva_vattr,
+		    &ip, kcred, vflg, NULL);
 		break;
 	case TX_MKXATTR:
-		error = zfs_make_xattrdir(dzp, &xva.xva_vattr, &vp, kcred);
+		error = zfs_make_xattrdir(dzp, &xva.xva_vattr, &ip, kcred);
 		break;
 	case TX_SYMLINK:
 		name = (char *)(lr + 1);
 		link = name + strlen(name) + 1;
-		error = zfs_symlink(ZTOV(dzp), name, &xva.xva_vattr,
-		    link, kcred, NULL, vflg);
+		error = zfs_symlink(ZTOI(dzp), name, &xva.xva_vattr,
+		    link, &ip, kcred, vflg);
 		break;
 	default:
 		error = ENOTSUP;
 	}
 
 out:
-	if (error == 0 && vp != NULL)
-		VN_RELE(vp);
+	if (error == 0 && ip != NULL)
+		iput(ip);
 
-	VN_RELE(ZTOV(dzp));
+	iput(ZTOI(dzp));
 
-	if (zfsvfs->z_fuid_replay)
-		zfs_fuid_info_free(zfsvfs->z_fuid_replay);
-	zfsvfs->z_fuid_replay = NULL;
+	if (zsb->z_fuid_replay)
+		zfs_fuid_info_free(zsb->z_fuid_replay);
+	zsb->z_fuid_replay = NULL;
 	return (error);
 }
 
 static int
-zfs_replay_remove(zfsvfs_t *zfsvfs, lr_remove_t *lr, boolean_t byteswap)
+zfs_replay_remove(zfs_sb_t *zsb, lr_remove_t *lr, boolean_t byteswap)
 {
 	char *name = (char *)(lr + 1);	/* name follows lr_remove_t */
 	znode_t *dzp;
@@ -540,60 +552,63 @@ zfs_replay_remove(zfsvfs_t *zfsvfs, lr_remove_t *lr, boolean_t byteswap)
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_doid, &dzp)) != 0)
 		return (error);
 
+#ifdef HAVE_PN_UTILS
 	if (lr->lr_common.lrc_txtype & TX_CI)
 		vflg |= FIGNORECASE;
+#endif
 
 	switch ((int)lr->lr_common.lrc_txtype) {
 	case TX_REMOVE:
-		error = zfs_remove(ZTOV(dzp), name, kcred, NULL, vflg);
+		error = zfs_remove(ZTOI(dzp), name, kcred);
 		break;
 	case TX_RMDIR:
-		error = zfs_rmdir(ZTOV(dzp), name, NULL, kcred, NULL, vflg);
+		error = zfs_rmdir(ZTOI(dzp), name, NULL, kcred, vflg);
 		break;
 	default:
 		error = ENOTSUP;
 	}
 
-	VN_RELE(ZTOV(dzp));
+	iput(ZTOI(dzp));
 
 	return (error);
 }
 
 static int
-zfs_replay_link(zfsvfs_t *zfsvfs, lr_link_t *lr, boolean_t byteswap)
+zfs_replay_link(zfs_sb_t *zsb, lr_link_t *lr, boolean_t byteswap)
 {
 	char *name = (char *)(lr + 1);	/* name follows lr_link_t */
 	znode_t *dzp, *zp;
 	int error;
-	int vflg = 0;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_doid, &dzp)) != 0)
 		return (error);
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_link_obj, &zp)) != 0) {
-		VN_RELE(ZTOV(dzp));
+	if ((error = zfs_zget(zsb, lr->lr_link_obj, &zp)) != 0) {
+		iput(ZTOI(dzp));
 		return (error);
 	}
 
+#ifdef HAVE_PN_UTILS
 	if (lr->lr_common.lrc_txtype & TX_CI)
 		vflg |= FIGNORECASE;
+#endif
 
-	error = zfs_link(ZTOV(dzp), ZTOV(zp), name, kcred, NULL, vflg);
+	error = zfs_link(ZTOI(dzp), ZTOI(zp), name, kcred);
 
-	VN_RELE(ZTOV(zp));
-	VN_RELE(ZTOV(dzp));
+	iput(ZTOI(zp));
+	iput(ZTOI(dzp));
 
 	return (error);
 }
 
 static int
-zfs_replay_rename(zfsvfs_t *zfsvfs, lr_rename_t *lr, boolean_t byteswap)
+zfs_replay_rename(zfs_sb_t *zsb, lr_rename_t *lr, boolean_t byteswap)
 {
 	char *sname = (char *)(lr + 1);	/* sname and tname follow lr_rename_t */
 	char *tname = sname + strlen(sname) + 1;
@@ -604,39 +619,39 @@ zfs_replay_rename(zfsvfs_t *zfsvfs, lr_rename_t *lr, boolean_t byteswap)
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_sdoid, &sdzp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_sdoid, &sdzp)) != 0)
 		return (error);
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_tdoid, &tdzp)) != 0) {
-		VN_RELE(ZTOV(sdzp));
+	if ((error = zfs_zget(zsb, lr->lr_tdoid, &tdzp)) != 0) {
+		iput(ZTOI(sdzp));
 		return (error);
 	}
 
 	if (lr->lr_common.lrc_txtype & TX_CI)
 		vflg |= FIGNORECASE;
 
-	error = zfs_rename(ZTOV(sdzp), sname, ZTOV(tdzp), tname, kcred,
-	    NULL, vflg);
+	error = zfs_rename(ZTOI(sdzp), sname, ZTOI(tdzp), tname, kcred, vflg);
 
-	VN_RELE(ZTOV(tdzp));
-	VN_RELE(ZTOV(sdzp));
+	iput(ZTOI(tdzp));
+	iput(ZTOI(sdzp));
 
 	return (error);
 }
 
 static int
-zfs_replay_write(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
+zfs_replay_write(zfs_sb_t *zsb, lr_write_t *lr, boolean_t byteswap)
 {
+#if 0
 	char *data = (char *)(lr + 1);	/* data follows lr_write_t */
+#endif
 	znode_t	*zp;
 	int error;
-	ssize_t resid;
 	uint64_t eod, offset, length;
 
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
+	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0) {
 		/*
 		 * As we can log writes out of order, it's possible the
 		 * file has been removed. In this case just drop the write
@@ -659,10 +674,10 @@ zfs_replay_write(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
 	 * write needs to be there. So we write the whole block and
 	 * reduce the eof. This needs to be done within the single dmu
 	 * transaction created within vn_rdwr -> zfs_write. So a possible
-	 * new end of file is passed through in zfsvfs->z_replay_eof
+	 * new end of file is passed through in zsb->z_replay_eof
 	 */
 
-	zfsvfs->z_replay_eof = 0; /* 0 means don't change end of file */
+	zsb->z_replay_eof = 0; /* 0 means don't change end of file */
 
 	/* If it's a dmu_sync() block, write the whole block */
 	if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {
@@ -672,14 +687,19 @@ zfs_replay_write(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
 			length = blocksize;
 		}
 		if (zp->z_size < eod)
-			zfsvfs->z_replay_eof = eod;
+			zsb->z_replay_eof = eod;
 	}
 
-	error = vn_rdwr(UIO_WRITE, ZTOV(zp), data, length, offset,
+	/*
+	 * XXX: Use zfs_write() once uio types are removed
+	 */
+#if 0
+	 error = vn_rdwr(UIO_WRITE, ZTOI(zp), data, length, offset,
 	    UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
+#endif
 
-	VN_RELE(ZTOV(zp));
-	zfsvfs->z_replay_eof = 0;	/* safety */
+	iput(ZTOI(zp));
+	zsb->z_replay_eof = 0;	/* safety */
 
 	return (error);
 }
@@ -691,7 +711,7 @@ zfs_replay_write(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
  * the file is grown.
  */
 static int
-zfs_replay_write2(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
+zfs_replay_write2(zfs_sb_t *zsb, lr_write_t *lr, boolean_t byteswap)
 {
 	znode_t	*zp;
 	int error;
@@ -700,19 +720,19 @@ zfs_replay_write2(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0)
 		return (error);
 
 top:
 	end = lr->lr_offset + lr->lr_length;
 	if (end > zp->z_size) {
-		dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);
+		dmu_tx_t *tx = dmu_tx_create(zsb->z_os);
 
 		zp->z_size = end;
 		dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
 		error = dmu_tx_assign(tx, TXG_WAIT);
 		if (error) {
-			VN_RELE(ZTOV(zp));
+			iput(ZTOI(zp));
 			if (error == ERESTART) {
 				dmu_tx_wait(tx);
 				dmu_tx_abort(tx);
@@ -721,22 +741,22 @@ top:
 			dmu_tx_abort(tx);
 			return (error);
 		}
-		(void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
+		(void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zsb),
 		    (void *)&zp->z_size, sizeof (uint64_t), tx);
 
 		/* Ensure the replayed seq is updated */
-		(void) zil_replaying(zfsvfs->z_log, tx);
+		(void) zil_replaying(zsb->z_log, tx);
 
 		dmu_tx_commit(tx);
 	}
 
-	VN_RELE(ZTOV(zp));
+	iput(ZTOI(zp));
 
 	return (error);
 }
 
 static int
-zfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap)
+zfs_replay_truncate(zfs_sb_t *zsb, lr_truncate_t *lr, boolean_t byteswap)
 {
 	znode_t *zp;
 	flock64_t fl;
@@ -745,7 +765,7 @@ zfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap)
 	if (byteswap)
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0)
 		return (error);
 
 	bzero(&fl, sizeof (fl));
@@ -754,68 +774,75 @@ zfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap)
 	fl.l_start = lr->lr_offset;
 	fl.l_len = lr->lr_length;
 
-	error = zfs_space(ZTOV(zp), F_FREESP, &fl, FWRITE | FOFFMAX,
-	    lr->lr_offset, kcred, NULL);
+	error = zfs_space(ZTOI(zp), F_FREESP, &fl, FWRITE | FOFFMAX,
+	    lr->lr_offset, kcred);
 
-	VN_RELE(ZTOV(zp));
+	iput(ZTOI(zp));
 
 	return (error);
 }
 
 static int
-zfs_replay_setattr(zfsvfs_t *zfsvfs, lr_setattr_t *lr, boolean_t byteswap)
+zfs_replay_setattr(zfs_sb_t *zsb, lr_setattr_t *lr, boolean_t byteswap)
 {
 	znode_t *zp;
+#ifdef HAVE_XVATTR
 	xvattr_t xva;
-	vattr_t *vap = &xva.xva_vattr;
+#endif /* HAVE_XATTR */
+	struct iattr attr;
 	int error;
 	void *start;
 
+#ifdef HAVE_XVATTR
 	xva_init(&xva);
+#endif /* HAVE_XVATTR */
 	if (byteswap) {
 		byteswap_uint64_array(lr, sizeof (*lr));
 
+#ifdef HAVE_XVATTR
 		if ((lr->lr_mask & AT_XVATTR) &&
-		    zfsvfs->z_version >= ZPL_VERSION_INITIAL)
+		    zsb->z_version >= ZPL_VERSION_INITIAL)
 			zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
+#endif /* HAVE_XVATTR */
 	}
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0)
 		return (error);
 
-	zfs_init_vattr(vap, lr->lr_mask, lr->lr_mode,
-	    lr->lr_uid, lr->lr_gid, 0, lr->lr_foid);
+	zfs_init_iattr(&attr, lr->lr_mask, lr->lr_mode, lr->lr_uid, lr->lr_gid);
 
-	vap->va_size = lr->lr_size;
-	ZFS_TIME_DECODE(&vap->va_atime, lr->lr_atime);
-	ZFS_TIME_DECODE(&vap->va_mtime, lr->lr_mtime);
+	attr.ia_size = lr->lr_size;
+	ZFS_TIME_DECODE(&attr.ia_atime, lr->lr_atime);
+	ZFS_TIME_DECODE(&attr.ia_mtime, lr->lr_mtime);
 
 	/*
 	 * Fill in xvattr_t portions if necessary.
 	 */
 
 	start = (lr_setattr_t *)(lr + 1);
-	if (vap->va_mask & AT_XVATTR) {
+#ifdef HAVE_XVATTR
+	if (iattr->ia_mask & AT_XVATTR) {
 		zfs_replay_xvattr((lr_attr_t *)start, &xva);
 		start = (caddr_t)start +
 		    ZIL_XVAT_SIZE(((lr_attr_t *)start)->lr_attr_masksize);
 	} else
 		xva.xva_vattr.va_mask &= ~AT_XVATTR;
+#endif /* HAVE_XVATTR */
 
-	zfsvfs->z_fuid_replay = zfs_replay_fuid_domain(start, &start,
+	zsb->z_fuid_replay = zfs_replay_fuid_domain(start, &start,
 	    lr->lr_uid, lr->lr_gid);
 
-	error = zfs_setattr(ZTOV(zp), vap, 0, kcred, NULL);
+	error = zfs_setattr(ZTOI(zp), &attr, 0, kcred);
 
-	zfs_fuid_info_free(zfsvfs->z_fuid_replay);
-	zfsvfs->z_fuid_replay = NULL;
-	VN_RELE(ZTOV(zp));
+	zfs_fuid_info_free(zsb->z_fuid_replay);
+	zsb->z_fuid_replay = NULL;
+	iput(ZTOI(zp));
 
 	return (error);
 }
 
 static int
-zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap)
+zfs_replay_acl_v0(zfs_sb_t *zsb, lr_acl_v0_t *lr, boolean_t byteswap)
 {
 	ace_t *ace = (ace_t *)(lr + 1);	/* ace array follows lr_acl_t */
 	vsecattr_t vsa;
@@ -827,7 +854,7 @@ zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap)
 		zfs_oldace_byteswap(ace, lr->lr_aclcnt);
 	}
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0)
 		return (error);
 
 	bzero(&vsa, sizeof (vsa));
@@ -837,9 +864,9 @@ zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap)
 	vsa.vsa_aclflags = 0;
 	vsa.vsa_aclentp = ace;
 
-	error = zfs_setsecattr(ZTOV(zp), &vsa, 0, kcred, NULL);
+	error = zfs_setsecattr(ZTOI(zp), &vsa, 0, kcred);
 
-	VN_RELE(ZTOV(zp));
+	iput(ZTOI(zp));
 
 	return (error);
 }
@@ -859,7 +886,7 @@ zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap)
  *
  */
 static int
-zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap)
+zfs_replay_acl(zfs_sb_t *zsb, lr_acl_t *lr, boolean_t byteswap)
 {
 	ace_t *ace = (ace_t *)(lr + 1);
 	vsecattr_t vsa;
@@ -876,7 +903,7 @@ zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap)
 		}
 	}
 
-	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
+	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0)
 		return (error);
 
 	bzero(&vsa, sizeof (vsa));
@@ -890,18 +917,18 @@ zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap)
 		void *fuidstart = (caddr_t)ace +
 		    ZIL_ACE_LENGTH(lr->lr_acl_bytes);
 
-		zfsvfs->z_fuid_replay =
+		zsb->z_fuid_replay =
 		    zfs_replay_fuids(fuidstart, &fuidstart,
 		    lr->lr_fuidcnt, lr->lr_domcnt, 0, 0);
 	}
 
-	error = zfs_setsecattr(ZTOV(zp), &vsa, 0, kcred, NULL);
+	error = zfs_setsecattr(ZTOI(zp), &vsa, 0, kcred);
 
-	if (zfsvfs->z_fuid_replay)
-		zfs_fuid_info_free(zfsvfs->z_fuid_replay);
+	if (zsb->z_fuid_replay)
+		zfs_fuid_info_free(zsb->z_fuid_replay);
 
-	zfsvfs->z_fuid_replay = NULL;
-	VN_RELE(ZTOV(zp));
+	zsb->z_fuid_replay = NULL;
+	iput(ZTOI(zp));
 
 	return (error);
 }
@@ -910,26 +937,25 @@ zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap)
  * Callback vectors for replaying records
  */
 zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE] = {
-	zfs_replay_error,	/* 0 no such transaction type */
-	zfs_replay_create,	/* TX_CREATE */
-	zfs_replay_create,	/* TX_MKDIR */
-	zfs_replay_create,	/* TX_MKXATTR */
-	zfs_replay_create,	/* TX_SYMLINK */
-	zfs_replay_remove,	/* TX_REMOVE */
-	zfs_replay_remove,	/* TX_RMDIR */
-	zfs_replay_link,	/* TX_LINK */
-	zfs_replay_rename,	/* TX_RENAME */
-	zfs_replay_write,	/* TX_WRITE */
-	zfs_replay_truncate,	/* TX_TRUNCATE */
-	zfs_replay_setattr,	/* TX_SETATTR */
-	zfs_replay_acl_v0,	/* TX_ACL_V0 */
-	zfs_replay_acl,		/* TX_ACL */
-	zfs_replay_create_acl,	/* TX_CREATE_ACL */
-	zfs_replay_create,	/* TX_CREATE_ATTR */
-	zfs_replay_create_acl,	/* TX_CREATE_ACL_ATTR */
-	zfs_replay_create_acl,	/* TX_MKDIR_ACL */
-	zfs_replay_create,	/* TX_MKDIR_ATTR */
-	zfs_replay_create_acl,	/* TX_MKDIR_ACL_ATTR */
-	zfs_replay_write2,	/* TX_WRITE2 */
+	(zil_replay_func_t *)zfs_replay_error,		/* no such type */
+	(zil_replay_func_t *)zfs_replay_create,		/* TX_CREATE */
+	(zil_replay_func_t *)zfs_replay_create,		/* TX_MKDIR */
+	(zil_replay_func_t *)zfs_replay_create,		/* TX_MKXATTR */
+	(zil_replay_func_t *)zfs_replay_create,		/* TX_SYMLINK */
+	(zil_replay_func_t *)zfs_replay_remove,		/* TX_REMOVE */
+	(zil_replay_func_t *)zfs_replay_remove,		/* TX_RMDIR */
+	(zil_replay_func_t *)zfs_replay_link,		/* TX_LINK */
+	(zil_replay_func_t *)zfs_replay_rename,		/* TX_RENAME */
+	(zil_replay_func_t *)zfs_replay_write,		/* TX_WRITE */
+	(zil_replay_func_t *)zfs_replay_truncate,	/* TX_TRUNCATE */
+	(zil_replay_func_t *)zfs_replay_setattr,	/* TX_SETATTR */
+	(zil_replay_func_t *)zfs_replay_acl_v0,		/* TX_ACL_V0 */
+	(zil_replay_func_t *)zfs_replay_acl,		/* TX_ACL */
+	(zil_replay_func_t *)zfs_replay_create_acl,	/* TX_CREATE_ACL */
+	(zil_replay_func_t *)zfs_replay_create,		/* TX_CREATE_ATTR */
+	(zil_replay_func_t *)zfs_replay_create_acl,	/* TX_CREATE_ACL_ATTR */
+	(zil_replay_func_t *)zfs_replay_create_acl,	/* TX_MKDIR_ACL */
+	(zil_replay_func_t *)zfs_replay_create,		/* TX_MKDIR_ATTR */
+	(zil_replay_func_t *)zfs_replay_create_acl,	/* TX_MKDIR_ACL_ATTR */
+	(zil_replay_func_t *)zfs_replay_write2,		/* TX_WRITE2 */
 };
-#endif /* HAVE_ZPL */