?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BRT should return EOPNOTSUPP
[zfs.git] / module / zfs / zfs_replay.c
blob09c7be853bf9b9390c25ca6d632c29eb3e9c4799
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 https://opensource.org/licenses/CDDL-1.0.
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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2012 Cyril Plisko. All rights reserved.
24 * Copyright (c) 2013, 2017 by Delphix. All rights reserved.
25 * Copyright (c) 2021, 2022 by Pawel Jakub Dawidek
26 */
27
28 #include <sys/types.h>
29 #include <sys/param.h>
30 #include <sys/sysmacros.h>
31 #include <sys/cmn_err.h>
32 #include <sys/kmem.h>
33 #include <sys/thread.h>
34 #include <sys/file.h>
35 #include <sys/fcntl.h>
36 #include <sys/vfs.h>
37 #include <sys/fs/zfs.h>
38 #include <sys/zfs_znode.h>
39 #include <sys/zfs_dir.h>
40 #include <sys/zfs_acl.h>
41 #include <sys/zfs_fuid.h>
42 #include <sys/zfs_vnops.h>
43 #include <sys/spa.h>
44 #include <sys/zil.h>
45 #include <sys/byteorder.h>
46 #include <sys/stat.h>
47 #include <sys/acl.h>
48 #include <sys/atomic.h>
49 #include <sys/cred.h>
50 #include <sys/zpl.h>
51 #include <sys/dmu_objset.h>
52 #include <sys/zfeature.h>
53
54 /*
55 * NB: FreeBSD expects to be able to do vnode locking in lookup and
56 * hold the locks across all subsequent VOPs until vput is called.
57 * This means that its zfs vnops routines can't do any internal locking.
58 * In order to have the same contract as the Linux vnops there would
59 * needed to be duplicate locked vnops. If the vnops were used more widely
60 * in common code this would likely be preferable. However, currently
61 * this is the only file where this is the case.
62 */
63
64 /*
65 * Functions to replay ZFS intent log (ZIL) records
66 * The functions are called through a function vector (zfs_replay_vector)
67 * which is indexed by the transaction type.
68 */
69
70 static void
71 zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode,
72 uint64_t uid, uint64_t gid, uint64_t rdev, uint64_t nodeid)
73 {
74 memset(vap, 0, sizeof (*vap));
75 vap->va_mask = (uint_t)mask;
76 vap->va_mode = mode;
77 #if defined(__FreeBSD__) || defined(__APPLE__)
78 vap->va_type = IFTOVT(mode);
79 #endif
80 vap->va_uid = (uid_t)(IS_EPHEMERAL(uid)) ? -1 : uid;
81 vap->va_gid = (gid_t)(IS_EPHEMERAL(gid)) ? -1 : gid;
82 vap->va_rdev = zfs_cmpldev(rdev);
83 vap->va_nodeid = nodeid;
84 }
85
86 static int
87 zfs_replay_error(void *arg1, void *arg2, boolean_t byteswap)
88 {
89 (void) arg1, (void) arg2, (void) byteswap;
90 return (SET_ERROR(ENOTSUP));
91 }
92
93 static void
94 zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap)
95 {
96 xoptattr_t *xoap = NULL;
97 uint64_t *attrs;
98 uint64_t *crtime;
99 uint32_t *bitmap;
100 void *scanstamp;
101 int i;
102
103 xvap->xva_vattr.va_mask |= ATTR_XVATTR;
104 if ((xoap = xva_getxoptattr(xvap)) == NULL) {
105 xvap->xva_vattr.va_mask &= ~ATTR_XVATTR; /* shouldn't happen */
106 return;
107 }
108
109 ASSERT(lrattr->lr_attr_masksize == xvap->xva_mapsize);
110
111 bitmap = &lrattr->lr_attr_bitmap;
112 for (i = 0; i != lrattr->lr_attr_masksize; i++, bitmap++)
113 xvap->xva_reqattrmap[i] = *bitmap;
114
115 attrs = (uint64_t *)(lrattr + lrattr->lr_attr_masksize - 1);
116 crtime = attrs + 1;
117 scanstamp = (caddr_t)(crtime + 2);
118
119 if (XVA_ISSET_REQ(xvap, XAT_HIDDEN))
120 xoap->xoa_hidden = ((*attrs & XAT0_HIDDEN) != 0);
121 if (XVA_ISSET_REQ(xvap, XAT_SYSTEM))
122 xoap->xoa_system = ((*attrs & XAT0_SYSTEM) != 0);
123 if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE))
124 xoap->xoa_archive = ((*attrs & XAT0_ARCHIVE) != 0);
125 if (XVA_ISSET_REQ(xvap, XAT_READONLY))
126 xoap->xoa_readonly = ((*attrs & XAT0_READONLY) != 0);
127 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE))
128 xoap->xoa_immutable = ((*attrs & XAT0_IMMUTABLE) != 0);
129 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK))
130 xoap->xoa_nounlink = ((*attrs & XAT0_NOUNLINK) != 0);
131 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY))
132 xoap->xoa_appendonly = ((*attrs & XAT0_APPENDONLY) != 0);
133 if (XVA_ISSET_REQ(xvap, XAT_NODUMP))
134 xoap->xoa_nodump = ((*attrs & XAT0_NODUMP) != 0);
135 if (XVA_ISSET_REQ(xvap, XAT_OPAQUE))
136 xoap->xoa_opaque = ((*attrs & XAT0_OPAQUE) != 0);
137 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED))
138 xoap->xoa_av_modified = ((*attrs & XAT0_AV_MODIFIED) != 0);
139 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED))
140 xoap->xoa_av_quarantined =
141 ((*attrs & XAT0_AV_QUARANTINED) != 0);
142 if (XVA_ISSET_REQ(xvap, XAT_CREATETIME))
143 ZFS_TIME_DECODE(&xoap->xoa_createtime, crtime);
144 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) {
145 ASSERT(!XVA_ISSET_REQ(xvap, XAT_PROJID));
146
147 memcpy(xoap->xoa_av_scanstamp, scanstamp, AV_SCANSTAMP_SZ);
148 } else if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
149 /*
150 * XAT_PROJID and XAT_AV_SCANSTAMP will never be valid
151 * at the same time, so we can share the same space.
152 */
153 memcpy(&xoap->xoa_projid, scanstamp, sizeof (uint64_t));
154 }
155 if (XVA_ISSET_REQ(xvap, XAT_REPARSE))
156 xoap->xoa_reparse = ((*attrs & XAT0_REPARSE) != 0);
157 if (XVA_ISSET_REQ(xvap, XAT_OFFLINE))
158 xoap->xoa_offline = ((*attrs & XAT0_OFFLINE) != 0);
159 if (XVA_ISSET_REQ(xvap, XAT_SPARSE))
160 xoap->xoa_sparse = ((*attrs & XAT0_SPARSE) != 0);
161 if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT))
162 xoap->xoa_projinherit = ((*attrs & XAT0_PROJINHERIT) != 0);
163 }
164
165 static int
166 zfs_replay_domain_cnt(uint64_t uid, uint64_t gid)
167 {
168 uint64_t uid_idx;
169 uint64_t gid_idx;
170 int domcnt = 0;
171
172 uid_idx = FUID_INDEX(uid);
173 gid_idx = FUID_INDEX(gid);
174 if (uid_idx)
175 domcnt++;
176 if (gid_idx > 0 && gid_idx != uid_idx)
177 domcnt++;
178
179 return (domcnt);
180 }
181
182 static void *
183 zfs_replay_fuid_domain_common(zfs_fuid_info_t *fuid_infop, void *start,
184 int domcnt)
185 {
186 int i;
187
188 for (i = 0; i != domcnt; i++) {
189 fuid_infop->z_domain_table[i] = start;
190 start = (caddr_t)start + strlen(start) + 1;
191 }
192
193 return (start);
194 }
195
196 /*
197 * Set the uid/gid in the fuid_info structure.
198 */
199 static void
200 zfs_replay_fuid_ugid(zfs_fuid_info_t *fuid_infop, uint64_t uid, uint64_t gid)
201 {
202 /*
203 * If owner or group are log specific FUIDs then slurp up
204 * domain information and build zfs_fuid_info_t
205 */
206 if (IS_EPHEMERAL(uid))
207 fuid_infop->z_fuid_owner = uid;
208
209 if (IS_EPHEMERAL(gid))
210 fuid_infop->z_fuid_group = gid;
211 }
212
213 /*
214 * Load fuid domains into fuid_info_t
215 */
216 static zfs_fuid_info_t *
217 zfs_replay_fuid_domain(void *buf, void **end, uint64_t uid, uint64_t gid)
218 {
219 int domcnt;
220
221 zfs_fuid_info_t *fuid_infop;
222
223 fuid_infop = zfs_fuid_info_alloc();
224
225 domcnt = zfs_replay_domain_cnt(uid, gid);
226
227 if (domcnt == 0)
228 return (fuid_infop);
229
230 fuid_infop->z_domain_table =
231 kmem_zalloc(domcnt * sizeof (char *), KM_SLEEP);
232
233 zfs_replay_fuid_ugid(fuid_infop, uid, gid);
234
235 fuid_infop->z_domain_cnt = domcnt;
236 *end = zfs_replay_fuid_domain_common(fuid_infop, buf, domcnt);
237 return (fuid_infop);
238 }
239
240 /*
241 * load zfs_fuid_t's and fuid_domains into fuid_info_t
242 */
243 static zfs_fuid_info_t *
244 zfs_replay_fuids(void *start, void **end, int idcnt, int domcnt, uint64_t uid,
245 uint64_t gid)
246 {
247 uint64_t *log_fuid = (uint64_t *)start;
248 zfs_fuid_info_t *fuid_infop;
249 int i;
250
251 fuid_infop = zfs_fuid_info_alloc();
252 fuid_infop->z_domain_cnt = domcnt;
253
254 fuid_infop->z_domain_table =
255 kmem_zalloc(domcnt * sizeof (char *), KM_SLEEP);
256
257 for (i = 0; i != idcnt; i++) {
258 zfs_fuid_t *zfuid;
259
260 zfuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP);
261 zfuid->z_logfuid = *log_fuid;
262 zfuid->z_id = -1;
263 zfuid->z_domidx = 0;
264 list_insert_tail(&fuid_infop->z_fuids, zfuid);
265 log_fuid++;
266 }
267
268 zfs_replay_fuid_ugid(fuid_infop, uid, gid);
269
270 *end = zfs_replay_fuid_domain_common(fuid_infop, log_fuid, domcnt);
271 return (fuid_infop);
272 }
273
274 static void
275 zfs_replay_swap_attrs(lr_attr_t *lrattr)
276 {
277 /* swap the lr_attr structure */
278 byteswap_uint32_array(lrattr, sizeof (*lrattr));
279 /* swap the bitmap */
280 byteswap_uint32_array(lrattr + 1, (lrattr->lr_attr_masksize - 1) *
281 sizeof (uint32_t));
282 /* swap the attributes, create time + 64 bit word for attributes */
283 byteswap_uint64_array((caddr_t)(lrattr + 1) + (sizeof (uint32_t) *
284 (lrattr->lr_attr_masksize - 1)), 3 * sizeof (uint64_t));
285 }
286
287 /*
288 * Replay file create with optional ACL, xvattr information as well
289 * as option FUID information.
290 */
291 static int
292 zfs_replay_create_acl(void *arg1, void *arg2, boolean_t byteswap)
293 {
294 zfsvfs_t *zfsvfs = arg1;
295 lr_acl_create_t *lracl = arg2;
296 char *name = NULL; /* location determined later */
297 lr_create_t *lr = (lr_create_t *)lracl;
298 znode_t *dzp;
299 znode_t *zp;
300 xvattr_t xva;
301 int vflg = 0;
302 vsecattr_t vsec = { 0 };
303 lr_attr_t *lrattr;
304 void *aclstart;
305 void *fuidstart;
306 size_t xvatlen = 0;
307 uint64_t txtype;
308 uint64_t objid;
309 uint64_t dnodesize;
310 int error;
311
312 txtype = (lr->lr_common.lrc_txtype & ~TX_CI);
313 if (byteswap) {
314 byteswap_uint64_array(lracl, sizeof (*lracl));
315 if (txtype == TX_CREATE_ACL_ATTR ||
316 txtype == TX_MKDIR_ACL_ATTR) {
317 lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
318 zfs_replay_swap_attrs(lrattr);
319 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
320 }
321
322 aclstart = (caddr_t)(lracl + 1) + xvatlen;
323 zfs_ace_byteswap(aclstart, lracl->lr_acl_bytes, B_FALSE);
324 /* swap fuids */
325 if (lracl->lr_fuidcnt) {
326 byteswap_uint64_array((caddr_t)aclstart +
327 ZIL_ACE_LENGTH(lracl->lr_acl_bytes),
328 lracl->lr_fuidcnt * sizeof (uint64_t));
329 }
330 }
331
332 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
333 return (error);
334
335 objid = LR_FOID_GET_OBJ(lr->lr_foid);
336 dnodesize = LR_FOID_GET_SLOTS(lr->lr_foid) << DNODE_SHIFT;
337
338 xva_init(&xva);
339 zfs_init_vattr(&xva.xva_vattr, ATTR_MODE | ATTR_UID | ATTR_GID,
340 lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, objid);
341
342 /*
343 * All forms of zfs create (create, mkdir, mkxattrdir, symlink)
344 * eventually end up in zfs_mknode(), which assigns the object's
345 * creation time, generation number, and dnode size. The generic
346 * zfs_create() has no concept of these attributes, so we smuggle
347 * the values inside the vattr's otherwise unused va_ctime,
348 * va_nblocks, and va_fsid fields.
349 */
350 ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
351 xva.xva_vattr.va_nblocks = lr->lr_gen;
352 xva.xva_vattr.va_fsid = dnodesize;
353
354 error = dnode_try_claim(zfsvfs->z_os, objid, dnodesize >> DNODE_SHIFT);
355 if (error)
356 goto bail;
357
358 if (lr->lr_common.lrc_txtype & TX_CI)
359 vflg |= FIGNORECASE;
360 switch (txtype) {
361 case TX_CREATE_ACL:
362 aclstart = (caddr_t)(lracl + 1);
363 fuidstart = (caddr_t)aclstart +
364 ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
365 zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
366 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
367 lr->lr_uid, lr->lr_gid);
368 zfs_fallthrough;
369 case TX_CREATE_ACL_ATTR:
370 if (name == NULL) {
371 lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
372 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
373 xva.xva_vattr.va_mask |= ATTR_XVATTR;
374 zfs_replay_xvattr(lrattr, &xva);
375 }
376 vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS;
377 vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen;
378 vsec.vsa_aclcnt = lracl->lr_aclcnt;
379 vsec.vsa_aclentsz = lracl->lr_acl_bytes;
380 vsec.vsa_aclflags = lracl->lr_acl_flags;
381 if (zfsvfs->z_fuid_replay == NULL) {
382 fuidstart = (caddr_t)(lracl + 1) + xvatlen +
383 ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
384 zfsvfs->z_fuid_replay =
385 zfs_replay_fuids(fuidstart,
386 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
387 lr->lr_uid, lr->lr_gid);
388 }
389
390 #if defined(__linux__)
391 error = zfs_create(dzp, name, &xva.xva_vattr,
392 0, 0, &zp, kcred, vflg, &vsec, zfs_init_idmap);
393 #else
394 error = zfs_create(dzp, name, &xva.xva_vattr,
395 0, 0, &zp, kcred, vflg, &vsec, NULL);
396 #endif
397 break;
398 case TX_MKDIR_ACL:
399 aclstart = (caddr_t)(lracl + 1);
400 fuidstart = (caddr_t)aclstart +
401 ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
402 zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart,
403 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
404 lr->lr_uid, lr->lr_gid);
405 zfs_fallthrough;
406 case TX_MKDIR_ACL_ATTR:
407 if (name == NULL) {
408 lrattr = (lr_attr_t *)(caddr_t)(lracl + 1);
409 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
410 zfs_replay_xvattr(lrattr, &xva);
411 }
412 vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS;
413 vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen;
414 vsec.vsa_aclcnt = lracl->lr_aclcnt;
415 vsec.vsa_aclentsz = lracl->lr_acl_bytes;
416 vsec.vsa_aclflags = lracl->lr_acl_flags;
417 if (zfsvfs->z_fuid_replay == NULL) {
418 fuidstart = (caddr_t)(lracl + 1) + xvatlen +
419 ZIL_ACE_LENGTH(lracl->lr_acl_bytes);
420 zfsvfs->z_fuid_replay =
421 zfs_replay_fuids(fuidstart,
422 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt,
423 lr->lr_uid, lr->lr_gid);
424 }
425 #if defined(__linux__)
426 error = zfs_mkdir(dzp, name, &xva.xva_vattr,
427 &zp, kcred, vflg, &vsec, zfs_init_idmap);
428 #else
429 error = zfs_mkdir(dzp, name, &xva.xva_vattr,
430 &zp, kcred, vflg, &vsec, NULL);
431 #endif
432 break;
433 default:
434 error = SET_ERROR(ENOTSUP);
435 }
436
437 bail:
438 if (error == 0 && zp != NULL) {
439 #ifdef __FreeBSD__
440 VOP_UNLOCK1(ZTOV(zp));
441 #endif
442 zrele(zp);
443 }
444 zrele(dzp);
445
446 if (zfsvfs->z_fuid_replay)
447 zfs_fuid_info_free(zfsvfs->z_fuid_replay);
448 zfsvfs->z_fuid_replay = NULL;
449
450 return (error);
451 }
452
453 static int
454 zfs_replay_create(void *arg1, void *arg2, boolean_t byteswap)
455 {
456 zfsvfs_t *zfsvfs = arg1;
457 lr_create_t *lr = arg2;
458 char *name = NULL; /* location determined later */
459 char *link; /* symlink content follows name */
460 znode_t *dzp;
461 znode_t *zp = NULL;
462 xvattr_t xva;
463 int vflg = 0;
464 size_t lrsize = sizeof (lr_create_t);
465 lr_attr_t *lrattr;
466 void *start;
467 size_t xvatlen;
468 uint64_t txtype;
469 uint64_t objid;
470 uint64_t dnodesize;
471 int error;
472
473 txtype = (lr->lr_common.lrc_txtype & ~TX_CI);
474 if (byteswap) {
475 byteswap_uint64_array(lr, sizeof (*lr));
476 if (txtype == TX_CREATE_ATTR || txtype == TX_MKDIR_ATTR)
477 zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
478 }
479
480
481 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
482 return (error);
483
484 objid = LR_FOID_GET_OBJ(lr->lr_foid);
485 dnodesize = LR_FOID_GET_SLOTS(lr->lr_foid) << DNODE_SHIFT;
486
487 xva_init(&xva);
488 zfs_init_vattr(&xva.xva_vattr, ATTR_MODE | ATTR_UID | ATTR_GID,
489 lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, objid);
490
491 /*
492 * All forms of zfs create (create, mkdir, mkxattrdir, symlink)
493 * eventually end up in zfs_mknode(), which assigns the object's
494 * creation time, generation number, and dnode slot count. The
495 * generic zfs_create() has no concept of these attributes, so
496 * we smuggle the values inside the vattr's otherwise unused
497 * va_ctime, va_nblocks, and va_fsid fields.
498 */
499 ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime);
500 xva.xva_vattr.va_nblocks = lr->lr_gen;
501 xva.xva_vattr.va_fsid = dnodesize;
502
503 error = dnode_try_claim(zfsvfs->z_os, objid, dnodesize >> DNODE_SHIFT);
504 if (error)
505 goto out;
506
507 if (lr->lr_common.lrc_txtype & TX_CI)
508 vflg |= FIGNORECASE;
509
510 /*
511 * Symlinks don't have fuid info, and CIFS never creates
512 * symlinks.
513 *
514 * The _ATTR versions will grab the fuid info in their subcases.
515 */
516 if (txtype != TX_SYMLINK &&
517 txtype != TX_MKDIR_ATTR &&
518 txtype != TX_CREATE_ATTR) {
519 start = (lr + 1);
520 zfsvfs->z_fuid_replay =
521 zfs_replay_fuid_domain(start, &start,
522 lr->lr_uid, lr->lr_gid);
523 }
524
525 switch (txtype) {
526 case TX_CREATE_ATTR:
527 lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
528 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
529 zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
530 start = (caddr_t)(lr + 1) + xvatlen;
531 zfsvfs->z_fuid_replay =
532 zfs_replay_fuid_domain(start, &start,
533 lr->lr_uid, lr->lr_gid);
534 name = (char *)start;
535 zfs_fallthrough;
536
537 case TX_CREATE:
538 if (name == NULL)
539 name = (char *)start;
540
541 #if defined(__linux__)
542 error = zfs_create(dzp, name, &xva.xva_vattr,
543 0, 0, &zp, kcred, vflg, NULL, zfs_init_idmap);
544 #else
545 error = zfs_create(dzp, name, &xva.xva_vattr,
546 0, 0, &zp, kcred, vflg, NULL, NULL);
547 #endif
548 break;
549 case TX_MKDIR_ATTR:
550 lrattr = (lr_attr_t *)(caddr_t)(lr + 1);
551 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize);
552 zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva);
553 start = (caddr_t)(lr + 1) + xvatlen;
554 zfsvfs->z_fuid_replay =
555 zfs_replay_fuid_domain(start, &start,
556 lr->lr_uid, lr->lr_gid);
557 name = (char *)start;
558 zfs_fallthrough;
559
560 case TX_MKDIR:
561 if (name == NULL)
562 name = (char *)(lr + 1);
563
564 #if defined(__linux__)
565 error = zfs_mkdir(dzp, name, &xva.xva_vattr,
566 &zp, kcred, vflg, NULL, zfs_init_idmap);
567 #else
568 error = zfs_mkdir(dzp, name, &xva.xva_vattr,
569 &zp, kcred, vflg, NULL, NULL);
570 #endif
571
572 break;
573 case TX_MKXATTR:
574 error = zfs_make_xattrdir(dzp, &xva.xva_vattr, &zp, kcred);
575 break;
576 case TX_SYMLINK:
577 name = (char *)(lr + 1);
578 link = name + strlen(name) + 1;
579 #if defined(__linux__)
580 error = zfs_symlink(dzp, name, &xva.xva_vattr,
581 link, &zp, kcred, vflg, zfs_init_idmap);
582 #else
583 error = zfs_symlink(dzp, name, &xva.xva_vattr,
584 link, &zp, kcred, vflg, NULL);
585 #endif
586 break;
587 default:
588 error = SET_ERROR(ENOTSUP);
589 }
590
591 out:
592 if (error == 0 && zp != NULL) {
593 #ifdef __FreeBSD__
594 VOP_UNLOCK1(ZTOV(zp));
595 #endif
596 zrele(zp);
597 }
598 zrele(dzp);
599
600 if (zfsvfs->z_fuid_replay)
601 zfs_fuid_info_free(zfsvfs->z_fuid_replay);
602 zfsvfs->z_fuid_replay = NULL;
603 return (error);
604 }
605
606 static int
607 zfs_replay_remove(void *arg1, void *arg2, boolean_t byteswap)
608 {
609 zfsvfs_t *zfsvfs = arg1;
610 lr_remove_t *lr = arg2;
611 char *name = (char *)(lr + 1); /* name follows lr_remove_t */
612 znode_t *dzp;
613 int error;
614 int vflg = 0;
615
616 if (byteswap)
617 byteswap_uint64_array(lr, sizeof (*lr));
618
619 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
620 return (error);
621
622 if (lr->lr_common.lrc_txtype & TX_CI)
623 vflg |= FIGNORECASE;
624
625 switch ((int)lr->lr_common.lrc_txtype) {
626 case TX_REMOVE:
627 error = zfs_remove(dzp, name, kcred, vflg);
628 break;
629 case TX_RMDIR:
630 error = zfs_rmdir(dzp, name, NULL, kcred, vflg);
631 break;
632 default:
633 error = SET_ERROR(ENOTSUP);
634 }
635
636 zrele(dzp);
637
638 return (error);
639 }
640
641 static int
642 zfs_replay_link(void *arg1, void *arg2, boolean_t byteswap)
643 {
644 zfsvfs_t *zfsvfs = arg1;
645 lr_link_t *lr = arg2;
646 char *name = (char *)(lr + 1); /* name follows lr_link_t */
647 znode_t *dzp, *zp;
648 int error;
649 int vflg = 0;
650
651 if (byteswap)
652 byteswap_uint64_array(lr, sizeof (*lr));
653
654 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)
655 return (error);
656
657 if ((error = zfs_zget(zfsvfs, lr->lr_link_obj, &zp)) != 0) {
658 zrele(dzp);
659 return (error);
660 }
661
662 if (lr->lr_common.lrc_txtype & TX_CI)
663 vflg |= FIGNORECASE;
664
665 error = zfs_link(dzp, zp, name, kcred, vflg);
666 zrele(zp);
667 zrele(dzp);
668
669 return (error);
670 }
671
672 static int
673 do_zfs_replay_rename(zfsvfs_t *zfsvfs, lr_rename_t *lr, char *sname,
674 char *tname, uint64_t rflags, vattr_t *wo_vap)
675 {
676 znode_t *sdzp, *tdzp;
677 int error, vflg = 0;
678
679 /* Only Linux currently supports RENAME_* flags. */
680 #ifdef __linux__
681 VERIFY0(rflags & ~(RENAME_EXCHANGE | RENAME_WHITEOUT));
682
683 /* wo_vap must be non-NULL iff. we're doing RENAME_WHITEOUT */
684 VERIFY_EQUIV(rflags & RENAME_WHITEOUT, wo_vap != NULL);
685 #else
686 VERIFY0(rflags);
687 #endif
688
689 if ((error = zfs_zget(zfsvfs, lr->lr_sdoid, &sdzp)) != 0)
690 return (error);
691
692 if ((error = zfs_zget(zfsvfs, lr->lr_tdoid, &tdzp)) != 0) {
693 zrele(sdzp);
694 return (error);
695 }
696
697 if (lr->lr_common.lrc_txtype & TX_CI)
698 vflg |= FIGNORECASE;
699
700 #if defined(__linux__)
701 error = zfs_rename(sdzp, sname, tdzp, tname, kcred, vflg, rflags,
702 wo_vap, zfs_init_idmap);
703 #else
704 error = zfs_rename(sdzp, sname, tdzp, tname, kcred, vflg, rflags,
705 wo_vap, NULL);
706 #endif
707
708 zrele(tdzp);
709 zrele(sdzp);
710 return (error);
711 }
712
713 static int
714 zfs_replay_rename(void *arg1, void *arg2, boolean_t byteswap)
715 {
716 zfsvfs_t *zfsvfs = arg1;
717 lr_rename_t *lr = arg2;
718 char *sname = (char *)(lr + 1); /* sname and tname follow lr_rename_t */
719 char *tname = sname + strlen(sname) + 1;
720
721 if (byteswap)
722 byteswap_uint64_array(lr, sizeof (*lr));
723
724 return (do_zfs_replay_rename(zfsvfs, lr, sname, tname, 0, NULL));
725 }
726
727 static int
728 zfs_replay_rename_exchange(void *arg1, void *arg2, boolean_t byteswap)
729 {
730 #ifdef __linux__
731 zfsvfs_t *zfsvfs = arg1;
732 lr_rename_t *lr = arg2;
733 char *sname = (char *)(lr + 1); /* sname and tname follow lr_rename_t */
734 char *tname = sname + strlen(sname) + 1;
735
736 if (byteswap)
737 byteswap_uint64_array(lr, sizeof (*lr));
738
739 return (do_zfs_replay_rename(zfsvfs, lr, sname, tname, RENAME_EXCHANGE,
740 NULL));
741 #else
742 return (SET_ERROR(ENOTSUP));
743 #endif
744 }
745
746 static int
747 zfs_replay_rename_whiteout(void *arg1, void *arg2, boolean_t byteswap)
748 {
749 #ifdef __linux__
750 zfsvfs_t *zfsvfs = arg1;
751 lr_rename_whiteout_t *lr = arg2;
752 int error;
753 /* sname and tname follow lr_rename_whiteout_t */
754 char *sname = (char *)(lr + 1);
755 char *tname = sname + strlen(sname) + 1;
756 /* For the whiteout file. */
757 xvattr_t xva;
758 uint64_t objid;
759 uint64_t dnodesize;
760
761 if (byteswap)
762 byteswap_uint64_array(lr, sizeof (*lr));
763
764 objid = LR_FOID_GET_OBJ(lr->lr_wfoid);
765 dnodesize = LR_FOID_GET_SLOTS(lr->lr_wfoid) << DNODE_SHIFT;
766
767 xva_init(&xva);
768 zfs_init_vattr(&xva.xva_vattr, ATTR_MODE | ATTR_UID | ATTR_GID,
769 lr->lr_wmode, lr->lr_wuid, lr->lr_wgid, lr->lr_wrdev, objid);
770
771 /*
772 * As with TX_CREATE, RENAME_WHITEOUT ends up in zfs_mknode(), which
773 * assigns the object's creation time, generation number, and dnode
774 * slot count. The generic zfs_rename() has no concept of these
775 * attributes, so we smuggle the values inside the vattr's otherwise
776 * unused va_ctime, va_nblocks, and va_fsid fields.
777 */
778 ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_wcrtime);
779 xva.xva_vattr.va_nblocks = lr->lr_wgen;
780 xva.xva_vattr.va_fsid = dnodesize;
781
782 error = dnode_try_claim(zfsvfs->z_os, objid, dnodesize >> DNODE_SHIFT);
783 if (error)
784 return (error);
785
786 return (do_zfs_replay_rename(zfsvfs, &lr->lr_rename, sname, tname,
787 RENAME_WHITEOUT, &xva.xva_vattr));
788 #else
789 return (SET_ERROR(ENOTSUP));
790 #endif
791 }
792
793 static int
794 zfs_replay_write(void *arg1, void *arg2, boolean_t byteswap)
795 {
796 zfsvfs_t *zfsvfs = arg1;
797 lr_write_t *lr = arg2;
798 char *data = (char *)(lr + 1); /* data follows lr_write_t */
799 znode_t *zp;
800 int error;
801 uint64_t eod, offset, length;
802
803 if (byteswap)
804 byteswap_uint64_array(lr, sizeof (*lr));
805
806 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
807 /*
808 * As we can log writes out of order, it's possible the
809 * file has been removed. In this case just drop the write
810 * and return success.
811 */
812 if (error == ENOENT)
813 error = 0;
814 return (error);
815 }
816
817 offset = lr->lr_offset;
818 length = lr->lr_length;
819 eod = offset + length; /* end of data for this write */
820
821 /*
822 * This may be a write from a dmu_sync() for a whole block,
823 * and may extend beyond the current end of the file.
824 * We can't just replay what was written for this TX_WRITE as
825 * a future TX_WRITE2 may extend the eof and the data for that
826 * write needs to be there. So we write the whole block and
827 * reduce the eof. This needs to be done within the single dmu
828 * transaction created within vn_rdwr -> zfs_write. So a possible
829 * new end of file is passed through in zfsvfs->z_replay_eof
830 */
831
832 zfsvfs->z_replay_eof = 0; /* 0 means don't change end of file */
833
834 /* If it's a dmu_sync() block, write the whole block */
835 if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {
836 uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr);
837 if (length < blocksize) {
838 offset -= offset % blocksize;
839 length = blocksize;
840 }
841 if (zp->z_size < eod)
842 zfsvfs->z_replay_eof = eod;
843 }
844 error = zfs_write_simple(zp, data, length, offset, NULL);
845 zrele(zp);
846 zfsvfs->z_replay_eof = 0; /* safety */
847
848 return (error);
849 }
850
851 /*
852 * TX_WRITE2 are only generated when dmu_sync() returns EALREADY
853 * meaning the pool block is already being synced. So now that we always write
854 * out full blocks, all we have to do is expand the eof if
855 * the file is grown.
856 */
857 static int
858 zfs_replay_write2(void *arg1, void *arg2, boolean_t byteswap)
859 {
860 zfsvfs_t *zfsvfs = arg1;
861 lr_write_t *lr = arg2;
862 znode_t *zp;
863 int error;
864 uint64_t end;
865
866 if (byteswap)
867 byteswap_uint64_array(lr, sizeof (*lr));
868
869 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
870 return (error);
871
872 top:
873 end = lr->lr_offset + lr->lr_length;
874 if (end > zp->z_size) {
875 dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);
876
877 zp->z_size = end;
878 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
879 error = dmu_tx_assign(tx, TXG_WAIT);
880 if (error) {
881 zrele(zp);
882 if (error == ERESTART) {
883 dmu_tx_wait(tx);
884 dmu_tx_abort(tx);
885 goto top;
886 }
887 dmu_tx_abort(tx);
888 return (error);
889 }
890 (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
891 (void *)&zp->z_size, sizeof (uint64_t), tx);
892
893 /* Ensure the replayed seq is updated */
894 (void) zil_replaying(zfsvfs->z_log, tx);
895
896 dmu_tx_commit(tx);
897 }
898
899 zrele(zp);
900
901 return (error);
902 }
903
904 static int
905 zfs_replay_truncate(void *arg1, void *arg2, boolean_t byteswap)
906 {
907 zfsvfs_t *zfsvfs = arg1;
908 lr_truncate_t *lr = arg2;
909 znode_t *zp;
910 flock64_t fl = {0};
911 int error;
912
913 if (byteswap)
914 byteswap_uint64_array(lr, sizeof (*lr));
915
916 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
917 return (error);
918
919 fl.l_type = F_WRLCK;
920 fl.l_whence = SEEK_SET;
921 fl.l_start = lr->lr_offset;
922 fl.l_len = lr->lr_length;
923
924 error = zfs_space(zp, F_FREESP, &fl, O_RDWR | O_LARGEFILE,
925 lr->lr_offset, kcred);
926
927 zrele(zp);
928
929 return (error);
930 }
931
932 static int
933 zfs_replay_setattr(void *arg1, void *arg2, boolean_t byteswap)
934 {
935 zfsvfs_t *zfsvfs = arg1;
936 lr_setattr_t *lr = arg2;
937 znode_t *zp;
938 xvattr_t xva;
939 vattr_t *vap = &xva.xva_vattr;
940 int error;
941 void *start;
942
943 xva_init(&xva);
944 if (byteswap) {
945 byteswap_uint64_array(lr, sizeof (*lr));
946
947 if ((lr->lr_mask & ATTR_XVATTR) &&
948 zfsvfs->z_version >= ZPL_VERSION_INITIAL)
949 zfs_replay_swap_attrs((lr_attr_t *)(lr + 1));
950 }
951
952 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
953 return (error);
954
955 zfs_init_vattr(vap, lr->lr_mask, lr->lr_mode,
956 lr->lr_uid, lr->lr_gid, 0, lr->lr_foid);
957
958 vap->va_size = lr->lr_size;
959 ZFS_TIME_DECODE(&vap->va_atime, lr->lr_atime);
960 ZFS_TIME_DECODE(&vap->va_mtime, lr->lr_mtime);
961 gethrestime(&vap->va_ctime);
962 vap->va_mask |= ATTR_CTIME;
963
964 /*
965 * Fill in xvattr_t portions if necessary.
966 */
967
968 start = (lr_setattr_t *)(lr + 1);
969 if (vap->va_mask & ATTR_XVATTR) {
970 zfs_replay_xvattr((lr_attr_t *)start, &xva);
971 start = (caddr_t)start +
972 ZIL_XVAT_SIZE(((lr_attr_t *)start)->lr_attr_masksize);
973 } else
974 xva.xva_vattr.va_mask &= ~ATTR_XVATTR;
975
976 zfsvfs->z_fuid_replay = zfs_replay_fuid_domain(start, &start,
977 lr->lr_uid, lr->lr_gid);
978
979 #if defined(__linux__)
980 error = zfs_setattr(zp, vap, 0, kcred, zfs_init_idmap);
981 #else
982 error = zfs_setattr(zp, vap, 0, kcred, NULL);
983 #endif
984
985 zfs_fuid_info_free(zfsvfs->z_fuid_replay);
986 zfsvfs->z_fuid_replay = NULL;
987 zrele(zp);
988
989 return (error);
990 }
991
992 static int
993 zfs_replay_setsaxattr(void *arg1, void *arg2, boolean_t byteswap)
994 {
995 zfsvfs_t *zfsvfs = arg1;
996 lr_setsaxattr_t *lr = arg2;
997 znode_t *zp;
998 nvlist_t *nvl;
999 size_t sa_size;
1000 char *name;
1001 char *value;
1002 size_t size;
1003 int error = 0;
1004
1005 ASSERT(spa_feature_is_active(zfsvfs->z_os->os_spa,
1006 SPA_FEATURE_ZILSAXATTR));
1007 if (byteswap)
1008 byteswap_uint64_array(lr, sizeof (*lr));
1009
1010 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
1011 return (error);
1012
1013 rw_enter(&zp->z_xattr_lock, RW_WRITER);
1014 mutex_enter(&zp->z_lock);
1015 if (zp->z_xattr_cached == NULL)
1016 error = zfs_sa_get_xattr(zp);
1017 mutex_exit(&zp->z_lock);
1018
1019 if (error)
1020 goto out;
1021
1022 ASSERT(zp->z_xattr_cached);
1023 nvl = zp->z_xattr_cached;
1024
1025 /* Get xattr name, value and size from log record */
1026 size = lr->lr_size;
1027 name = (char *)(lr + 1);
1028 if (size == 0) {
1029 value = NULL;
1030 error = nvlist_remove(nvl, name, DATA_TYPE_BYTE_ARRAY);
1031 } else {
1032 value = name + strlen(name) + 1;
1033 /* Limited to 32k to keep nvpair memory allocations small */
1034 if (size > DXATTR_MAX_ENTRY_SIZE) {
1035 error = SET_ERROR(EFBIG);
1036 goto out;
1037 }
1038
1039 /* Prevent the DXATTR SA from consuming the entire SA region */
1040 error = nvlist_size(nvl, &sa_size, NV_ENCODE_XDR);
1041 if (error)
1042 goto out;
1043
1044 if (sa_size > DXATTR_MAX_SA_SIZE) {
1045 error = SET_ERROR(EFBIG);
1046 goto out;
1047 }
1048
1049 error = nvlist_add_byte_array(nvl, name, (uchar_t *)value,
1050 size);
1051 }
1052
1053 /*
1054 * Update the SA for additions, modifications, and removals. On
1055 * error drop the inconsistent cached version of the nvlist, it
1056 * will be reconstructed from the ARC when next accessed.
1057 */
1058 if (error == 0)
1059 error = zfs_sa_set_xattr(zp, name, value, size);
1060
1061 if (error) {
1062 nvlist_free(nvl);
1063 zp->z_xattr_cached = NULL;
1064 }
1065
1066 out:
1067 rw_exit(&zp->z_xattr_lock);
1068 zrele(zp);
1069 return (error);
1070 }
1071
1072 static int
1073 zfs_replay_acl_v0(void *arg1, void *arg2, boolean_t byteswap)
1074 {
1075 zfsvfs_t *zfsvfs = arg1;
1076 lr_acl_v0_t *lr = arg2;
1077 ace_t *ace = (ace_t *)(lr + 1); /* ace array follows lr_acl_t */
1078 vsecattr_t vsa = {0};
1079 znode_t *zp;
1080 int error;
1081
1082 if (byteswap) {
1083 byteswap_uint64_array(lr, sizeof (*lr));
1084 zfs_oldace_byteswap(ace, lr->lr_aclcnt);
1085 }
1086
1087 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
1088 return (error);
1089
1090 vsa.vsa_mask = VSA_ACE | VSA_ACECNT;
1091 vsa.vsa_aclcnt = lr->lr_aclcnt;
1092 vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt;
1093 vsa.vsa_aclflags = 0;
1094 vsa.vsa_aclentp = ace;
1095
1096 error = zfs_setsecattr(zp, &vsa, 0, kcred);
1097
1098 zrele(zp);
1099
1100 return (error);
1101 }
1102
1103 /*
1104 * Replaying ACLs is complicated by FUID support.
1105 * The log record may contain some optional data
1106 * to be used for replaying FUID's. These pieces
1107 * are the actual FUIDs that were created initially.
1108 * The FUID table index may no longer be valid and
1109 * during zfs_create() a new index may be assigned.
1110 * Because of this the log will contain the original
1111 * domain+rid in order to create a new FUID.
1112 *
1113 * The individual ACEs may contain an ephemeral uid/gid which is no
1114 * longer valid and will need to be replaced with an actual FUID.
1115 *
1116 */
1117 static int
1118 zfs_replay_acl(void *arg1, void *arg2, boolean_t byteswap)
1119 {
1120 zfsvfs_t *zfsvfs = arg1;
1121 lr_acl_t *lr = arg2;
1122 ace_t *ace = (ace_t *)(lr + 1);
1123 vsecattr_t vsa = {0};
1124 znode_t *zp;
1125 int error;
1126
1127 if (byteswap) {
1128 byteswap_uint64_array(lr, sizeof (*lr));
1129 zfs_ace_byteswap(ace, lr->lr_acl_bytes, B_FALSE);
1130 if (lr->lr_fuidcnt) {
1131 byteswap_uint64_array((caddr_t)ace +
1132 ZIL_ACE_LENGTH(lr->lr_acl_bytes),
1133 lr->lr_fuidcnt * sizeof (uint64_t));
1134 }
1135 }
1136
1137 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)
1138 return (error);
1139
1140 vsa.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS;
1141 vsa.vsa_aclcnt = lr->lr_aclcnt;
1142 vsa.vsa_aclentp = ace;
1143 vsa.vsa_aclentsz = lr->lr_acl_bytes;
1144 vsa.vsa_aclflags = lr->lr_acl_flags;
1145
1146 if (lr->lr_fuidcnt) {
1147 void *fuidstart = (caddr_t)ace +
1148 ZIL_ACE_LENGTH(lr->lr_acl_bytes);
1149
1150 zfsvfs->z_fuid_replay =
1151 zfs_replay_fuids(fuidstart, &fuidstart,
1152 lr->lr_fuidcnt, lr->lr_domcnt, 0, 0);
1153 }
1154
1155 error = zfs_setsecattr(zp, &vsa, 0, kcred);
1156
1157 if (zfsvfs->z_fuid_replay)
1158 zfs_fuid_info_free(zfsvfs->z_fuid_replay);
1159
1160 zfsvfs->z_fuid_replay = NULL;
1161 zrele(zp);
1162
1163 return (error);
1164 }
1165
1166 static int
1167 zfs_replay_clone_range(void *arg1, void *arg2, boolean_t byteswap)
1168 {
1169 zfsvfs_t *zfsvfs = arg1;
1170 lr_clone_range_t *lr = arg2;
1171 znode_t *zp;
1172 int error;
1173
1174 if (byteswap)
1175 byteswap_uint64_array(lr, sizeof (*lr));
1176
1177 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) {
1178 /*
1179 * Clones can be logged out of order, so don't be surprised if
1180 * the file is gone - just return success.
1181 */
1182 if (error == ENOENT)
1183 error = 0;
1184 return (error);
1185 }
1186
1187 error = zfs_clone_range_replay(zp, lr->lr_offset, lr->lr_length,
1188 lr->lr_blksz, lr->lr_bps, lr->lr_nbps);
1189
1190 zrele(zp);
1191 return (error);
1192 }
1193
1194 /*
1195 * Callback vectors for replaying records
1196 */
1197 zil_replay_func_t *const zfs_replay_vector[TX_MAX_TYPE] = {
1198 zfs_replay_error, /* no such type */
1199 zfs_replay_create, /* TX_CREATE */
1200 zfs_replay_create, /* TX_MKDIR */
1201 zfs_replay_create, /* TX_MKXATTR */
1202 zfs_replay_create, /* TX_SYMLINK */
1203 zfs_replay_remove, /* TX_REMOVE */
1204 zfs_replay_remove, /* TX_RMDIR */
1205 zfs_replay_link, /* TX_LINK */
1206 zfs_replay_rename, /* TX_RENAME */
1207 zfs_replay_write, /* TX_WRITE */
1208 zfs_replay_truncate, /* TX_TRUNCATE */
1209 zfs_replay_setattr, /* TX_SETATTR */
1210 zfs_replay_acl_v0, /* TX_ACL_V0 */
1211 zfs_replay_acl, /* TX_ACL */
1212 zfs_replay_create_acl, /* TX_CREATE_ACL */
1213 zfs_replay_create, /* TX_CREATE_ATTR */
1214 zfs_replay_create_acl, /* TX_CREATE_ACL_ATTR */
1215 zfs_replay_create_acl, /* TX_MKDIR_ACL */
1216 zfs_replay_create, /* TX_MKDIR_ATTR */
1217 zfs_replay_create_acl, /* TX_MKDIR_ACL_ATTR */
1218 zfs_replay_write2, /* TX_WRITE2 */
1219 zfs_replay_setsaxattr, /* TX_SETSAXATTR */
1220 zfs_replay_rename_exchange, /* TX_RENAME_EXCHANGE */
1221 zfs_replay_rename_whiteout, /* TX_RENAME_WHITEOUT */
1222 zfs_replay_clone_range, /* TX_CLONE_RANGE */
1223 };
OpenZFS on Linux and FreeBSD