sys/contrib/openzfs/module/zfs/zfs_replay.c

   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 };