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