xref: /freebsd/sys/contrib/openzfs/module/os/linux/zfs/zfs_acl.c (revision e92ffd9b626833ebdbf2742c8ffddc6cd94b963e)
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  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
25  */
26 
27 
28 #include <sys/types.h>
29 #include <sys/param.h>
30 #include <sys/time.h>
31 #include <sys/sysmacros.h>
32 #include <sys/vfs.h>
33 #include <sys/vnode.h>
34 #include <sys/sid.h>
35 #include <sys/file.h>
36 #include <sys/stat.h>
37 #include <sys/kmem.h>
38 #include <sys/cmn_err.h>
39 #include <sys/errno.h>
40 #include <sys/fs/zfs.h>
41 #include <sys/policy.h>
42 #include <sys/zfs_znode.h>
43 #include <sys/zfs_fuid.h>
44 #include <sys/zfs_acl.h>
45 #include <sys/zfs_dir.h>
46 #include <sys/zfs_quota.h>
47 #include <sys/zfs_vfsops.h>
48 #include <sys/dmu.h>
49 #include <sys/dnode.h>
50 #include <sys/zap.h>
51 #include <sys/sa.h>
52 #include <sys/trace_acl.h>
53 #include <sys/zpl.h>
54 
55 #define	ALLOW	ACE_ACCESS_ALLOWED_ACE_TYPE
56 #define	DENY	ACE_ACCESS_DENIED_ACE_TYPE
57 #define	MAX_ACE_TYPE	ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE
58 #define	MIN_ACE_TYPE	ALLOW
59 
60 #define	OWNING_GROUP		(ACE_GROUP|ACE_IDENTIFIER_GROUP)
61 #define	EVERYONE_ALLOW_MASK (ACE_READ_ACL|ACE_READ_ATTRIBUTES | \
62     ACE_READ_NAMED_ATTRS|ACE_SYNCHRONIZE)
63 #define	EVERYONE_DENY_MASK (ACE_WRITE_ACL|ACE_WRITE_OWNER | \
64     ACE_WRITE_ATTRIBUTES|ACE_WRITE_NAMED_ATTRS)
65 #define	OWNER_ALLOW_MASK (ACE_WRITE_ACL | ACE_WRITE_OWNER | \
66     ACE_WRITE_ATTRIBUTES|ACE_WRITE_NAMED_ATTRS)
67 
68 #define	ZFS_CHECKED_MASKS (ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_DATA| \
69     ACE_READ_NAMED_ATTRS|ACE_WRITE_DATA|ACE_WRITE_ATTRIBUTES| \
70     ACE_WRITE_NAMED_ATTRS|ACE_APPEND_DATA|ACE_EXECUTE|ACE_WRITE_OWNER| \
71     ACE_WRITE_ACL|ACE_DELETE|ACE_DELETE_CHILD|ACE_SYNCHRONIZE)
72 
73 #define	WRITE_MASK_DATA (ACE_WRITE_DATA|ACE_APPEND_DATA|ACE_WRITE_NAMED_ATTRS)
74 #define	WRITE_MASK_ATTRS (ACE_WRITE_ACL|ACE_WRITE_OWNER|ACE_WRITE_ATTRIBUTES| \
75     ACE_DELETE|ACE_DELETE_CHILD)
76 #define	WRITE_MASK (WRITE_MASK_DATA|WRITE_MASK_ATTRS)
77 
78 #define	OGE_CLEAR	(ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \
79     ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_EXECUTE)
80 
81 #define	OKAY_MASK_BITS (ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \
82     ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_EXECUTE)
83 
84 #define	ALL_INHERIT	(ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE | \
85     ACE_NO_PROPAGATE_INHERIT_ACE|ACE_INHERIT_ONLY_ACE|ACE_INHERITED_ACE)
86 
87 #define	RESTRICTED_CLEAR	(ACE_WRITE_ACL|ACE_WRITE_OWNER)
88 
89 #define	V4_ACL_WIDE_FLAGS (ZFS_ACL_AUTO_INHERIT|ZFS_ACL_DEFAULTED|\
90     ZFS_ACL_PROTECTED)
91 
92 #define	ZFS_ACL_WIDE_FLAGS (V4_ACL_WIDE_FLAGS|ZFS_ACL_TRIVIAL|ZFS_INHERIT_ACE|\
93     ZFS_ACL_OBJ_ACE)
94 
95 #define	ALL_MODE_EXECS (S_IXUSR | S_IXGRP | S_IXOTH)
96 
97 #define	IDMAP_WK_CREATOR_OWNER_UID	2147483648U
98 
99 static uint16_t
100 zfs_ace_v0_get_type(void *acep)
101 {
102 	return (((zfs_oldace_t *)acep)->z_type);
103 }
104 
105 static uint16_t
106 zfs_ace_v0_get_flags(void *acep)
107 {
108 	return (((zfs_oldace_t *)acep)->z_flags);
109 }
110 
111 static uint32_t
112 zfs_ace_v0_get_mask(void *acep)
113 {
114 	return (((zfs_oldace_t *)acep)->z_access_mask);
115 }
116 
117 static uint64_t
118 zfs_ace_v0_get_who(void *acep)
119 {
120 	return (((zfs_oldace_t *)acep)->z_fuid);
121 }
122 
123 static void
124 zfs_ace_v0_set_type(void *acep, uint16_t type)
125 {
126 	((zfs_oldace_t *)acep)->z_type = type;
127 }
128 
129 static void
130 zfs_ace_v0_set_flags(void *acep, uint16_t flags)
131 {
132 	((zfs_oldace_t *)acep)->z_flags = flags;
133 }
134 
135 static void
136 zfs_ace_v0_set_mask(void *acep, uint32_t mask)
137 {
138 	((zfs_oldace_t *)acep)->z_access_mask = mask;
139 }
140 
141 static void
142 zfs_ace_v0_set_who(void *acep, uint64_t who)
143 {
144 	((zfs_oldace_t *)acep)->z_fuid = who;
145 }
146 
147 /*ARGSUSED*/
148 static size_t
149 zfs_ace_v0_size(void *acep)
150 {
151 	return (sizeof (zfs_oldace_t));
152 }
153 
154 static size_t
155 zfs_ace_v0_abstract_size(void)
156 {
157 	return (sizeof (zfs_oldace_t));
158 }
159 
160 static int
161 zfs_ace_v0_mask_off(void)
162 {
163 	return (offsetof(zfs_oldace_t, z_access_mask));
164 }
165 
166 /*ARGSUSED*/
167 static int
168 zfs_ace_v0_data(void *acep, void **datap)
169 {
170 	*datap = NULL;
171 	return (0);
172 }
173 
174 static const acl_ops_t zfs_acl_v0_ops = {
175 	.ace_mask_get = zfs_ace_v0_get_mask,
176 	.ace_mask_set = zfs_ace_v0_set_mask,
177 	.ace_flags_get = zfs_ace_v0_get_flags,
178 	.ace_flags_set = zfs_ace_v0_set_flags,
179 	.ace_type_get = zfs_ace_v0_get_type,
180 	.ace_type_set = zfs_ace_v0_set_type,
181 	.ace_who_get = zfs_ace_v0_get_who,
182 	.ace_who_set = zfs_ace_v0_set_who,
183 	.ace_size = zfs_ace_v0_size,
184 	.ace_abstract_size = zfs_ace_v0_abstract_size,
185 	.ace_mask_off = zfs_ace_v0_mask_off,
186 	.ace_data = zfs_ace_v0_data
187 };
188 
189 static uint16_t
190 zfs_ace_fuid_get_type(void *acep)
191 {
192 	return (((zfs_ace_hdr_t *)acep)->z_type);
193 }
194 
195 static uint16_t
196 zfs_ace_fuid_get_flags(void *acep)
197 {
198 	return (((zfs_ace_hdr_t *)acep)->z_flags);
199 }
200 
201 static uint32_t
202 zfs_ace_fuid_get_mask(void *acep)
203 {
204 	return (((zfs_ace_hdr_t *)acep)->z_access_mask);
205 }
206 
207 static uint64_t
208 zfs_ace_fuid_get_who(void *args)
209 {
210 	uint16_t entry_type;
211 	zfs_ace_t *acep = args;
212 
213 	entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS;
214 
215 	if (entry_type == ACE_OWNER || entry_type == OWNING_GROUP ||
216 	    entry_type == ACE_EVERYONE)
217 		return (-1);
218 	return (((zfs_ace_t *)acep)->z_fuid);
219 }
220 
221 static void
222 zfs_ace_fuid_set_type(void *acep, uint16_t type)
223 {
224 	((zfs_ace_hdr_t *)acep)->z_type = type;
225 }
226 
227 static void
228 zfs_ace_fuid_set_flags(void *acep, uint16_t flags)
229 {
230 	((zfs_ace_hdr_t *)acep)->z_flags = flags;
231 }
232 
233 static void
234 zfs_ace_fuid_set_mask(void *acep, uint32_t mask)
235 {
236 	((zfs_ace_hdr_t *)acep)->z_access_mask = mask;
237 }
238 
239 static void
240 zfs_ace_fuid_set_who(void *arg, uint64_t who)
241 {
242 	zfs_ace_t *acep = arg;
243 
244 	uint16_t entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS;
245 
246 	if (entry_type == ACE_OWNER || entry_type == OWNING_GROUP ||
247 	    entry_type == ACE_EVERYONE)
248 		return;
249 	acep->z_fuid = who;
250 }
251 
252 static size_t
253 zfs_ace_fuid_size(void *acep)
254 {
255 	zfs_ace_hdr_t *zacep = acep;
256 	uint16_t entry_type;
257 
258 	switch (zacep->z_type) {
259 	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
260 	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
261 	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
262 	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
263 		return (sizeof (zfs_object_ace_t));
264 	case ALLOW:
265 	case DENY:
266 		entry_type =
267 		    (((zfs_ace_hdr_t *)acep)->z_flags & ACE_TYPE_FLAGS);
268 		if (entry_type == ACE_OWNER ||
269 		    entry_type == OWNING_GROUP ||
270 		    entry_type == ACE_EVERYONE)
271 			return (sizeof (zfs_ace_hdr_t));
272 		fallthrough;
273 	default:
274 		return (sizeof (zfs_ace_t));
275 	}
276 }
277 
278 static size_t
279 zfs_ace_fuid_abstract_size(void)
280 {
281 	return (sizeof (zfs_ace_hdr_t));
282 }
283 
284 static int
285 zfs_ace_fuid_mask_off(void)
286 {
287 	return (offsetof(zfs_ace_hdr_t, z_access_mask));
288 }
289 
290 static int
291 zfs_ace_fuid_data(void *acep, void **datap)
292 {
293 	zfs_ace_t *zacep = acep;
294 	zfs_object_ace_t *zobjp;
295 
296 	switch (zacep->z_hdr.z_type) {
297 	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
298 	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
299 	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
300 	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
301 		zobjp = acep;
302 		*datap = (caddr_t)zobjp + sizeof (zfs_ace_t);
303 		return (sizeof (zfs_object_ace_t) - sizeof (zfs_ace_t));
304 	default:
305 		*datap = NULL;
306 		return (0);
307 	}
308 }
309 
310 static const acl_ops_t zfs_acl_fuid_ops = {
311 	.ace_mask_get = zfs_ace_fuid_get_mask,
312 	.ace_mask_set = zfs_ace_fuid_set_mask,
313 	.ace_flags_get = zfs_ace_fuid_get_flags,
314 	.ace_flags_set = zfs_ace_fuid_set_flags,
315 	.ace_type_get = zfs_ace_fuid_get_type,
316 	.ace_type_set = zfs_ace_fuid_set_type,
317 	.ace_who_get = zfs_ace_fuid_get_who,
318 	.ace_who_set = zfs_ace_fuid_set_who,
319 	.ace_size = zfs_ace_fuid_size,
320 	.ace_abstract_size = zfs_ace_fuid_abstract_size,
321 	.ace_mask_off = zfs_ace_fuid_mask_off,
322 	.ace_data = zfs_ace_fuid_data
323 };
324 
325 /*
326  * The following three functions are provided for compatibility with
327  * older ZPL version in order to determine if the file use to have
328  * an external ACL and what version of ACL previously existed on the
329  * file.  Would really be nice to not need this, sigh.
330  */
331 uint64_t
332 zfs_external_acl(znode_t *zp)
333 {
334 	zfs_acl_phys_t acl_phys;
335 	int error;
336 
337 	if (zp->z_is_sa)
338 		return (0);
339 
340 	/*
341 	 * Need to deal with a potential
342 	 * race where zfs_sa_upgrade could cause
343 	 * z_isa_sa to change.
344 	 *
345 	 * If the lookup fails then the state of z_is_sa should have
346 	 * changed.
347 	 */
348 
349 	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(ZTOZSB(zp)),
350 	    &acl_phys, sizeof (acl_phys))) == 0)
351 		return (acl_phys.z_acl_extern_obj);
352 	else {
353 		/*
354 		 * after upgrade the SA_ZPL_ZNODE_ACL should have been
355 		 * removed
356 		 */
357 		VERIFY(zp->z_is_sa && error == ENOENT);
358 		return (0);
359 	}
360 }
361 
362 /*
363  * Determine size of ACL in bytes
364  *
365  * This is more complicated than it should be since we have to deal
366  * with old external ACLs.
367  */
368 static int
369 zfs_acl_znode_info(znode_t *zp, int *aclsize, int *aclcount,
370     zfs_acl_phys_t *aclphys)
371 {
372 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
373 	uint64_t acl_count;
374 	int size;
375 	int error;
376 
377 	ASSERT(MUTEX_HELD(&zp->z_acl_lock));
378 	if (zp->z_is_sa) {
379 		if ((error = sa_size(zp->z_sa_hdl, SA_ZPL_DACL_ACES(zfsvfs),
380 		    &size)) != 0)
381 			return (error);
382 		*aclsize = size;
383 		if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_DACL_COUNT(zfsvfs),
384 		    &acl_count, sizeof (acl_count))) != 0)
385 			return (error);
386 		*aclcount = acl_count;
387 	} else {
388 		if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zfsvfs),
389 		    aclphys, sizeof (*aclphys))) != 0)
390 			return (error);
391 
392 		if (aclphys->z_acl_version == ZFS_ACL_VERSION_INITIAL) {
393 			*aclsize = ZFS_ACL_SIZE(aclphys->z_acl_size);
394 			*aclcount = aclphys->z_acl_size;
395 		} else {
396 			*aclsize = aclphys->z_acl_size;
397 			*aclcount = aclphys->z_acl_count;
398 		}
399 	}
400 	return (0);
401 }
402 
403 int
404 zfs_znode_acl_version(znode_t *zp)
405 {
406 	zfs_acl_phys_t acl_phys;
407 
408 	if (zp->z_is_sa)
409 		return (ZFS_ACL_VERSION_FUID);
410 	else {
411 		int error;
412 
413 		/*
414 		 * Need to deal with a potential
415 		 * race where zfs_sa_upgrade could cause
416 		 * z_isa_sa to change.
417 		 *
418 		 * If the lookup fails then the state of z_is_sa should have
419 		 * changed.
420 		 */
421 		if ((error = sa_lookup(zp->z_sa_hdl,
422 		    SA_ZPL_ZNODE_ACL(ZTOZSB(zp)),
423 		    &acl_phys, sizeof (acl_phys))) == 0)
424 			return (acl_phys.z_acl_version);
425 		else {
426 			/*
427 			 * After upgrade SA_ZPL_ZNODE_ACL should have
428 			 * been removed.
429 			 */
430 			VERIFY(zp->z_is_sa && error == ENOENT);
431 			return (ZFS_ACL_VERSION_FUID);
432 		}
433 	}
434 }
435 
436 static int
437 zfs_acl_version(int version)
438 {
439 	if (version < ZPL_VERSION_FUID)
440 		return (ZFS_ACL_VERSION_INITIAL);
441 	else
442 		return (ZFS_ACL_VERSION_FUID);
443 }
444 
445 static int
446 zfs_acl_version_zp(znode_t *zp)
447 {
448 	return (zfs_acl_version(ZTOZSB(zp)->z_version));
449 }
450 
451 zfs_acl_t *
452 zfs_acl_alloc(int vers)
453 {
454 	zfs_acl_t *aclp;
455 
456 	aclp = kmem_zalloc(sizeof (zfs_acl_t), KM_SLEEP);
457 	list_create(&aclp->z_acl, sizeof (zfs_acl_node_t),
458 	    offsetof(zfs_acl_node_t, z_next));
459 	aclp->z_version = vers;
460 	if (vers == ZFS_ACL_VERSION_FUID)
461 		aclp->z_ops = &zfs_acl_fuid_ops;
462 	else
463 		aclp->z_ops = &zfs_acl_v0_ops;
464 	return (aclp);
465 }
466 
467 zfs_acl_node_t *
468 zfs_acl_node_alloc(size_t bytes)
469 {
470 	zfs_acl_node_t *aclnode;
471 
472 	aclnode = kmem_zalloc(sizeof (zfs_acl_node_t), KM_SLEEP);
473 	if (bytes) {
474 		aclnode->z_acldata = kmem_alloc(bytes, KM_SLEEP);
475 		aclnode->z_allocdata = aclnode->z_acldata;
476 		aclnode->z_allocsize = bytes;
477 		aclnode->z_size = bytes;
478 	}
479 
480 	return (aclnode);
481 }
482 
483 static void
484 zfs_acl_node_free(zfs_acl_node_t *aclnode)
485 {
486 	if (aclnode->z_allocsize)
487 		kmem_free(aclnode->z_allocdata, aclnode->z_allocsize);
488 	kmem_free(aclnode, sizeof (zfs_acl_node_t));
489 }
490 
491 static void
492 zfs_acl_release_nodes(zfs_acl_t *aclp)
493 {
494 	zfs_acl_node_t *aclnode;
495 
496 	while ((aclnode = list_head(&aclp->z_acl))) {
497 		list_remove(&aclp->z_acl, aclnode);
498 		zfs_acl_node_free(aclnode);
499 	}
500 	aclp->z_acl_count = 0;
501 	aclp->z_acl_bytes = 0;
502 }
503 
504 void
505 zfs_acl_free(zfs_acl_t *aclp)
506 {
507 	zfs_acl_release_nodes(aclp);
508 	list_destroy(&aclp->z_acl);
509 	kmem_free(aclp, sizeof (zfs_acl_t));
510 }
511 
512 static boolean_t
513 zfs_acl_valid_ace_type(uint_t type, uint_t flags)
514 {
515 	uint16_t entry_type;
516 
517 	switch (type) {
518 	case ALLOW:
519 	case DENY:
520 	case ACE_SYSTEM_AUDIT_ACE_TYPE:
521 	case ACE_SYSTEM_ALARM_ACE_TYPE:
522 		entry_type = flags & ACE_TYPE_FLAGS;
523 		return (entry_type == ACE_OWNER ||
524 		    entry_type == OWNING_GROUP ||
525 		    entry_type == ACE_EVERYONE || entry_type == 0 ||
526 		    entry_type == ACE_IDENTIFIER_GROUP);
527 	default:
528 		if (type >= MIN_ACE_TYPE && type <= MAX_ACE_TYPE)
529 			return (B_TRUE);
530 	}
531 	return (B_FALSE);
532 }
533 
534 static boolean_t
535 zfs_ace_valid(umode_t obj_mode, zfs_acl_t *aclp, uint16_t type, uint16_t iflags)
536 {
537 	/*
538 	 * first check type of entry
539 	 */
540 
541 	if (!zfs_acl_valid_ace_type(type, iflags))
542 		return (B_FALSE);
543 
544 	switch (type) {
545 	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
546 	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
547 	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
548 	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
549 		if (aclp->z_version < ZFS_ACL_VERSION_FUID)
550 			return (B_FALSE);
551 		aclp->z_hints |= ZFS_ACL_OBJ_ACE;
552 	}
553 
554 	/*
555 	 * next check inheritance level flags
556 	 */
557 
558 	if (S_ISDIR(obj_mode) &&
559 	    (iflags & (ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE)))
560 		aclp->z_hints |= ZFS_INHERIT_ACE;
561 
562 	if (iflags & (ACE_INHERIT_ONLY_ACE|ACE_NO_PROPAGATE_INHERIT_ACE)) {
563 		if ((iflags & (ACE_FILE_INHERIT_ACE|
564 		    ACE_DIRECTORY_INHERIT_ACE)) == 0) {
565 			return (B_FALSE);
566 		}
567 	}
568 
569 	return (B_TRUE);
570 }
571 
572 static void *
573 zfs_acl_next_ace(zfs_acl_t *aclp, void *start, uint64_t *who,
574     uint32_t *access_mask, uint16_t *iflags, uint16_t *type)
575 {
576 	zfs_acl_node_t *aclnode;
577 
578 	ASSERT(aclp);
579 
580 	if (start == NULL) {
581 		aclnode = list_head(&aclp->z_acl);
582 		if (aclnode == NULL)
583 			return (NULL);
584 
585 		aclp->z_next_ace = aclnode->z_acldata;
586 		aclp->z_curr_node = aclnode;
587 		aclnode->z_ace_idx = 0;
588 	}
589 
590 	aclnode = aclp->z_curr_node;
591 
592 	if (aclnode == NULL)
593 		return (NULL);
594 
595 	if (aclnode->z_ace_idx >= aclnode->z_ace_count) {
596 		aclnode = list_next(&aclp->z_acl, aclnode);
597 		if (aclnode == NULL)
598 			return (NULL);
599 		else {
600 			aclp->z_curr_node = aclnode;
601 			aclnode->z_ace_idx = 0;
602 			aclp->z_next_ace = aclnode->z_acldata;
603 		}
604 	}
605 
606 	if (aclnode->z_ace_idx < aclnode->z_ace_count) {
607 		void *acep = aclp->z_next_ace;
608 		size_t ace_size;
609 
610 		/*
611 		 * Make sure we don't overstep our bounds
612 		 */
613 		ace_size = aclp->z_ops->ace_size(acep);
614 
615 		if (((caddr_t)acep + ace_size) >
616 		    ((caddr_t)aclnode->z_acldata + aclnode->z_size)) {
617 			return (NULL);
618 		}
619 
620 		*iflags = aclp->z_ops->ace_flags_get(acep);
621 		*type = aclp->z_ops->ace_type_get(acep);
622 		*access_mask = aclp->z_ops->ace_mask_get(acep);
623 		*who = aclp->z_ops->ace_who_get(acep);
624 		aclp->z_next_ace = (caddr_t)aclp->z_next_ace + ace_size;
625 		aclnode->z_ace_idx++;
626 
627 		return ((void *)acep);
628 	}
629 	return (NULL);
630 }
631 
632 /*ARGSUSED*/
633 static uint64_t
634 zfs_ace_walk(void *datap, uint64_t cookie, int aclcnt,
635     uint16_t *flags, uint16_t *type, uint32_t *mask)
636 {
637 	zfs_acl_t *aclp = datap;
638 	zfs_ace_hdr_t *acep = (zfs_ace_hdr_t *)(uintptr_t)cookie;
639 	uint64_t who;
640 
641 	acep = zfs_acl_next_ace(aclp, acep, &who, mask,
642 	    flags, type);
643 	return ((uint64_t)(uintptr_t)acep);
644 }
645 
646 /*
647  * Copy ACE to internal ZFS format.
648  * While processing the ACL each ACE will be validated for correctness.
649  * ACE FUIDs will be created later.
650  */
651 static int
652 zfs_copy_ace_2_fuid(zfsvfs_t *zfsvfs, umode_t obj_mode, zfs_acl_t *aclp,
653     void *datap, zfs_ace_t *z_acl, uint64_t aclcnt, size_t *size,
654     zfs_fuid_info_t **fuidp, cred_t *cr)
655 {
656 	int i;
657 	uint16_t entry_type;
658 	zfs_ace_t *aceptr = z_acl;
659 	ace_t *acep = datap;
660 	zfs_object_ace_t *zobjacep;
661 	ace_object_t *aceobjp;
662 
663 	for (i = 0; i != aclcnt; i++) {
664 		aceptr->z_hdr.z_access_mask = acep->a_access_mask;
665 		aceptr->z_hdr.z_flags = acep->a_flags;
666 		aceptr->z_hdr.z_type = acep->a_type;
667 		entry_type = aceptr->z_hdr.z_flags & ACE_TYPE_FLAGS;
668 		if (entry_type != ACE_OWNER && entry_type != OWNING_GROUP &&
669 		    entry_type != ACE_EVERYONE) {
670 			aceptr->z_fuid = zfs_fuid_create(zfsvfs, acep->a_who,
671 			    cr, (entry_type == 0) ?
672 			    ZFS_ACE_USER : ZFS_ACE_GROUP, fuidp);
673 		}
674 
675 		/*
676 		 * Make sure ACE is valid
677 		 */
678 		if (zfs_ace_valid(obj_mode, aclp, aceptr->z_hdr.z_type,
679 		    aceptr->z_hdr.z_flags) != B_TRUE)
680 			return (SET_ERROR(EINVAL));
681 
682 		switch (acep->a_type) {
683 		case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
684 		case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
685 		case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
686 		case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
687 			zobjacep = (zfs_object_ace_t *)aceptr;
688 			aceobjp = (ace_object_t *)acep;
689 
690 			bcopy(aceobjp->a_obj_type, zobjacep->z_object_type,
691 			    sizeof (aceobjp->a_obj_type));
692 			bcopy(aceobjp->a_inherit_obj_type,
693 			    zobjacep->z_inherit_type,
694 			    sizeof (aceobjp->a_inherit_obj_type));
695 			acep = (ace_t *)((caddr_t)acep + sizeof (ace_object_t));
696 			break;
697 		default:
698 			acep = (ace_t *)((caddr_t)acep + sizeof (ace_t));
699 		}
700 
701 		aceptr = (zfs_ace_t *)((caddr_t)aceptr +
702 		    aclp->z_ops->ace_size(aceptr));
703 	}
704 
705 	*size = (caddr_t)aceptr - (caddr_t)z_acl;
706 
707 	return (0);
708 }
709 
710 /*
711  * Copy ZFS ACEs to fixed size ace_t layout
712  */
713 static void
714 zfs_copy_fuid_2_ace(zfsvfs_t *zfsvfs, zfs_acl_t *aclp, cred_t *cr,
715     void *datap, int filter)
716 {
717 	uint64_t who;
718 	uint32_t access_mask;
719 	uint16_t iflags, type;
720 	zfs_ace_hdr_t *zacep = NULL;
721 	ace_t *acep = datap;
722 	ace_object_t *objacep;
723 	zfs_object_ace_t *zobjacep;
724 	size_t ace_size;
725 	uint16_t entry_type;
726 
727 	while ((zacep = zfs_acl_next_ace(aclp, zacep,
728 	    &who, &access_mask, &iflags, &type))) {
729 
730 		switch (type) {
731 		case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
732 		case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
733 		case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
734 		case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
735 			if (filter) {
736 				continue;
737 			}
738 			zobjacep = (zfs_object_ace_t *)zacep;
739 			objacep = (ace_object_t *)acep;
740 			bcopy(zobjacep->z_object_type,
741 			    objacep->a_obj_type,
742 			    sizeof (zobjacep->z_object_type));
743 			bcopy(zobjacep->z_inherit_type,
744 			    objacep->a_inherit_obj_type,
745 			    sizeof (zobjacep->z_inherit_type));
746 			ace_size = sizeof (ace_object_t);
747 			break;
748 		default:
749 			ace_size = sizeof (ace_t);
750 			break;
751 		}
752 
753 		entry_type = (iflags & ACE_TYPE_FLAGS);
754 		if ((entry_type != ACE_OWNER &&
755 		    entry_type != OWNING_GROUP &&
756 		    entry_type != ACE_EVERYONE)) {
757 			acep->a_who = zfs_fuid_map_id(zfsvfs, who,
758 			    cr, (entry_type & ACE_IDENTIFIER_GROUP) ?
759 			    ZFS_ACE_GROUP : ZFS_ACE_USER);
760 		} else {
761 			acep->a_who = (uid_t)(int64_t)who;
762 		}
763 		acep->a_access_mask = access_mask;
764 		acep->a_flags = iflags;
765 		acep->a_type = type;
766 		acep = (ace_t *)((caddr_t)acep + ace_size);
767 	}
768 }
769 
770 static int
771 zfs_copy_ace_2_oldace(umode_t obj_mode, zfs_acl_t *aclp, ace_t *acep,
772     zfs_oldace_t *z_acl, int aclcnt, size_t *size)
773 {
774 	int i;
775 	zfs_oldace_t *aceptr = z_acl;
776 
777 	for (i = 0; i != aclcnt; i++, aceptr++) {
778 		aceptr->z_access_mask = acep[i].a_access_mask;
779 		aceptr->z_type = acep[i].a_type;
780 		aceptr->z_flags = acep[i].a_flags;
781 		aceptr->z_fuid = acep[i].a_who;
782 		/*
783 		 * Make sure ACE is valid
784 		 */
785 		if (zfs_ace_valid(obj_mode, aclp, aceptr->z_type,
786 		    aceptr->z_flags) != B_TRUE)
787 			return (SET_ERROR(EINVAL));
788 	}
789 	*size = (caddr_t)aceptr - (caddr_t)z_acl;
790 	return (0);
791 }
792 
793 /*
794  * convert old ACL format to new
795  */
796 void
797 zfs_acl_xform(znode_t *zp, zfs_acl_t *aclp, cred_t *cr)
798 {
799 	zfs_oldace_t *oldaclp;
800 	int i;
801 	uint16_t type, iflags;
802 	uint32_t access_mask;
803 	uint64_t who;
804 	void *cookie = NULL;
805 	zfs_acl_node_t *newaclnode;
806 
807 	ASSERT(aclp->z_version == ZFS_ACL_VERSION_INITIAL);
808 	/*
809 	 * First create the ACE in a contiguous piece of memory
810 	 * for zfs_copy_ace_2_fuid().
811 	 *
812 	 * We only convert an ACL once, so this won't happen
813 	 * every time.
814 	 */
815 	oldaclp = kmem_alloc(sizeof (zfs_oldace_t) * aclp->z_acl_count,
816 	    KM_SLEEP);
817 	i = 0;
818 	while ((cookie = zfs_acl_next_ace(aclp, cookie, &who,
819 	    &access_mask, &iflags, &type))) {
820 		oldaclp[i].z_flags = iflags;
821 		oldaclp[i].z_type = type;
822 		oldaclp[i].z_fuid = who;
823 		oldaclp[i++].z_access_mask = access_mask;
824 	}
825 
826 	newaclnode = zfs_acl_node_alloc(aclp->z_acl_count *
827 	    sizeof (zfs_object_ace_t));
828 	aclp->z_ops = &zfs_acl_fuid_ops;
829 	VERIFY(zfs_copy_ace_2_fuid(ZTOZSB(zp), ZTOI(zp)->i_mode,
830 	    aclp, oldaclp, newaclnode->z_acldata, aclp->z_acl_count,
831 	    &newaclnode->z_size, NULL, cr) == 0);
832 	newaclnode->z_ace_count = aclp->z_acl_count;
833 	aclp->z_version = ZFS_ACL_VERSION;
834 	kmem_free(oldaclp, aclp->z_acl_count * sizeof (zfs_oldace_t));
835 
836 	/*
837 	 * Release all previous ACL nodes
838 	 */
839 
840 	zfs_acl_release_nodes(aclp);
841 
842 	list_insert_head(&aclp->z_acl, newaclnode);
843 
844 	aclp->z_acl_bytes = newaclnode->z_size;
845 	aclp->z_acl_count = newaclnode->z_ace_count;
846 
847 }
848 
849 /*
850  * Convert unix access mask to v4 access mask
851  */
852 static uint32_t
853 zfs_unix_to_v4(uint32_t access_mask)
854 {
855 	uint32_t new_mask = 0;
856 
857 	if (access_mask & S_IXOTH)
858 		new_mask |= ACE_EXECUTE;
859 	if (access_mask & S_IWOTH)
860 		new_mask |= ACE_WRITE_DATA;
861 	if (access_mask & S_IROTH)
862 		new_mask |= ACE_READ_DATA;
863 	return (new_mask);
864 }
865 
866 static void
867 zfs_set_ace(zfs_acl_t *aclp, void *acep, uint32_t access_mask,
868     uint16_t access_type, uint64_t fuid, uint16_t entry_type)
869 {
870 	uint16_t type = entry_type & ACE_TYPE_FLAGS;
871 
872 	aclp->z_ops->ace_mask_set(acep, access_mask);
873 	aclp->z_ops->ace_type_set(acep, access_type);
874 	aclp->z_ops->ace_flags_set(acep, entry_type);
875 	if ((type != ACE_OWNER && type != OWNING_GROUP &&
876 	    type != ACE_EVERYONE))
877 		aclp->z_ops->ace_who_set(acep, fuid);
878 }
879 
880 /*
881  * Determine mode of file based on ACL.
882  */
883 uint64_t
884 zfs_mode_compute(uint64_t fmode, zfs_acl_t *aclp,
885     uint64_t *pflags, uint64_t fuid, uint64_t fgid)
886 {
887 	int		entry_type;
888 	mode_t		mode;
889 	mode_t		seen = 0;
890 	zfs_ace_hdr_t 	*acep = NULL;
891 	uint64_t	who;
892 	uint16_t	iflags, type;
893 	uint32_t	access_mask;
894 	boolean_t	an_exec_denied = B_FALSE;
895 
896 	mode = (fmode & (S_IFMT | S_ISUID | S_ISGID | S_ISVTX));
897 
898 	while ((acep = zfs_acl_next_ace(aclp, acep, &who,
899 	    &access_mask, &iflags, &type))) {
900 
901 		if (!zfs_acl_valid_ace_type(type, iflags))
902 			continue;
903 
904 		entry_type = (iflags & ACE_TYPE_FLAGS);
905 
906 		/*
907 		 * Skip over any inherit_only ACEs
908 		 */
909 		if (iflags & ACE_INHERIT_ONLY_ACE)
910 			continue;
911 
912 		if (entry_type == ACE_OWNER || (entry_type == 0 &&
913 		    who == fuid)) {
914 			if ((access_mask & ACE_READ_DATA) &&
915 			    (!(seen & S_IRUSR))) {
916 				seen |= S_IRUSR;
917 				if (type == ALLOW) {
918 					mode |= S_IRUSR;
919 				}
920 			}
921 			if ((access_mask & ACE_WRITE_DATA) &&
922 			    (!(seen & S_IWUSR))) {
923 				seen |= S_IWUSR;
924 				if (type == ALLOW) {
925 					mode |= S_IWUSR;
926 				}
927 			}
928 			if ((access_mask & ACE_EXECUTE) &&
929 			    (!(seen & S_IXUSR))) {
930 				seen |= S_IXUSR;
931 				if (type == ALLOW) {
932 					mode |= S_IXUSR;
933 				}
934 			}
935 		} else if (entry_type == OWNING_GROUP ||
936 		    (entry_type == ACE_IDENTIFIER_GROUP && who == fgid)) {
937 			if ((access_mask & ACE_READ_DATA) &&
938 			    (!(seen & S_IRGRP))) {
939 				seen |= S_IRGRP;
940 				if (type == ALLOW) {
941 					mode |= S_IRGRP;
942 				}
943 			}
944 			if ((access_mask & ACE_WRITE_DATA) &&
945 			    (!(seen & S_IWGRP))) {
946 				seen |= S_IWGRP;
947 				if (type == ALLOW) {
948 					mode |= S_IWGRP;
949 				}
950 			}
951 			if ((access_mask & ACE_EXECUTE) &&
952 			    (!(seen & S_IXGRP))) {
953 				seen |= S_IXGRP;
954 				if (type == ALLOW) {
955 					mode |= S_IXGRP;
956 				}
957 			}
958 		} else if (entry_type == ACE_EVERYONE) {
959 			if ((access_mask & ACE_READ_DATA)) {
960 				if (!(seen & S_IRUSR)) {
961 					seen |= S_IRUSR;
962 					if (type == ALLOW) {
963 						mode |= S_IRUSR;
964 					}
965 				}
966 				if (!(seen & S_IRGRP)) {
967 					seen |= S_IRGRP;
968 					if (type == ALLOW) {
969 						mode |= S_IRGRP;
970 					}
971 				}
972 				if (!(seen & S_IROTH)) {
973 					seen |= S_IROTH;
974 					if (type == ALLOW) {
975 						mode |= S_IROTH;
976 					}
977 				}
978 			}
979 			if ((access_mask & ACE_WRITE_DATA)) {
980 				if (!(seen & S_IWUSR)) {
981 					seen |= S_IWUSR;
982 					if (type == ALLOW) {
983 						mode |= S_IWUSR;
984 					}
985 				}
986 				if (!(seen & S_IWGRP)) {
987 					seen |= S_IWGRP;
988 					if (type == ALLOW) {
989 						mode |= S_IWGRP;
990 					}
991 				}
992 				if (!(seen & S_IWOTH)) {
993 					seen |= S_IWOTH;
994 					if (type == ALLOW) {
995 						mode |= S_IWOTH;
996 					}
997 				}
998 			}
999 			if ((access_mask & ACE_EXECUTE)) {
1000 				if (!(seen & S_IXUSR)) {
1001 					seen |= S_IXUSR;
1002 					if (type == ALLOW) {
1003 						mode |= S_IXUSR;
1004 					}
1005 				}
1006 				if (!(seen & S_IXGRP)) {
1007 					seen |= S_IXGRP;
1008 					if (type == ALLOW) {
1009 						mode |= S_IXGRP;
1010 					}
1011 				}
1012 				if (!(seen & S_IXOTH)) {
1013 					seen |= S_IXOTH;
1014 					if (type == ALLOW) {
1015 						mode |= S_IXOTH;
1016 					}
1017 				}
1018 			}
1019 		} else {
1020 			/*
1021 			 * Only care if this IDENTIFIER_GROUP or
1022 			 * USER ACE denies execute access to someone,
1023 			 * mode is not affected
1024 			 */
1025 			if ((access_mask & ACE_EXECUTE) && type == DENY)
1026 				an_exec_denied = B_TRUE;
1027 		}
1028 	}
1029 
1030 	/*
1031 	 * Failure to allow is effectively a deny, so execute permission
1032 	 * is denied if it was never mentioned or if we explicitly
1033 	 * weren't allowed it.
1034 	 */
1035 	if (!an_exec_denied &&
1036 	    ((seen & ALL_MODE_EXECS) != ALL_MODE_EXECS ||
1037 	    (mode & ALL_MODE_EXECS) != ALL_MODE_EXECS))
1038 		an_exec_denied = B_TRUE;
1039 
1040 	if (an_exec_denied)
1041 		*pflags &= ~ZFS_NO_EXECS_DENIED;
1042 	else
1043 		*pflags |= ZFS_NO_EXECS_DENIED;
1044 
1045 	return (mode);
1046 }
1047 
1048 /*
1049  * Read an external acl object.  If the intent is to modify, always
1050  * create a new acl and leave any cached acl in place.
1051  */
1052 int
1053 zfs_acl_node_read(struct znode *zp, boolean_t have_lock, zfs_acl_t **aclpp,
1054     boolean_t will_modify)
1055 {
1056 	zfs_acl_t	*aclp;
1057 	int		aclsize = 0;
1058 	int		acl_count = 0;
1059 	zfs_acl_node_t	*aclnode;
1060 	zfs_acl_phys_t	znode_acl;
1061 	int		version;
1062 	int		error;
1063 	boolean_t	drop_lock = B_FALSE;
1064 
1065 	ASSERT(MUTEX_HELD(&zp->z_acl_lock));
1066 
1067 	if (zp->z_acl_cached && !will_modify) {
1068 		*aclpp = zp->z_acl_cached;
1069 		return (0);
1070 	}
1071 
1072 	/*
1073 	 * close race where znode could be upgrade while trying to
1074 	 * read the znode attributes.
1075 	 *
1076 	 * But this could only happen if the file isn't already an SA
1077 	 * znode
1078 	 */
1079 	if (!zp->z_is_sa && !have_lock) {
1080 		mutex_enter(&zp->z_lock);
1081 		drop_lock = B_TRUE;
1082 	}
1083 	version = zfs_znode_acl_version(zp);
1084 
1085 	if ((error = zfs_acl_znode_info(zp, &aclsize,
1086 	    &acl_count, &znode_acl)) != 0) {
1087 		goto done;
1088 	}
1089 
1090 	aclp = zfs_acl_alloc(version);
1091 
1092 	aclp->z_acl_count = acl_count;
1093 	aclp->z_acl_bytes = aclsize;
1094 
1095 	aclnode = zfs_acl_node_alloc(aclsize);
1096 	aclnode->z_ace_count = aclp->z_acl_count;
1097 	aclnode->z_size = aclsize;
1098 
1099 	if (!zp->z_is_sa) {
1100 		if (znode_acl.z_acl_extern_obj) {
1101 			error = dmu_read(ZTOZSB(zp)->z_os,
1102 			    znode_acl.z_acl_extern_obj, 0, aclnode->z_size,
1103 			    aclnode->z_acldata, DMU_READ_PREFETCH);
1104 		} else {
1105 			bcopy(znode_acl.z_ace_data, aclnode->z_acldata,
1106 			    aclnode->z_size);
1107 		}
1108 	} else {
1109 		error = sa_lookup(zp->z_sa_hdl, SA_ZPL_DACL_ACES(ZTOZSB(zp)),
1110 		    aclnode->z_acldata, aclnode->z_size);
1111 	}
1112 
1113 	if (error != 0) {
1114 		zfs_acl_free(aclp);
1115 		zfs_acl_node_free(aclnode);
1116 		/* convert checksum errors into IO errors */
1117 		if (error == ECKSUM)
1118 			error = SET_ERROR(EIO);
1119 		goto done;
1120 	}
1121 
1122 	list_insert_head(&aclp->z_acl, aclnode);
1123 
1124 	*aclpp = aclp;
1125 	if (!will_modify)
1126 		zp->z_acl_cached = aclp;
1127 done:
1128 	if (drop_lock)
1129 		mutex_exit(&zp->z_lock);
1130 	return (error);
1131 }
1132 
1133 /*ARGSUSED*/
1134 void
1135 zfs_acl_data_locator(void **dataptr, uint32_t *length, uint32_t buflen,
1136     boolean_t start, void *userdata)
1137 {
1138 	zfs_acl_locator_cb_t *cb = (zfs_acl_locator_cb_t *)userdata;
1139 
1140 	if (start) {
1141 		cb->cb_acl_node = list_head(&cb->cb_aclp->z_acl);
1142 	} else {
1143 		cb->cb_acl_node = list_next(&cb->cb_aclp->z_acl,
1144 		    cb->cb_acl_node);
1145 	}
1146 	*dataptr = cb->cb_acl_node->z_acldata;
1147 	*length = cb->cb_acl_node->z_size;
1148 }
1149 
1150 int
1151 zfs_acl_chown_setattr(znode_t *zp)
1152 {
1153 	int error;
1154 	zfs_acl_t *aclp;
1155 
1156 	if (ZTOZSB(zp)->z_acl_type == ZFS_ACLTYPE_POSIX)
1157 		return (0);
1158 
1159 	ASSERT(MUTEX_HELD(&zp->z_lock));
1160 	ASSERT(MUTEX_HELD(&zp->z_acl_lock));
1161 
1162 	error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE);
1163 	if (error == 0 && aclp->z_acl_count > 0)
1164 		zp->z_mode = ZTOI(zp)->i_mode =
1165 		    zfs_mode_compute(zp->z_mode, aclp,
1166 		    &zp->z_pflags, KUID_TO_SUID(ZTOI(zp)->i_uid),
1167 		    KGID_TO_SGID(ZTOI(zp)->i_gid));
1168 
1169 	/*
1170 	 * Some ZFS implementations (ZEVO) create neither a ZNODE_ACL
1171 	 * nor a DACL_ACES SA in which case ENOENT is returned from
1172 	 * zfs_acl_node_read() when the SA can't be located.
1173 	 * Allow chown/chgrp to succeed in these cases rather than
1174 	 * returning an error that makes no sense in the context of
1175 	 * the caller.
1176 	 */
1177 	if (error == ENOENT)
1178 		return (0);
1179 
1180 	return (error);
1181 }
1182 
1183 typedef struct trivial_acl {
1184 	uint32_t	allow0;		/* allow mask for bits only in owner */
1185 	uint32_t	deny1;		/* deny mask for bits not in owner */
1186 	uint32_t	deny2;		/* deny mask for bits not in group */
1187 	uint32_t	owner;		/* allow mask matching mode */
1188 	uint32_t	group;		/* allow mask matching mode */
1189 	uint32_t	everyone;	/* allow mask matching mode */
1190 } trivial_acl_t;
1191 
1192 static void
1193 acl_trivial_access_masks(mode_t mode, boolean_t isdir, trivial_acl_t *masks)
1194 {
1195 	uint32_t read_mask = ACE_READ_DATA;
1196 	uint32_t write_mask = ACE_WRITE_DATA|ACE_APPEND_DATA;
1197 	uint32_t execute_mask = ACE_EXECUTE;
1198 
1199 	if (isdir)
1200 		write_mask |= ACE_DELETE_CHILD;
1201 
1202 	masks->deny1 = 0;
1203 
1204 	if (!(mode & S_IRUSR) && (mode & (S_IRGRP|S_IROTH)))
1205 		masks->deny1 |= read_mask;
1206 	if (!(mode & S_IWUSR) && (mode & (S_IWGRP|S_IWOTH)))
1207 		masks->deny1 |= write_mask;
1208 	if (!(mode & S_IXUSR) && (mode & (S_IXGRP|S_IXOTH)))
1209 		masks->deny1 |= execute_mask;
1210 
1211 	masks->deny2 = 0;
1212 	if (!(mode & S_IRGRP) && (mode & S_IROTH))
1213 		masks->deny2 |= read_mask;
1214 	if (!(mode & S_IWGRP) && (mode & S_IWOTH))
1215 		masks->deny2 |= write_mask;
1216 	if (!(mode & S_IXGRP) && (mode & S_IXOTH))
1217 		masks->deny2 |= execute_mask;
1218 
1219 	masks->allow0 = 0;
1220 	if ((mode & S_IRUSR) && (!(mode & S_IRGRP) && (mode & S_IROTH)))
1221 		masks->allow0 |= read_mask;
1222 	if ((mode & S_IWUSR) && (!(mode & S_IWGRP) && (mode & S_IWOTH)))
1223 		masks->allow0 |= write_mask;
1224 	if ((mode & S_IXUSR) && (!(mode & S_IXGRP) && (mode & S_IXOTH)))
1225 		masks->allow0 |= execute_mask;
1226 
1227 	masks->owner = ACE_WRITE_ATTRIBUTES|ACE_WRITE_OWNER|ACE_WRITE_ACL|
1228 	    ACE_WRITE_NAMED_ATTRS|ACE_READ_ACL|ACE_READ_ATTRIBUTES|
1229 	    ACE_READ_NAMED_ATTRS|ACE_SYNCHRONIZE;
1230 	if (mode & S_IRUSR)
1231 		masks->owner |= read_mask;
1232 	if (mode & S_IWUSR)
1233 		masks->owner |= write_mask;
1234 	if (mode & S_IXUSR)
1235 		masks->owner |= execute_mask;
1236 
1237 	masks->group = ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_NAMED_ATTRS|
1238 	    ACE_SYNCHRONIZE;
1239 	if (mode & S_IRGRP)
1240 		masks->group |= read_mask;
1241 	if (mode & S_IWGRP)
1242 		masks->group |= write_mask;
1243 	if (mode & S_IXGRP)
1244 		masks->group |= execute_mask;
1245 
1246 	masks->everyone = ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_NAMED_ATTRS|
1247 	    ACE_SYNCHRONIZE;
1248 	if (mode & S_IROTH)
1249 		masks->everyone |= read_mask;
1250 	if (mode & S_IWOTH)
1251 		masks->everyone |= write_mask;
1252 	if (mode & S_IXOTH)
1253 		masks->everyone |= execute_mask;
1254 }
1255 
1256 /*
1257  * ace_trivial:
1258  * determine whether an ace_t acl is trivial
1259  *
1260  * Trivialness implies that the acl is composed of only
1261  * owner, group, everyone entries.  ACL can't
1262  * have read_acl denied, and write_owner/write_acl/write_attributes
1263  * can only be owner@ entry.
1264  */
1265 static int
1266 ace_trivial_common(void *acep, int aclcnt,
1267     uint64_t (*walk)(void *, uint64_t, int aclcnt,
1268     uint16_t *, uint16_t *, uint32_t *))
1269 {
1270 	uint16_t flags;
1271 	uint32_t mask;
1272 	uint16_t type;
1273 	uint64_t cookie = 0;
1274 
1275 	while ((cookie = walk(acep, cookie, aclcnt, &flags, &type, &mask))) {
1276 		switch (flags & ACE_TYPE_FLAGS) {
1277 		case ACE_OWNER:
1278 		case ACE_GROUP|ACE_IDENTIFIER_GROUP:
1279 		case ACE_EVERYONE:
1280 			break;
1281 		default:
1282 			return (1);
1283 		}
1284 
1285 		if (flags & (ACE_FILE_INHERIT_ACE|
1286 		    ACE_DIRECTORY_INHERIT_ACE|ACE_NO_PROPAGATE_INHERIT_ACE|
1287 		    ACE_INHERIT_ONLY_ACE))
1288 			return (1);
1289 
1290 		/*
1291 		 * Special check for some special bits
1292 		 *
1293 		 * Don't allow anybody to deny reading basic
1294 		 * attributes or a files ACL.
1295 		 */
1296 		if ((mask & (ACE_READ_ACL|ACE_READ_ATTRIBUTES)) &&
1297 		    (type == ACE_ACCESS_DENIED_ACE_TYPE))
1298 			return (1);
1299 
1300 		/*
1301 		 * Delete permission is never set by default
1302 		 */
1303 		if (mask & ACE_DELETE)
1304 			return (1);
1305 
1306 		/*
1307 		 * Child delete permission should be accompanied by write
1308 		 */
1309 		if ((mask & ACE_DELETE_CHILD) && !(mask & ACE_WRITE_DATA))
1310 			return (1);
1311 
1312 		/*
1313 		 * only allow owner@ to have
1314 		 * write_acl/write_owner/write_attributes/write_xattr/
1315 		 */
1316 		if (type == ACE_ACCESS_ALLOWED_ACE_TYPE &&
1317 		    (!(flags & ACE_OWNER) && (mask &
1318 		    (ACE_WRITE_OWNER|ACE_WRITE_ACL| ACE_WRITE_ATTRIBUTES|
1319 		    ACE_WRITE_NAMED_ATTRS))))
1320 			return (1);
1321 
1322 	}
1323 
1324 	return (0);
1325 }
1326 
1327 /*
1328  * common code for setting ACLs.
1329  *
1330  * This function is called from zfs_mode_update, zfs_perm_init, and zfs_setacl.
1331  * zfs_setacl passes a non-NULL inherit pointer (ihp) to indicate that it's
1332  * already checked the acl and knows whether to inherit.
1333  */
1334 int
1335 zfs_aclset_common(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, dmu_tx_t *tx)
1336 {
1337 	int			error;
1338 	zfsvfs_t		*zfsvfs = ZTOZSB(zp);
1339 	dmu_object_type_t	otype;
1340 	zfs_acl_locator_cb_t	locate = { 0 };
1341 	uint64_t		mode;
1342 	sa_bulk_attr_t		bulk[5];
1343 	uint64_t		ctime[2];
1344 	int			count = 0;
1345 	zfs_acl_phys_t		acl_phys;
1346 
1347 	mode = zp->z_mode;
1348 
1349 	mode = zfs_mode_compute(mode, aclp, &zp->z_pflags,
1350 	    KUID_TO_SUID(ZTOI(zp)->i_uid), KGID_TO_SGID(ZTOI(zp)->i_gid));
1351 
1352 	zp->z_mode = ZTOI(zp)->i_mode = mode;
1353 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
1354 	    &mode, sizeof (mode));
1355 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
1356 	    &zp->z_pflags, sizeof (zp->z_pflags));
1357 	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
1358 	    &ctime, sizeof (ctime));
1359 
1360 	if (zp->z_acl_cached) {
1361 		zfs_acl_free(zp->z_acl_cached);
1362 		zp->z_acl_cached = NULL;
1363 	}
1364 
1365 	/*
1366 	 * Upgrade needed?
1367 	 */
1368 	if (!zfsvfs->z_use_fuids) {
1369 		otype = DMU_OT_OLDACL;
1370 	} else {
1371 		if ((aclp->z_version == ZFS_ACL_VERSION_INITIAL) &&
1372 		    (zfsvfs->z_version >= ZPL_VERSION_FUID))
1373 			zfs_acl_xform(zp, aclp, cr);
1374 		ASSERT(aclp->z_version >= ZFS_ACL_VERSION_FUID);
1375 		otype = DMU_OT_ACL;
1376 	}
1377 
1378 	/*
1379 	 * Arrgh, we have to handle old on disk format
1380 	 * as well as newer (preferred) SA format.
1381 	 */
1382 
1383 	if (zp->z_is_sa) { /* the easy case, just update the ACL attribute */
1384 		locate.cb_aclp = aclp;
1385 		SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_DACL_ACES(zfsvfs),
1386 		    zfs_acl_data_locator, &locate, aclp->z_acl_bytes);
1387 		SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_DACL_COUNT(zfsvfs),
1388 		    NULL, &aclp->z_acl_count, sizeof (uint64_t));
1389 	} else { /* Painful legacy way */
1390 		zfs_acl_node_t *aclnode;
1391 		uint64_t off = 0;
1392 		uint64_t aoid;
1393 
1394 		if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zfsvfs),
1395 		    &acl_phys, sizeof (acl_phys))) != 0)
1396 			return (error);
1397 
1398 		aoid = acl_phys.z_acl_extern_obj;
1399 
1400 		if (aclp->z_acl_bytes > ZFS_ACE_SPACE) {
1401 			/*
1402 			 * If ACL was previously external and we are now
1403 			 * converting to new ACL format then release old
1404 			 * ACL object and create a new one.
1405 			 */
1406 			if (aoid &&
1407 			    aclp->z_version != acl_phys.z_acl_version) {
1408 				error = dmu_object_free(zfsvfs->z_os, aoid, tx);
1409 				if (error)
1410 					return (error);
1411 				aoid = 0;
1412 			}
1413 			if (aoid == 0) {
1414 				aoid = dmu_object_alloc(zfsvfs->z_os,
1415 				    otype, aclp->z_acl_bytes,
1416 				    otype == DMU_OT_ACL ?
1417 				    DMU_OT_SYSACL : DMU_OT_NONE,
1418 				    otype == DMU_OT_ACL ?
1419 				    DN_OLD_MAX_BONUSLEN : 0, tx);
1420 			} else {
1421 				(void) dmu_object_set_blocksize(zfsvfs->z_os,
1422 				    aoid, aclp->z_acl_bytes, 0, tx);
1423 			}
1424 			acl_phys.z_acl_extern_obj = aoid;
1425 			for (aclnode = list_head(&aclp->z_acl); aclnode;
1426 			    aclnode = list_next(&aclp->z_acl, aclnode)) {
1427 				if (aclnode->z_ace_count == 0)
1428 					continue;
1429 				dmu_write(zfsvfs->z_os, aoid, off,
1430 				    aclnode->z_size, aclnode->z_acldata, tx);
1431 				off += aclnode->z_size;
1432 			}
1433 		} else {
1434 			void *start = acl_phys.z_ace_data;
1435 			/*
1436 			 * Migrating back embedded?
1437 			 */
1438 			if (acl_phys.z_acl_extern_obj) {
1439 				error = dmu_object_free(zfsvfs->z_os,
1440 				    acl_phys.z_acl_extern_obj, tx);
1441 				if (error)
1442 					return (error);
1443 				acl_phys.z_acl_extern_obj = 0;
1444 			}
1445 
1446 			for (aclnode = list_head(&aclp->z_acl); aclnode;
1447 			    aclnode = list_next(&aclp->z_acl, aclnode)) {
1448 				if (aclnode->z_ace_count == 0)
1449 					continue;
1450 				bcopy(aclnode->z_acldata, start,
1451 				    aclnode->z_size);
1452 				start = (caddr_t)start + aclnode->z_size;
1453 			}
1454 		}
1455 		/*
1456 		 * If Old version then swap count/bytes to match old
1457 		 * layout of znode_acl_phys_t.
1458 		 */
1459 		if (aclp->z_version == ZFS_ACL_VERSION_INITIAL) {
1460 			acl_phys.z_acl_size = aclp->z_acl_count;
1461 			acl_phys.z_acl_count = aclp->z_acl_bytes;
1462 		} else {
1463 			acl_phys.z_acl_size = aclp->z_acl_bytes;
1464 			acl_phys.z_acl_count = aclp->z_acl_count;
1465 		}
1466 		acl_phys.z_acl_version = aclp->z_version;
1467 
1468 		SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ZNODE_ACL(zfsvfs), NULL,
1469 		    &acl_phys, sizeof (acl_phys));
1470 	}
1471 
1472 	/*
1473 	 * Replace ACL wide bits, but first clear them.
1474 	 */
1475 	zp->z_pflags &= ~ZFS_ACL_WIDE_FLAGS;
1476 
1477 	zp->z_pflags |= aclp->z_hints;
1478 
1479 	if (ace_trivial_common(aclp, 0, zfs_ace_walk) == 0)
1480 		zp->z_pflags |= ZFS_ACL_TRIVIAL;
1481 
1482 	zfs_tstamp_update_setup(zp, STATE_CHANGED, NULL, ctime);
1483 	return (sa_bulk_update(zp->z_sa_hdl, bulk, count, tx));
1484 }
1485 
1486 static void
1487 zfs_acl_chmod(boolean_t isdir, uint64_t mode, boolean_t split, boolean_t trim,
1488     zfs_acl_t *aclp)
1489 {
1490 	void		*acep = NULL;
1491 	uint64_t	who;
1492 	int		new_count, new_bytes;
1493 	int		ace_size;
1494 	int		entry_type;
1495 	uint16_t	iflags, type;
1496 	uint32_t	access_mask;
1497 	zfs_acl_node_t	*newnode;
1498 	size_t		abstract_size = aclp->z_ops->ace_abstract_size();
1499 	void		*zacep;
1500 	trivial_acl_t	masks;
1501 
1502 	new_count = new_bytes = 0;
1503 
1504 	acl_trivial_access_masks((mode_t)mode, isdir, &masks);
1505 
1506 	newnode = zfs_acl_node_alloc((abstract_size * 6) + aclp->z_acl_bytes);
1507 
1508 	zacep = newnode->z_acldata;
1509 	if (masks.allow0) {
1510 		zfs_set_ace(aclp, zacep, masks.allow0, ALLOW, -1, ACE_OWNER);
1511 		zacep = (void *)((uintptr_t)zacep + abstract_size);
1512 		new_count++;
1513 		new_bytes += abstract_size;
1514 	}
1515 	if (masks.deny1) {
1516 		zfs_set_ace(aclp, zacep, masks.deny1, DENY, -1, ACE_OWNER);
1517 		zacep = (void *)((uintptr_t)zacep + abstract_size);
1518 		new_count++;
1519 		new_bytes += abstract_size;
1520 	}
1521 	if (masks.deny2) {
1522 		zfs_set_ace(aclp, zacep, masks.deny2, DENY, -1, OWNING_GROUP);
1523 		zacep = (void *)((uintptr_t)zacep + abstract_size);
1524 		new_count++;
1525 		new_bytes += abstract_size;
1526 	}
1527 
1528 	while ((acep = zfs_acl_next_ace(aclp, acep, &who, &access_mask,
1529 	    &iflags, &type))) {
1530 		entry_type = (iflags & ACE_TYPE_FLAGS);
1531 		/*
1532 		 * ACEs used to represent the file mode may be divided
1533 		 * into an equivalent pair of inherit-only and regular
1534 		 * ACEs, if they are inheritable.
1535 		 * Skip regular ACEs, which are replaced by the new mode.
1536 		 */
1537 		if (split && (entry_type == ACE_OWNER ||
1538 		    entry_type == OWNING_GROUP ||
1539 		    entry_type == ACE_EVERYONE)) {
1540 			if (!isdir || !(iflags &
1541 			    (ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE)))
1542 				continue;
1543 			/*
1544 			 * We preserve owner@, group@, or @everyone
1545 			 * permissions, if they are inheritable, by
1546 			 * copying them to inherit_only ACEs. This
1547 			 * prevents inheritable permissions from being
1548 			 * altered along with the file mode.
1549 			 */
1550 			iflags |= ACE_INHERIT_ONLY_ACE;
1551 		}
1552 
1553 		/*
1554 		 * If this ACL has any inheritable ACEs, mark that in
1555 		 * the hints (which are later masked into the pflags)
1556 		 * so create knows to do inheritance.
1557 		 */
1558 		if (isdir && (iflags &
1559 		    (ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE)))
1560 			aclp->z_hints |= ZFS_INHERIT_ACE;
1561 
1562 		if ((type != ALLOW && type != DENY) ||
1563 		    (iflags & ACE_INHERIT_ONLY_ACE)) {
1564 			switch (type) {
1565 			case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
1566 			case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
1567 			case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
1568 			case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
1569 				aclp->z_hints |= ZFS_ACL_OBJ_ACE;
1570 				break;
1571 			}
1572 		} else {
1573 			/*
1574 			 * Limit permissions to be no greater than
1575 			 * group permissions.
1576 			 * The "aclinherit" and "aclmode" properties
1577 			 * affect policy for create and chmod(2),
1578 			 * respectively.
1579 			 */
1580 			if ((type == ALLOW) && trim)
1581 				access_mask &= masks.group;
1582 		}
1583 		zfs_set_ace(aclp, zacep, access_mask, type, who, iflags);
1584 		ace_size = aclp->z_ops->ace_size(acep);
1585 		zacep = (void *)((uintptr_t)zacep + ace_size);
1586 		new_count++;
1587 		new_bytes += ace_size;
1588 	}
1589 	zfs_set_ace(aclp, zacep, masks.owner, ALLOW, -1, ACE_OWNER);
1590 	zacep = (void *)((uintptr_t)zacep + abstract_size);
1591 	zfs_set_ace(aclp, zacep, masks.group, ALLOW, -1, OWNING_GROUP);
1592 	zacep = (void *)((uintptr_t)zacep + abstract_size);
1593 	zfs_set_ace(aclp, zacep, masks.everyone, ALLOW, -1, ACE_EVERYONE);
1594 
1595 	new_count += 3;
1596 	new_bytes += abstract_size * 3;
1597 	zfs_acl_release_nodes(aclp);
1598 	aclp->z_acl_count = new_count;
1599 	aclp->z_acl_bytes = new_bytes;
1600 	newnode->z_ace_count = new_count;
1601 	newnode->z_size = new_bytes;
1602 	list_insert_tail(&aclp->z_acl, newnode);
1603 }
1604 
1605 int
1606 zfs_acl_chmod_setattr(znode_t *zp, zfs_acl_t **aclp, uint64_t mode)
1607 {
1608 	int error = 0;
1609 
1610 	mutex_enter(&zp->z_acl_lock);
1611 	mutex_enter(&zp->z_lock);
1612 	if (ZTOZSB(zp)->z_acl_mode == ZFS_ACL_DISCARD)
1613 		*aclp = zfs_acl_alloc(zfs_acl_version_zp(zp));
1614 	else
1615 		error = zfs_acl_node_read(zp, B_TRUE, aclp, B_TRUE);
1616 
1617 	if (error == 0) {
1618 		(*aclp)->z_hints = zp->z_pflags & V4_ACL_WIDE_FLAGS;
1619 		zfs_acl_chmod(S_ISDIR(ZTOI(zp)->i_mode), mode, B_TRUE,
1620 		    (ZTOZSB(zp)->z_acl_mode == ZFS_ACL_GROUPMASK), *aclp);
1621 	}
1622 	mutex_exit(&zp->z_lock);
1623 	mutex_exit(&zp->z_acl_lock);
1624 
1625 	return (error);
1626 }
1627 
1628 /*
1629  * Should ACE be inherited?
1630  */
1631 static int
1632 zfs_ace_can_use(umode_t obj_mode, uint16_t acep_flags)
1633 {
1634 	int	iflags = (acep_flags & 0xf);
1635 
1636 	if (S_ISDIR(obj_mode) && (iflags & ACE_DIRECTORY_INHERIT_ACE))
1637 		return (1);
1638 	else if (iflags & ACE_FILE_INHERIT_ACE)
1639 		return (!(S_ISDIR(obj_mode) &&
1640 		    (iflags & ACE_NO_PROPAGATE_INHERIT_ACE)));
1641 	return (0);
1642 }
1643 
1644 /*
1645  * inherit inheritable ACEs from parent
1646  */
1647 static zfs_acl_t *
1648 zfs_acl_inherit(zfsvfs_t *zfsvfs, umode_t va_mode, zfs_acl_t *paclp,
1649     uint64_t mode, boolean_t *need_chmod)
1650 {
1651 	void		*pacep = NULL;
1652 	void		*acep;
1653 	zfs_acl_node_t  *aclnode;
1654 	zfs_acl_t	*aclp = NULL;
1655 	uint64_t	who;
1656 	uint32_t	access_mask;
1657 	uint16_t	iflags, newflags, type;
1658 	size_t		ace_size;
1659 	void		*data1, *data2;
1660 	size_t		data1sz, data2sz;
1661 	uint_t		aclinherit;
1662 	boolean_t	isdir = S_ISDIR(va_mode);
1663 	boolean_t	isreg = S_ISREG(va_mode);
1664 
1665 	*need_chmod = B_TRUE;
1666 
1667 	aclp = zfs_acl_alloc(paclp->z_version);
1668 	aclinherit = zfsvfs->z_acl_inherit;
1669 	if (aclinherit == ZFS_ACL_DISCARD || S_ISLNK(va_mode))
1670 		return (aclp);
1671 
1672 	while ((pacep = zfs_acl_next_ace(paclp, pacep, &who,
1673 	    &access_mask, &iflags, &type))) {
1674 
1675 		/*
1676 		 * don't inherit bogus ACEs
1677 		 */
1678 		if (!zfs_acl_valid_ace_type(type, iflags))
1679 			continue;
1680 
1681 		/*
1682 		 * Check if ACE is inheritable by this vnode
1683 		 */
1684 		if ((aclinherit == ZFS_ACL_NOALLOW && type == ALLOW) ||
1685 		    !zfs_ace_can_use(va_mode, iflags))
1686 			continue;
1687 
1688 		/*
1689 		 * If owner@, group@, or everyone@ inheritable
1690 		 * then zfs_acl_chmod() isn't needed.
1691 		 */
1692 		if ((aclinherit == ZFS_ACL_PASSTHROUGH ||
1693 		    aclinherit == ZFS_ACL_PASSTHROUGH_X) &&
1694 		    ((iflags & (ACE_OWNER|ACE_EVERYONE)) ||
1695 		    ((iflags & OWNING_GROUP) == OWNING_GROUP)) &&
1696 		    (isreg || (isdir && (iflags & ACE_DIRECTORY_INHERIT_ACE))))
1697 			*need_chmod = B_FALSE;
1698 
1699 		/*
1700 		 * Strip inherited execute permission from file if
1701 		 * not in mode
1702 		 */
1703 		if (aclinherit == ZFS_ACL_PASSTHROUGH_X && type == ALLOW &&
1704 		    !isdir && ((mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0)) {
1705 			access_mask &= ~ACE_EXECUTE;
1706 		}
1707 
1708 		/*
1709 		 * Strip write_acl and write_owner from permissions
1710 		 * when inheriting an ACE
1711 		 */
1712 		if (aclinherit == ZFS_ACL_RESTRICTED && type == ALLOW) {
1713 			access_mask &= ~RESTRICTED_CLEAR;
1714 		}
1715 
1716 		ace_size = aclp->z_ops->ace_size(pacep);
1717 		aclnode = zfs_acl_node_alloc(ace_size);
1718 		list_insert_tail(&aclp->z_acl, aclnode);
1719 		acep = aclnode->z_acldata;
1720 
1721 		zfs_set_ace(aclp, acep, access_mask, type,
1722 		    who, iflags|ACE_INHERITED_ACE);
1723 
1724 		/*
1725 		 * Copy special opaque data if any
1726 		 */
1727 		if ((data1sz = paclp->z_ops->ace_data(pacep, &data1)) != 0) {
1728 			VERIFY((data2sz = aclp->z_ops->ace_data(acep,
1729 			    &data2)) == data1sz);
1730 			bcopy(data1, data2, data2sz);
1731 		}
1732 
1733 		aclp->z_acl_count++;
1734 		aclnode->z_ace_count++;
1735 		aclp->z_acl_bytes += aclnode->z_size;
1736 		newflags = aclp->z_ops->ace_flags_get(acep);
1737 
1738 		/*
1739 		 * If ACE is not to be inherited further, or if the vnode is
1740 		 * not a directory, remove all inheritance flags
1741 		 */
1742 		if (!isdir || (iflags & ACE_NO_PROPAGATE_INHERIT_ACE)) {
1743 			newflags &= ~ALL_INHERIT;
1744 			aclp->z_ops->ace_flags_set(acep,
1745 			    newflags|ACE_INHERITED_ACE);
1746 			continue;
1747 		}
1748 
1749 		/*
1750 		 * This directory has an inheritable ACE
1751 		 */
1752 		aclp->z_hints |= ZFS_INHERIT_ACE;
1753 
1754 		/*
1755 		 * If only FILE_INHERIT is set then turn on
1756 		 * inherit_only
1757 		 */
1758 		if ((iflags & (ACE_FILE_INHERIT_ACE |
1759 		    ACE_DIRECTORY_INHERIT_ACE)) == ACE_FILE_INHERIT_ACE) {
1760 			newflags |= ACE_INHERIT_ONLY_ACE;
1761 			aclp->z_ops->ace_flags_set(acep,
1762 			    newflags|ACE_INHERITED_ACE);
1763 		} else {
1764 			newflags &= ~ACE_INHERIT_ONLY_ACE;
1765 			aclp->z_ops->ace_flags_set(acep,
1766 			    newflags|ACE_INHERITED_ACE);
1767 		}
1768 	}
1769 	if (zfsvfs->z_acl_mode == ZFS_ACL_RESTRICTED &&
1770 	    aclp->z_acl_count != 0) {
1771 		*need_chmod = B_FALSE;
1772 	}
1773 
1774 	return (aclp);
1775 }
1776 
1777 /*
1778  * Create file system object initial permissions
1779  * including inheritable ACEs.
1780  * Also, create FUIDs for owner and group.
1781  */
1782 int
1783 zfs_acl_ids_create(znode_t *dzp, int flag, vattr_t *vap, cred_t *cr,
1784     vsecattr_t *vsecp, zfs_acl_ids_t *acl_ids)
1785 {
1786 	int		error;
1787 	zfsvfs_t	*zfsvfs = ZTOZSB(dzp);
1788 	zfs_acl_t	*paclp;
1789 	gid_t		gid = vap->va_gid;
1790 	boolean_t	need_chmod = B_TRUE;
1791 	boolean_t	trim = B_FALSE;
1792 	boolean_t	inherited = B_FALSE;
1793 
1794 	bzero(acl_ids, sizeof (zfs_acl_ids_t));
1795 	acl_ids->z_mode = vap->va_mode;
1796 
1797 	if (vsecp)
1798 		if ((error = zfs_vsec_2_aclp(zfsvfs, vap->va_mode, vsecp,
1799 		    cr, &acl_ids->z_fuidp, &acl_ids->z_aclp)) != 0)
1800 			return (error);
1801 
1802 	acl_ids->z_fuid = vap->va_uid;
1803 	acl_ids->z_fgid = vap->va_gid;
1804 #ifdef HAVE_KSID
1805 	/*
1806 	 * Determine uid and gid.
1807 	 */
1808 	if ((flag & IS_ROOT_NODE) || zfsvfs->z_replay ||
1809 	    ((flag & IS_XATTR) && (S_ISDIR(vap->va_mode)))) {
1810 		acl_ids->z_fuid = zfs_fuid_create(zfsvfs, (uint64_t)vap->va_uid,
1811 		    cr, ZFS_OWNER, &acl_ids->z_fuidp);
1812 		acl_ids->z_fgid = zfs_fuid_create(zfsvfs, (uint64_t)vap->va_gid,
1813 		    cr, ZFS_GROUP, &acl_ids->z_fuidp);
1814 		gid = vap->va_gid;
1815 	} else {
1816 		acl_ids->z_fuid = zfs_fuid_create_cred(zfsvfs, ZFS_OWNER,
1817 		    cr, &acl_ids->z_fuidp);
1818 		acl_ids->z_fgid = 0;
1819 		if (vap->va_mask & AT_GID)  {
1820 			acl_ids->z_fgid = zfs_fuid_create(zfsvfs,
1821 			    (uint64_t)vap->va_gid,
1822 			    cr, ZFS_GROUP, &acl_ids->z_fuidp);
1823 			gid = vap->va_gid;
1824 			if (acl_ids->z_fgid != KGID_TO_SGID(ZTOI(dzp)->i_gid) &&
1825 			    !groupmember(vap->va_gid, cr) &&
1826 			    secpolicy_vnode_create_gid(cr) != 0)
1827 				acl_ids->z_fgid = 0;
1828 		}
1829 		if (acl_ids->z_fgid == 0) {
1830 			if (dzp->z_mode & S_ISGID) {
1831 				char		*domain;
1832 				uint32_t	rid;
1833 
1834 				acl_ids->z_fgid = KGID_TO_SGID(
1835 				    ZTOI(dzp)->i_gid);
1836 				gid = zfs_fuid_map_id(zfsvfs, acl_ids->z_fgid,
1837 				    cr, ZFS_GROUP);
1838 
1839 				if (zfsvfs->z_use_fuids &&
1840 				    IS_EPHEMERAL(acl_ids->z_fgid)) {
1841 					domain = zfs_fuid_idx_domain(
1842 					    &zfsvfs->z_fuid_idx,
1843 					    FUID_INDEX(acl_ids->z_fgid));
1844 					rid = FUID_RID(acl_ids->z_fgid);
1845 					zfs_fuid_node_add(&acl_ids->z_fuidp,
1846 					    domain, rid,
1847 					    FUID_INDEX(acl_ids->z_fgid),
1848 					    acl_ids->z_fgid, ZFS_GROUP);
1849 				}
1850 			} else {
1851 				acl_ids->z_fgid = zfs_fuid_create_cred(zfsvfs,
1852 				    ZFS_GROUP, cr, &acl_ids->z_fuidp);
1853 				gid = crgetgid(cr);
1854 			}
1855 		}
1856 	}
1857 #endif /* HAVE_KSID */
1858 
1859 	/*
1860 	 * If we're creating a directory, and the parent directory has the
1861 	 * set-GID bit set, set in on the new directory.
1862 	 * Otherwise, if the user is neither privileged nor a member of the
1863 	 * file's new group, clear the file's set-GID bit.
1864 	 */
1865 
1866 	if (!(flag & IS_ROOT_NODE) && (dzp->z_mode & S_ISGID) &&
1867 	    (S_ISDIR(vap->va_mode))) {
1868 		acl_ids->z_mode |= S_ISGID;
1869 	} else {
1870 		if ((acl_ids->z_mode & S_ISGID) &&
1871 		    secpolicy_vnode_setids_setgids(cr, gid) != 0)
1872 			acl_ids->z_mode &= ~S_ISGID;
1873 	}
1874 
1875 	if (acl_ids->z_aclp == NULL) {
1876 		mutex_enter(&dzp->z_acl_lock);
1877 		mutex_enter(&dzp->z_lock);
1878 		if (!(flag & IS_ROOT_NODE) &&
1879 		    (dzp->z_pflags & ZFS_INHERIT_ACE) &&
1880 		    !(dzp->z_pflags & ZFS_XATTR)) {
1881 			VERIFY(0 == zfs_acl_node_read(dzp, B_TRUE,
1882 			    &paclp, B_FALSE));
1883 			acl_ids->z_aclp = zfs_acl_inherit(zfsvfs,
1884 			    vap->va_mode, paclp, acl_ids->z_mode, &need_chmod);
1885 			inherited = B_TRUE;
1886 		} else {
1887 			acl_ids->z_aclp =
1888 			    zfs_acl_alloc(zfs_acl_version_zp(dzp));
1889 			acl_ids->z_aclp->z_hints |= ZFS_ACL_TRIVIAL;
1890 		}
1891 		mutex_exit(&dzp->z_lock);
1892 		mutex_exit(&dzp->z_acl_lock);
1893 
1894 		if (need_chmod) {
1895 			if (S_ISDIR(vap->va_mode))
1896 				acl_ids->z_aclp->z_hints |=
1897 				    ZFS_ACL_AUTO_INHERIT;
1898 
1899 			if (zfsvfs->z_acl_mode == ZFS_ACL_GROUPMASK &&
1900 			    zfsvfs->z_acl_inherit != ZFS_ACL_PASSTHROUGH &&
1901 			    zfsvfs->z_acl_inherit != ZFS_ACL_PASSTHROUGH_X)
1902 				trim = B_TRUE;
1903 			zfs_acl_chmod(vap->va_mode, acl_ids->z_mode, B_FALSE,
1904 			    trim, acl_ids->z_aclp);
1905 		}
1906 	}
1907 
1908 	if (inherited || vsecp) {
1909 		acl_ids->z_mode = zfs_mode_compute(acl_ids->z_mode,
1910 		    acl_ids->z_aclp, &acl_ids->z_aclp->z_hints,
1911 		    acl_ids->z_fuid, acl_ids->z_fgid);
1912 		if (ace_trivial_common(acl_ids->z_aclp, 0, zfs_ace_walk) == 0)
1913 			acl_ids->z_aclp->z_hints |= ZFS_ACL_TRIVIAL;
1914 	}
1915 
1916 	return (0);
1917 }
1918 
1919 /*
1920  * Free ACL and fuid_infop, but not the acl_ids structure
1921  */
1922 void
1923 zfs_acl_ids_free(zfs_acl_ids_t *acl_ids)
1924 {
1925 	if (acl_ids->z_aclp)
1926 		zfs_acl_free(acl_ids->z_aclp);
1927 	if (acl_ids->z_fuidp)
1928 		zfs_fuid_info_free(acl_ids->z_fuidp);
1929 	acl_ids->z_aclp = NULL;
1930 	acl_ids->z_fuidp = NULL;
1931 }
1932 
1933 boolean_t
1934 zfs_acl_ids_overquota(zfsvfs_t *zv, zfs_acl_ids_t *acl_ids, uint64_t projid)
1935 {
1936 	return (zfs_id_overquota(zv, DMU_USERUSED_OBJECT, acl_ids->z_fuid) ||
1937 	    zfs_id_overquota(zv, DMU_GROUPUSED_OBJECT, acl_ids->z_fgid) ||
1938 	    (projid != ZFS_DEFAULT_PROJID && projid != ZFS_INVALID_PROJID &&
1939 	    zfs_id_overquota(zv, DMU_PROJECTUSED_OBJECT, projid)));
1940 }
1941 
1942 /*
1943  * Retrieve a file's ACL
1944  */
1945 int
1946 zfs_getacl(znode_t *zp, vsecattr_t *vsecp, boolean_t skipaclchk, cred_t *cr)
1947 {
1948 	zfs_acl_t	*aclp;
1949 	ulong_t		mask;
1950 	int		error;
1951 	int 		count = 0;
1952 	int		largeace = 0;
1953 
1954 	mask = vsecp->vsa_mask & (VSA_ACE | VSA_ACECNT |
1955 	    VSA_ACE_ACLFLAGS | VSA_ACE_ALLTYPES);
1956 
1957 	if (mask == 0)
1958 		return (SET_ERROR(ENOSYS));
1959 
1960 	if ((error = zfs_zaccess(zp, ACE_READ_ACL, 0, skipaclchk, cr)))
1961 		return (error);
1962 
1963 	mutex_enter(&zp->z_acl_lock);
1964 
1965 	error = zfs_acl_node_read(zp, B_FALSE, &aclp, B_FALSE);
1966 	if (error != 0) {
1967 		mutex_exit(&zp->z_acl_lock);
1968 		return (error);
1969 	}
1970 
1971 	/*
1972 	 * Scan ACL to determine number of ACEs
1973 	 */
1974 	if ((zp->z_pflags & ZFS_ACL_OBJ_ACE) && !(mask & VSA_ACE_ALLTYPES)) {
1975 		void *zacep = NULL;
1976 		uint64_t who;
1977 		uint32_t access_mask;
1978 		uint16_t type, iflags;
1979 
1980 		while ((zacep = zfs_acl_next_ace(aclp, zacep,
1981 		    &who, &access_mask, &iflags, &type))) {
1982 			switch (type) {
1983 			case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
1984 			case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
1985 			case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
1986 			case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
1987 				largeace++;
1988 				continue;
1989 			default:
1990 				count++;
1991 			}
1992 		}
1993 		vsecp->vsa_aclcnt = count;
1994 	} else
1995 		count = (int)aclp->z_acl_count;
1996 
1997 	if (mask & VSA_ACECNT) {
1998 		vsecp->vsa_aclcnt = count;
1999 	}
2000 
2001 	if (mask & VSA_ACE) {
2002 		size_t aclsz;
2003 
2004 		aclsz = count * sizeof (ace_t) +
2005 		    sizeof (ace_object_t) * largeace;
2006 
2007 		vsecp->vsa_aclentp = kmem_alloc(aclsz, KM_SLEEP);
2008 		vsecp->vsa_aclentsz = aclsz;
2009 
2010 		if (aclp->z_version == ZFS_ACL_VERSION_FUID)
2011 			zfs_copy_fuid_2_ace(ZTOZSB(zp), aclp, cr,
2012 			    vsecp->vsa_aclentp, !(mask & VSA_ACE_ALLTYPES));
2013 		else {
2014 			zfs_acl_node_t *aclnode;
2015 			void *start = vsecp->vsa_aclentp;
2016 
2017 			for (aclnode = list_head(&aclp->z_acl); aclnode;
2018 			    aclnode = list_next(&aclp->z_acl, aclnode)) {
2019 				bcopy(aclnode->z_acldata, start,
2020 				    aclnode->z_size);
2021 				start = (caddr_t)start + aclnode->z_size;
2022 			}
2023 			ASSERT((caddr_t)start - (caddr_t)vsecp->vsa_aclentp ==
2024 			    aclp->z_acl_bytes);
2025 		}
2026 	}
2027 	if (mask & VSA_ACE_ACLFLAGS) {
2028 		vsecp->vsa_aclflags = 0;
2029 		if (zp->z_pflags & ZFS_ACL_DEFAULTED)
2030 			vsecp->vsa_aclflags |= ACL_DEFAULTED;
2031 		if (zp->z_pflags & ZFS_ACL_PROTECTED)
2032 			vsecp->vsa_aclflags |= ACL_PROTECTED;
2033 		if (zp->z_pflags & ZFS_ACL_AUTO_INHERIT)
2034 			vsecp->vsa_aclflags |= ACL_AUTO_INHERIT;
2035 	}
2036 
2037 	mutex_exit(&zp->z_acl_lock);
2038 
2039 	return (0);
2040 }
2041 
2042 int
2043 zfs_vsec_2_aclp(zfsvfs_t *zfsvfs, umode_t obj_mode,
2044     vsecattr_t *vsecp, cred_t *cr, zfs_fuid_info_t **fuidp, zfs_acl_t **zaclp)
2045 {
2046 	zfs_acl_t *aclp;
2047 	zfs_acl_node_t *aclnode;
2048 	int aclcnt = vsecp->vsa_aclcnt;
2049 	int error;
2050 
2051 	if (vsecp->vsa_aclcnt > MAX_ACL_ENTRIES || vsecp->vsa_aclcnt <= 0)
2052 		return (SET_ERROR(EINVAL));
2053 
2054 	aclp = zfs_acl_alloc(zfs_acl_version(zfsvfs->z_version));
2055 
2056 	aclp->z_hints = 0;
2057 	aclnode = zfs_acl_node_alloc(aclcnt * sizeof (zfs_object_ace_t));
2058 	if (aclp->z_version == ZFS_ACL_VERSION_INITIAL) {
2059 		if ((error = zfs_copy_ace_2_oldace(obj_mode, aclp,
2060 		    (ace_t *)vsecp->vsa_aclentp, aclnode->z_acldata,
2061 		    aclcnt, &aclnode->z_size)) != 0) {
2062 			zfs_acl_free(aclp);
2063 			zfs_acl_node_free(aclnode);
2064 			return (error);
2065 		}
2066 	} else {
2067 		if ((error = zfs_copy_ace_2_fuid(zfsvfs, obj_mode, aclp,
2068 		    vsecp->vsa_aclentp, aclnode->z_acldata, aclcnt,
2069 		    &aclnode->z_size, fuidp, cr)) != 0) {
2070 			zfs_acl_free(aclp);
2071 			zfs_acl_node_free(aclnode);
2072 			return (error);
2073 		}
2074 	}
2075 	aclp->z_acl_bytes = aclnode->z_size;
2076 	aclnode->z_ace_count = aclcnt;
2077 	aclp->z_acl_count = aclcnt;
2078 	list_insert_head(&aclp->z_acl, aclnode);
2079 
2080 	/*
2081 	 * If flags are being set then add them to z_hints
2082 	 */
2083 	if (vsecp->vsa_mask & VSA_ACE_ACLFLAGS) {
2084 		if (vsecp->vsa_aclflags & ACL_PROTECTED)
2085 			aclp->z_hints |= ZFS_ACL_PROTECTED;
2086 		if (vsecp->vsa_aclflags & ACL_DEFAULTED)
2087 			aclp->z_hints |= ZFS_ACL_DEFAULTED;
2088 		if (vsecp->vsa_aclflags & ACL_AUTO_INHERIT)
2089 			aclp->z_hints |= ZFS_ACL_AUTO_INHERIT;
2090 	}
2091 
2092 	*zaclp = aclp;
2093 
2094 	return (0);
2095 }
2096 
2097 /*
2098  * Set a file's ACL
2099  */
2100 int
2101 zfs_setacl(znode_t *zp, vsecattr_t *vsecp, boolean_t skipaclchk, cred_t *cr)
2102 {
2103 	zfsvfs_t	*zfsvfs = ZTOZSB(zp);
2104 	zilog_t		*zilog = zfsvfs->z_log;
2105 	ulong_t		mask = vsecp->vsa_mask & (VSA_ACE | VSA_ACECNT);
2106 	dmu_tx_t	*tx;
2107 	int		error;
2108 	zfs_acl_t	*aclp;
2109 	zfs_fuid_info_t	*fuidp = NULL;
2110 	boolean_t	fuid_dirtied;
2111 	uint64_t	acl_obj;
2112 
2113 	if (mask == 0)
2114 		return (SET_ERROR(ENOSYS));
2115 
2116 	if (zp->z_pflags & ZFS_IMMUTABLE)
2117 		return (SET_ERROR(EPERM));
2118 
2119 	if ((error = zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr)))
2120 		return (error);
2121 
2122 	error = zfs_vsec_2_aclp(zfsvfs, ZTOI(zp)->i_mode, vsecp, cr, &fuidp,
2123 	    &aclp);
2124 	if (error)
2125 		return (error);
2126 
2127 	/*
2128 	 * If ACL wide flags aren't being set then preserve any
2129 	 * existing flags.
2130 	 */
2131 	if (!(vsecp->vsa_mask & VSA_ACE_ACLFLAGS)) {
2132 		aclp->z_hints |=
2133 		    (zp->z_pflags & V4_ACL_WIDE_FLAGS);
2134 	}
2135 top:
2136 	mutex_enter(&zp->z_acl_lock);
2137 	mutex_enter(&zp->z_lock);
2138 
2139 	tx = dmu_tx_create(zfsvfs->z_os);
2140 
2141 	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
2142 
2143 	fuid_dirtied = zfsvfs->z_fuid_dirty;
2144 	if (fuid_dirtied)
2145 		zfs_fuid_txhold(zfsvfs, tx);
2146 
2147 	/*
2148 	 * If old version and ACL won't fit in bonus and we aren't
2149 	 * upgrading then take out necessary DMU holds
2150 	 */
2151 
2152 	if ((acl_obj = zfs_external_acl(zp)) != 0) {
2153 		if (zfsvfs->z_version >= ZPL_VERSION_FUID &&
2154 		    zfs_znode_acl_version(zp) <= ZFS_ACL_VERSION_INITIAL) {
2155 			dmu_tx_hold_free(tx, acl_obj, 0,
2156 			    DMU_OBJECT_END);
2157 			dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
2158 			    aclp->z_acl_bytes);
2159 		} else {
2160 			dmu_tx_hold_write(tx, acl_obj, 0, aclp->z_acl_bytes);
2161 		}
2162 	} else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) {
2163 		dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, aclp->z_acl_bytes);
2164 	}
2165 
2166 	zfs_sa_upgrade_txholds(tx, zp);
2167 	error = dmu_tx_assign(tx, TXG_NOWAIT);
2168 	if (error) {
2169 		mutex_exit(&zp->z_acl_lock);
2170 		mutex_exit(&zp->z_lock);
2171 
2172 		if (error == ERESTART) {
2173 			dmu_tx_wait(tx);
2174 			dmu_tx_abort(tx);
2175 			goto top;
2176 		}
2177 		dmu_tx_abort(tx);
2178 		zfs_acl_free(aclp);
2179 		return (error);
2180 	}
2181 
2182 	error = zfs_aclset_common(zp, aclp, cr, tx);
2183 	ASSERT(error == 0);
2184 	ASSERT(zp->z_acl_cached == NULL);
2185 	zp->z_acl_cached = aclp;
2186 
2187 	if (fuid_dirtied)
2188 		zfs_fuid_sync(zfsvfs, tx);
2189 
2190 	zfs_log_acl(zilog, tx, zp, vsecp, fuidp);
2191 
2192 	if (fuidp)
2193 		zfs_fuid_info_free(fuidp);
2194 	dmu_tx_commit(tx);
2195 
2196 	mutex_exit(&zp->z_lock);
2197 	mutex_exit(&zp->z_acl_lock);
2198 
2199 	return (error);
2200 }
2201 
2202 /*
2203  * Check accesses of interest (AoI) against attributes of the dataset
2204  * such as read-only.  Returns zero if no AoI conflict with dataset
2205  * attributes, otherwise an appropriate errno is returned.
2206  */
2207 static int
2208 zfs_zaccess_dataset_check(znode_t *zp, uint32_t v4_mode)
2209 {
2210 	if ((v4_mode & WRITE_MASK) && (zfs_is_readonly(ZTOZSB(zp))) &&
2211 	    (!Z_ISDEV(ZTOI(zp)->i_mode) ||
2212 	    (Z_ISDEV(ZTOI(zp)->i_mode) && (v4_mode & WRITE_MASK_ATTRS)))) {
2213 		return (SET_ERROR(EROFS));
2214 	}
2215 
2216 	/*
2217 	 * Intentionally allow ZFS_READONLY through here.
2218 	 * See zfs_zaccess_common().
2219 	 */
2220 	if ((v4_mode & WRITE_MASK_DATA) &&
2221 	    (zp->z_pflags & ZFS_IMMUTABLE)) {
2222 		return (SET_ERROR(EPERM));
2223 	}
2224 
2225 	if ((v4_mode & (ACE_DELETE | ACE_DELETE_CHILD)) &&
2226 	    (zp->z_pflags & ZFS_NOUNLINK)) {
2227 		return (SET_ERROR(EPERM));
2228 	}
2229 
2230 	if (((v4_mode & (ACE_READ_DATA|ACE_EXECUTE)) &&
2231 	    (zp->z_pflags & ZFS_AV_QUARANTINED))) {
2232 		return (SET_ERROR(EACCES));
2233 	}
2234 
2235 	return (0);
2236 }
2237 
2238 /*
2239  * The primary usage of this function is to loop through all of the
2240  * ACEs in the znode, determining what accesses of interest (AoI) to
2241  * the caller are allowed or denied.  The AoI are expressed as bits in
2242  * the working_mode parameter.  As each ACE is processed, bits covered
2243  * by that ACE are removed from the working_mode.  This removal
2244  * facilitates two things.  The first is that when the working mode is
2245  * empty (= 0), we know we've looked at all the AoI. The second is
2246  * that the ACE interpretation rules don't allow a later ACE to undo
2247  * something granted or denied by an earlier ACE.  Removing the
2248  * discovered access or denial enforces this rule.  At the end of
2249  * processing the ACEs, all AoI that were found to be denied are
2250  * placed into the working_mode, giving the caller a mask of denied
2251  * accesses.  Returns:
2252  *	0		if all AoI granted
2253  *	EACCES 		if the denied mask is non-zero
2254  *	other error	if abnormal failure (e.g., IO error)
2255  *
2256  * A secondary usage of the function is to determine if any of the
2257  * AoI are granted.  If an ACE grants any access in
2258  * the working_mode, we immediately short circuit out of the function.
2259  * This mode is chosen by setting anyaccess to B_TRUE.  The
2260  * working_mode is not a denied access mask upon exit if the function
2261  * is used in this manner.
2262  */
2263 static int
2264 zfs_zaccess_aces_check(znode_t *zp, uint32_t *working_mode,
2265     boolean_t anyaccess, cred_t *cr)
2266 {
2267 	zfsvfs_t	*zfsvfs = ZTOZSB(zp);
2268 	zfs_acl_t	*aclp;
2269 	int		error;
2270 	uid_t		uid = crgetuid(cr);
2271 	uint64_t	who;
2272 	uint16_t	type, iflags;
2273 	uint16_t	entry_type;
2274 	uint32_t	access_mask;
2275 	uint32_t	deny_mask = 0;
2276 	zfs_ace_hdr_t	*acep = NULL;
2277 	boolean_t	checkit;
2278 	uid_t		gowner;
2279 	uid_t		fowner;
2280 
2281 	zfs_fuid_map_ids(zp, cr, &fowner, &gowner);
2282 
2283 	mutex_enter(&zp->z_acl_lock);
2284 
2285 	error = zfs_acl_node_read(zp, B_FALSE, &aclp, B_FALSE);
2286 	if (error != 0) {
2287 		mutex_exit(&zp->z_acl_lock);
2288 		return (error);
2289 	}
2290 
2291 	ASSERT(zp->z_acl_cached);
2292 
2293 	while ((acep = zfs_acl_next_ace(aclp, acep, &who, &access_mask,
2294 	    &iflags, &type))) {
2295 		uint32_t mask_matched;
2296 
2297 		if (!zfs_acl_valid_ace_type(type, iflags))
2298 			continue;
2299 
2300 		if (S_ISDIR(ZTOI(zp)->i_mode) &&
2301 		    (iflags & ACE_INHERIT_ONLY_ACE))
2302 			continue;
2303 
2304 		/* Skip ACE if it does not affect any AoI */
2305 		mask_matched = (access_mask & *working_mode);
2306 		if (!mask_matched)
2307 			continue;
2308 
2309 		entry_type = (iflags & ACE_TYPE_FLAGS);
2310 
2311 		checkit = B_FALSE;
2312 
2313 		switch (entry_type) {
2314 		case ACE_OWNER:
2315 			if (uid == fowner)
2316 				checkit = B_TRUE;
2317 			break;
2318 		case OWNING_GROUP:
2319 			who = gowner;
2320 			fallthrough;
2321 		case ACE_IDENTIFIER_GROUP:
2322 			checkit = zfs_groupmember(zfsvfs, who, cr);
2323 			break;
2324 		case ACE_EVERYONE:
2325 			checkit = B_TRUE;
2326 			break;
2327 
2328 		/* USER Entry */
2329 		default:
2330 			if (entry_type == 0) {
2331 				uid_t newid;
2332 
2333 				newid = zfs_fuid_map_id(zfsvfs, who, cr,
2334 				    ZFS_ACE_USER);
2335 				if (newid != IDMAP_WK_CREATOR_OWNER_UID &&
2336 				    uid == newid)
2337 					checkit = B_TRUE;
2338 				break;
2339 			} else {
2340 				mutex_exit(&zp->z_acl_lock);
2341 				return (SET_ERROR(EIO));
2342 			}
2343 		}
2344 
2345 		if (checkit) {
2346 			if (type == DENY) {
2347 				DTRACE_PROBE3(zfs__ace__denies,
2348 				    znode_t *, zp,
2349 				    zfs_ace_hdr_t *, acep,
2350 				    uint32_t, mask_matched);
2351 				deny_mask |= mask_matched;
2352 			} else {
2353 				DTRACE_PROBE3(zfs__ace__allows,
2354 				    znode_t *, zp,
2355 				    zfs_ace_hdr_t *, acep,
2356 				    uint32_t, mask_matched);
2357 				if (anyaccess) {
2358 					mutex_exit(&zp->z_acl_lock);
2359 					return (0);
2360 				}
2361 			}
2362 			*working_mode &= ~mask_matched;
2363 		}
2364 
2365 		/* Are we done? */
2366 		if (*working_mode == 0)
2367 			break;
2368 	}
2369 
2370 	mutex_exit(&zp->z_acl_lock);
2371 
2372 	/* Put the found 'denies' back on the working mode */
2373 	if (deny_mask) {
2374 		*working_mode |= deny_mask;
2375 		return (SET_ERROR(EACCES));
2376 	} else if (*working_mode) {
2377 		return (-1);
2378 	}
2379 
2380 	return (0);
2381 }
2382 
2383 /*
2384  * Return true if any access whatsoever granted, we don't actually
2385  * care what access is granted.
2386  */
2387 boolean_t
2388 zfs_has_access(znode_t *zp, cred_t *cr)
2389 {
2390 	uint32_t have = ACE_ALL_PERMS;
2391 
2392 	if (zfs_zaccess_aces_check(zp, &have, B_TRUE, cr) != 0) {
2393 		uid_t owner;
2394 
2395 		owner = zfs_fuid_map_id(ZTOZSB(zp),
2396 		    KUID_TO_SUID(ZTOI(zp)->i_uid), cr, ZFS_OWNER);
2397 		return (secpolicy_vnode_any_access(cr, ZTOI(zp), owner) == 0);
2398 	}
2399 	return (B_TRUE);
2400 }
2401 
2402 static int
2403 zfs_zaccess_common(znode_t *zp, uint32_t v4_mode, uint32_t *working_mode,
2404     boolean_t *check_privs, boolean_t skipaclchk, cred_t *cr)
2405 {
2406 	zfsvfs_t *zfsvfs = ZTOZSB(zp);
2407 	int err;
2408 
2409 	*working_mode = v4_mode;
2410 	*check_privs = B_TRUE;
2411 
2412 	/*
2413 	 * Short circuit empty requests
2414 	 */
2415 	if (v4_mode == 0 || zfsvfs->z_replay) {
2416 		*working_mode = 0;
2417 		return (0);
2418 	}
2419 
2420 	if ((err = zfs_zaccess_dataset_check(zp, v4_mode)) != 0) {
2421 		*check_privs = B_FALSE;
2422 		return (err);
2423 	}
2424 
2425 	/*
2426 	 * The caller requested that the ACL check be skipped.  This
2427 	 * would only happen if the caller checked VOP_ACCESS() with a
2428 	 * 32 bit ACE mask and already had the appropriate permissions.
2429 	 */
2430 	if (skipaclchk) {
2431 		*working_mode = 0;
2432 		return (0);
2433 	}
2434 
2435 	/*
2436 	 * Note: ZFS_READONLY represents the "DOS R/O" attribute.
2437 	 * When that flag is set, we should behave as if write access
2438 	 * were not granted by anything in the ACL.  In particular:
2439 	 * We _must_ allow writes after opening the file r/w, then
2440 	 * setting the DOS R/O attribute, and writing some more.
2441 	 * (Similar to how you can write after fchmod(fd, 0444).)
2442 	 *
2443 	 * Therefore ZFS_READONLY is ignored in the dataset check
2444 	 * above, and checked here as if part of the ACL check.
2445 	 * Also note: DOS R/O is ignored for directories.
2446 	 */
2447 	if ((v4_mode & WRITE_MASK_DATA) &&
2448 	    S_ISDIR(ZTOI(zp)->i_mode) &&
2449 	    (zp->z_pflags & ZFS_READONLY)) {
2450 		return (SET_ERROR(EPERM));
2451 	}
2452 
2453 	return (zfs_zaccess_aces_check(zp, working_mode, B_FALSE, cr));
2454 }
2455 
2456 static int
2457 zfs_zaccess_append(znode_t *zp, uint32_t *working_mode, boolean_t *check_privs,
2458     cred_t *cr)
2459 {
2460 	if (*working_mode != ACE_WRITE_DATA)
2461 		return (SET_ERROR(EACCES));
2462 
2463 	return (zfs_zaccess_common(zp, ACE_APPEND_DATA, working_mode,
2464 	    check_privs, B_FALSE, cr));
2465 }
2466 
2467 int
2468 zfs_fastaccesschk_execute(znode_t *zdp, cred_t *cr)
2469 {
2470 	boolean_t owner = B_FALSE;
2471 	boolean_t groupmbr = B_FALSE;
2472 	boolean_t is_attr;
2473 	uid_t uid = crgetuid(cr);
2474 	int error;
2475 
2476 	if (zdp->z_pflags & ZFS_AV_QUARANTINED)
2477 		return (SET_ERROR(EACCES));
2478 
2479 	is_attr = ((zdp->z_pflags & ZFS_XATTR) &&
2480 	    (S_ISDIR(ZTOI(zdp)->i_mode)));
2481 	if (is_attr)
2482 		goto slow;
2483 
2484 
2485 	mutex_enter(&zdp->z_acl_lock);
2486 
2487 	if (zdp->z_pflags & ZFS_NO_EXECS_DENIED) {
2488 		mutex_exit(&zdp->z_acl_lock);
2489 		return (0);
2490 	}
2491 
2492 	if (KUID_TO_SUID(ZTOI(zdp)->i_uid) != 0 ||
2493 	    KGID_TO_SGID(ZTOI(zdp)->i_gid) != 0) {
2494 		mutex_exit(&zdp->z_acl_lock);
2495 		goto slow;
2496 	}
2497 
2498 	if (uid == KUID_TO_SUID(ZTOI(zdp)->i_uid)) {
2499 		owner = B_TRUE;
2500 		if (zdp->z_mode & S_IXUSR) {
2501 			mutex_exit(&zdp->z_acl_lock);
2502 			return (0);
2503 		} else {
2504 			mutex_exit(&zdp->z_acl_lock);
2505 			goto slow;
2506 		}
2507 	}
2508 	if (groupmember(KGID_TO_SGID(ZTOI(zdp)->i_gid), cr)) {
2509 		groupmbr = B_TRUE;
2510 		if (zdp->z_mode & S_IXGRP) {
2511 			mutex_exit(&zdp->z_acl_lock);
2512 			return (0);
2513 		} else {
2514 			mutex_exit(&zdp->z_acl_lock);
2515 			goto slow;
2516 		}
2517 	}
2518 	if (!owner && !groupmbr) {
2519 		if (zdp->z_mode & S_IXOTH) {
2520 			mutex_exit(&zdp->z_acl_lock);
2521 			return (0);
2522 		}
2523 	}
2524 
2525 	mutex_exit(&zdp->z_acl_lock);
2526 
2527 slow:
2528 	DTRACE_PROBE(zfs__fastpath__execute__access__miss);
2529 	ZFS_ENTER(ZTOZSB(zdp));
2530 	error = zfs_zaccess(zdp, ACE_EXECUTE, 0, B_FALSE, cr);
2531 	ZFS_EXIT(ZTOZSB(zdp));
2532 	return (error);
2533 }
2534 
2535 /*
2536  * Determine whether Access should be granted/denied.
2537  *
2538  * The least priv subsystem is always consulted as a basic privilege
2539  * can define any form of access.
2540  */
2541 int
2542 zfs_zaccess(znode_t *zp, int mode, int flags, boolean_t skipaclchk, cred_t *cr)
2543 {
2544 	uint32_t	working_mode;
2545 	int		error;
2546 	int		is_attr;
2547 	boolean_t 	check_privs;
2548 	znode_t		*xzp;
2549 	znode_t 	*check_zp = zp;
2550 	mode_t		needed_bits;
2551 	uid_t		owner;
2552 
2553 	is_attr = ((zp->z_pflags & ZFS_XATTR) && S_ISDIR(ZTOI(zp)->i_mode));
2554 
2555 	/*
2556 	 * If attribute then validate against base file
2557 	 */
2558 	if (is_attr) {
2559 		if ((error = zfs_zget(ZTOZSB(zp),
2560 		    zp->z_xattr_parent, &xzp)) != 0) {
2561 			return (error);
2562 		}
2563 
2564 		check_zp = xzp;
2565 
2566 		/*
2567 		 * fixup mode to map to xattr perms
2568 		 */
2569 
2570 		if (mode & (ACE_WRITE_DATA|ACE_APPEND_DATA)) {
2571 			mode &= ~(ACE_WRITE_DATA|ACE_APPEND_DATA);
2572 			mode |= ACE_WRITE_NAMED_ATTRS;
2573 		}
2574 
2575 		if (mode & (ACE_READ_DATA|ACE_EXECUTE)) {
2576 			mode &= ~(ACE_READ_DATA|ACE_EXECUTE);
2577 			mode |= ACE_READ_NAMED_ATTRS;
2578 		}
2579 	}
2580 
2581 	owner = zfs_fuid_map_id(ZTOZSB(zp), KUID_TO_SUID(ZTOI(zp)->i_uid),
2582 	    cr, ZFS_OWNER);
2583 	/*
2584 	 * Map the bits required to the standard inode flags
2585 	 * S_IRUSR|S_IWUSR|S_IXUSR in the needed_bits.  Map the bits
2586 	 * mapped by working_mode (currently missing) in missing_bits.
2587 	 * Call secpolicy_vnode_access2() with (needed_bits & ~checkmode),
2588 	 * needed_bits.
2589 	 */
2590 	needed_bits = 0;
2591 
2592 	working_mode = mode;
2593 	if ((working_mode & (ACE_READ_ACL|ACE_READ_ATTRIBUTES)) &&
2594 	    owner == crgetuid(cr))
2595 		working_mode &= ~(ACE_READ_ACL|ACE_READ_ATTRIBUTES);
2596 
2597 	if (working_mode & (ACE_READ_DATA|ACE_READ_NAMED_ATTRS|
2598 	    ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_SYNCHRONIZE))
2599 		needed_bits |= S_IRUSR;
2600 	if (working_mode & (ACE_WRITE_DATA|ACE_WRITE_NAMED_ATTRS|
2601 	    ACE_APPEND_DATA|ACE_WRITE_ATTRIBUTES|ACE_SYNCHRONIZE))
2602 		needed_bits |= S_IWUSR;
2603 	if (working_mode & ACE_EXECUTE)
2604 		needed_bits |= S_IXUSR;
2605 
2606 	if ((error = zfs_zaccess_common(check_zp, mode, &working_mode,
2607 	    &check_privs, skipaclchk, cr)) == 0) {
2608 		if (is_attr)
2609 			zrele(xzp);
2610 		return (secpolicy_vnode_access2(cr, ZTOI(zp), owner,
2611 		    needed_bits, needed_bits));
2612 	}
2613 
2614 	if (error && !check_privs) {
2615 		if (is_attr)
2616 			zrele(xzp);
2617 		return (error);
2618 	}
2619 
2620 	if (error && (flags & V_APPEND)) {
2621 		error = zfs_zaccess_append(zp, &working_mode, &check_privs, cr);
2622 	}
2623 
2624 	if (error && check_privs) {
2625 		mode_t		checkmode = 0;
2626 
2627 		/*
2628 		 * First check for implicit owner permission on
2629 		 * read_acl/read_attributes
2630 		 */
2631 
2632 		error = 0;
2633 		ASSERT(working_mode != 0);
2634 
2635 		if ((working_mode & (ACE_READ_ACL|ACE_READ_ATTRIBUTES) &&
2636 		    owner == crgetuid(cr)))
2637 			working_mode &= ~(ACE_READ_ACL|ACE_READ_ATTRIBUTES);
2638 
2639 		if (working_mode & (ACE_READ_DATA|ACE_READ_NAMED_ATTRS|
2640 		    ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_SYNCHRONIZE))
2641 			checkmode |= S_IRUSR;
2642 		if (working_mode & (ACE_WRITE_DATA|ACE_WRITE_NAMED_ATTRS|
2643 		    ACE_APPEND_DATA|ACE_WRITE_ATTRIBUTES|ACE_SYNCHRONIZE))
2644 			checkmode |= S_IWUSR;
2645 		if (working_mode & ACE_EXECUTE)
2646 			checkmode |= S_IXUSR;
2647 
2648 		error = secpolicy_vnode_access2(cr, ZTOI(check_zp), owner,
2649 		    needed_bits & ~checkmode, needed_bits);
2650 
2651 		if (error == 0 && (working_mode & ACE_WRITE_OWNER))
2652 			error = secpolicy_vnode_chown(cr, owner);
2653 		if (error == 0 && (working_mode & ACE_WRITE_ACL))
2654 			error = secpolicy_vnode_setdac(cr, owner);
2655 
2656 		if (error == 0 && (working_mode &
2657 		    (ACE_DELETE|ACE_DELETE_CHILD)))
2658 			error = secpolicy_vnode_remove(cr);
2659 
2660 		if (error == 0 && (working_mode & ACE_SYNCHRONIZE)) {
2661 			error = secpolicy_vnode_chown(cr, owner);
2662 		}
2663 		if (error == 0) {
2664 			/*
2665 			 * See if any bits other than those already checked
2666 			 * for are still present.  If so then return EACCES
2667 			 */
2668 			if (working_mode & ~(ZFS_CHECKED_MASKS)) {
2669 				error = SET_ERROR(EACCES);
2670 			}
2671 		}
2672 	} else if (error == 0) {
2673 		error = secpolicy_vnode_access2(cr, ZTOI(zp), owner,
2674 		    needed_bits, needed_bits);
2675 	}
2676 
2677 	if (is_attr)
2678 		zrele(xzp);
2679 
2680 	return (error);
2681 }
2682 
2683 /*
2684  * Translate traditional unix S_IRUSR/S_IWUSR/S_IXUSR mode into
2685  * NFSv4-style ZFS ACL format and call zfs_zaccess()
2686  */
2687 int
2688 zfs_zaccess_rwx(znode_t *zp, mode_t mode, int flags, cred_t *cr)
2689 {
2690 	return (zfs_zaccess(zp, zfs_unix_to_v4(mode >> 6), flags, B_FALSE, cr));
2691 }
2692 
2693 /*
2694  * Access function for secpolicy_vnode_setattr
2695  */
2696 int
2697 zfs_zaccess_unix(znode_t *zp, mode_t mode, cred_t *cr)
2698 {
2699 	int v4_mode = zfs_unix_to_v4(mode >> 6);
2700 
2701 	return (zfs_zaccess(zp, v4_mode, 0, B_FALSE, cr));
2702 }
2703 
2704 /* See zfs_zaccess_delete() */
2705 static const boolean_t zfs_write_implies_delete_child = B_TRUE;
2706 
2707 /*
2708  * Determine whether delete access should be granted.
2709  *
2710  * The following chart outlines how we handle delete permissions which is
2711  * how recent versions of windows (Windows 2008) handles it.  The efficiency
2712  * comes from not having to check the parent ACL where the object itself grants
2713  * delete:
2714  *
2715  *      -------------------------------------------------------
2716  *      |   Parent Dir  |      Target Object Permissions      |
2717  *      |  permissions  |                                     |
2718  *      -------------------------------------------------------
2719  *      |               | ACL Allows | ACL Denies| Delete     |
2720  *      |               |  Delete    |  Delete   | unspecified|
2721  *      -------------------------------------------------------
2722  *      | ACL Allows    | Permit     | Deny *    | Permit     |
2723  *      | DELETE_CHILD  |            |           |            |
2724  *      -------------------------------------------------------
2725  *      | ACL Denies    | Permit     | Deny      | Deny       |
2726  *      | DELETE_CHILD  |            |           |            |
2727  *      -------------------------------------------------------
2728  *      | ACL specifies |            |           |            |
2729  *      | only allow    | Permit     | Deny *    | Permit     |
2730  *      | write and     |            |           |            |
2731  *      | execute       |            |           |            |
2732  *      -------------------------------------------------------
2733  *      | ACL denies    |            |           |            |
2734  *      | write and     | Permit     | Deny      | Deny       |
2735  *      | execute       |            |           |            |
2736  *      -------------------------------------------------------
2737  *         ^
2738  *         |
2739  *         Re. execute permission on the directory:  if that's missing,
2740  *	   the vnode lookup of the target will fail before we get here.
2741  *
2742  * Re [*] in the table above:  NFSv4 would normally Permit delete for
2743  * these two cells of the matrix.
2744  * See acl.h for notes on which ACE_... flags should be checked for which
2745  * operations.  Specifically, the NFSv4 committee recommendation is in
2746  * conflict with the Windows interpretation of DENY ACEs, where DENY ACEs
2747  * should take precedence ahead of ALLOW ACEs.
2748  *
2749  * This implementation always consults the target object's ACL first.
2750  * If a DENY ACE is present on the target object that specifies ACE_DELETE,
2751  * delete access is denied.  If an ALLOW ACE with ACE_DELETE is present on
2752  * the target object, access is allowed.  If and only if no entries with
2753  * ACE_DELETE are present in the object's ACL, check the container's ACL
2754  * for entries with ACE_DELETE_CHILD.
2755  *
2756  * A summary of the logic implemented from the table above is as follows:
2757  *
2758  * First check for DENY ACEs that apply.
2759  * If either target or container has a deny, EACCES.
2760  *
2761  * Delete access can then be summarized as follows:
2762  * 1: The object to be deleted grants ACE_DELETE, or
2763  * 2: The containing directory grants ACE_DELETE_CHILD.
2764  * In a Windows system, that would be the end of the story.
2765  * In this system, (2) has some complications...
2766  * 2a: "sticky" bit on a directory adds restrictions, and
2767  * 2b: existing ACEs from previous versions of ZFS may
2768  * not carry ACE_DELETE_CHILD where they should, so we
2769  * also allow delete when ACE_WRITE_DATA is granted.
2770  *
2771  * Note: 2b is technically a work-around for a prior bug,
2772  * which hopefully can go away some day.  For those who
2773  * no longer need the work around, and for testing, this
2774  * work-around is made conditional via the tunable:
2775  * zfs_write_implies_delete_child
2776  */
2777 int
2778 zfs_zaccess_delete(znode_t *dzp, znode_t *zp, cred_t *cr)
2779 {
2780 	uint32_t wanted_dirperms;
2781 	uint32_t dzp_working_mode = 0;
2782 	uint32_t zp_working_mode = 0;
2783 	int dzp_error, zp_error;
2784 	boolean_t dzpcheck_privs;
2785 	boolean_t zpcheck_privs;
2786 
2787 	if (zp->z_pflags & (ZFS_IMMUTABLE | ZFS_NOUNLINK))
2788 		return (SET_ERROR(EPERM));
2789 
2790 	/*
2791 	 * Case 1:
2792 	 * If target object grants ACE_DELETE then we are done.  This is
2793 	 * indicated by a return value of 0.  For this case we don't worry
2794 	 * about the sticky bit because sticky only applies to the parent
2795 	 * directory and this is the child access result.
2796 	 *
2797 	 * If we encounter a DENY ACE here, we're also done (EACCES).
2798 	 * Note that if we hit a DENY ACE here (on the target) it should
2799 	 * take precedence over a DENY ACE on the container, so that when
2800 	 * we have more complete auditing support we will be able to
2801 	 * report an access failure against the specific target.
2802 	 * (This is part of why we're checking the target first.)
2803 	 */
2804 	zp_error = zfs_zaccess_common(zp, ACE_DELETE, &zp_working_mode,
2805 	    &zpcheck_privs, B_FALSE, cr);
2806 	if (zp_error == EACCES) {
2807 		/* We hit a DENY ACE. */
2808 		if (!zpcheck_privs)
2809 			return (SET_ERROR(zp_error));
2810 		return (secpolicy_vnode_remove(cr));
2811 
2812 	}
2813 	if (zp_error == 0)
2814 		return (0);
2815 
2816 	/*
2817 	 * Case 2:
2818 	 * If the containing directory grants ACE_DELETE_CHILD,
2819 	 * or we're in backward compatibility mode and the
2820 	 * containing directory has ACE_WRITE_DATA, allow.
2821 	 * Case 2b is handled with wanted_dirperms.
2822 	 */
2823 	wanted_dirperms = ACE_DELETE_CHILD;
2824 	if (zfs_write_implies_delete_child)
2825 		wanted_dirperms |= ACE_WRITE_DATA;
2826 	dzp_error = zfs_zaccess_common(dzp, wanted_dirperms,
2827 	    &dzp_working_mode, &dzpcheck_privs, B_FALSE, cr);
2828 	if (dzp_error == EACCES) {
2829 		/* We hit a DENY ACE. */
2830 		if (!dzpcheck_privs)
2831 			return (SET_ERROR(dzp_error));
2832 		return (secpolicy_vnode_remove(cr));
2833 	}
2834 
2835 	/*
2836 	 * Cases 2a, 2b (continued)
2837 	 *
2838 	 * Note: dzp_working_mode now contains any permissions
2839 	 * that were NOT granted.  Therefore, if any of the
2840 	 * wanted_dirperms WERE granted, we will have:
2841 	 *   dzp_working_mode != wanted_dirperms
2842 	 * We're really asking if ANY of those permissions
2843 	 * were granted, and if so, grant delete access.
2844 	 */
2845 	if (dzp_working_mode != wanted_dirperms)
2846 		dzp_error = 0;
2847 
2848 	/*
2849 	 * dzp_error is 0 if the container granted us permissions to "modify".
2850 	 * If we do not have permission via one or more ACEs, our current
2851 	 * privileges may still permit us to modify the container.
2852 	 *
2853 	 * dzpcheck_privs is false when i.e. the FS is read-only.
2854 	 * Otherwise, do privilege checks for the container.
2855 	 */
2856 	if (dzp_error != 0 && dzpcheck_privs) {
2857 		uid_t owner;
2858 
2859 		/*
2860 		 * The secpolicy call needs the requested access and
2861 		 * the current access mode of the container, but it
2862 		 * only knows about Unix-style modes (VEXEC, VWRITE),
2863 		 * so this must condense the fine-grained ACE bits into
2864 		 * Unix modes.
2865 		 *
2866 		 * The VEXEC flag is easy, because we know that has
2867 		 * always been checked before we get here (during the
2868 		 * lookup of the target vnode).  The container has not
2869 		 * granted us permissions to "modify", so we do not set
2870 		 * the VWRITE flag in the current access mode.
2871 		 */
2872 		owner = zfs_fuid_map_id(ZTOZSB(dzp),
2873 		    KUID_TO_SUID(ZTOI(dzp)->i_uid), cr, ZFS_OWNER);
2874 		dzp_error = secpolicy_vnode_access2(cr, ZTOI(dzp),
2875 		    owner, S_IXUSR, S_IWUSR|S_IXUSR);
2876 	}
2877 	if (dzp_error != 0) {
2878 		/*
2879 		 * Note: We may have dzp_error = -1 here (from
2880 		 * zfs_zacess_common).  Don't return that.
2881 		 */
2882 		return (SET_ERROR(EACCES));
2883 	}
2884 
2885 
2886 	/*
2887 	 * At this point, we know that the directory permissions allow
2888 	 * us to modify, but we still need to check for the additional
2889 	 * restrictions that apply when the "sticky bit" is set.
2890 	 *
2891 	 * Yes, zfs_sticky_remove_access() also checks this bit, but
2892 	 * checking it here and skipping the call below is nice when
2893 	 * you're watching all of this with dtrace.
2894 	 */
2895 	if ((dzp->z_mode & S_ISVTX) == 0)
2896 		return (0);
2897 
2898 	/*
2899 	 * zfs_sticky_remove_access will succeed if:
2900 	 * 1. The sticky bit is absent.
2901 	 * 2. We pass the sticky bit restrictions.
2902 	 * 3. We have privileges that always allow file removal.
2903 	 */
2904 	return (zfs_sticky_remove_access(dzp, zp, cr));
2905 }
2906 
2907 int
2908 zfs_zaccess_rename(znode_t *sdzp, znode_t *szp, znode_t *tdzp,
2909     znode_t *tzp, cred_t *cr)
2910 {
2911 	int add_perm;
2912 	int error;
2913 
2914 	if (szp->z_pflags & ZFS_AV_QUARANTINED)
2915 		return (SET_ERROR(EACCES));
2916 
2917 	add_perm = S_ISDIR(ZTOI(szp)->i_mode) ?
2918 	    ACE_ADD_SUBDIRECTORY : ACE_ADD_FILE;
2919 
2920 	/*
2921 	 * Rename permissions are combination of delete permission +
2922 	 * add file/subdir permission.
2923 	 */
2924 
2925 	/*
2926 	 * first make sure we do the delete portion.
2927 	 *
2928 	 * If that succeeds then check for add_file/add_subdir permissions
2929 	 */
2930 
2931 	if ((error = zfs_zaccess_delete(sdzp, szp, cr)))
2932 		return (error);
2933 
2934 	/*
2935 	 * If we have a tzp, see if we can delete it?
2936 	 */
2937 	if (tzp) {
2938 		if ((error = zfs_zaccess_delete(tdzp, tzp, cr)))
2939 			return (error);
2940 	}
2941 
2942 	/*
2943 	 * Now check for add permissions
2944 	 */
2945 	error = zfs_zaccess(tdzp, add_perm, 0, B_FALSE, cr);
2946 
2947 	return (error);
2948 }
2949