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