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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 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 (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 } 133 134 static int 135 zfs_replay_domain_cnt(uint64_t uid, uint64_t gid) 136 { 137 uint64_t uid_idx; 138 uint64_t gid_idx; 139 int domcnt = 0; 140 141 uid_idx = FUID_INDEX(uid); 142 gid_idx = FUID_INDEX(gid); 143 if (uid_idx) 144 domcnt++; 145 if (gid_idx > 0 && gid_idx != uid_idx) 146 domcnt++; 147 148 return (domcnt); 149 } 150 151 static void * 152 zfs_replay_fuid_domain_common(zfs_fuid_info_t *fuid_infop, void *start, 153 int domcnt) 154 { 155 int i; 156 157 for (i = 0; i != domcnt; i++) { 158 fuid_infop->z_domain_table[i] = start; 159 start = (caddr_t)start + strlen(start) + 1; 160 } 161 162 return (start); 163 } 164 165 /* 166 * Set the uid/gid in the fuid_info structure. 167 */ 168 static void 169 zfs_replay_fuid_ugid(zfs_fuid_info_t *fuid_infop, uint64_t uid, uint64_t gid) 170 { 171 /* 172 * If owner or group are log specific FUIDs then slurp up 173 * domain information and build zfs_fuid_info_t 174 */ 175 if (IS_EPHEMERAL(uid)) 176 fuid_infop->z_fuid_owner = uid; 177 178 if (IS_EPHEMERAL(gid)) 179 fuid_infop->z_fuid_group = gid; 180 } 181 182 /* 183 * Load fuid domains into fuid_info_t 184 */ 185 static zfs_fuid_info_t * 186 zfs_replay_fuid_domain(void *buf, void **end, uint64_t uid, uint64_t gid) 187 { 188 int domcnt; 189 190 zfs_fuid_info_t *fuid_infop; 191 192 fuid_infop = zfs_fuid_info_alloc(); 193 194 domcnt = zfs_replay_domain_cnt(uid, gid); 195 196 if (domcnt == 0) 197 return (fuid_infop); 198 199 fuid_infop->z_domain_table = 200 kmem_zalloc(domcnt * sizeof (char **), KM_SLEEP); 201 202 zfs_replay_fuid_ugid(fuid_infop, uid, gid); 203 204 fuid_infop->z_domain_cnt = domcnt; 205 *end = zfs_replay_fuid_domain_common(fuid_infop, buf, domcnt); 206 return (fuid_infop); 207 } 208 209 /* 210 * load zfs_fuid_t's and fuid_domains into fuid_info_t 211 */ 212 static zfs_fuid_info_t * 213 zfs_replay_fuids(void *start, void **end, int idcnt, int domcnt, uint64_t uid, 214 uint64_t gid) 215 { 216 uint64_t *log_fuid = (uint64_t *)start; 217 zfs_fuid_info_t *fuid_infop; 218 int i; 219 220 fuid_infop = zfs_fuid_info_alloc(); 221 fuid_infop->z_domain_cnt = domcnt; 222 223 fuid_infop->z_domain_table = 224 kmem_zalloc(domcnt * sizeof (char **), KM_SLEEP); 225 226 for (i = 0; i != idcnt; i++) { 227 zfs_fuid_t *zfuid; 228 229 zfuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP); 230 zfuid->z_logfuid = *log_fuid; 231 zfuid->z_id = -1; 232 zfuid->z_domidx = 0; 233 list_insert_tail(&fuid_infop->z_fuids, zfuid); 234 log_fuid++; 235 } 236 237 zfs_replay_fuid_ugid(fuid_infop, uid, gid); 238 239 *end = zfs_replay_fuid_domain_common(fuid_infop, log_fuid, domcnt); 240 return (fuid_infop); 241 } 242 243 static void 244 zfs_replay_swap_attrs(lr_attr_t *lrattr) 245 { 246 /* swap the lr_attr structure */ 247 byteswap_uint32_array(lrattr, sizeof (*lrattr)); 248 /* swap the bitmap */ 249 byteswap_uint32_array(lrattr + 1, (lrattr->lr_attr_masksize - 1) * 250 sizeof (uint32_t)); 251 /* swap the attributes, create time + 64 bit word for attributes */ 252 byteswap_uint64_array((caddr_t)(lrattr + 1) + (sizeof (uint32_t) * 253 (lrattr->lr_attr_masksize - 1)), 3 * sizeof (uint64_t)); 254 } 255 256 /* 257 * Replay file create with optional ACL, xvattr information as well 258 * as option FUID information. 259 */ 260 static int 261 zfs_replay_create_acl(zfsvfs_t *zfsvfs, 262 lr_acl_create_t *lracl, boolean_t byteswap) 263 { 264 char *name = NULL; /* location determined later */ 265 lr_create_t *lr = (lr_create_t *)lracl; 266 znode_t *dzp; 267 vnode_t *vp = NULL; 268 xvattr_t xva; 269 int vflg = 0; 270 vsecattr_t vsec = { 0 }; 271 lr_attr_t *lrattr; 272 void *aclstart; 273 void *fuidstart; 274 size_t xvatlen = 0; 275 uint64_t txtype; 276 int error; 277 278 txtype = (lr->lr_common.lrc_txtype & ~TX_CI); 279 if (byteswap) { 280 byteswap_uint64_array(lracl, sizeof (*lracl)); 281 if (txtype == TX_CREATE_ACL_ATTR || 282 txtype == TX_MKDIR_ACL_ATTR) { 283 lrattr = (lr_attr_t *)(caddr_t)(lracl + 1); 284 zfs_replay_swap_attrs(lrattr); 285 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); 286 } 287 288 aclstart = (caddr_t)(lracl + 1) + xvatlen; 289 zfs_ace_byteswap(aclstart, lracl->lr_acl_bytes, B_FALSE); 290 /* swap fuids */ 291 if (lracl->lr_fuidcnt) { 292 byteswap_uint64_array((caddr_t)aclstart + 293 ZIL_ACE_LENGTH(lracl->lr_acl_bytes), 294 lracl->lr_fuidcnt * sizeof (uint64_t)); 295 } 296 } 297 298 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0) 299 return (error); 300 301 xva_init(&xva); 302 zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID, 303 lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid); 304 305 /* 306 * All forms of zfs create (create, mkdir, mkxattrdir, symlink) 307 * eventually end up in zfs_mknode(), which assigns the object's 308 * creation time and generation number. The generic VOP_CREATE() 309 * doesn't have either concept, so we smuggle the values inside 310 * the vattr's otherwise unused va_ctime and va_nblocks fields. 311 */ 312 ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime); 313 xva.xva_vattr.va_nblocks = lr->lr_gen; 314 315 error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL); 316 if (error != ENOENT) 317 goto bail; 318 319 if (lr->lr_common.lrc_txtype & TX_CI) 320 vflg |= FIGNORECASE; 321 switch (txtype) { 322 case TX_CREATE_ACL: 323 aclstart = (caddr_t)(lracl + 1); 324 fuidstart = (caddr_t)aclstart + 325 ZIL_ACE_LENGTH(lracl->lr_acl_bytes); 326 zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart, 327 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt, 328 lr->lr_uid, lr->lr_gid); 329 /*FALLTHROUGH*/ 330 case TX_CREATE_ACL_ATTR: 331 if (name == NULL) { 332 lrattr = (lr_attr_t *)(caddr_t)(lracl + 1); 333 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); 334 xva.xva_vattr.va_mask |= AT_XVATTR; 335 zfs_replay_xvattr(lrattr, &xva); 336 } 337 vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS; 338 vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen; 339 vsec.vsa_aclcnt = lracl->lr_aclcnt; 340 vsec.vsa_aclentsz = lracl->lr_acl_bytes; 341 vsec.vsa_aclflags = lracl->lr_acl_flags; 342 if (zfsvfs->z_fuid_replay == NULL) { 343 fuidstart = (caddr_t)(lracl + 1) + xvatlen + 344 ZIL_ACE_LENGTH(lracl->lr_acl_bytes); 345 zfsvfs->z_fuid_replay = 346 zfs_replay_fuids(fuidstart, 347 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt, 348 lr->lr_uid, lr->lr_gid); 349 } 350 351 error = VOP_CREATE(ZTOV(dzp), name, &xva.xva_vattr, 352 0, 0, &vp, kcred, vflg, NULL, &vsec); 353 break; 354 case TX_MKDIR_ACL: 355 aclstart = (caddr_t)(lracl + 1); 356 fuidstart = (caddr_t)aclstart + 357 ZIL_ACE_LENGTH(lracl->lr_acl_bytes); 358 zfsvfs->z_fuid_replay = zfs_replay_fuids(fuidstart, 359 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt, 360 lr->lr_uid, lr->lr_gid); 361 /*FALLTHROUGH*/ 362 case TX_MKDIR_ACL_ATTR: 363 if (name == NULL) { 364 lrattr = (lr_attr_t *)(caddr_t)(lracl + 1); 365 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); 366 zfs_replay_xvattr(lrattr, &xva); 367 } 368 vsec.vsa_mask = VSA_ACE | VSA_ACE_ACLFLAGS; 369 vsec.vsa_aclentp = (caddr_t)(lracl + 1) + xvatlen; 370 vsec.vsa_aclcnt = lracl->lr_aclcnt; 371 vsec.vsa_aclentsz = lracl->lr_acl_bytes; 372 vsec.vsa_aclflags = lracl->lr_acl_flags; 373 if (zfsvfs->z_fuid_replay == NULL) { 374 fuidstart = (caddr_t)(lracl + 1) + xvatlen + 375 ZIL_ACE_LENGTH(lracl->lr_acl_bytes); 376 zfsvfs->z_fuid_replay = 377 zfs_replay_fuids(fuidstart, 378 (void *)&name, lracl->lr_fuidcnt, lracl->lr_domcnt, 379 lr->lr_uid, lr->lr_gid); 380 } 381 error = VOP_MKDIR(ZTOV(dzp), name, &xva.xva_vattr, 382 &vp, kcred, NULL, vflg, &vsec); 383 break; 384 default: 385 error = ENOTSUP; 386 } 387 388 bail: 389 if (error == 0 && vp != NULL) 390 VN_RELE(vp); 391 392 VN_RELE(ZTOV(dzp)); 393 394 if (zfsvfs->z_fuid_replay) 395 zfs_fuid_info_free(zfsvfs->z_fuid_replay); 396 zfsvfs->z_fuid_replay = NULL; 397 398 return (error); 399 } 400 401 static int 402 zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap) 403 { 404 char *name = NULL; /* location determined later */ 405 char *link; /* symlink content follows name */ 406 znode_t *dzp; 407 vnode_t *vp = NULL; 408 xvattr_t xva; 409 int vflg = 0; 410 size_t lrsize = sizeof (lr_create_t); 411 lr_attr_t *lrattr; 412 void *start; 413 size_t xvatlen; 414 uint64_t txtype; 415 int error; 416 417 txtype = (lr->lr_common.lrc_txtype & ~TX_CI); 418 if (byteswap) { 419 byteswap_uint64_array(lr, sizeof (*lr)); 420 if (txtype == TX_CREATE_ATTR || txtype == TX_MKDIR_ATTR) 421 zfs_replay_swap_attrs((lr_attr_t *)(lr + 1)); 422 } 423 424 425 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0) 426 return (error); 427 428 xva_init(&xva); 429 zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID, 430 lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid); 431 432 /* 433 * All forms of zfs create (create, mkdir, mkxattrdir, symlink) 434 * eventually end up in zfs_mknode(), which assigns the object's 435 * creation time and generation number. The generic VOP_CREATE() 436 * doesn't have either concept, so we smuggle the values inside 437 * the vattr's otherwise unused va_ctime and va_nblocks fields. 438 */ 439 ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime); 440 xva.xva_vattr.va_nblocks = lr->lr_gen; 441 442 error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL); 443 if (error != ENOENT) 444 goto out; 445 446 if (lr->lr_common.lrc_txtype & TX_CI) 447 vflg |= FIGNORECASE; 448 449 /* 450 * Symlinks don't have fuid info, and CIFS never creates 451 * symlinks. 452 * 453 * The _ATTR versions will grab the fuid info in their subcases. 454 */ 455 if ((int)lr->lr_common.lrc_txtype != TX_SYMLINK && 456 (int)lr->lr_common.lrc_txtype != TX_MKDIR_ATTR && 457 (int)lr->lr_common.lrc_txtype != TX_CREATE_ATTR) { 458 start = (lr + 1); 459 zfsvfs->z_fuid_replay = 460 zfs_replay_fuid_domain(start, &start, 461 lr->lr_uid, lr->lr_gid); 462 } 463 464 switch (txtype) { 465 case TX_CREATE_ATTR: 466 lrattr = (lr_attr_t *)(caddr_t)(lr + 1); 467 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); 468 zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva); 469 start = (caddr_t)(lr + 1) + xvatlen; 470 zfsvfs->z_fuid_replay = 471 zfs_replay_fuid_domain(start, &start, 472 lr->lr_uid, lr->lr_gid); 473 name = (char *)start; 474 475 /*FALLTHROUGH*/ 476 case TX_CREATE: 477 if (name == NULL) 478 name = (char *)start; 479 480 error = VOP_CREATE(ZTOV(dzp), name, &xva.xva_vattr, 481 0, 0, &vp, kcred, vflg, NULL, NULL); 482 break; 483 case TX_MKDIR_ATTR: 484 lrattr = (lr_attr_t *)(caddr_t)(lr + 1); 485 xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); 486 zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva); 487 start = (caddr_t)(lr + 1) + xvatlen; 488 zfsvfs->z_fuid_replay = 489 zfs_replay_fuid_domain(start, &start, 490 lr->lr_uid, lr->lr_gid); 491 name = (char *)start; 492 493 /*FALLTHROUGH*/ 494 case TX_MKDIR: 495 if (name == NULL) 496 name = (char *)(lr + 1); 497 498 error = VOP_MKDIR(ZTOV(dzp), name, &xva.xva_vattr, 499 &vp, kcred, NULL, vflg, NULL); 500 break; 501 case TX_MKXATTR: 502 error = zfs_make_xattrdir(dzp, &xva.xva_vattr, &vp, kcred); 503 break; 504 case TX_SYMLINK: 505 name = (char *)(lr + 1); 506 link = name + strlen(name) + 1; 507 error = VOP_SYMLINK(ZTOV(dzp), name, &xva.xva_vattr, 508 link, kcred, NULL, vflg); 509 break; 510 default: 511 error = ENOTSUP; 512 } 513 514 out: 515 if (error == 0 && vp != NULL) 516 VN_RELE(vp); 517 518 VN_RELE(ZTOV(dzp)); 519 520 if (zfsvfs->z_fuid_replay) 521 zfs_fuid_info_free(zfsvfs->z_fuid_replay); 522 zfsvfs->z_fuid_replay = NULL; 523 return (error); 524 } 525 526 static int 527 zfs_replay_remove(zfsvfs_t *zfsvfs, lr_remove_t *lr, boolean_t byteswap) 528 { 529 char *name = (char *)(lr + 1); /* name follows lr_remove_t */ 530 znode_t *dzp; 531 int error; 532 int vflg = 0; 533 534 if (byteswap) 535 byteswap_uint64_array(lr, sizeof (*lr)); 536 537 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0) 538 return (error); 539 540 if (lr->lr_common.lrc_txtype & TX_CI) 541 vflg |= FIGNORECASE; 542 543 switch ((int)lr->lr_common.lrc_txtype) { 544 case TX_REMOVE: 545 error = VOP_REMOVE(ZTOV(dzp), name, kcred, NULL, vflg); 546 break; 547 case TX_RMDIR: 548 error = VOP_RMDIR(ZTOV(dzp), name, NULL, kcred, NULL, vflg); 549 break; 550 default: 551 error = ENOTSUP; 552 } 553 554 VN_RELE(ZTOV(dzp)); 555 556 return (error); 557 } 558 559 static int 560 zfs_replay_link(zfsvfs_t *zfsvfs, lr_link_t *lr, boolean_t byteswap) 561 { 562 char *name = (char *)(lr + 1); /* name follows lr_link_t */ 563 znode_t *dzp, *zp; 564 int error; 565 int vflg = 0; 566 567 if (byteswap) 568 byteswap_uint64_array(lr, sizeof (*lr)); 569 570 if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0) 571 return (error); 572 573 if ((error = zfs_zget(zfsvfs, lr->lr_link_obj, &zp)) != 0) { 574 VN_RELE(ZTOV(dzp)); 575 return (error); 576 } 577 578 if (lr->lr_common.lrc_txtype & TX_CI) 579 vflg |= FIGNORECASE; 580 581 error = VOP_LINK(ZTOV(dzp), ZTOV(zp), name, kcred, NULL, vflg); 582 583 VN_RELE(ZTOV(zp)); 584 VN_RELE(ZTOV(dzp)); 585 586 return (error); 587 } 588 589 static int 590 zfs_replay_rename(zfsvfs_t *zfsvfs, lr_rename_t *lr, boolean_t byteswap) 591 { 592 char *sname = (char *)(lr + 1); /* sname and tname follow lr_rename_t */ 593 char *tname = sname + strlen(sname) + 1; 594 znode_t *sdzp, *tdzp; 595 int error; 596 int vflg = 0; 597 598 if (byteswap) 599 byteswap_uint64_array(lr, sizeof (*lr)); 600 601 if ((error = zfs_zget(zfsvfs, lr->lr_sdoid, &sdzp)) != 0) 602 return (error); 603 604 if ((error = zfs_zget(zfsvfs, lr->lr_tdoid, &tdzp)) != 0) { 605 VN_RELE(ZTOV(sdzp)); 606 return (error); 607 } 608 609 if (lr->lr_common.lrc_txtype & TX_CI) 610 vflg |= FIGNORECASE; 611 612 error = VOP_RENAME(ZTOV(sdzp), sname, ZTOV(tdzp), tname, kcred, 613 NULL, vflg); 614 615 VN_RELE(ZTOV(tdzp)); 616 VN_RELE(ZTOV(sdzp)); 617 618 return (error); 619 } 620 621 static int 622 zfs_replay_write(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap) 623 { 624 char *data = (char *)(lr + 1); /* data follows lr_write_t */ 625 znode_t *zp; 626 int error; 627 ssize_t resid; 628 uint64_t orig_eof, eod, offset, length; 629 630 if (byteswap) 631 byteswap_uint64_array(lr, sizeof (*lr)); 632 633 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) { 634 /* 635 * As we can log writes out of order, it's possible the 636 * file has been removed. In this case just drop the write 637 * and return success. 638 */ 639 if (error == ENOENT) 640 error = 0; 641 return (error); 642 } 643 644 offset = lr->lr_offset; 645 length = lr->lr_length; 646 eod = offset + length; /* end of data for this write */ 647 648 orig_eof = zp->z_phys->zp_size; 649 650 /* If it's a dmu_sync() block, write the whole block */ 651 if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) { 652 uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr); 653 if (length < blocksize) { 654 offset -= offset % blocksize; 655 length = blocksize; 656 } 657 } 658 659 error = vn_rdwr(UIO_WRITE, ZTOV(zp), data, length, offset, 660 UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid); 661 662 /* 663 * This may be a write from a dmu_sync() for a whole block, 664 * and may extend beyond the current end of the file. 665 * We can't just replay what was written for this TX_WRITE as 666 * a future TX_WRITE2 may extend the eof and the data for that 667 * write needs to be there. So we write the whole block and 668 * reduce the eof. 669 */ 670 if (orig_eof < zp->z_phys->zp_size) /* file length grew ? */ 671 zp->z_phys->zp_size = eod; 672 673 VN_RELE(ZTOV(zp)); 674 675 return (error); 676 } 677 678 /* 679 * TX_WRITE2 are only generated when dmu_sync() returns EALREADY 680 * meaning the pool block is already being synced. So now that we always write 681 * out full blocks, all we have to do is expand the eof if 682 * the file is grown. 683 */ 684 static int 685 zfs_replay_write2(zfsvfs_t *zfsvfs, lr_write_t *lr, boolean_t byteswap) 686 { 687 znode_t *zp; 688 int error; 689 uint64_t end; 690 691 if (byteswap) 692 byteswap_uint64_array(lr, sizeof (*lr)); 693 694 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) 695 return (error); 696 697 end = lr->lr_offset + lr->lr_length; 698 if (end > zp->z_phys->zp_size) { 699 ASSERT3U(end - zp->z_phys->zp_size, <, zp->z_blksz); 700 zp->z_phys->zp_size = end; 701 } 702 703 VN_RELE(ZTOV(zp)); 704 705 return (error); 706 } 707 708 static int 709 zfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap) 710 { 711 znode_t *zp; 712 flock64_t fl; 713 int error; 714 715 if (byteswap) 716 byteswap_uint64_array(lr, sizeof (*lr)); 717 718 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) 719 return (error); 720 721 bzero(&fl, sizeof (fl)); 722 fl.l_type = F_WRLCK; 723 fl.l_whence = 0; 724 fl.l_start = lr->lr_offset; 725 fl.l_len = lr->lr_length; 726 727 error = VOP_SPACE(ZTOV(zp), F_FREESP, &fl, FWRITE | FOFFMAX, 728 lr->lr_offset, kcred, NULL); 729 730 VN_RELE(ZTOV(zp)); 731 732 return (error); 733 } 734 735 static int 736 zfs_replay_setattr(zfsvfs_t *zfsvfs, lr_setattr_t *lr, boolean_t byteswap) 737 { 738 znode_t *zp; 739 xvattr_t xva; 740 vattr_t *vap = &xva.xva_vattr; 741 int error; 742 void *start; 743 744 xva_init(&xva); 745 if (byteswap) { 746 byteswap_uint64_array(lr, sizeof (*lr)); 747 748 if ((lr->lr_mask & AT_XVATTR) && 749 zfsvfs->z_version >= ZPL_VERSION_INITIAL) 750 zfs_replay_swap_attrs((lr_attr_t *)(lr + 1)); 751 } 752 753 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) 754 return (error); 755 756 zfs_init_vattr(vap, lr->lr_mask, lr->lr_mode, 757 lr->lr_uid, lr->lr_gid, 0, lr->lr_foid); 758 759 vap->va_size = lr->lr_size; 760 ZFS_TIME_DECODE(&vap->va_atime, lr->lr_atime); 761 ZFS_TIME_DECODE(&vap->va_mtime, lr->lr_mtime); 762 763 /* 764 * Fill in xvattr_t portions if necessary. 765 */ 766 767 start = (lr_setattr_t *)(lr + 1); 768 if (vap->va_mask & AT_XVATTR) { 769 zfs_replay_xvattr((lr_attr_t *)start, &xva); 770 start = (caddr_t)start + 771 ZIL_XVAT_SIZE(((lr_attr_t *)start)->lr_attr_masksize); 772 } else 773 xva.xva_vattr.va_mask &= ~AT_XVATTR; 774 775 zfsvfs->z_fuid_replay = zfs_replay_fuid_domain(start, &start, 776 lr->lr_uid, lr->lr_gid); 777 778 error = VOP_SETATTR(ZTOV(zp), vap, 0, kcred, NULL); 779 780 zfs_fuid_info_free(zfsvfs->z_fuid_replay); 781 zfsvfs->z_fuid_replay = NULL; 782 VN_RELE(ZTOV(zp)); 783 784 return (error); 785 } 786 787 static int 788 zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap) 789 { 790 ace_t *ace = (ace_t *)(lr + 1); /* ace array follows lr_acl_t */ 791 vsecattr_t vsa; 792 znode_t *zp; 793 int error; 794 795 if (byteswap) { 796 byteswap_uint64_array(lr, sizeof (*lr)); 797 zfs_oldace_byteswap(ace, lr->lr_aclcnt); 798 } 799 800 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) 801 return (error); 802 803 bzero(&vsa, sizeof (vsa)); 804 vsa.vsa_mask = VSA_ACE | VSA_ACECNT; 805 vsa.vsa_aclcnt = lr->lr_aclcnt; 806 vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt; 807 vsa.vsa_aclflags = 0; 808 vsa.vsa_aclentp = ace; 809 810 error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL); 811 812 VN_RELE(ZTOV(zp)); 813 814 return (error); 815 } 816 817 /* 818 * Replaying ACLs is complicated by FUID support. 819 * The log record may contain some optional data 820 * to be used for replaying FUID's. These pieces 821 * are the actual FUIDs that were created initially. 822 * The FUID table index may no longer be valid and 823 * during zfs_create() a new index may be assigned. 824 * Because of this the log will contain the original 825 * doman+rid in order to create a new FUID. 826 * 827 * The individual ACEs may contain an ephemeral uid/gid which is no 828 * longer valid and will need to be replaced with an actual FUID. 829 * 830 */ 831 static int 832 zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap) 833 { 834 ace_t *ace = (ace_t *)(lr + 1); 835 vsecattr_t vsa; 836 znode_t *zp; 837 int error; 838 839 if (byteswap) { 840 byteswap_uint64_array(lr, sizeof (*lr)); 841 zfs_ace_byteswap(ace, lr->lr_acl_bytes, B_FALSE); 842 if (lr->lr_fuidcnt) { 843 byteswap_uint64_array((caddr_t)ace + 844 ZIL_ACE_LENGTH(lr->lr_acl_bytes), 845 lr->lr_fuidcnt * sizeof (uint64_t)); 846 } 847 } 848 849 if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) 850 return (error); 851 852 bzero(&vsa, sizeof (vsa)); 853 vsa.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS; 854 vsa.vsa_aclcnt = lr->lr_aclcnt; 855 vsa.vsa_aclentp = ace; 856 vsa.vsa_aclentsz = lr->lr_acl_bytes; 857 vsa.vsa_aclflags = lr->lr_acl_flags; 858 859 if (lr->lr_fuidcnt) { 860 void *fuidstart = (caddr_t)ace + 861 ZIL_ACE_LENGTH(lr->lr_acl_bytes); 862 863 zfsvfs->z_fuid_replay = 864 zfs_replay_fuids(fuidstart, &fuidstart, 865 lr->lr_fuidcnt, lr->lr_domcnt, 0, 0); 866 } 867 868 error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL); 869 870 if (zfsvfs->z_fuid_replay) 871 zfs_fuid_info_free(zfsvfs->z_fuid_replay); 872 873 zfsvfs->z_fuid_replay = NULL; 874 VN_RELE(ZTOV(zp)); 875 876 return (error); 877 } 878 879 /* 880 * Callback vectors for replaying records 881 */ 882 zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE] = { 883 zfs_replay_error, /* 0 no such transaction type */ 884 zfs_replay_create, /* TX_CREATE */ 885 zfs_replay_create, /* TX_MKDIR */ 886 zfs_replay_create, /* TX_MKXATTR */ 887 zfs_replay_create, /* TX_SYMLINK */ 888 zfs_replay_remove, /* TX_REMOVE */ 889 zfs_replay_remove, /* TX_RMDIR */ 890 zfs_replay_link, /* TX_LINK */ 891 zfs_replay_rename, /* TX_RENAME */ 892 zfs_replay_write, /* TX_WRITE */ 893 zfs_replay_truncate, /* TX_TRUNCATE */ 894 zfs_replay_setattr, /* TX_SETATTR */ 895 zfs_replay_acl_v0, /* TX_ACL_V0 */ 896 zfs_replay_acl, /* TX_ACL */ 897 zfs_replay_create_acl, /* TX_CREATE_ACL */ 898 zfs_replay_create, /* TX_CREATE_ATTR */ 899 zfs_replay_create_acl, /* TX_CREATE_ACL_ATTR */ 900 zfs_replay_create_acl, /* TX_MKDIR_ACL */ 901 zfs_replay_create, /* TX_MKDIR_ATTR */ 902 zfs_replay_create_acl, /* TX_MKDIR_ACL_ATTR */ 903 zfs_replay_write2, /* TX_WRITE2 */ 904 }; 905
Indexes created Wed Feb 10 08:15:04 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
