2 * Copyright (c) 2017, Fedor Uporov
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/types.h>
33 #include <sys/kernel.h>
34 #include <sys/malloc.h>
35 #include <sys/vnode.h>
38 #include <sys/endian.h>
40 #include <sys/mount.h>
41 #include <sys/extattr.h>
43 #include <fs/ext2fs/fs.h>
44 #include <fs/ext2fs/ext2fs.h>
45 #include <fs/ext2fs/inode.h>
46 #include <fs/ext2fs/ext2_acl.h>
47 #include <fs/ext2fs/ext2_extattr.h>
48 #include <fs/ext2fs/ext2_extern.h>
49 #include <fs/ext2fs/ext2_dinode.h>
50 #include <fs/ext2fs/ext2_mount.h>
55 ext2_sync_acl_from_inode(struct inode *ip, struct acl *acl)
57 struct acl_entry *acl_mask, *acl_group_obj;
61 * Update ACL_USER_OBJ, ACL_OTHER, but simply identify ACL_MASK
62 * and ACL_GROUP_OBJ for use after we know whether ACL_MASK is
67 for (i = 0; i < acl->acl_cnt; i++) {
68 switch (acl->acl_entry[i].ae_tag) {
70 acl->acl_entry[i].ae_perm = acl_posix1e_mode_to_perm(
71 ACL_USER_OBJ, ip->i_mode);
72 acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID;
76 acl_group_obj = &acl->acl_entry[i];
77 acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID;
81 acl->acl_entry[i].ae_perm = acl_posix1e_mode_to_perm(
82 ACL_OTHER, ip->i_mode);
83 acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID;
87 acl_mask = &acl->acl_entry[i];
88 acl->acl_entry[i].ae_id = ACL_UNDEFINED_ID;
96 panic("ext2_sync_acl_from_inode(): bad ae_tag");
100 if (acl_group_obj == NULL)
101 panic("ext2_sync_acl_from_inode(): no ACL_GROUP_OBJ");
103 if (acl_mask == NULL) {
105 * There is no ACL_MASK, so update ACL_GROUP_OBJ.
107 acl_group_obj->ae_perm = acl_posix1e_mode_to_perm(
108 ACL_GROUP_OBJ, ip->i_mode);
111 * Update the ACL_MASK entry instead of ACL_GROUP_OBJ.
113 acl_mask->ae_perm = acl_posix1e_mode_to_perm(ACL_GROUP_OBJ,
119 ext2_sync_inode_from_acl(struct acl *acl, struct inode *ip)
122 ip->i_mode &= ACL_PRESERVE_MASK;
123 ip->i_mode |= acl_posix1e_acl_to_mode(acl);
127 * Convert from filesystem to in-memory representation.
130 ext4_acl_from_disk(char *value, size_t size, struct acl *acl)
140 if (((struct ext2_acl_header *)value)->a_version != EXT4_ACL_VERSION)
143 if (size < sizeof(struct ext2_acl_header))
146 s = size - sizeof(struct ext2_acl_header);
147 s -= 4 * sizeof(struct ext2_acl_entry_short);
149 if ((size - sizeof(struct ext2_acl_header)) %
150 sizeof(struct ext2_acl_entry_short))
153 count = (size - sizeof(struct ext2_acl_header)) /
154 sizeof(struct ext2_acl_entry_short);
156 if (s % sizeof(struct ext2_acl_entry))
159 count = s / sizeof(struct ext2_acl_entry) + 4;
161 if (count <= 0 || count > acl->acl_maxcnt)
164 value = value + sizeof(struct ext2_acl_header);
166 for (n = 0; n < count; n++) {
167 struct ext2_acl_entry *entry = (struct ext2_acl_entry *)value;
168 if ((char *)value + sizeof(struct ext2_acl_entry_short) > end)
171 acl->acl_entry[n].ae_tag = entry->ae_tag;
172 acl->acl_entry[n].ae_perm = entry->ae_perm;
174 switch (acl->acl_entry[n].ae_tag) {
179 value = (char *)value + sizeof(struct ext2_acl_entry_short);
183 value = (char *)value + sizeof(struct ext2_acl_entry);
184 if ((char *)value > end)
187 acl->acl_entry[n].ae_id = entry->ae_id;
191 value = (char *)value + sizeof(struct ext2_acl_entry);
192 if ((char *)value > end)
195 acl->acl_entry[n].ae_id = entry->ae_id;
206 acl->acl_cnt = count;
212 ext2_getacl_posix1e(struct vop_getacl_args *ap)
215 const char *attrname;
220 switch (ap->a_type) {
221 case ACL_TYPE_DEFAULT:
222 attrnamespace = POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE;
223 attrname = POSIX1E_ACL_DEFAULT_EXTATTR_NAME;
225 case ACL_TYPE_ACCESS:
226 attrnamespace = POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE;
227 attrname = POSIX1E_ACL_ACCESS_EXTATTR_NAME;
233 len = sizeof(*ap->a_aclp) + sizeof(struct ext2_acl_header);
234 value = malloc(len, M_ACL, M_WAITOK);
238 error = vn_extattr_get(ap->a_vp, IO_NODELOCKED, attrnamespace, attrname,
239 &len, value, ap->a_td);
240 if (error == ENOATTR) {
241 switch (ap->a_type) {
242 case ACL_TYPE_ACCESS:
243 ap->a_aclp->acl_cnt = 3;
244 ap->a_aclp->acl_entry[0].ae_tag = ACL_USER_OBJ;
245 ap->a_aclp->acl_entry[0].ae_id = ACL_UNDEFINED_ID;
246 ap->a_aclp->acl_entry[0].ae_perm = ACL_PERM_NONE;
247 ap->a_aclp->acl_entry[1].ae_tag = ACL_GROUP_OBJ;
248 ap->a_aclp->acl_entry[1].ae_id = ACL_UNDEFINED_ID;
249 ap->a_aclp->acl_entry[1].ae_perm = ACL_PERM_NONE;
250 ap->a_aclp->acl_entry[2].ae_tag = ACL_OTHER;
251 ap->a_aclp->acl_entry[2].ae_id = ACL_UNDEFINED_ID;
252 ap->a_aclp->acl_entry[2].ae_perm = ACL_PERM_NONE;
255 case ACL_TYPE_DEFAULT:
256 ap->a_aclp->acl_cnt = 0;
259 } else if (error != 0)
263 error = ext4_acl_from_disk(value, len, ap->a_aclp);
268 if (error == ENOATTR)
271 if (ap->a_type == ACL_TYPE_ACCESS)
272 ext2_sync_acl_from_inode(VTOI(ap->a_vp), ap->a_aclp);
280 ext2_getacl(struct vop_getacl_args *ap)
283 if (((ap->a_vp->v_mount->mnt_flag & MNT_ACLS) == 0) ||
284 ((ap->a_vp->v_mount->mnt_flag & MNT_NFS4ACLS) != 0))
287 if (ap->a_type == ACL_TYPE_NFS4)
290 return (ext2_getacl_posix1e(ap));
294 * Convert from in-memory to filesystem representation.
297 ext4_acl_to_disk(const struct acl *acl, size_t *size, char *value)
299 struct ext2_acl_header *ext_acl;
304 if (acl->acl_cnt <= 4)
305 disk_size = sizeof(struct ext2_acl_header) +
306 acl->acl_cnt * sizeof(struct ext2_acl_entry_short);
308 disk_size = sizeof(struct ext2_acl_header) +
309 4 * sizeof(struct ext2_acl_entry_short) +
310 (acl->acl_cnt - 4) * sizeof(struct ext2_acl_entry);
312 if (disk_size > *size)
316 ext_acl = (struct ext2_acl_header *)value;
318 ext_acl->a_version = EXT4_ACL_VERSION;
319 e = (char *)ext_acl + sizeof(struct ext2_acl_header);
320 for (n = 0; n < acl->acl_cnt; n++) {
321 const struct acl_entry *acl_e = &acl->acl_entry[n];
322 struct ext2_acl_entry *entry = (struct ext2_acl_entry *)e;
323 entry->ae_tag = acl_e->ae_tag;
324 entry->ae_perm = acl_e->ae_perm;
325 switch (acl_e->ae_tag) {
327 entry->ae_id = acl_e->ae_id;
328 e += sizeof(struct ext2_acl_entry);
332 entry->ae_id = acl_e->ae_id;
333 e += sizeof(struct ext2_acl_entry);
340 e += sizeof(struct ext2_acl_entry_short);
352 ext2_setacl_posix1e(struct vop_setacl_args *ap)
354 struct inode *ip = VTOI(ap->a_vp);
359 if ((ap->a_vp->v_mount->mnt_flag & MNT_ACLS) == 0)
363 * If this is a set operation rather than a delete operation,
364 * invoke VOP_ACLCHECK() on the passed ACL to determine if it is
365 * valid for the target. This will include a check on ap->a_type.
367 if (ap->a_aclp != NULL) {
371 error = VOP_ACLCHECK(ap->a_vp, ap->a_type, ap->a_aclp,
372 ap->a_cred, ap->a_td);
378 * POSIX.1e allows only deletion of the default ACL on a
379 * directory (ACL_TYPE_DEFAULT).
381 if (ap->a_type != ACL_TYPE_DEFAULT)
383 if (ap->a_vp->v_type != VDIR)
387 if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
391 * Authorize the ACL operation.
393 if (ip->i_flags & (IMMUTABLE | APPEND))
397 * Must hold VADMIN (be file owner) or have appropriate privilege.
399 if ((error = VOP_ACCESS(ap->a_vp, VADMIN, ap->a_cred, ap->a_td)))
402 switch (ap->a_type) {
403 case ACL_TYPE_ACCESS:
404 len = sizeof(*ap->a_aclp) + sizeof(struct ext2_acl_header);
405 value = malloc(len, M_ACL, M_WAITOK | M_ZERO);
406 error = ext4_acl_to_disk(ap->a_aclp, &len, value);
408 error = vn_extattr_set(ap->a_vp, IO_NODELOCKED,
409 POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE,
410 POSIX1E_ACL_ACCESS_EXTATTR_NAME, len,
416 case ACL_TYPE_DEFAULT:
417 if (ap->a_aclp == NULL) {
418 error = vn_extattr_rm(ap->a_vp, IO_NODELOCKED,
419 POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE,
420 POSIX1E_ACL_DEFAULT_EXTATTR_NAME, ap->a_td);
423 * Attempting to delete a non-present default ACL
424 * will return success for portability purposes.
427 * XXX: Note that since we can't distinguish
428 * "that EA is not supported" from "that EA is not
429 * defined", the success case here overlaps the
430 * the ENOATTR->EOPNOTSUPP case below.
432 if (error == ENOATTR)
435 len = sizeof(*ap->a_aclp) + sizeof(struct ext2_acl_header);
436 value = malloc(len, M_ACL, M_WAITOK | M_ZERO);
437 error = ext4_acl_to_disk(ap->a_aclp, &len, value);
439 error = vn_extattr_set(ap->a_vp, IO_NODELOCKED,
440 POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE,
441 POSIX1E_ACL_DEFAULT_EXTATTR_NAME, len,
453 * Map lack of attribute definition in UFS_EXTATTR into lack of
454 * support for ACLs on the filesystem.
456 if (error == ENOATTR)
462 if (ap->a_type == ACL_TYPE_ACCESS) {
464 * Now that the EA is successfully updated, update the
465 * inode and mark it as changed.
467 ext2_sync_inode_from_acl(ap->a_aclp, ip);
468 ip->i_flag |= IN_CHANGE;
469 error = ext2_update(ip->i_vnode, 1);
472 VN_KNOTE_UNLOCKED(ap->a_vp, NOTE_ATTRIB);
478 ext2_setacl(struct vop_setacl_args *ap)
480 if (((ap->a_vp->v_mount->mnt_flag & MNT_ACLS) == 0) ||
481 ((ap->a_vp->v_mount->mnt_flag & MNT_NFS4ACLS) != 0))
484 if (ap->a_type == ACL_TYPE_NFS4)
487 return (ext2_setacl_posix1e(ap));
491 * Check the validity of an ACL for a file.
494 ext2_aclcheck(struct vop_aclcheck_args *ap)
497 if (((ap->a_vp->v_mount->mnt_flag & MNT_ACLS) == 0) ||
498 ((ap->a_vp->v_mount->mnt_flag & MNT_NFS4ACLS) != 0))
501 if (ap->a_type == ACL_TYPE_NFS4)
504 if ((ap->a_vp->v_mount->mnt_flag & MNT_ACLS) == 0)
508 * Verify we understand this type of ACL, and that it applies
509 * to this kind of object.
510 * Rely on the acl_posix1e_check() routine to verify the contents.
512 switch (ap->a_type) {
513 case ACL_TYPE_ACCESS:
516 case ACL_TYPE_DEFAULT:
517 if (ap->a_vp->v_type != VDIR)
525 return (acl_posix1e_check(ap->a_aclp));