xref: /illumos-gate/usr/src/uts/common/fs/zfs/zfs_replay.c (revision 8436ade26aba9b9e816d73f396e44d9abc90add0)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <sys/types.h>
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/sysmacros.h>
32 #include <sys/cmn_err.h>
33 #include <sys/kmem.h>
34 #include <sys/thread.h>
35 #include <sys/file.h>
36 #include <sys/fcntl.h>
37 #include <sys/vfs.h>
38 #include <sys/fs/zfs.h>
39 #include <sys/zfs_znode.h>
40 #include <sys/zfs_dir.h>
41 #include <sys/zfs_acl.h>
42 #include <sys/zfs_fuid.h>
43 #include <sys/spa.h>
44 #include <sys/zil.h>
45 #include <sys/byteorder.h>
46 #include <sys/stat.h>
47 #include <sys/mode.h>
48 #include <sys/acl.h>
49 #include <sys/atomic.h>
50 #include <sys/cred.h>
51 
52 /*
53  * Functions to replay ZFS intent log (ZIL) records
54  * The functions are called through a function vector (zfs_replay_vector)
55  * which is indexed by the transaction type.
56  */
57 
58 static void
59 zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode,
60 	uint64_t uid, uint64_t gid, uint64_t rdev, uint64_t nodeid)
61 {
62 	bzero(vap, sizeof (*vap));
63 	vap->va_mask = (uint_t)mask;
64 	vap->va_type = IFTOVT(mode);
65 	vap->va_mode = mode & MODEMASK;
66 	vap->va_uid = (uid_t)(IS_EPHEMERAL(uid)) ? -1 : uid;
67 	vap->va_gid = (gid_t)(IS_EPHEMERAL(gid)) ? -1 : gid;
68 	vap->va_rdev = zfs_cmpldev(rdev);
69 	vap->va_nodeid = nodeid;
70 }
71 
72 /* ARGSUSED */
73 static int
74 zfs_replay_error(zfsvfs_t *zfsvfs, lr_t *lr, boolean_t byteswap)
75 {
76 	return (ENOTSUP);
77 }
78 
79 static void
80 zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap)
81 {
82 	xoptattr_t *xoap = NULL;
83 	uint64_t *attrs;
84 	uint64_t *crtime;
85 	uint32_t *bitmap;
86 	void *scanstamp;
87 	int i;
88 
89 	xvap->xva_vattr.va_mask |= AT_XVATTR;
90 	if ((xoap = xva_getxoptattr(xvap)) == NULL) {
91 		xvap->xva_vattr.va_mask &= ~AT_XVATTR; /* shouldn't happen */
92 		return;
93 	}
94 
95 	ASSERT(lrattr->lr_attr_masksize == xvap->xva_mapsize);
96 
97 	bitmap = &lrattr->lr_attr_bitmap;
98 	for (i = 0; i != lrattr->lr_attr_masksize; i++, bitmap++)
99 		xvap->xva_reqattrmap[i] = *bitmap;
100 
101 	attrs = (uint64_t *)(lrattr + lrattr->lr_attr_masksize - 1);
102 	crtime = attrs + 1;
103 	scanstamp = (caddr_t)(crtime + 2);
104 
105 	if (XVA_ISSET_REQ(xvap, XAT_HIDDEN))
106 		xoap->xoa_hidden = ((*attrs & XAT0_HIDDEN) != 0);
107 	if (XVA_ISSET_REQ(xvap, XAT_SYSTEM))
108 		xoap->xoa_system = ((*attrs & XAT0_SYSTEM) != 0);
109 	if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE))
110 		xoap->xoa_archive = ((*attrs & XAT0_ARCHIVE) != 0);
111 	if (XVA_ISSET_REQ(xvap, XAT_READONLY))
112 		xoap->xoa_readonly = ((*attrs & XAT0_READONLY) != 0);
113 	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE))
114 		xoap->xoa_immutable = ((*attrs & XAT0_IMMUTABLE) != 0);
115 	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK))
116 		xoap->xoa_nounlink = ((*attrs & XAT0_NOUNLINK) != 0);
117 	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY))
118 		xoap->xoa_appendonly = ((*attrs & XAT0_APPENDONLY) != 0);
119 	if (XVA_ISSET_REQ(xvap, XAT_NODUMP))
120 		xoap->xoa_nodump = ((*attrs & XAT0_NODUMP) != 0);
121 	if (XVA_ISSET_REQ(xvap, XAT_OPAQUE))
122 		xoap->xoa_opaque = ((*attrs & XAT0_OPAQUE) != 0);
123 	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED))
124 		xoap->xoa_av_modified = ((*attrs & XAT0_AV_MODIFIED) != 0);
125 	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED))
126 		xoap->xoa_av_quarantined =
127 		    ((*attrs & XAT0_AV_QUARANTINED) != 0);
128 	if (XVA_ISSET_REQ(xvap, XAT_CREATETIME))
129 		ZFS_TIME_DECODE(&xoap->xoa_createtime, crtime);
130 	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP))
131 		bcopy(scanstamp, xoap->xoa_av_scanstamp, AV_SCANSTAMP_SZ);
132 }
133 
134 static int
135 zfs_replay_domain_cnt(uint64_t uid, uint64_t gid)
136 {
137 	uint64_t uid_idx;
138 	uint64_t gid_idx;
139 	int domcnt = 0;
140 
141 	uid_idx = FUID_INDEX(uid);
142 	gid_idx = FUID_INDEX(gid);
143 	if (uid_idx)
144 		domcnt++;
145 	if (gid_idx > 0 && gid_idx != uid_idx)
146 		domcnt++;
147 
148 	return (domcnt);
149 }
150 
151 static void *
152 zfs_replay_fuid_domain_common(zfs_fuid_info_t *fuid_infop, void *start,
153     int domcnt)
154 {
155 	int i;
156 
157 	for (i = 0; i != domcnt; i++) {
158 		fuid_infop->z_domain_table[i] = start;
159 		start = (caddr_t)start + strlen(start) + 1;
160 	}
161 
162 	return (start);
163 }
164 
165 /*
166  * Set the uid/gid in the fuid_info structure.
167  */
168 static void
169 zfs_replay_fuid_ugid(zfs_fuid_info_t *fuid_infop, uint64_t uid, uint64_t gid)
170 {
171 	/*
172 	 * If owner or group are log specific FUIDs then slurp up
173 	 * domain information and build zfs_fuid_info_t
174 	 */
175 	if (IS_EPHEMERAL(uid))
176 		fuid_infop->z_fuid_owner = uid;
177 
178 	if (IS_EPHEMERAL(gid))
179 		fuid_infop->z_fuid_group = gid;
180 }
181 
182 /*
183  * Load fuid domains into fuid_info_t
184  */
185 static zfs_fuid_info_t *
186 zfs_replay_fuid_domain(void *buf, void **end, uint64_t uid, uint64_t gid)
187 {
188 	int domcnt;
189 
190 	zfs_fuid_info_t *fuid_infop;
191 
192 	fuid_infop = zfs_fuid_info_alloc();
193 
194 	domcnt = zfs_replay_domain_cnt(uid, gid);
195 
196 	if (domcnt == 0)
197 		return (fuid_infop);
198 
199 	fuid_infop->z_domain_table =
200 	    kmem_zalloc(domcnt * sizeof (char **), KM_SLEEP);
201 
202 	zfs_replay_fuid_ugid(fuid_infop, uid, gid);
203 
204 	fuid_infop->z_domain_cnt = domcnt;
205 	*end = zfs_replay_fuid_domain_common(fuid_infop, buf, domcnt);
206 	return (fuid_infop);
207 }
208 
209 /*
210  * load zfs_fuid_t's and fuid_domains into fuid_info_t
211  */
212 static zfs_fuid_info_t *
213 zfs_replay_fuids(void *start, void **end, int idcnt, int domcnt, uint64_t uid,
214     uint64_t gid)
215 {
216 	uint64_t *log_fuid = (uint64_t *)start;
217 	zfs_fuid_info_t *fuid_infop;
218 	int i;
219 
220 	fuid_infop = zfs_fuid_info_alloc();
221 	fuid_infop->z_domain_cnt = domcnt;
222 
223 	fuid_infop->z_domain_table =
224 	    kmem_zalloc(domcnt * sizeof (char **), KM_SLEEP);
225 
226 	for (i = 0; i != idcnt; i++) {
227 		zfs_fuid_t *zfuid;
228 
229 		zfuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP);
230 		zfuid->z_logfuid = *log_fuid;
231 		zfuid->z_id = -1;
232 		zfuid->z_domidx = 0;
233 		list_insert_tail(&fuid_infop->z_fuids, zfuid);
234 		log_fuid++;
235 	}
236 
237 	zfs_replay_fuid_ugid(fuid_infop, uid, gid);
238 
239 	*end = zfs_replay_fuid_domain_common(fuid_infop, log_fuid, domcnt);
240 	return (fuid_infop);
241 }
242 
243 static void
244 zfs_replay_swap_attrs(lr_attr_t *lrattr)
245 {
246 	/* swap the lr_attr structure */
247 	byteswap_uint32_array(lrattr, sizeof (*lrattr));
248 	/* swap the bitmap */
249 	byteswap_uint32_array(lrattr + 1, (lrattr->lr_attr_masksize - 1) *
250 	    sizeof (uint32_t));
251 	/* swap the attributes, create time + 64 bit word for attributes */
252 	byteswap_uint64_array((caddr_t)(lrattr + 1) + (sizeof (uint32_t) *
253 	    (lrattr->lr_attr_masksize - 1)), 3 * sizeof (uint64_t));
254 }
255 
256 /*
257  * Replay file create with optional ACL, xvattr information as well
258  * as option FUID information.
259  */
260 static int
261 zfs_replay_create_acl(zfsvfs_t *zfsvfs,
262     lr_acl_create_t *lracl, boolean_t byteswap)
263 {
264 	char *name = NULL;		/* location determined later */
265 	lr_create_t *lr = (lr_create_t *)lracl;
266 	znode_t *dzp;
267 	vnode_t *vp = NULL;
268 	xvattr_t xva;
269 	int vflg = 0;
270 	vsecattr_t vsec = { 0 };
271 	lr_attr_t *lrattr;
272 	void *aclstart;
273 	void *fuidstart;
274 	size_t xvatlen = 0;
275 	uint64_t txtype;
276 	int error;
277 
278 	if (byteswap) {
279 		byteswap_uint64_array(lracl, sizeof (*lracl));
280 		txtype = (int)lr->lr_common.lrc_txtype;
281 		if (txtype == TX_CREATE_ACL_ATTR ||
282 		    txtype == TX_MKDIR_ACL_ATTR) {
283 			lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
284 			zfs_replay_swap_attrs(lrattr);
285 			xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
286 		}
287 
288 		aclstart = (caddr_t)(lracl + 1) + xvatlen;
289 		zfs_ace_byteswap(aclstart, lracl->lr_acl_bytes, B_FALSE);
290 		/* swap fuids */
291 		if (lracl->lr_fuidcnt) {
292 			byteswap_uint64_array((caddr_t)aclstart +
293 			    ZIL_ACE_LENGTH(lracl->lr_acl_bytes),
294 			    lracl->lr_fuidcnt * sizeof (uint64_t));
295 		}
296 	}
297 
298 	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
299 		return (error);
300 
301 	xva_init(&xva);
302 	zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID,
303 	    lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid);
304 
305 	/*
306 	 * All forms of zfs create (create, mkdir, mkxattrdir, symlink)
307 	 * eventually end up in zfs_mknode(), which assigns the object's
308 	 * creation time and generation number.  The generic VOP_CREATE()
309 	 * doesn't have either concept, so we smuggle the values inside
310 	 * the vattr's otherwise unused va_ctime and va_nblocks fields.
311 	 */
312 	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
313 	xva.xva_vattr.va_nblocks = lr->lr_gen;
314 
315 	error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL);
316 	if (error != ENOENT)
317 		goto bail;
318 
319 	if (lr->lr_common.lrc_txtype & TX_CI)
320 		vflg |= FIGNORECASE;
321 	switch ((int)lr->lr_common.lrc_txtype) {
322 	case TX_CREATE_ACL:
323 		aclstart = (caddr_t)(lracl + 1);
324 		fuidstart = (caddr_t)aclstart +
325 		    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
326 		zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
327 		    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
328 		    lr->lr_uid, lr->lr_gid);
329 		/*FALLTHROUGH*/
330 	case TX_CREATE_ACL_ATTR:
331 		if (name == NULL) {
332 			lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
333 			xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
334 			xva.xva_vattr.va_mask |= AT_XVATTR;
335 			zfs_replay_xvattr(lrattr, &xva);
336 		}
337 		vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS;
338 		vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen;
339 		vsec.vsa_aclcnt = lracl->lr_aclcnt;
340 		vsec.vsa_aclentsz = lracl->lr_acl_bytes;
341 		vsec.vsa_aclflags = lracl->lr_acl_flags;
342 		if (zfsvfs->z_fuid_replay == NULL) {
343 			fuidstart = (caddr_t)(lracl + 1) + xvatlen +
344 			    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
345 			zfsvfs->z_fuid_replay =
346 			    zfs_replay_fuids(fuidstart,
347 			    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
348 			    lr->lr_uid, lr->lr_gid);
349 		}
350 
351 		error = VOP_CREATE(ZTOV(dzp), name, &xva.xva_vattr,
352 		    0, 0, &vp, kcred, vflg, NULL, &vsec);
353 		break;
354 	case TX_MKDIR_ACL:
355 		aclstart = (caddr_t)(lracl + 1);
356 		fuidstart = (caddr_t)aclstart +
357 		    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
358 		zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
359 		    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
360 		    lr->lr_uid, lr->lr_gid);
361 		/*FALLTHROUGH*/
362 	case TX_MKDIR_ACL_ATTR:
363 		if (name == NULL) {
364 			lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
365 			xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
366 			zfs_replay_xvattr(lrattr, &xva);
367 		}
368 		vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS;
369 		vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen;
370 		vsec.vsa_aclcnt = lracl->lr_aclcnt;
371 		vsec.vsa_aclentsz = lracl->lr_acl_bytes;
372 		vsec.vsa_aclflags = lracl->lr_acl_flags;
373 		if (zfsvfs->z_fuid_replay == NULL) {
374 			fuidstart = (caddr_t)(lracl + 1) + xvatlen +
375 			    ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
376 			zfsvfs->z_fuid_replay =
377 			    zfs_replay_fuids(fuidstart,
378 			    (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
379 			    lr->lr_uid, lr->lr_gid);
380 		}
381 		error = VOP_MKDIR(ZTOV(dzp), name, &xva.xva_vattr,
382 		    &vp, kcred, NULL, vflg, &vsec);
383 		break;
384 	default:
385 		error = ENOTSUP;
386 	}
387 
388 bail:
389 	if (error == 0 && vp != NULL)
390 		VN_RELE(vp);
391 
392 	VN_RELE(ZTOV(dzp));
393 
394 	zfs_fuid_info_free(zfsvfs->z_fuid_replay);
395 	zfsvfs->z_fuid_replay = NULL;
396 
397 	return (error);
398 }
399 
400 static int
401 zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap)
402 {
403 	char *name = NULL;		/* location determined later */
404 	char *link;			/* symlink content follows name */
405 	znode_t *dzp;
406 	vnode_t *vp = NULL;
407 	xvattr_t xva;
408 	int vflg = 0;
409 	size_t lrsize = sizeof (lr_create_t);
410 	lr_attr_t *lrattr;
411 	void *start;
412 	size_t xvatlen;
413 	uint64_t txtype;
414 	int error;
415 
416 	if (byteswap) {
417 		byteswap_uint64_array(lr, sizeof (*lr));
418 		txtype = (int)lr->lr_common.lrc_txtype;
419 		if (txtype == TX_CREATE_ATTR || txtype == TX_MKDIR_ATTR)
420 			zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
421 	}
422 
423 
424 	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
425 		return (error);
426 
427 	xva_init(&xva);
428 	zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID,
429 	    lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid);
430 
431 	/*
432 	 * All forms of zfs create (create, mkdir, mkxattrdir, symlink)
433 	 * eventually end up in zfs_mknode(), which assigns the object's
434 	 * creation time and generation number.  The generic VOP_CREATE()
435 	 * doesn't have either concept, so we smuggle the values inside
436 	 * the vattr's otherwise unused va_ctime and va_nblocks fields.
437 	 */
438 	ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
439 	xva.xva_vattr.va_nblocks = lr->lr_gen;
440 
441 	error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL);
442 	if (error != ENOENT)
443 		goto out;
444 
445 	if (lr->lr_common.lrc_txtype & TX_CI)
446 		vflg |= FIGNORECASE;
447 
448 	/*
449 	 * Symlinks don't have fuid info, and CIFS never creates
450 	 * symlinks.
451 	 *
452 	 * The _ATTR versions will grab the fuid info in their subcases.
453 	 */
454 	if ((int)lr->lr_common.lrc_txtype != TX_SYMLINK &&
455 	    (int)lr->lr_common.lrc_txtype != TX_MKDIR_ATTR &&
456 	    (int)lr->lr_common.lrc_txtype != TX_CREATE_ATTR) {
457 		start = (lr + 1);
458 		zfsvfs->z_fuid_replay =
459 		    zfs_replay_fuid_domain(start, &start,
460 		    lr->lr_uid, lr->lr_gid);
461 	}
462 
463 	switch ((int)lr->lr_common.lrc_txtype) {
464 	case TX_CREATE_ATTR:
465 		lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
466 		xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
467 		zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
468 		start = (caddr_t)(lr + 1) + xvatlen;
469 		zfsvfs->z_fuid_replay =
470 		    zfs_replay_fuid_domain(start, &start,
471 		    lr->lr_uid, lr->lr_gid);
472 		name = (char *)start;
473 
474 		/*FALLTHROUGH*/
475 	case TX_CREATE:
476 		if (name == NULL)
477 			name = (char *)start;
478 
479 		error = VOP_CREATE(ZTOV(dzp), name, &xva.xva_vattr,
480 		    0, 0, &vp, kcred, vflg, NULL, NULL);
481 		break;
482 	case TX_MKDIR_ATTR:
483 		lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
484 		xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
485 		zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
486 		start = (caddr_t)(lr + 1) + xvatlen;
487 		zfsvfs->z_fuid_replay =
488 		    zfs_replay_fuid_domain(start, &start,
489 		    lr->lr_uid, lr->lr_gid);
490 		name = (char *)start;
491 
492 		/*FALLTHROUGH*/
493 	case TX_MKDIR:
494 		if (name == NULL)
495 			name = (char *)(lr + 1);
496 
497 		error = VOP_MKDIR(ZTOV(dzp), name, &xva.xva_vattr,
498 		    &vp, kcred, NULL, vflg, NULL);
499 		break;
500 	case TX_MKXATTR:
501 		name = (char *)(lr + 1);
502 		error = zfs_make_xattrdir(dzp, &xva.xva_vattr, &vp, kcred);
503 		break;
504 	case TX_SYMLINK:
505 		name = (char *)(lr + 1);
506 		link = name + strlen(name) + 1;
507 		error = VOP_SYMLINK(ZTOV(dzp), name, &xva.xva_vattr,
508 		    link, kcred, NULL, vflg);
509 		break;
510 	default:
511 		error = ENOTSUP;
512 	}
513 
514 out:
515 	if (error == 0 && vp != NULL)
516 		VN_RELE(vp);
517 
518 	VN_RELE(ZTOV(dzp));
519 
520 	if (zfsvfs->z_fuid_replay)
521 		zfs_fuid_info_free(zfsvfs->z_fuid_replay);
522 	zfsvfs->z_fuid_replay = NULL;
523 	return (error);
524 }
525 
526 static int
527 zfs_replay_remove(zfsvfs_t *zfsvfs, lr_remove_t *lr, boolean_t byteswap)
528 {
529 	char *name = (char *)(lr + 1);	/* name follows lr_remove_t */
530 	znode_t *dzp;
531 	int error;
532 	int vflg = 0;
533 
534 	if (byteswap)
535 		byteswap_uint64_array(lr, sizeof (*lr));
536 
537 	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
538 		return (error);
539 
540 	if (lr->lr_common.lrc_txtype & TX_CI)
541 		vflg |= FIGNORECASE;
542 
543 	switch ((int)lr->lr_common.lrc_txtype) {
544 	case TX_REMOVE:
545 		error = VOP_REMOVE(ZTOV(dzp), name, kcred, NULL, vflg);
546 		break;
547 	case TX_RMDIR:
548 		error = VOP_RMDIR(ZTOV(dzp), name, NULL, kcred, NULL, vflg);
549 		break;
550 	default:
551 		error = ENOTSUP;
552 	}
553 
554 	VN_RELE(ZTOV(dzp));
555 
556 	return (error);
557 }
558 
559 static int
560 zfs_replay_link(zfsvfs_t *zfsvfs, lr_link_t *lr, boolean_t byteswap)
561 {
562 	char *name = (char *)(lr + 1);	/* name follows lr_link_t */
563 	znode_t *dzp, *zp;
564 	int error;
565 	int vflg = 0;
566 
567 	if (byteswap)
568 		byteswap_uint64_array(lr, sizeof (*lr));
569 
570 	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
571 		return (error);
572 
573 	if ((error = zfs_zget(zfsvfs, lr->lr_link_obj, &zp)) != 0) {
574 		VN_RELE(ZTOV(dzp));
575 		return (error);
576 	}
577 
578 	if (lr->lr_common.lrc_txtype & TX_CI)
579 		vflg |= FIGNORECASE;
580 
581 	error = VOP_LINK(ZTOV(dzp), ZTOV(zp), name, kcred, NULL, vflg);
582 
583 	VN_RELE(ZTOV(zp));
584 	VN_RELE(ZTOV(dzp));
585 
586 	return (error);
587 }
588 
589 static int
590 zfs_replay_rename(zfsvfs_t *zfsvfs, lr_rename_t *lr, boolean_t byteswap)
591 {
592 	char *sname = (char *)(lr + 1);	/* sname and tname follow lr_rename_t */
593 	char *tname = sname + strlen(sname) + 1;
594 	znode_t *sdzp, *tdzp;
595 	int error;
596 	int vflg = 0;
597 
598 	if (byteswap)
599 		byteswap_uint64_array(lr, sizeof (*lr));
600 
601 	if ((error = zfs_zget(zfsvfs, lr->lr_sdoid, &sdzp)) != 0)
602 		return (error);
603 
604 	if ((error = zfs_zget(zfsvfs, lr->lr_tdoid, &tdzp)) != 0) {
605 		VN_RELE(ZTOV(sdzp));
606 		return (error);
607 	}
608 
609 	if (lr->lr_common.lrc_txtype & TX_CI)
610 		vflg |= FIGNORECASE;
611 
612 	error = VOP_RENAME(ZTOV(sdzp), sname, ZTOV(tdzp), tname, kcred,
613 	    NULL, vflg);
614 
615 	VN_RELE(ZTOV(tdzp));
616 	VN_RELE(ZTOV(sdzp));
617 
618 	return (error);
619 }
620 
621 static int
622 zfs_replay_write(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap)
623 {
624 	char *data = (char *)(lr + 1);	/* data follows lr_write_t */
625 	znode_t	*zp;
626 	int error;
627 	ssize_t resid;
628 
629 	if (byteswap)
630 		byteswap_uint64_array(lr, sizeof (*lr));
631 
632 	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
633 		/*
634 		 * As we can log writes out of order, it's possible the
635 		 * file has been removed. In this case just drop the write
636 		 * and return success.
637 		 */
638 		if (error == ENOENT)
639 			error = 0;
640 		return (error);
641 	}
642 
643 	error = vn_rdwr(UIO_WRITE, ZTOV(zp), data, lr->lr_length,
644 	    lr->lr_offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
645 
646 	VN_RELE(ZTOV(zp));
647 
648 	return (error);
649 }
650 
651 static int
652 zfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap)
653 {
654 	znode_t *zp;
655 	flock64_t fl;
656 	int error;
657 
658 	if (byteswap)
659 		byteswap_uint64_array(lr, sizeof (*lr));
660 
661 	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
662 		/*
663 		 * As we can log truncates out of order, it's possible the
664 		 * file has been removed. In this case just drop the truncate
665 		 * and return success.
666 		 */
667 		if (error == ENOENT)
668 			error = 0;
669 		return (error);
670 	}
671 
672 	bzero(&fl, sizeof (fl));
673 	fl.l_type = F_WRLCK;
674 	fl.l_whence = 0;
675 	fl.l_start = lr->lr_offset;
676 	fl.l_len = lr->lr_length;
677 
678 	error = VOP_SPACE(ZTOV(zp), F_FREESP, &fl, FWRITE | FOFFMAX,
679 	    lr->lr_offset, kcred, NULL);
680 
681 	VN_RELE(ZTOV(zp));
682 
683 	return (error);
684 }
685 
686 static int
687 zfs_replay_setattr(zfsvfs_t *zfsvfs, lr_setattr_t *lr, boolean_t byteswap)
688 {
689 	znode_t *zp;
690 	xvattr_t xva;
691 	vattr_t *vap = &xva.xva_vattr;
692 	int error;
693 	void *start;
694 
695 	xva_init(&xva);
696 	if (byteswap) {
697 		byteswap_uint64_array(lr, sizeof (*lr));
698 
699 		if ((lr->lr_mask & AT_XVATTR) &&
700 		    zfsvfs->z_version >= ZPL_VERSION_INITIAL)
701 			zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
702 	}
703 
704 	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
705 		/*
706 		 * As we can log setattrs out of order, it's possible the
707 		 * file has been removed. In this case just drop the setattr
708 		 * and return success.
709 		 */
710 		if (error == ENOENT)
711 			error = 0;
712 		return (error);
713 	}
714 
715 	zfs_init_vattr(vap, lr->lr_mask, lr->lr_mode,
716 	    lr->lr_uid, lr->lr_gid, 0, lr->lr_foid);
717 
718 	vap->va_size = lr->lr_size;
719 	ZFS_TIME_DECODE(&vap->va_atime, lr->lr_atime);
720 	ZFS_TIME_DECODE(&vap->va_mtime, lr->lr_mtime);
721 
722 	/*
723 	 * Fill in xvattr_t portions if necessary.
724 	 */
725 
726 	start = (lr_setattr_t *)(lr + 1);
727 	if (vap->va_mask & AT_XVATTR) {
728 		zfs_replay_xvattr((lr_attr_t *)start, &xva);
729 		start = (caddr_t)start +
730 		    ZIL_XVAT_SIZE(((lr_attr_t *)start)->lr_attr_masksize);
731 	} else
732 		xva.xva_vattr.va_mask &= ~AT_XVATTR;
733 
734 	zfsvfs->z_fuid_replay = zfs_replay_fuid_domain(start, &start,
735 	    lr->lr_uid, lr->lr_gid);
736 
737 	error = VOP_SETATTR(ZTOV(zp), vap, 0, kcred, NULL);
738 
739 	zfs_fuid_info_free(zfsvfs->z_fuid_replay);
740 	zfsvfs->z_fuid_replay = NULL;
741 	VN_RELE(ZTOV(zp));
742 
743 	return (error);
744 }
745 
746 static int
747 zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap)
748 {
749 	ace_t *ace = (ace_t *)(lr + 1);	/* ace array follows lr_acl_t */
750 	vsecattr_t vsa;
751 	znode_t *zp;
752 	int error;
753 
754 	if (byteswap) {
755 		byteswap_uint64_array(lr, sizeof (*lr));
756 		zfs_oldace_byteswap(ace, lr->lr_aclcnt);
757 	}
758 
759 	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
760 		/*
761 		 * As we can log acls out of order, it's possible the
762 		 * file has been removed. In this case just drop the acl
763 		 * and return success.
764 		 */
765 		if (error == ENOENT)
766 			error = 0;
767 		return (error);
768 	}
769 
770 	bzero(&vsa, sizeof (vsa));
771 	vsa.vsa_mask = VSA_ACE | VSA_ACECNT;
772 	vsa.vsa_aclcnt = lr->lr_aclcnt;
773 	vsa.vsa_aclentp = ace;
774 
775 	error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL);
776 
777 	VN_RELE(ZTOV(zp));
778 
779 	return (error);
780 }
781 
782 /*
783  * Replaying ACLs is complicated by FUID support.
784  * The log record may contain some optional data
785  * to be used for replaying FUID's.  These pieces
786  * are the actual FUIDs that were created initially.
787  * The FUID table index may no longer be valid and
788  * during zfs_create() a new index may be assigned.
789  * Because of this the log will contain the original
790  * doman+rid in order to create a new FUID.
791  *
792  * The individual ACEs may contain an ephemeral uid/gid which is no
793  * longer valid and will need to be replaced with an actual FUID.
794  *
795  */
796 static int
797 zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap)
798 {
799 	ace_t *ace = (ace_t *)(lr + 1);
800 	vsecattr_t vsa;
801 	znode_t *zp;
802 	int error;
803 
804 	if (byteswap) {
805 		byteswap_uint64_array(lr, sizeof (*lr));
806 		zfs_ace_byteswap(ace, lr->lr_acl_bytes, B_FALSE);
807 		if (lr->lr_fuidcnt) {
808 			byteswap_uint64_array((caddr_t)ace +
809 			    ZIL_ACE_LENGTH(lr->lr_acl_bytes),
810 			    lr->lr_fuidcnt * sizeof (uint64_t));
811 		}
812 	}
813 
814 	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
815 		/*
816 		 * As we can log acls out of order, it's possible the
817 		 * file has been removed. In this case just drop the acl
818 		 * and return success.
819 		 */
820 		if (error == ENOENT)
821 			error = 0;
822 		return (error);
823 	}
824 
825 	bzero(&vsa, sizeof (vsa));
826 	vsa.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS;
827 	vsa.vsa_aclcnt = lr->lr_aclcnt;
828 	vsa.vsa_aclentp = ace;
829 	vsa.vsa_aclentsz = lr->lr_acl_bytes;
830 	vsa.vsa_aclflags = lr->lr_acl_flags;
831 
832 	if (lr->lr_fuidcnt) {
833 		void *fuidstart = (caddr_t)ace +
834 		    ZIL_ACE_LENGTH(lr->lr_acl_bytes);
835 
836 		zfsvfs->z_fuid_replay =
837 		    zfs_replay_fuids(fuidstart, &fuidstart,
838 		    lr->lr_fuidcnt, lr->lr_domcnt, 0, 0);
839 	}
840 
841 	error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL);
842 
843 	if (zfsvfs->z_fuid_replay)
844 		zfs_fuid_info_free(zfsvfs->z_fuid_replay);
845 
846 	zfsvfs->z_fuid_replay = NULL;
847 	VN_RELE(ZTOV(zp));
848 
849 	return (error);
850 }
851 
852 /*
853  * Callback vectors for replaying records
854  */
855 zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE] = {
856 	zfs_replay_error,	/* 0 no such transaction type */
857 	zfs_replay_create,	/* TX_CREATE */
858 	zfs_replay_create,	/* TX_MKDIR */
859 	zfs_replay_create,	/* TX_MKXATTR */
860 	zfs_replay_create,	/* TX_SYMLINK */
861 	zfs_replay_remove,	/* TX_REMOVE */
862 	zfs_replay_remove,	/* TX_RMDIR */
863 	zfs_replay_link,	/* TX_LINK */
864 	zfs_replay_rename,	/* TX_RENAME */
865 	zfs_replay_write,	/* TX_WRITE */
866 	zfs_replay_truncate,	/* TX_TRUNCATE */
867 	zfs_replay_setattr,	/* TX_SETATTR */
868 	zfs_replay_acl_v0,	/* TX_ACL_V0 */
869 	zfs_replay_acl,		/* TX_ACL */
870 	zfs_replay_create_acl,	/* TX_CREATE_ACL */
871 	zfs_replay_create,	/* TX_CREATE_ATTR */
872 	zfs_replay_create_acl,	/* TX_CREATE_ACL_ATTR */
873 	zfs_replay_create_acl,	/* TX_MKDIR_ACL */
874 	zfs_replay_create,	/* TX_MKDIR_ATTR */
875 	zfs_replay_create_acl,	/* TX_MKDIR_ACL_ATTR */
876 };
877