]>
git.proxmox.com Git - mirror_zfs.git/blob - module/zfs/zfs_replay.c
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.
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.
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]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
25 #include <sys/types.h>
26 #include <sys/param.h>
27 #include <sys/systm.h>
28 #include <sys/sysmacros.h>
29 #include <sys/cmn_err.h>
31 #include <sys/thread.h>
33 #include <sys/fcntl.h>
35 #include <sys/fs/zfs.h>
36 #include <sys/zfs_znode.h>
37 #include <sys/zfs_dir.h>
38 #include <sys/zfs_acl.h>
39 #include <sys/zfs_fuid.h>
40 #include <sys/zfs_vnops.h>
43 #include <sys/byteorder.h>
47 #include <sys/atomic.h>
52 * Functions to replay ZFS intent log (ZIL) records
53 * The functions are called through a function vector (zfs_replay_vector)
54 * which is indexed by the transaction type.
58 zfs_init_vattr(vattr_t
*vap
, uint64_t mask
, uint64_t mode
,
59 uint64_t uid
, uint64_t gid
, uint64_t rdev
, uint64_t nodeid
)
61 bzero(vap
, sizeof (*vap
));
62 vap
->va_mask
= (uint_t
)mask
;
63 vap
->va_type
= IFTOVT(mode
);
65 vap
->va_uid
= (uid_t
)(IS_EPHEMERAL(uid
)) ? -1 : uid
;
66 vap
->va_gid
= (gid_t
)(IS_EPHEMERAL(gid
)) ? -1 : gid
;
68 vap
->va_nodeid
= nodeid
;
73 zfs_replay_error(zfs_sb_t
*zsb
, lr_t
*lr
, boolean_t byteswap
)
79 zfs_replay_xvattr(lr_attr_t
*lrattr
, xvattr_t
*xvap
)
81 xoptattr_t
*xoap
= NULL
;
88 xvap
->xva_vattr
.va_mask
|= ATTR_XVATTR
;
89 if ((xoap
= xva_getxoptattr(xvap
)) == NULL
) {
90 xvap
->xva_vattr
.va_mask
&= ~ATTR_XVATTR
; /* shouldn't happen */
94 ASSERT(lrattr
->lr_attr_masksize
== xvap
->xva_mapsize
);
96 bitmap
= &lrattr
->lr_attr_bitmap
;
97 for (i
= 0; i
!= lrattr
->lr_attr_masksize
; i
++, bitmap
++)
98 xvap
->xva_reqattrmap
[i
] = *bitmap
;
100 attrs
= (uint64_t *)(lrattr
+ lrattr
->lr_attr_masksize
- 1);
102 scanstamp
= (caddr_t
)(crtime
+ 2);
104 if (XVA_ISSET_REQ(xvap
, XAT_HIDDEN
))
105 xoap
->xoa_hidden
= ((*attrs
& XAT0_HIDDEN
) != 0);
106 if (XVA_ISSET_REQ(xvap
, XAT_SYSTEM
))
107 xoap
->xoa_system
= ((*attrs
& XAT0_SYSTEM
) != 0);
108 if (XVA_ISSET_REQ(xvap
, XAT_ARCHIVE
))
109 xoap
->xoa_archive
= ((*attrs
& XAT0_ARCHIVE
) != 0);
110 if (XVA_ISSET_REQ(xvap
, XAT_READONLY
))
111 xoap
->xoa_readonly
= ((*attrs
& XAT0_READONLY
) != 0);
112 if (XVA_ISSET_REQ(xvap
, XAT_IMMUTABLE
))
113 xoap
->xoa_immutable
= ((*attrs
& XAT0_IMMUTABLE
) != 0);
114 if (XVA_ISSET_REQ(xvap
, XAT_NOUNLINK
))
115 xoap
->xoa_nounlink
= ((*attrs
& XAT0_NOUNLINK
) != 0);
116 if (XVA_ISSET_REQ(xvap
, XAT_APPENDONLY
))
117 xoap
->xoa_appendonly
= ((*attrs
& XAT0_APPENDONLY
) != 0);
118 if (XVA_ISSET_REQ(xvap
, XAT_NODUMP
))
119 xoap
->xoa_nodump
= ((*attrs
& XAT0_NODUMP
) != 0);
120 if (XVA_ISSET_REQ(xvap
, XAT_OPAQUE
))
121 xoap
->xoa_opaque
= ((*attrs
& XAT0_OPAQUE
) != 0);
122 if (XVA_ISSET_REQ(xvap
, XAT_AV_MODIFIED
))
123 xoap
->xoa_av_modified
= ((*attrs
& XAT0_AV_MODIFIED
) != 0);
124 if (XVA_ISSET_REQ(xvap
, XAT_AV_QUARANTINED
))
125 xoap
->xoa_av_quarantined
=
126 ((*attrs
& XAT0_AV_QUARANTINED
) != 0);
127 if (XVA_ISSET_REQ(xvap
, XAT_CREATETIME
))
128 ZFS_TIME_DECODE(&xoap
->xoa_createtime
, crtime
);
129 if (XVA_ISSET_REQ(xvap
, XAT_AV_SCANSTAMP
))
130 bcopy(scanstamp
, xoap
->xoa_av_scanstamp
, AV_SCANSTAMP_SZ
);
131 if (XVA_ISSET_REQ(xvap
, XAT_REPARSE
))
132 xoap
->xoa_reparse
= ((*attrs
& XAT0_REPARSE
) != 0);
133 if (XVA_ISSET_REQ(xvap
, XAT_OFFLINE
))
134 xoap
->xoa_offline
= ((*attrs
& XAT0_OFFLINE
) != 0);
135 if (XVA_ISSET_REQ(xvap
, XAT_SPARSE
))
136 xoap
->xoa_sparse
= ((*attrs
& XAT0_SPARSE
) != 0);
140 zfs_replay_domain_cnt(uint64_t uid
, uint64_t gid
)
146 uid_idx
= FUID_INDEX(uid
);
147 gid_idx
= FUID_INDEX(gid
);
150 if (gid_idx
> 0 && gid_idx
!= uid_idx
)
157 zfs_replay_fuid_domain_common(zfs_fuid_info_t
*fuid_infop
, void *start
,
162 for (i
= 0; i
!= domcnt
; i
++) {
163 fuid_infop
->z_domain_table
[i
] = start
;
164 start
= (caddr_t
)start
+ strlen(start
) + 1;
171 * Set the uid/gid in the fuid_info structure.
174 zfs_replay_fuid_ugid(zfs_fuid_info_t
*fuid_infop
, uint64_t uid
, uint64_t gid
)
177 * If owner or group are log specific FUIDs then slurp up
178 * domain information and build zfs_fuid_info_t
180 if (IS_EPHEMERAL(uid
))
181 fuid_infop
->z_fuid_owner
= uid
;
183 if (IS_EPHEMERAL(gid
))
184 fuid_infop
->z_fuid_group
= gid
;
188 * Load fuid domains into fuid_info_t
190 static zfs_fuid_info_t
*
191 zfs_replay_fuid_domain(void *buf
, void **end
, uint64_t uid
, uint64_t gid
)
195 zfs_fuid_info_t
*fuid_infop
;
197 fuid_infop
= zfs_fuid_info_alloc();
199 domcnt
= zfs_replay_domain_cnt(uid
, gid
);
204 fuid_infop
->z_domain_table
=
205 kmem_zalloc(domcnt
* sizeof (char **), KM_SLEEP
);
207 zfs_replay_fuid_ugid(fuid_infop
, uid
, gid
);
209 fuid_infop
->z_domain_cnt
= domcnt
;
210 *end
= zfs_replay_fuid_domain_common(fuid_infop
, buf
, domcnt
);
215 * load zfs_fuid_t's and fuid_domains into fuid_info_t
217 static zfs_fuid_info_t
*
218 zfs_replay_fuids(void *start
, void **end
, int idcnt
, int domcnt
, uint64_t uid
,
221 uint64_t *log_fuid
= (uint64_t *)start
;
222 zfs_fuid_info_t
*fuid_infop
;
225 fuid_infop
= zfs_fuid_info_alloc();
226 fuid_infop
->z_domain_cnt
= domcnt
;
228 fuid_infop
->z_domain_table
=
229 kmem_zalloc(domcnt
* sizeof (char **), KM_SLEEP
);
231 for (i
= 0; i
!= idcnt
; i
++) {
234 zfuid
= kmem_alloc(sizeof (zfs_fuid_t
), KM_SLEEP
);
235 zfuid
->z_logfuid
= *log_fuid
;
238 list_insert_tail(&fuid_infop
->z_fuids
, zfuid
);
242 zfs_replay_fuid_ugid(fuid_infop
, uid
, gid
);
244 *end
= zfs_replay_fuid_domain_common(fuid_infop
, log_fuid
, domcnt
);
249 zfs_replay_swap_attrs(lr_attr_t
*lrattr
)
251 /* swap the lr_attr structure */
252 byteswap_uint32_array(lrattr
, sizeof (*lrattr
));
253 /* swap the bitmap */
254 byteswap_uint32_array(lrattr
+ 1, (lrattr
->lr_attr_masksize
- 1) *
256 /* swap the attributes, create time + 64 bit word for attributes */
257 byteswap_uint64_array((caddr_t
)(lrattr
+ 1) + (sizeof (uint32_t) *
258 (lrattr
->lr_attr_masksize
- 1)), 3 * sizeof (uint64_t));
262 * Replay file create with optional ACL, xvattr information as well
263 * as option FUID information.
266 zfs_replay_create_acl(zfs_sb_t
*zsb
, lr_acl_create_t
*lracl
, boolean_t byteswap
)
268 char *name
= NULL
; /* location determined later */
269 lr_create_t
*lr
= (lr_create_t
*)lracl
;
271 struct inode
*ip
= NULL
;
274 vsecattr_t vsec
= { 0 };
282 txtype
= (lr
->lr_common
.lrc_txtype
& ~TX_CI
);
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
);
292 aclstart
= (caddr_t
)(lracl
+ 1) + xvatlen
;
293 zfs_ace_byteswap(aclstart
, lracl
->lr_acl_bytes
, B_FALSE
);
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));
302 if ((error
= zfs_zget(zsb
, lr
->lr_doid
, &dzp
)) != 0)
306 zfs_init_vattr(&xva
.xva_vattr
, ATTR_MODE
| ATTR_UID
| ATTR_GID
,
307 lr
->lr_mode
, lr
->lr_uid
, lr
->lr_gid
, lr
->lr_rdev
, lr
->lr_foid
);
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 zfs_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.
316 ZFS_TIME_DECODE(&xva
.xva_vattr
.va_ctime
, lr
->lr_crtime
);
317 xva
.xva_vattr
.va_nblocks
= lr
->lr_gen
;
319 error
= dmu_object_info(zsb
->z_os
, lr
->lr_foid
, NULL
);
323 if (lr
->lr_common
.lrc_txtype
& TX_CI
)
327 aclstart
= (caddr_t
)(lracl
+ 1);
328 fuidstart
= (caddr_t
)aclstart
+
329 ZIL_ACE_LENGTH(lracl
->lr_acl_bytes
);
330 zsb
->z_fuid_replay
= zfs_replay_fuids(fuidstart
,
331 (void *)&name
, lracl
->lr_fuidcnt
, lracl
->lr_domcnt
,
332 lr
->lr_uid
, lr
->lr_gid
);
334 case TX_CREATE_ACL_ATTR
:
336 lrattr
= (lr_attr_t
*)(caddr_t
)(lracl
+ 1);
337 xvatlen
= ZIL_XVAT_SIZE(lrattr
->lr_attr_masksize
);
338 xva
.xva_vattr
.va_mask
|= ATTR_XVATTR
;
339 zfs_replay_xvattr(lrattr
, &xva
);
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 (zsb
->z_fuid_replay
== NULL
) {
347 fuidstart
= (caddr_t
)(lracl
+ 1) + xvatlen
+
348 ZIL_ACE_LENGTH(lracl
->lr_acl_bytes
);
350 zfs_replay_fuids(fuidstart
,
351 (void *)&name
, lracl
->lr_fuidcnt
, lracl
->lr_domcnt
,
352 lr
->lr_uid
, lr
->lr_gid
);
355 error
= zfs_create(ZTOI(dzp
), name
, &xva
.xva_vattr
,
356 0, 0, &ip
, kcred
, vflg
, &vsec
);
359 aclstart
= (caddr_t
)(lracl
+ 1);
360 fuidstart
= (caddr_t
)aclstart
+
361 ZIL_ACE_LENGTH(lracl
->lr_acl_bytes
);
362 zsb
->z_fuid_replay
= zfs_replay_fuids(fuidstart
,
363 (void *)&name
, lracl
->lr_fuidcnt
, lracl
->lr_domcnt
,
364 lr
->lr_uid
, lr
->lr_gid
);
366 case TX_MKDIR_ACL_ATTR
:
368 lrattr
= (lr_attr_t
*)(caddr_t
)(lracl
+ 1);
369 xvatlen
= ZIL_XVAT_SIZE(lrattr
->lr_attr_masksize
);
370 zfs_replay_xvattr(lrattr
, &xva
);
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 (zsb
->z_fuid_replay
== NULL
) {
378 fuidstart
= (caddr_t
)(lracl
+ 1) + xvatlen
+
379 ZIL_ACE_LENGTH(lracl
->lr_acl_bytes
);
381 zfs_replay_fuids(fuidstart
,
382 (void *)&name
, lracl
->lr_fuidcnt
, lracl
->lr_domcnt
,
383 lr
->lr_uid
, lr
->lr_gid
);
385 error
= zfs_mkdir(ZTOI(dzp
), name
, &xva
.xva_vattr
,
386 &ip
, kcred
, vflg
, &vsec
);
393 if (error
== 0 && ip
!= NULL
)
398 if (zsb
->z_fuid_replay
)
399 zfs_fuid_info_free(zsb
->z_fuid_replay
);
400 zsb
->z_fuid_replay
= NULL
;
406 zfs_replay_create(zfs_sb_t
*zsb
, lr_create_t
*lr
, boolean_t byteswap
)
408 char *name
= NULL
; /* location determined later */
409 char *link
; /* symlink content follows name */
411 struct inode
*ip
= NULL
;
414 size_t lrsize
= sizeof (lr_create_t
);
421 txtype
= (lr
->lr_common
.lrc_txtype
& ~TX_CI
);
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));
429 if ((error
= zfs_zget(zsb
, lr
->lr_doid
, &dzp
)) != 0)
433 zfs_init_vattr(&xva
.xva_vattr
, ATTR_MODE
| ATTR_UID
| ATTR_GID
,
434 lr
->lr_mode
, lr
->lr_uid
, lr
->lr_gid
, lr
->lr_rdev
, lr
->lr_foid
);
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 zfs_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.
443 ZFS_TIME_DECODE(&xva
.xva_vattr
.va_ctime
, lr
->lr_crtime
);
444 xva
.xva_vattr
.va_nblocks
= lr
->lr_gen
;
446 error
= dmu_object_info(zsb
->z_os
, lr
->lr_foid
, NULL
);
450 if (lr
->lr_common
.lrc_txtype
& TX_CI
)
454 * Symlinks don't have fuid info, and CIFS never creates
457 * The _ATTR versions will grab the fuid info in their subcases.
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
) {
464 zfs_replay_fuid_domain(start
, &start
,
465 lr
->lr_uid
, lr
->lr_gid
);
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
;
475 zfs_replay_fuid_domain(start
, &start
,
476 lr
->lr_uid
, lr
->lr_gid
);
477 name
= (char *)start
;
482 name
= (char *)start
;
484 error
= zfs_create(ZTOI(dzp
), name
, &xva
.xva_vattr
,
485 0, 0, &ip
, kcred
, vflg
, NULL
);
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
;
493 zfs_replay_fuid_domain(start
, &start
,
494 lr
->lr_uid
, lr
->lr_gid
);
495 name
= (char *)start
;
500 name
= (char *)(lr
+ 1);
502 error
= zfs_mkdir(ZTOI(dzp
), name
, &xva
.xva_vattr
,
503 &ip
, kcred
, vflg
, NULL
);
506 error
= zfs_make_xattrdir(dzp
, &xva
.xva_vattr
, &ip
, kcred
);
509 name
= (char *)(lr
+ 1);
510 link
= name
+ strlen(name
) + 1;
511 error
= zfs_symlink(ZTOI(dzp
), name
, &xva
.xva_vattr
,
512 link
, &ip
, kcred
, vflg
);
519 if (error
== 0 && ip
!= NULL
)
524 if (zsb
->z_fuid_replay
)
525 zfs_fuid_info_free(zsb
->z_fuid_replay
);
526 zsb
->z_fuid_replay
= NULL
;
531 zfs_replay_remove(zfs_sb_t
*zsb
, lr_remove_t
*lr
, boolean_t byteswap
)
533 char *name
= (char *)(lr
+ 1); /* name follows lr_remove_t */
539 byteswap_uint64_array(lr
, sizeof (*lr
));
541 if ((error
= zfs_zget(zsb
, lr
->lr_doid
, &dzp
)) != 0)
544 if (lr
->lr_common
.lrc_txtype
& TX_CI
)
547 switch ((int)lr
->lr_common
.lrc_txtype
) {
549 error
= zfs_remove(ZTOI(dzp
), name
, kcred
);
552 error
= zfs_rmdir(ZTOI(dzp
), name
, NULL
, kcred
, vflg
);
564 zfs_replay_link(zfs_sb_t
*zsb
, lr_link_t
*lr
, boolean_t byteswap
)
566 char *name
= (char *)(lr
+ 1); /* name follows lr_link_t */
572 byteswap_uint64_array(lr
, sizeof (*lr
));
574 if ((error
= zfs_zget(zsb
, lr
->lr_doid
, &dzp
)) != 0)
577 if ((error
= zfs_zget(zsb
, lr
->lr_link_obj
, &zp
)) != 0) {
582 if (lr
->lr_common
.lrc_txtype
& TX_CI
)
585 error
= zfs_link(ZTOI(dzp
), ZTOI(zp
), name
, kcred
);
594 zfs_replay_rename(zfs_sb_t
*zsb
, lr_rename_t
*lr
, boolean_t byteswap
)
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
;
603 byteswap_uint64_array(lr
, sizeof (*lr
));
605 if ((error
= zfs_zget(zsb
, lr
->lr_sdoid
, &sdzp
)) != 0)
608 if ((error
= zfs_zget(zsb
, lr
->lr_tdoid
, &tdzp
)) != 0) {
613 if (lr
->lr_common
.lrc_txtype
& TX_CI
)
616 error
= zfs_rename(ZTOI(sdzp
), sname
, ZTOI(tdzp
), tname
, kcred
, vflg
);
625 zfs_replay_write(zfs_sb_t
*zsb
, lr_write_t
*lr
, boolean_t byteswap
)
627 char *data
= (char *)(lr
+ 1); /* data follows lr_write_t */
630 uint64_t eod
, offset
, length
;
633 byteswap_uint64_array(lr
, sizeof (*lr
));
635 if ((error
= zfs_zget(zsb
, lr
->lr_foid
, &zp
)) != 0) {
637 * As we can log writes out of order, it's possible the
638 * file has been removed. In this case just drop the write
639 * and return success.
646 offset
= lr
->lr_offset
;
647 length
= lr
->lr_length
;
648 eod
= offset
+ length
; /* end of data for this write */
651 * This may be a write from a dmu_sync() for a whole block,
652 * and may extend beyond the current end of the file.
653 * We can't just replay what was written for this TX_WRITE as
654 * a future TX_WRITE2 may extend the eof and the data for that
655 * write needs to be there. So we write the whole block and
656 * reduce the eof. This needs to be done within the single dmu
657 * transaction created within vn_rdwr -> zfs_write. So a possible
658 * new end of file is passed through in zsb->z_replay_eof
661 zsb
->z_replay_eof
= 0; /* 0 means don't change end of file */
663 /* If it's a dmu_sync() block, write the whole block */
664 if (lr
->lr_common
.lrc_reclen
== sizeof (lr_write_t
)) {
665 uint64_t blocksize
= BP_GET_LSIZE(&lr
->lr_blkptr
);
666 if (length
< blocksize
) {
667 offset
-= offset
% blocksize
;
670 if (zp
->z_size
< eod
)
671 zsb
->z_replay_eof
= eod
;
674 error
= zpl_write_common(ZTOI(zp
), data
, length
, offset
,
675 UIO_SYSSPACE
, 0, kcred
);
680 error
= EIO
; /* Short write */
684 zsb
->z_replay_eof
= 0; /* safety */
690 * TX_WRITE2 are only generated when dmu_sync() returns EALREADY
691 * meaning the pool block is already being synced. So now that we always write
692 * out full blocks, all we have to do is expand the eof if
696 zfs_replay_write2(zfs_sb_t
*zsb
, lr_write_t
*lr
, boolean_t byteswap
)
703 byteswap_uint64_array(lr
, sizeof (*lr
));
705 if ((error
= zfs_zget(zsb
, lr
->lr_foid
, &zp
)) != 0)
709 end
= lr
->lr_offset
+ lr
->lr_length
;
710 if (end
> zp
->z_size
) {
711 dmu_tx_t
*tx
= dmu_tx_create(zsb
->z_os
);
714 dmu_tx_hold_sa(tx
, zp
->z_sa_hdl
, B_FALSE
);
715 error
= dmu_tx_assign(tx
, TXG_WAIT
);
718 if (error
== ERESTART
) {
726 (void) sa_update(zp
->z_sa_hdl
, SA_ZPL_SIZE(zsb
),
727 (void *)&zp
->z_size
, sizeof (uint64_t), tx
);
729 /* Ensure the replayed seq is updated */
730 (void) zil_replaying(zsb
->z_log
, tx
);
741 zfs_replay_truncate(zfs_sb_t
*zsb
, lr_truncate_t
*lr
, boolean_t byteswap
)
748 byteswap_uint64_array(lr
, sizeof (*lr
));
750 if ((error
= zfs_zget(zsb
, lr
->lr_foid
, &zp
)) != 0)
753 bzero(&fl
, sizeof (fl
));
756 fl
.l_start
= lr
->lr_offset
;
757 fl
.l_len
= lr
->lr_length
;
759 error
= zfs_space(ZTOI(zp
), F_FREESP
, &fl
, FWRITE
| FOFFMAX
,
760 lr
->lr_offset
, kcred
);
768 zfs_replay_setattr(zfs_sb_t
*zsb
, lr_setattr_t
*lr
, boolean_t byteswap
)
772 vattr_t
*vap
= &xva
.xva_vattr
;
778 byteswap_uint64_array(lr
, sizeof (*lr
));
780 if ((lr
->lr_mask
& ATTR_XVATTR
) &&
781 zsb
->z_version
>= ZPL_VERSION_INITIAL
)
782 zfs_replay_swap_attrs((lr_attr_t
*)(lr
+ 1));
785 if ((error
= zfs_zget(zsb
, lr
->lr_foid
, &zp
)) != 0)
788 zfs_init_vattr(vap
, lr
->lr_mask
, lr
->lr_mode
,
789 lr
->lr_uid
, lr
->lr_gid
, 0, lr
->lr_foid
);
791 vap
->va_size
= lr
->lr_size
;
792 ZFS_TIME_DECODE(&vap
->va_atime
, lr
->lr_atime
);
793 ZFS_TIME_DECODE(&vap
->va_mtime
, lr
->lr_mtime
);
796 * Fill in xvattr_t portions if necessary.
799 start
= (lr_setattr_t
*)(lr
+ 1);
800 if (vap
->va_mask
& ATTR_XVATTR
) {
801 zfs_replay_xvattr((lr_attr_t
*)start
, &xva
);
802 start
= (caddr_t
)start
+
803 ZIL_XVAT_SIZE(((lr_attr_t
*)start
)->lr_attr_masksize
);
805 xva
.xva_vattr
.va_mask
&= ~ATTR_XVATTR
;
807 zsb
->z_fuid_replay
= zfs_replay_fuid_domain(start
, &start
,
808 lr
->lr_uid
, lr
->lr_gid
);
810 error
= zfs_setattr(ZTOI(zp
), vap
, 0, kcred
);
812 zfs_fuid_info_free(zsb
->z_fuid_replay
);
813 zsb
->z_fuid_replay
= NULL
;
820 zfs_replay_acl_v0(zfs_sb_t
*zsb
, lr_acl_v0_t
*lr
, boolean_t byteswap
)
822 ace_t
*ace
= (ace_t
*)(lr
+ 1); /* ace array follows lr_acl_t */
828 byteswap_uint64_array(lr
, sizeof (*lr
));
829 zfs_oldace_byteswap(ace
, lr
->lr_aclcnt
);
832 if ((error
= zfs_zget(zsb
, lr
->lr_foid
, &zp
)) != 0)
835 bzero(&vsa
, sizeof (vsa
));
836 vsa
.vsa_mask
= VSA_ACE
| VSA_ACECNT
;
837 vsa
.vsa_aclcnt
= lr
->lr_aclcnt
;
838 vsa
.vsa_aclentsz
= sizeof (ace_t
) * vsa
.vsa_aclcnt
;
839 vsa
.vsa_aclflags
= 0;
840 vsa
.vsa_aclentp
= ace
;
842 error
= zfs_setsecattr(ZTOI(zp
), &vsa
, 0, kcred
);
850 * Replaying ACLs is complicated by FUID support.
851 * The log record may contain some optional data
852 * to be used for replaying FUID's. These pieces
853 * are the actual FUIDs that were created initially.
854 * The FUID table index may no longer be valid and
855 * during zfs_create() a new index may be assigned.
856 * Because of this the log will contain the original
857 * doman+rid in order to create a new FUID.
859 * The individual ACEs may contain an ephemeral uid/gid which is no
860 * longer valid and will need to be replaced with an actual FUID.
864 zfs_replay_acl(zfs_sb_t
*zsb
, lr_acl_t
*lr
, boolean_t byteswap
)
866 ace_t
*ace
= (ace_t
*)(lr
+ 1);
872 byteswap_uint64_array(lr
, sizeof (*lr
));
873 zfs_ace_byteswap(ace
, lr
->lr_acl_bytes
, B_FALSE
);
874 if (lr
->lr_fuidcnt
) {
875 byteswap_uint64_array((caddr_t
)ace
+
876 ZIL_ACE_LENGTH(lr
->lr_acl_bytes
),
877 lr
->lr_fuidcnt
* sizeof (uint64_t));
881 if ((error
= zfs_zget(zsb
, lr
->lr_foid
, &zp
)) != 0)
884 bzero(&vsa
, sizeof (vsa
));
885 vsa
.vsa_mask
= VSA_ACE
| VSA_ACECNT
| VSA_ACE_ACLFLAGS
;
886 vsa
.vsa_aclcnt
= lr
->lr_aclcnt
;
887 vsa
.vsa_aclentp
= ace
;
888 vsa
.vsa_aclentsz
= lr
->lr_acl_bytes
;
889 vsa
.vsa_aclflags
= lr
->lr_acl_flags
;
891 if (lr
->lr_fuidcnt
) {
892 void *fuidstart
= (caddr_t
)ace
+
893 ZIL_ACE_LENGTH(lr
->lr_acl_bytes
);
896 zfs_replay_fuids(fuidstart
, &fuidstart
,
897 lr
->lr_fuidcnt
, lr
->lr_domcnt
, 0, 0);
900 error
= zfs_setsecattr(ZTOI(zp
), &vsa
, 0, kcred
);
902 if (zsb
->z_fuid_replay
)
903 zfs_fuid_info_free(zsb
->z_fuid_replay
);
905 zsb
->z_fuid_replay
= NULL
;
912 * Callback vectors for replaying records
914 zil_replay_func_t
*zfs_replay_vector
[TX_MAX_TYPE
] = {
915 (zil_replay_func_t
*)zfs_replay_error
, /* no such type */
916 (zil_replay_func_t
*)zfs_replay_create
, /* TX_CREATE */
917 (zil_replay_func_t
*)zfs_replay_create
, /* TX_MKDIR */
918 (zil_replay_func_t
*)zfs_replay_create
, /* TX_MKXATTR */
919 (zil_replay_func_t
*)zfs_replay_create
, /* TX_SYMLINK */
920 (zil_replay_func_t
*)zfs_replay_remove
, /* TX_REMOVE */
921 (zil_replay_func_t
*)zfs_replay_remove
, /* TX_RMDIR */
922 (zil_replay_func_t
*)zfs_replay_link
, /* TX_LINK */
923 (zil_replay_func_t
*)zfs_replay_rename
, /* TX_RENAME */
924 (zil_replay_func_t
*)zfs_replay_write
, /* TX_WRITE */
925 (zil_replay_func_t
*)zfs_replay_truncate
, /* TX_TRUNCATE */
926 (zil_replay_func_t
*)zfs_replay_setattr
, /* TX_SETATTR */
927 (zil_replay_func_t
*)zfs_replay_acl_v0
, /* TX_ACL_V0 */
928 (zil_replay_func_t
*)zfs_replay_acl
, /* TX_ACL */
929 (zil_replay_func_t
*)zfs_replay_create_acl
, /* TX_CREATE_ACL */
930 (zil_replay_func_t
*)zfs_replay_create
, /* TX_CREATE_ATTR */
931 (zil_replay_func_t
*)zfs_replay_create_acl
, /* TX_CREATE_ACL_ATTR */
932 (zil_replay_func_t
*)zfs_replay_create_acl
, /* TX_MKDIR_ACL */
933 (zil_replay_func_t
*)zfs_replay_create
, /* TX_MKDIR_ATTR */
934 (zil_replay_func_t
*)zfs_replay_create_acl
, /* TX_MKDIR_ACL_ATTR */
935 (zil_replay_func_t
*)zfs_replay_write2
, /* TX_WRITE2 */