X-Git-Url: https://git.camperquake.de/gitweb.cgi?a=blobdiff_plain;f=module%2Fzfs%2Fzfs_replay.c;h=813250c37dc4dd2ac03c5bca21bd4e219790fddb;hb=refs%2Fheads%2Frertzinger%2Ffeature-zpool-get--p;hp=9fb3368569906b7e40604249ab5b7899cd9d8f76;hpb=572e285762521df27fe5b026f409ba1a21abb7ac;p=zfs.git

diff --git a/module/zfs/zfs_replay.c b/module/zfs/zfs_replay.c
index 9fb3368..813250c 100644
--- a/module/zfs/zfs_replay.c
+++ b/module/zfs/zfs_replay.c
@@ -20,6 +20,7 @@
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012 Cyril Plisko. All rights reserved.
  */
 
 #include <sys/types.h>
@@ -37,6 +38,7 @@
 #include <sys/zfs_dir.h>
 #include <sys/zfs_acl.h>
 #include <sys/zfs_fuid.h>
+#include <sys/zfs_vnops.h>
 #include <sys/spa.h>
 #include <sys/zil.h>
 #include <sys/byteorder.h>
@@ -45,6 +47,7 @@
 #include <sys/acl.h>
 #include <sys/atomic.h>
 #include <sys/cred.h>
+#include <sys/zpl.h>
 
 /*
  * Functions to replay ZFS intent log (ZIL) records
@@ -59,16 +62,16 @@ zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode,
 	bzero(vap, sizeof (*vap));
 	vap->va_mask = (uint_t)mask;
 	vap->va_type = IFTOVT(mode);
-	vap->va_mode = mode & MODEMASK;
+	vap->va_mode = mode;
 	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_rdev = rdev;
 	vap->va_nodeid = nodeid;
 }
 
 /* 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);
 }
@@ -83,9 +86,9 @@ zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap)
 	void *scanstamp;
 	int i;
 
-	xvap->xva_vattr.va_mask |= AT_XVATTR;
+	xvap->xva_vattr.va_mask |= ATTR_XVATTR;
 	if ((xoap = xva_getxoptattr(xvap)) == NULL) {
-		xvap->xva_vattr.va_mask &= ~AT_XVATTR; /* shouldn't happen */
+		xvap->xva_vattr.va_mask &= ~ATTR_XVATTR; /* shouldn't happen */
 		return;
 	}
 
@@ -261,13 +264,12 @@ 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;
 	xvattr_t xva;
 	int vflg = 0;
 	vsecattr_t vsec = { 0 };
@@ -298,24 +300,24 @@ 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);
 
 	xva_init(&xva);
-	zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID,
+	zfs_init_vattr(&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)
 	 * eventually end up in zfs_mknode(), which assigns the object's
-	 * creation time and generation number.  The generic VOP_CREATE()
+	 * creation time and generation number.  The generic zfs_create()
 	 * doesn't have either concept, so we smuggle the values inside
 	 * the vattr's otherwise unused va_ctime and va_nblocks fields.
 	 */
 	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
 	xva.xva_vattr.va_nblocks = lr->lr_gen;
 
-	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;
 
@@ -326,7 +328,7 @@ 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*/
@@ -334,7 +336,7 @@ zfs_replay_create_acl(zfsvfs_t *zfsvfs,
 		if (name == NULL) {
 			lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
 			xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
-			xva.xva_vattr.va_mask |= AT_XVATTR;
+			xva.xva_vattr.va_mask |= ATTR_XVATTR;
 			zfs_replay_xvattr(lrattr, &xva);
 		}
 		vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS;
@@ -342,23 +344,23 @@ 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 = VOP_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, &vsec);
 		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*/
@@ -373,41 +375,41 @@ 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 = VOP_MKDIR(ZTOV(dzp), name, &xva.xva_vattr,
-		    &vp, kcred, NULL, vflg, &vsec);
+		error = zfs_mkdir(ZTOI(dzp), name, &xva.xva_vattr,
+		    &ip, kcred, vflg, &vsec);
 		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;
 	size_t lrsize = sizeof (lr_create_t);
@@ -425,24 +427,24 @@ 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);
 
 	xva_init(&xva);
-	zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID,
+	zfs_init_vattr(&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)
 	 * eventually end up in zfs_mknode(), which assigns the object's
-	 * creation time and generation number.  The generic VOP_CREATE()
+	 * creation time and generation number.  The generic zfs_create()
 	 * doesn't have either concept, so we smuggle the values inside
 	 * the vattr's otherwise unused va_ctime and va_nblocks fields.
 	 */
 	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
 	xva.xva_vattr.va_nblocks = lr->lr_gen;
 
-	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;
 
@@ -459,7 +461,7 @@ 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);
 	}
@@ -470,7 +472,7 @@ zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
 		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;
@@ -480,15 +482,15 @@ zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
 		if (name == NULL)
 			name = (char *)start;
 
-		error = VOP_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:
 		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;
@@ -498,36 +500,36 @@ zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
 		if (name == NULL)
 			name = (char *)(lr + 1);
 
-		error = VOP_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 = VOP_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;
@@ -537,7 +539,7 @@ 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);
 
 	if (lr->lr_common.lrc_txtype & TX_CI)
@@ -545,22 +547,22 @@ zfs_replay_remove(zfsvfs_t *zfsvfs, lr_remove_t *lr, boolean_t byteswap)
 
 	switch ((int)lr->lr_common.lrc_txtype) {
 	case TX_REMOVE:
-		error = VOP_REMOVE(ZTOV(dzp), name, kcred, NULL, vflg);
+		error = zfs_remove(ZTOI(dzp), name, kcred);
 		break;
 	case TX_RMDIR:
-		error = VOP_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;
@@ -570,27 +572,27 @@ zfs_replay_link(zfsvfs_t *zfsvfs, lr_link_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);
 
-	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);
 	}
 
 	if (lr->lr_common.lrc_txtype & TX_CI)
 		vflg |= FIGNORECASE;
 
-	error = VOP_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;
@@ -601,39 +603,37 @@ 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 = VOP_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)
 {
 	char *data = (char *)(lr + 1);	/* data follows lr_write_t */
 	znode_t	*zp;
-	int error;
-	ssize_t resid;
+	int error, written;
 	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
@@ -656,10 +656,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)) {
@@ -669,14 +669,18 @@ 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,
-	    UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
+	written = zpl_write_common(ZTOI(zp), data, length, offset,
+	    UIO_SYSSPACE, 0, kcred);
+	if (written < 0)
+		error = -written;
+	else if (written < length)
+		error = EIO; /* short write */
 
-	VN_RELE(ZTOV(zp));
-	zfsvfs->z_replay_eof = 0;	/* safety */
+	iput(ZTOI(zp));
+	zsb->z_replay_eof = 0;	/* safety */
 
 	return (error);
 }
@@ -688,7 +692,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;
@@ -697,19 +701,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);
@@ -718,22 +722,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;
@@ -742,7 +746,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));
@@ -751,16 +755,16 @@ 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 = VOP_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;
 	xvattr_t xva;
@@ -772,12 +776,12 @@ zfs_replay_setattr(zfsvfs_t *zfsvfs, lr_setattr_t *lr, boolean_t byteswap)
 	if (byteswap) {
 		byteswap_uint64_array(lr, sizeof (*lr));
 
-		if ((lr->lr_mask & AT_XVATTR) &&
-		    zfsvfs->z_version >= ZPL_VERSION_INITIAL)
+		if ((lr->lr_mask & ATTR_XVATTR) &&
+		    zsb->z_version >= ZPL_VERSION_INITIAL)
 			zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
 	}
 
-	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,
@@ -792,27 +796,27 @@ zfs_replay_setattr(zfsvfs_t *zfsvfs, lr_setattr_t *lr, boolean_t byteswap)
 	 */
 
 	start = (lr_setattr_t *)(lr + 1);
-	if (vap->va_mask & AT_XVATTR) {
+	if (vap->va_mask & ATTR_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;
+		xva.xva_vattr.va_mask &= ~ATTR_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 = VOP_SETATTR(ZTOV(zp), vap, 0, kcred, NULL);
+	error = zfs_setattr(ZTOI(zp), vap, 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;
@@ -824,7 +828,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));
@@ -834,9 +838,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 = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL);
+	error = zfs_setsecattr(ZTOI(zp), &vsa, 0, kcred);
 
-	VN_RELE(ZTOV(zp));
+	iput(ZTOI(zp));
 
 	return (error);
 }
@@ -856,7 +860,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;
@@ -873,7 +877,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));
@@ -887,18 +891,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 = VOP_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);
 }
@@ -906,26 +910,26 @@ 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_vector[TX_MAX_TYPE] = {
+	(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 */
 };