]>
Commit | Line | Data |
---|---|---|
34dc7c2f BB |
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 2008 Sun Microsystems, Inc. All rights reserved. | |
23 | * Use is subject to license terms. | |
24 | */ | |
25 | ||
b128c09f | 26 | #pragma ident "%Z%%M% %I% %E% SMI" |
34dc7c2f BB |
27 | |
28 | #include <sys/types.h> | |
29 | #include <sys/param.h> | |
30 | #include <sys/systm.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/spa.h> | |
44 | #include <sys/zil.h> | |
45 | #include <sys/byteorder.h> | |
46 | #include <sys/stat.h> | |
47 | #include <sys/mode.h> | |
48 | #include <sys/acl.h> | |
49 | #include <sys/atomic.h> | |
50 | #include <sys/cred.h> | |
51 | ||
52 | /* | |
53 | * Functions to replay ZFS intent log (ZIL) records | |
54 | * The functions are called through a function vector (zfs_replay_vector) | |
55 | * which is indexed by the transaction type. | |
56 | */ | |
57 | ||
58 | static void | |
59 | zfs_init_vattr(vattr_t *vap, uint64_t mask, uint64_t mode, | |
60 | uint64_t uid, uint64_t gid, uint64_t rdev, uint64_t nodeid) | |
61 | { | |
62 | bzero(vap, sizeof (*vap)); | |
63 | vap->va_mask = (uint_t)mask; | |
64 | vap->va_type = IFTOVT(mode); | |
65 | vap->va_mode = mode & MODEMASK; | |
66 | vap->va_uid = (uid_t)(IS_EPHEMERAL(uid)) ? -1 : uid; | |
67 | vap->va_gid = (gid_t)(IS_EPHEMERAL(gid)) ? -1 : gid; | |
68 | vap->va_rdev = zfs_cmpldev(rdev); | |
69 | vap->va_nodeid = nodeid; | |
70 | } | |
71 | ||
72 | /* ARGSUSED */ | |
73 | static int | |
74 | zfs_replay_error(zfsvfs_t *zfsvfs, lr_t *lr, boolean_t byteswap) | |
75 | { | |
76 | return (ENOTSUP); | |
77 | } | |
78 | ||
79 | static void | |
80 | zfs_replay_xvattr(lr_attr_t *lrattr, xvattr_t *xvap) | |
81 | { | |
82 | xoptattr_t *xoap = NULL; | |
83 | uint64_t *attrs; | |
84 | uint64_t *crtime; | |
85 | uint32_t *bitmap; | |
86 | void *scanstamp; | |
87 | int i; | |
88 | ||
89 | xvap->xva_vattr.va_mask |= AT_XVATTR; | |
90 | if ((xoap = xva_getxoptattr(xvap)) == NULL) { | |
91 | xvap->xva_vattr.va_mask &= ~AT_XVATTR; /* shouldn't happen */ | |
92 | return; | |
93 | } | |
94 | ||
95 | ASSERT(lrattr->lr_attr_masksize == xvap->xva_mapsize); | |
96 | ||
97 | bitmap = &lrattr->lr_attr_bitmap; | |
98 | for (i = 0; i != lrattr->lr_attr_masksize; i++, bitmap++) | |
99 | xvap->xva_reqattrmap[i] = *bitmap; | |
100 | ||
101 | attrs = (uint64_t *)(lrattr + lrattr->lr_attr_masksize - 1); | |
102 | crtime = attrs + 1; | |
103 | scanstamp = (caddr_t)(crtime + 2); | |
104 | ||
105 | if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) | |
106 | xoap->xoa_hidden = ((*attrs & XAT0_HIDDEN) != 0); | |
107 | if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) | |
108 | xoap->xoa_system = ((*attrs & XAT0_SYSTEM) != 0); | |
109 | if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) | |
110 | xoap->xoa_archive = ((*attrs & XAT0_ARCHIVE) != 0); | |
111 | if (XVA_ISSET_REQ(xvap, XAT_READONLY)) | |
112 | xoap->xoa_readonly = ((*attrs & XAT0_READONLY) != 0); | |
113 | if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) | |
114 | xoap->xoa_immutable = ((*attrs & XAT0_IMMUTABLE) != 0); | |
115 | if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) | |
116 | xoap->xoa_nounlink = ((*attrs & XAT0_NOUNLINK) != 0); | |
117 | if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) | |
118 | xoap->xoa_appendonly = ((*attrs & XAT0_APPENDONLY) != 0); | |
119 | if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) | |
120 | xoap->xoa_nodump = ((*attrs & XAT0_NODUMP) != 0); | |
121 | if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) | |
122 | xoap->xoa_opaque = ((*attrs & XAT0_OPAQUE) != 0); | |
123 | if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) | |
124 | xoap->xoa_av_modified = ((*attrs & XAT0_AV_MODIFIED) != 0); | |
125 | if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) | |
126 | xoap->xoa_av_quarantined = | |
127 | ((*attrs & XAT0_AV_QUARANTINED) != 0); | |
128 | if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) | |
129 | ZFS_TIME_DECODE(&xoap->xoa_createtime, crtime); | |
130 | if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) | |
131 | bcopy(scanstamp, xoap->xoa_av_scanstamp, AV_SCANSTAMP_SZ); | |
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 | if (byteswap) { | |
279 | byteswap_uint64_array(lracl, sizeof (*lracl)); | |
280 | txtype = (int)lr->lr_common.lrc_txtype; | |
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 ((int)lr->lr_common.lrc_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 | zfs_fuid_info_free(zfsvfs->z_fuid_replay); | |
395 | zfsvfs->z_fuid_replay = NULL; | |
396 | ||
397 | return (error); | |
398 | } | |
399 | ||
400 | static int | |
401 | zfs_replay_create(zfsvfs_t *zfsvfs, lr_create_t *lr, boolean_t byteswap) | |
402 | { | |
403 | char *name = NULL; /* location determined later */ | |
404 | char *link; /* symlink content follows name */ | |
405 | znode_t *dzp; | |
406 | vnode_t *vp = NULL; | |
407 | xvattr_t xva; | |
408 | int vflg = 0; | |
409 | size_t lrsize = sizeof (lr_create_t); | |
410 | lr_attr_t *lrattr; | |
411 | void *start; | |
412 | size_t xvatlen; | |
413 | uint64_t txtype; | |
414 | int error; | |
415 | ||
416 | if (byteswap) { | |
417 | byteswap_uint64_array(lr, sizeof (*lr)); | |
418 | txtype = (int)lr->lr_common.lrc_txtype; | |
419 | if (txtype == TX_CREATE_ATTR || txtype == TX_MKDIR_ATTR) | |
420 | zfs_replay_swap_attrs((lr_attr_t *)(lr + 1)); | |
421 | } | |
422 | ||
423 | ||
424 | if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0) | |
425 | return (error); | |
426 | ||
427 | xva_init(&xva); | |
428 | zfs_init_vattr(&xva.xva_vattr, AT_TYPE | AT_MODE | AT_UID | AT_GID, | |
429 | lr->lr_mode, lr->lr_uid, lr->lr_gid, lr->lr_rdev, lr->lr_foid); | |
430 | ||
431 | /* | |
432 | * All forms of zfs create (create, mkdir, mkxattrdir, symlink) | |
433 | * eventually end up in zfs_mknode(), which assigns the object's | |
434 | * creation time and generation number. The generic VOP_CREATE() | |
435 | * doesn't have either concept, so we smuggle the values inside | |
436 | * the vattr's otherwise unused va_ctime and va_nblocks fields. | |
437 | */ | |
438 | ZFS_TIME_DECODE(&xva.xva_vattr.va_ctime, lr->lr_crtime); | |
439 | xva.xva_vattr.va_nblocks = lr->lr_gen; | |
440 | ||
441 | error = dmu_object_info(zfsvfs->z_os, lr->lr_foid, NULL); | |
442 | if (error != ENOENT) | |
443 | goto out; | |
444 | ||
445 | if (lr->lr_common.lrc_txtype & TX_CI) | |
446 | vflg |= FIGNORECASE; | |
447 | ||
448 | /* | |
449 | * Symlinks don't have fuid info, and CIFS never creates | |
450 | * symlinks. | |
451 | * | |
452 | * The _ATTR versions will grab the fuid info in their subcases. | |
453 | */ | |
454 | if ((int)lr->lr_common.lrc_txtype != TX_SYMLINK && | |
455 | (int)lr->lr_common.lrc_txtype != TX_MKDIR_ATTR && | |
456 | (int)lr->lr_common.lrc_txtype != TX_CREATE_ATTR) { | |
457 | start = (lr + 1); | |
458 | zfsvfs->z_fuid_replay = | |
459 | zfs_replay_fuid_domain(start, &start, | |
460 | lr->lr_uid, lr->lr_gid); | |
461 | } | |
462 | ||
463 | switch ((int)lr->lr_common.lrc_txtype) { | |
464 | case TX_CREATE_ATTR: | |
465 | lrattr = (lr_attr_t *)(caddr_t)(lr + 1); | |
466 | xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); | |
467 | zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva); | |
468 | start = (caddr_t)(lr + 1) + xvatlen; | |
469 | zfsvfs->z_fuid_replay = | |
470 | zfs_replay_fuid_domain(start, &start, | |
471 | lr->lr_uid, lr->lr_gid); | |
472 | name = (char *)start; | |
473 | ||
474 | /*FALLTHROUGH*/ | |
475 | case TX_CREATE: | |
476 | if (name == NULL) | |
477 | name = (char *)start; | |
478 | ||
479 | error = VOP_CREATE(ZTOV(dzp), name, &xva.xva_vattr, | |
480 | 0, 0, &vp, kcred, vflg, NULL, NULL); | |
481 | break; | |
482 | case TX_MKDIR_ATTR: | |
483 | lrattr = (lr_attr_t *)(caddr_t)(lr + 1); | |
484 | xvatlen = ZIL_XVAT_SIZE(lrattr->lr_attr_masksize); | |
485 | zfs_replay_xvattr((lr_attr_t *)((caddr_t)lr + lrsize), &xva); | |
486 | start = (caddr_t)(lr + 1) + xvatlen; | |
487 | zfsvfs->z_fuid_replay = | |
488 | zfs_replay_fuid_domain(start, &start, | |
489 | lr->lr_uid, lr->lr_gid); | |
490 | name = (char *)start; | |
491 | ||
492 | /*FALLTHROUGH*/ | |
493 | case TX_MKDIR: | |
494 | if (name == NULL) | |
495 | name = (char *)(lr + 1); | |
496 | ||
497 | error = VOP_MKDIR(ZTOV(dzp), name, &xva.xva_vattr, | |
498 | &vp, kcred, NULL, vflg, NULL); | |
499 | break; | |
500 | case TX_MKXATTR: | |
501 | name = (char *)(lr + 1); | |
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 | ||
629 | if (byteswap) | |
630 | byteswap_uint64_array(lr, sizeof (*lr)); | |
631 | ||
632 | if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) { | |
633 | /* | |
634 | * As we can log writes out of order, it's possible the | |
635 | * file has been removed. In this case just drop the write | |
636 | * and return success. | |
637 | */ | |
638 | if (error == ENOENT) | |
639 | error = 0; | |
640 | return (error); | |
641 | } | |
642 | ||
643 | error = vn_rdwr(UIO_WRITE, ZTOV(zp), data, lr->lr_length, | |
644 | lr->lr_offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid); | |
645 | ||
646 | VN_RELE(ZTOV(zp)); | |
647 | ||
648 | return (error); | |
649 | } | |
650 | ||
651 | static int | |
652 | zfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap) | |
653 | { | |
654 | znode_t *zp; | |
655 | flock64_t fl; | |
656 | int error; | |
657 | ||
658 | if (byteswap) | |
659 | byteswap_uint64_array(lr, sizeof (*lr)); | |
660 | ||
661 | if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) { | |
662 | /* | |
663 | * As we can log truncates out of order, it's possible the | |
664 | * file has been removed. In this case just drop the truncate | |
665 | * and return success. | |
666 | */ | |
667 | if (error == ENOENT) | |
668 | error = 0; | |
669 | return (error); | |
670 | } | |
671 | ||
672 | bzero(&fl, sizeof (fl)); | |
673 | fl.l_type = F_WRLCK; | |
674 | fl.l_whence = 0; | |
675 | fl.l_start = lr->lr_offset; | |
676 | fl.l_len = lr->lr_length; | |
677 | ||
678 | error = VOP_SPACE(ZTOV(zp), F_FREESP, &fl, FWRITE | FOFFMAX, | |
679 | lr->lr_offset, kcred, NULL); | |
680 | ||
681 | VN_RELE(ZTOV(zp)); | |
682 | ||
683 | return (error); | |
684 | } | |
685 | ||
686 | static int | |
687 | zfs_replay_setattr(zfsvfs_t *zfsvfs, lr_setattr_t *lr, boolean_t byteswap) | |
688 | { | |
689 | znode_t *zp; | |
690 | xvattr_t xva; | |
691 | vattr_t *vap = &xva.xva_vattr; | |
692 | int error; | |
693 | void *start; | |
694 | ||
695 | xva_init(&xva); | |
696 | if (byteswap) { | |
697 | byteswap_uint64_array(lr, sizeof (*lr)); | |
698 | ||
699 | if ((lr->lr_mask & AT_XVATTR) && | |
700 | zfsvfs->z_version >= ZPL_VERSION_INITIAL) | |
701 | zfs_replay_swap_attrs((lr_attr_t *)(lr + 1)); | |
702 | } | |
703 | ||
704 | if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) { | |
705 | /* | |
706 | * As we can log setattrs out of order, it's possible the | |
707 | * file has been removed. In this case just drop the setattr | |
708 | * and return success. | |
709 | */ | |
710 | if (error == ENOENT) | |
711 | error = 0; | |
712 | return (error); | |
713 | } | |
714 | ||
715 | zfs_init_vattr(vap, lr->lr_mask, lr->lr_mode, | |
716 | lr->lr_uid, lr->lr_gid, 0, lr->lr_foid); | |
717 | ||
718 | vap->va_size = lr->lr_size; | |
719 | ZFS_TIME_DECODE(&vap->va_atime, lr->lr_atime); | |
720 | ZFS_TIME_DECODE(&vap->va_mtime, lr->lr_mtime); | |
721 | ||
722 | /* | |
723 | * Fill in xvattr_t portions if necessary. | |
724 | */ | |
725 | ||
726 | start = (lr_setattr_t *)(lr + 1); | |
727 | if (vap->va_mask & AT_XVATTR) { | |
728 | zfs_replay_xvattr((lr_attr_t *)start, &xva); | |
729 | start = (caddr_t)start + | |
730 | ZIL_XVAT_SIZE(((lr_attr_t *)start)->lr_attr_masksize); | |
731 | } else | |
732 | xva.xva_vattr.va_mask &= ~AT_XVATTR; | |
733 | ||
734 | zfsvfs->z_fuid_replay = zfs_replay_fuid_domain(start, &start, | |
735 | lr->lr_uid, lr->lr_gid); | |
736 | ||
737 | error = VOP_SETATTR(ZTOV(zp), vap, 0, kcred, NULL); | |
738 | ||
739 | zfs_fuid_info_free(zfsvfs->z_fuid_replay); | |
740 | zfsvfs->z_fuid_replay = NULL; | |
741 | VN_RELE(ZTOV(zp)); | |
742 | ||
743 | return (error); | |
744 | } | |
745 | ||
746 | static int | |
747 | zfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap) | |
748 | { | |
749 | ace_t *ace = (ace_t *)(lr + 1); /* ace array follows lr_acl_t */ | |
750 | vsecattr_t vsa; | |
751 | znode_t *zp; | |
752 | int error; | |
753 | ||
754 | if (byteswap) { | |
755 | byteswap_uint64_array(lr, sizeof (*lr)); | |
756 | zfs_oldace_byteswap(ace, lr->lr_aclcnt); | |
757 | } | |
758 | ||
759 | if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) { | |
760 | /* | |
761 | * As we can log acls out of order, it's possible the | |
762 | * file has been removed. In this case just drop the acl | |
763 | * and return success. | |
764 | */ | |
765 | if (error == ENOENT) | |
766 | error = 0; | |
767 | return (error); | |
768 | } | |
769 | ||
770 | bzero(&vsa, sizeof (vsa)); | |
771 | vsa.vsa_mask = VSA_ACE | VSA_ACECNT; | |
772 | vsa.vsa_aclcnt = lr->lr_aclcnt; | |
b128c09f BB |
773 | vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt; |
774 | vsa.vsa_aclflags = 0; | |
34dc7c2f BB |
775 | vsa.vsa_aclentp = ace; |
776 | ||
777 | error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL); | |
778 | ||
779 | VN_RELE(ZTOV(zp)); | |
780 | ||
781 | return (error); | |
782 | } | |
783 | ||
784 | /* | |
785 | * Replaying ACLs is complicated by FUID support. | |
786 | * The log record may contain some optional data | |
787 | * to be used for replaying FUID's. These pieces | |
788 | * are the actual FUIDs that were created initially. | |
789 | * The FUID table index may no longer be valid and | |
790 | * during zfs_create() a new index may be assigned. | |
791 | * Because of this the log will contain the original | |
792 | * doman+rid in order to create a new FUID. | |
793 | * | |
794 | * The individual ACEs may contain an ephemeral uid/gid which is no | |
795 | * longer valid and will need to be replaced with an actual FUID. | |
796 | * | |
797 | */ | |
798 | static int | |
799 | zfs_replay_acl(zfsvfs_t *zfsvfs, lr_acl_t *lr, boolean_t byteswap) | |
800 | { | |
801 | ace_t *ace = (ace_t *)(lr + 1); | |
802 | vsecattr_t vsa; | |
803 | znode_t *zp; | |
804 | int error; | |
805 | ||
806 | if (byteswap) { | |
807 | byteswap_uint64_array(lr, sizeof (*lr)); | |
808 | zfs_ace_byteswap(ace, lr->lr_acl_bytes, B_FALSE); | |
809 | if (lr->lr_fuidcnt) { | |
810 | byteswap_uint64_array((caddr_t)ace + | |
811 | ZIL_ACE_LENGTH(lr->lr_acl_bytes), | |
812 | lr->lr_fuidcnt * sizeof (uint64_t)); | |
813 | } | |
814 | } | |
815 | ||
816 | if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0) { | |
817 | /* | |
818 | * As we can log acls out of order, it's possible the | |
819 | * file has been removed. In this case just drop the acl | |
820 | * and return success. | |
821 | */ | |
822 | if (error == ENOENT) | |
823 | error = 0; | |
824 | return (error); | |
825 | } | |
826 | ||
827 | bzero(&vsa, sizeof (vsa)); | |
828 | vsa.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS; | |
829 | vsa.vsa_aclcnt = lr->lr_aclcnt; | |
830 | vsa.vsa_aclentp = ace; | |
831 | vsa.vsa_aclentsz = lr->lr_acl_bytes; | |
832 | vsa.vsa_aclflags = lr->lr_acl_flags; | |
833 | ||
834 | if (lr->lr_fuidcnt) { | |
835 | void *fuidstart = (caddr_t)ace + | |
836 | ZIL_ACE_LENGTH(lr->lr_acl_bytes); | |
837 | ||
838 | zfsvfs->z_fuid_replay = | |
839 | zfs_replay_fuids(fuidstart, &fuidstart, | |
840 | lr->lr_fuidcnt, lr->lr_domcnt, 0, 0); | |
841 | } | |
842 | ||
843 | error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL); | |
844 | ||
845 | if (zfsvfs->z_fuid_replay) | |
846 | zfs_fuid_info_free(zfsvfs->z_fuid_replay); | |
847 | ||
848 | zfsvfs->z_fuid_replay = NULL; | |
849 | VN_RELE(ZTOV(zp)); | |
850 | ||
851 | return (error); | |
852 | } | |
853 | ||
854 | /* | |
855 | * Callback vectors for replaying records | |
856 | */ | |
857 | zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE] = { | |
858 | zfs_replay_error, /* 0 no such transaction type */ | |
859 | zfs_replay_create, /* TX_CREATE */ | |
860 | zfs_replay_create, /* TX_MKDIR */ | |
861 | zfs_replay_create, /* TX_MKXATTR */ | |
862 | zfs_replay_create, /* TX_SYMLINK */ | |
863 | zfs_replay_remove, /* TX_REMOVE */ | |
864 | zfs_replay_remove, /* TX_RMDIR */ | |
865 | zfs_replay_link, /* TX_LINK */ | |
866 | zfs_replay_rename, /* TX_RENAME */ | |
867 | zfs_replay_write, /* TX_WRITE */ | |
868 | zfs_replay_truncate, /* TX_TRUNCATE */ | |
869 | zfs_replay_setattr, /* TX_SETATTR */ | |
870 | zfs_replay_acl_v0, /* TX_ACL_V0 */ | |
871 | zfs_replay_acl, /* TX_ACL */ | |
872 | zfs_replay_create_acl, /* TX_CREATE_ACL */ | |
873 | zfs_replay_create, /* TX_CREATE_ATTR */ | |
874 | zfs_replay_create_acl, /* TX_CREATE_ACL_ATTR */ | |
875 | zfs_replay_create_acl, /* TX_MKDIR_ACL */ | |
876 | zfs_replay_create, /* TX_MKDIR_ATTR */ | |
877 | zfs_replay_create_acl, /* TX_MKDIR_ACL_ATTR */ | |
878 | }; |