1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2002,2003 by Andreas Gruenbacher <a.gruenbacher@computer.org>
5 * Fixes from William Schumacher incorporated on 15 March 2001.
6 * (Reported by Charles Bertsch, <CBertsch@microtest.com>).
10 * This file contains generic functions for manipulating
11 * POSIX 1003.1e draft standard 17 ACLs.
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/atomic.h>
18 #include <linux/sched.h>
19 #include <linux/cred.h>
20 #include <linux/posix_acl.h>
21 #include <linux/posix_acl_xattr.h>
22 #include <linux/xattr.h>
23 #include <linux/export.h>
24 #include <linux/user_namespace.h>
25 #include <linux/namei.h>
26 #include <linux/mnt_idmapping.h>
27 #include <linux/iversion.h>
28 #include <linux/security.h>
29 #include <linux/evm.h>
30 #include <linux/fsnotify.h>
34 static struct posix_acl
**acl_by_type(struct inode
*inode
, int type
)
39 case ACL_TYPE_DEFAULT
:
40 return &inode
->i_default_acl
;
46 struct posix_acl
*get_cached_acl(struct inode
*inode
, int type
)
48 struct posix_acl
**p
= acl_by_type(inode
, type
);
49 struct posix_acl
*acl
;
53 acl
= rcu_dereference(*p
);
54 if (!acl
|| is_uncached_acl(acl
) ||
55 refcount_inc_not_zero(&acl
->a_refcount
))
63 EXPORT_SYMBOL(get_cached_acl
);
65 struct posix_acl
*get_cached_acl_rcu(struct inode
*inode
, int type
)
67 struct posix_acl
*acl
= rcu_dereference(*acl_by_type(inode
, type
));
69 if (acl
== ACL_DONT_CACHE
) {
70 struct posix_acl
*ret
;
72 ret
= inode
->i_op
->get_inode_acl(inode
, type
, LOOKUP_RCU
);
79 EXPORT_SYMBOL(get_cached_acl_rcu
);
81 void set_cached_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
83 struct posix_acl
**p
= acl_by_type(inode
, type
);
84 struct posix_acl
*old
;
86 old
= xchg(p
, posix_acl_dup(acl
));
87 if (!is_uncached_acl(old
))
88 posix_acl_release(old
);
90 EXPORT_SYMBOL(set_cached_acl
);
92 static void __forget_cached_acl(struct posix_acl
**p
)
94 struct posix_acl
*old
;
96 old
= xchg(p
, ACL_NOT_CACHED
);
97 if (!is_uncached_acl(old
))
98 posix_acl_release(old
);
101 void forget_cached_acl(struct inode
*inode
, int type
)
103 __forget_cached_acl(acl_by_type(inode
, type
));
105 EXPORT_SYMBOL(forget_cached_acl
);
107 void forget_all_cached_acls(struct inode
*inode
)
109 __forget_cached_acl(&inode
->i_acl
);
110 __forget_cached_acl(&inode
->i_default_acl
);
112 EXPORT_SYMBOL(forget_all_cached_acls
);
114 static struct posix_acl
*__get_acl(struct mnt_idmap
*idmap
,
115 struct dentry
*dentry
, struct inode
*inode
,
118 struct posix_acl
*sentinel
;
119 struct posix_acl
**p
;
120 struct posix_acl
*acl
;
123 * The sentinel is used to detect when another operation like
124 * set_cached_acl() or forget_cached_acl() races with get_inode_acl().
125 * It is guaranteed that is_uncached_acl(sentinel) is true.
128 acl
= get_cached_acl(inode
, type
);
129 if (!is_uncached_acl(acl
))
132 if (!IS_POSIXACL(inode
))
135 sentinel
= uncached_acl_sentinel(current
);
136 p
= acl_by_type(inode
, type
);
139 * If the ACL isn't being read yet, set our sentinel. Otherwise, the
140 * current value of the ACL will not be ACL_NOT_CACHED and so our own
141 * sentinel will not be set; another task will update the cache. We
142 * could wait for that other task to complete its job, but it's easier
143 * to just call ->get_inode_acl to fetch the ACL ourself. (This is
144 * going to be an unlikely race.)
146 cmpxchg(p
, ACL_NOT_CACHED
, sentinel
);
149 * Normally, the ACL returned by ->get{_inode}_acl will be cached.
150 * A filesystem can prevent that by calling
151 * forget_cached_acl(inode, type) in ->get{_inode}_acl.
153 * If the filesystem doesn't have a get{_inode}_ acl() function at all,
154 * we'll just create the negative cache entry.
156 if (dentry
&& inode
->i_op
->get_acl
) {
157 acl
= inode
->i_op
->get_acl(idmap
, dentry
, type
);
158 } else if (inode
->i_op
->get_inode_acl
) {
159 acl
= inode
->i_op
->get_inode_acl(inode
, type
, false);
161 set_cached_acl(inode
, type
, NULL
);
166 * Remove our sentinel so that we don't block future attempts
169 cmpxchg(p
, sentinel
, ACL_NOT_CACHED
);
174 * Cache the result, but only if our sentinel is still in place.
177 if (unlikely(cmpxchg(p
, sentinel
, acl
) != sentinel
))
178 posix_acl_release(acl
);
182 struct posix_acl
*get_inode_acl(struct inode
*inode
, int type
)
184 return __get_acl(&nop_mnt_idmap
, NULL
, inode
, type
);
186 EXPORT_SYMBOL(get_inode_acl
);
189 * Init a fresh posix_acl
192 posix_acl_init(struct posix_acl
*acl
, int count
)
194 refcount_set(&acl
->a_refcount
, 1);
195 acl
->a_count
= count
;
197 EXPORT_SYMBOL(posix_acl_init
);
200 * Allocate a new ACL with the specified number of entries.
203 posix_acl_alloc(int count
, gfp_t flags
)
205 const size_t size
= sizeof(struct posix_acl
) +
206 count
* sizeof(struct posix_acl_entry
);
207 struct posix_acl
*acl
= kmalloc(size
, flags
);
209 posix_acl_init(acl
, count
);
212 EXPORT_SYMBOL(posix_acl_alloc
);
218 posix_acl_clone(const struct posix_acl
*acl
, gfp_t flags
)
220 struct posix_acl
*clone
= NULL
;
223 int size
= sizeof(struct posix_acl
) + acl
->a_count
*
224 sizeof(struct posix_acl_entry
);
225 clone
= kmemdup(acl
, size
, flags
);
227 refcount_set(&clone
->a_refcount
, 1);
231 EXPORT_SYMBOL_GPL(posix_acl_clone
);
234 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
237 posix_acl_valid(struct user_namespace
*user_ns
, const struct posix_acl
*acl
)
239 const struct posix_acl_entry
*pa
, *pe
;
240 int state
= ACL_USER_OBJ
;
243 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
244 if (pa
->e_perm
& ~(ACL_READ
|ACL_WRITE
|ACL_EXECUTE
))
248 if (state
== ACL_USER_OBJ
) {
255 if (state
!= ACL_USER
)
257 if (!kuid_has_mapping(user_ns
, pa
->e_uid
))
263 if (state
== ACL_USER
) {
270 if (state
!= ACL_GROUP
)
272 if (!kgid_has_mapping(user_ns
, pa
->e_gid
))
278 if (state
!= ACL_GROUP
)
284 if (state
== ACL_OTHER
||
285 (state
== ACL_GROUP
&& !needs_mask
)) {
299 EXPORT_SYMBOL(posix_acl_valid
);
302 * Returns 0 if the acl can be exactly represented in the traditional
303 * file mode permission bits, or else 1. Returns -E... on error.
306 posix_acl_equiv_mode(const struct posix_acl
*acl
, umode_t
*mode_p
)
308 const struct posix_acl_entry
*pa
, *pe
;
313 * A null ACL can always be presented as mode bits.
318 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
321 mode
|= (pa
->e_perm
& S_IRWXO
) << 6;
324 mode
|= (pa
->e_perm
& S_IRWXO
) << 3;
327 mode
|= pa
->e_perm
& S_IRWXO
;
330 mode
= (mode
& ~S_IRWXG
) |
331 ((pa
->e_perm
& S_IRWXO
) << 3);
343 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
346 EXPORT_SYMBOL(posix_acl_equiv_mode
);
349 * Create an ACL representing the file mode permission bits of an inode.
352 posix_acl_from_mode(umode_t mode
, gfp_t flags
)
354 struct posix_acl
*acl
= posix_acl_alloc(3, flags
);
356 return ERR_PTR(-ENOMEM
);
358 acl
->a_entries
[0].e_tag
= ACL_USER_OBJ
;
359 acl
->a_entries
[0].e_perm
= (mode
& S_IRWXU
) >> 6;
361 acl
->a_entries
[1].e_tag
= ACL_GROUP_OBJ
;
362 acl
->a_entries
[1].e_perm
= (mode
& S_IRWXG
) >> 3;
364 acl
->a_entries
[2].e_tag
= ACL_OTHER
;
365 acl
->a_entries
[2].e_perm
= (mode
& S_IRWXO
);
368 EXPORT_SYMBOL(posix_acl_from_mode
);
371 * Return 0 if current is granted want access to the inode
372 * by the acl. Returns -E... otherwise.
375 posix_acl_permission(struct user_namespace
*mnt_userns
, struct inode
*inode
,
376 const struct posix_acl
*acl
, int want
)
378 const struct posix_acl_entry
*pa
, *pe
, *mask_obj
;
379 struct user_namespace
*fs_userns
= i_user_ns(inode
);
384 want
&= MAY_READ
| MAY_WRITE
| MAY_EXEC
;
386 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
389 /* (May have been checked already) */
390 vfsuid
= i_uid_into_vfsuid(mnt_userns
, inode
);
391 if (vfsuid_eq_kuid(vfsuid
, current_fsuid()))
395 vfsuid
= make_vfsuid(mnt_userns
, fs_userns
,
397 if (vfsuid_eq_kuid(vfsuid
, current_fsuid()))
401 vfsgid
= i_gid_into_vfsgid(mnt_userns
, inode
);
402 if (vfsgid_in_group_p(vfsgid
)) {
404 if ((pa
->e_perm
& want
) == want
)
409 vfsgid
= make_vfsgid(mnt_userns
, fs_userns
,
411 if (vfsgid_in_group_p(vfsgid
)) {
413 if ((pa
->e_perm
& want
) == want
)
431 for (mask_obj
= pa
+1; mask_obj
!= pe
; mask_obj
++) {
432 if (mask_obj
->e_tag
== ACL_MASK
) {
433 if ((pa
->e_perm
& mask_obj
->e_perm
& want
) == want
)
440 if ((pa
->e_perm
& want
) == want
)
446 * Modify acl when creating a new inode. The caller must ensure the acl is
447 * only referenced once.
449 * mode_p initially must contain the mode parameter to the open() / creat()
450 * system calls. All permissions that are not granted by the acl are removed.
451 * The permissions in the acl are changed to reflect the mode_p parameter.
453 static int posix_acl_create_masq(struct posix_acl
*acl
, umode_t
*mode_p
)
455 struct posix_acl_entry
*pa
, *pe
;
456 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
457 umode_t mode
= *mode_p
;
460 /* assert(atomic_read(acl->a_refcount) == 1); */
462 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
465 pa
->e_perm
&= (mode
>> 6) | ~S_IRWXO
;
466 mode
&= (pa
->e_perm
<< 6) | ~S_IRWXU
;
479 pa
->e_perm
&= mode
| ~S_IRWXO
;
480 mode
&= pa
->e_perm
| ~S_IRWXO
;
494 mask_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
495 mode
&= (mask_obj
->e_perm
<< 3) | ~S_IRWXG
;
499 group_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
500 mode
&= (group_obj
->e_perm
<< 3) | ~S_IRWXG
;
503 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
508 * Modify the ACL for the chmod syscall.
510 static int __posix_acl_chmod_masq(struct posix_acl
*acl
, umode_t mode
)
512 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
513 struct posix_acl_entry
*pa
, *pe
;
515 /* assert(atomic_read(acl->a_refcount) == 1); */
517 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
520 pa
->e_perm
= (mode
& S_IRWXU
) >> 6;
536 pa
->e_perm
= (mode
& S_IRWXO
);
545 mask_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
549 group_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
556 __posix_acl_create(struct posix_acl
**acl
, gfp_t gfp
, umode_t
*mode_p
)
558 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
561 err
= posix_acl_create_masq(clone
, mode_p
);
563 posix_acl_release(clone
);
567 posix_acl_release(*acl
);
571 EXPORT_SYMBOL(__posix_acl_create
);
574 __posix_acl_chmod(struct posix_acl
**acl
, gfp_t gfp
, umode_t mode
)
576 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
579 err
= __posix_acl_chmod_masq(clone
, mode
);
581 posix_acl_release(clone
);
585 posix_acl_release(*acl
);
589 EXPORT_SYMBOL(__posix_acl_chmod
);
592 * posix_acl_chmod - chmod a posix acl
594 * @mnt_userns: user namespace of the mount @inode was found from
595 * @dentry: dentry to check permissions on
596 * @mode: the new mode of @inode
598 * If the dentry has been found through an idmapped mount the user namespace of
599 * the vfsmount must be passed through @mnt_userns. This function will then
600 * take care to map the inode according to @mnt_userns before checking
601 * permissions. On non-idmapped mounts or if permission checking is to be
602 * performed on the raw inode simply passs init_user_ns.
605 posix_acl_chmod(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
608 struct inode
*inode
= d_inode(dentry
);
609 struct posix_acl
*acl
;
612 if (!IS_POSIXACL(inode
))
614 if (!inode
->i_op
->set_acl
)
617 acl
= get_inode_acl(inode
, ACL_TYPE_ACCESS
);
618 if (IS_ERR_OR_NULL(acl
)) {
619 if (acl
== ERR_PTR(-EOPNOTSUPP
))
624 ret
= __posix_acl_chmod(&acl
, GFP_KERNEL
, mode
);
627 ret
= inode
->i_op
->set_acl(mnt_userns
, dentry
, acl
, ACL_TYPE_ACCESS
);
628 posix_acl_release(acl
);
631 EXPORT_SYMBOL(posix_acl_chmod
);
634 posix_acl_create(struct inode
*dir
, umode_t
*mode
,
635 struct posix_acl
**default_acl
, struct posix_acl
**acl
)
638 struct posix_acl
*clone
;
644 if (S_ISLNK(*mode
) || !IS_POSIXACL(dir
))
647 p
= get_inode_acl(dir
, ACL_TYPE_DEFAULT
);
648 if (!p
|| p
== ERR_PTR(-EOPNOTSUPP
)) {
649 *mode
&= ~current_umask();
656 clone
= posix_acl_clone(p
, GFP_NOFS
);
660 ret
= posix_acl_create_masq(clone
, mode
);
662 goto err_release_clone
;
665 posix_acl_release(clone
);
670 posix_acl_release(p
);
677 posix_acl_release(clone
);
679 posix_acl_release(p
);
682 EXPORT_SYMBOL_GPL(posix_acl_create
);
685 * posix_acl_update_mode - update mode in set_acl
686 * @mnt_userns: user namespace of the mount @inode was found from
687 * @inode: target inode
688 * @mode_p: mode (pointer) for update
691 * Update the file mode when setting an ACL: compute the new file permission
692 * bits based on the ACL. In addition, if the ACL is equivalent to the new
693 * file mode, set *@acl to NULL to indicate that no ACL should be set.
695 * As with chmod, clear the setgid bit if the caller is not in the owning group
696 * or capable of CAP_FSETID (see inode_change_ok).
698 * If the inode has been found through an idmapped mount the user namespace of
699 * the vfsmount must be passed through @mnt_userns. This function will then
700 * take care to map the inode according to @mnt_userns before checking
701 * permissions. On non-idmapped mounts or if permission checking is to be
702 * performed on the raw inode simply passs init_user_ns.
704 * Called from set_acl inode operations.
706 int posix_acl_update_mode(struct user_namespace
*mnt_userns
,
707 struct inode
*inode
, umode_t
*mode_p
,
708 struct posix_acl
**acl
)
710 umode_t mode
= inode
->i_mode
;
713 error
= posix_acl_equiv_mode(*acl
, &mode
);
718 if (!vfsgid_in_group_p(i_gid_into_vfsgid(mnt_userns
, inode
)) &&
719 !capable_wrt_inode_uidgid(mnt_userns
, inode
, CAP_FSETID
))
724 EXPORT_SYMBOL(posix_acl_update_mode
);
727 * Fix up the uids and gids in posix acl extended attributes in place.
729 static int posix_acl_fix_xattr_common(const void *value
, size_t size
)
731 const struct posix_acl_xattr_header
*header
= value
;
736 if (size
< sizeof(struct posix_acl_xattr_header
))
738 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
741 count
= posix_acl_xattr_count(size
);
751 * posix_acl_from_xattr - convert POSIX ACLs from backing store to VFS format
752 * @userns: the filesystem's idmapping
753 * @value: the uapi representation of POSIX ACLs
754 * @size: the size of @void
756 * Filesystems that store POSIX ACLs in the unaltered uapi format should use
757 * posix_acl_from_xattr() when reading them from the backing store and
758 * converting them into the struct posix_acl VFS format. The helper is
759 * specifically intended to be called from the acl inode operation.
761 * The posix_acl_from_xattr() function will map the raw {g,u}id values stored
762 * in ACL_{GROUP,USER} entries into idmapping in @userns.
764 * Note that posix_acl_from_xattr() does not take idmapped mounts into account.
765 * If it did it calling it from the get acl inode operation would return POSIX
766 * ACLs mapped according to an idmapped mount which would mean that the value
767 * couldn't be cached for the filesystem. Idmapped mounts are taken into
768 * account on the fly during permission checking or right at the VFS -
769 * userspace boundary before reporting them to the user.
771 * Return: Allocated struct posix_acl on success, NULL for a valid header but
772 * without actual POSIX ACL entries, or ERR_PTR() encoded error code.
774 struct posix_acl
*posix_acl_from_xattr(struct user_namespace
*userns
,
775 const void *value
, size_t size
)
777 const struct posix_acl_xattr_header
*header
= value
;
778 const struct posix_acl_xattr_entry
*entry
= (const void *)(header
+ 1), *end
;
780 struct posix_acl
*acl
;
781 struct posix_acl_entry
*acl_e
;
783 count
= posix_acl_fix_xattr_common(value
, size
);
785 return ERR_PTR(count
);
789 acl
= posix_acl_alloc(count
, GFP_NOFS
);
791 return ERR_PTR(-ENOMEM
);
792 acl_e
= acl
->a_entries
;
794 for (end
= entry
+ count
; entry
!= end
; acl_e
++, entry
++) {
795 acl_e
->e_tag
= le16_to_cpu(entry
->e_tag
);
796 acl_e
->e_perm
= le16_to_cpu(entry
->e_perm
);
798 switch(acl_e
->e_tag
) {
806 acl_e
->e_uid
= make_kuid(userns
,
807 le32_to_cpu(entry
->e_id
));
808 if (!uid_valid(acl_e
->e_uid
))
812 acl_e
->e_gid
= make_kgid(userns
,
813 le32_to_cpu(entry
->e_id
));
814 if (!gid_valid(acl_e
->e_gid
))
825 posix_acl_release(acl
);
826 return ERR_PTR(-EINVAL
);
828 EXPORT_SYMBOL (posix_acl_from_xattr
);
831 * Convert from in-memory to extended attribute representation.
834 posix_acl_to_xattr(struct user_namespace
*user_ns
, const struct posix_acl
*acl
,
835 void *buffer
, size_t size
)
837 struct posix_acl_xattr_header
*ext_acl
= buffer
;
838 struct posix_acl_xattr_entry
*ext_entry
;
841 real_size
= posix_acl_xattr_size(acl
->a_count
);
844 if (real_size
> size
)
847 ext_entry
= (void *)(ext_acl
+ 1);
848 ext_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
850 for (n
=0; n
< acl
->a_count
; n
++, ext_entry
++) {
851 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
852 ext_entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
853 ext_entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
854 switch(acl_e
->e_tag
) {
857 cpu_to_le32(from_kuid(user_ns
, acl_e
->e_uid
));
861 cpu_to_le32(from_kgid(user_ns
, acl_e
->e_gid
));
864 ext_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
870 EXPORT_SYMBOL (posix_acl_to_xattr
);
873 * vfs_posix_acl_to_xattr - convert from kernel to userspace representation
874 * @idmap: idmap of the mount
875 * @inode: inode the posix acls are set on
876 * @acl: the posix acls as represented by the vfs
877 * @buffer: the buffer into which to convert @acl
878 * @size: size of @buffer
880 * This converts @acl from the VFS representation in the filesystem idmapping
881 * to the uapi form reportable to userspace. And mount and caller idmappings
882 * are handled appropriately.
884 * Return: On success, the size of the stored uapi posix acls, on error a
887 static ssize_t
vfs_posix_acl_to_xattr(struct mnt_idmap
*idmap
,
889 const struct posix_acl
*acl
, void *buffer
,
893 struct posix_acl_xattr_header
*ext_acl
= buffer
;
894 struct posix_acl_xattr_entry
*ext_entry
;
895 struct user_namespace
*fs_userns
, *caller_userns
;
896 struct user_namespace
*mnt_userns
;
897 ssize_t real_size
, n
;
901 real_size
= posix_acl_xattr_size(acl
->a_count
);
904 if (real_size
> size
)
907 ext_entry
= (void *)(ext_acl
+ 1);
908 ext_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
910 fs_userns
= i_user_ns(inode
);
911 caller_userns
= current_user_ns();
912 mnt_userns
= mnt_idmap_owner(idmap
);
913 for (n
=0; n
< acl
->a_count
; n
++, ext_entry
++) {
914 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
915 ext_entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
916 ext_entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
917 switch(acl_e
->e_tag
) {
919 vfsuid
= make_vfsuid(mnt_userns
, fs_userns
, acl_e
->e_uid
);
920 ext_entry
->e_id
= cpu_to_le32(from_kuid(
921 caller_userns
, vfsuid_into_kuid(vfsuid
)));
924 vfsgid
= make_vfsgid(mnt_userns
, fs_userns
, acl_e
->e_gid
);
925 ext_entry
->e_id
= cpu_to_le32(from_kgid(
926 caller_userns
, vfsgid_into_kgid(vfsgid
)));
929 ext_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
937 set_posix_acl(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
938 int type
, struct posix_acl
*acl
)
940 struct inode
*inode
= d_inode(dentry
);
942 if (!IS_POSIXACL(inode
))
944 if (!inode
->i_op
->set_acl
)
947 if (type
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
))
948 return acl
? -EACCES
: 0;
949 if (!inode_owner_or_capable(mnt_userns
, inode
))
953 int ret
= posix_acl_valid(inode
->i_sb
->s_user_ns
, acl
);
957 return inode
->i_op
->set_acl(mnt_userns
, dentry
, acl
, type
);
959 EXPORT_SYMBOL(set_posix_acl
);
962 posix_acl_xattr_list(struct dentry
*dentry
)
964 return IS_POSIXACL(d_backing_inode(dentry
));
967 const struct xattr_handler posix_acl_access_xattr_handler
= {
968 .name
= XATTR_NAME_POSIX_ACL_ACCESS
,
969 .flags
= ACL_TYPE_ACCESS
,
970 .list
= posix_acl_xattr_list
,
972 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler
);
974 const struct xattr_handler posix_acl_default_xattr_handler
= {
975 .name
= XATTR_NAME_POSIX_ACL_DEFAULT
,
976 .flags
= ACL_TYPE_DEFAULT
,
977 .list
= posix_acl_xattr_list
,
979 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler
);
981 int simple_set_acl(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
982 struct posix_acl
*acl
, int type
)
985 struct inode
*inode
= d_inode(dentry
);
987 if (type
== ACL_TYPE_ACCESS
) {
988 error
= posix_acl_update_mode(mnt_userns
, inode
,
989 &inode
->i_mode
, &acl
);
994 inode
->i_ctime
= current_time(inode
);
995 if (IS_I_VERSION(inode
))
996 inode_inc_iversion(inode
);
997 set_cached_acl(inode
, type
, acl
);
1001 int simple_acl_create(struct inode
*dir
, struct inode
*inode
)
1003 struct posix_acl
*default_acl
, *acl
;
1006 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
1010 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
);
1011 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
1014 posix_acl_release(default_acl
);
1016 posix_acl_release(acl
);
1020 static int vfs_set_acl_idmapped_mnt(struct user_namespace
*mnt_userns
,
1021 struct user_namespace
*fs_userns
,
1022 struct posix_acl
*acl
)
1024 for (int n
= 0; n
< acl
->a_count
; n
++) {
1025 struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
1027 switch (acl_e
->e_tag
) {
1029 acl_e
->e_uid
= from_vfsuid(mnt_userns
, fs_userns
,
1030 VFSUIDT_INIT(acl_e
->e_uid
));
1033 acl_e
->e_gid
= from_vfsgid(mnt_userns
, fs_userns
,
1034 VFSGIDT_INIT(acl_e
->e_gid
));
1043 * vfs_set_acl - set posix acls
1044 * @mnt_userns: user namespace of the mount
1045 * @dentry: the dentry based on which to set the posix acls
1046 * @acl_name: the name of the posix acl
1047 * @kacl: the posix acls in the appropriate VFS format
1049 * This function sets @kacl. The caller must all posix_acl_release() on @kacl
1052 * Return: On success 0, on error negative errno.
1054 int vfs_set_acl(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
1055 const char *acl_name
, struct posix_acl
*kacl
)
1059 struct inode
*inode
= d_inode(dentry
);
1060 struct inode
*delegated_inode
= NULL
;
1062 acl_type
= posix_acl_type(acl_name
);
1068 * If we're on an idmapped mount translate from mount specific
1069 * vfs{g,u}id_t into global filesystem k{g,u}id_t.
1070 * Afterwards we can cache the POSIX ACLs filesystem wide and -
1071 * if this is a filesystem with a backing store - ultimately
1072 * translate them to backing store values.
1074 error
= vfs_set_acl_idmapped_mnt(mnt_userns
, i_user_ns(inode
), kacl
);
1083 * We only care about restrictions the inode struct itself places upon
1084 * us otherwise POSIX ACLs aren't subject to any VFS restrictions.
1086 error
= may_write_xattr(mnt_userns
, inode
);
1088 goto out_inode_unlock
;
1090 error
= security_inode_set_acl(mnt_userns
, dentry
, acl_name
, kacl
);
1092 goto out_inode_unlock
;
1094 error
= try_break_deleg(inode
, &delegated_inode
);
1096 goto out_inode_unlock
;
1098 if (inode
->i_opflags
& IOP_XATTR
)
1099 error
= set_posix_acl(mnt_userns
, dentry
, acl_type
, kacl
);
1100 else if (unlikely(is_bad_inode(inode
)))
1103 error
= -EOPNOTSUPP
;
1105 fsnotify_xattr(dentry
);
1106 evm_inode_post_set_acl(dentry
, acl_name
, kacl
);
1110 inode_unlock(inode
);
1112 if (delegated_inode
) {
1113 error
= break_deleg_wait(&delegated_inode
);
1120 EXPORT_SYMBOL_GPL(vfs_set_acl
);
1123 * vfs_get_acl - get posix acls
1124 * @idmap: idmap of the mount
1125 * @dentry: the dentry based on which to retrieve the posix acls
1126 * @acl_name: the name of the posix acl
1128 * This function retrieves @kacl from the filesystem. The caller must all
1129 * posix_acl_release() on @kacl.
1131 * Return: On success POSIX ACLs in VFS format, on error negative errno.
1133 struct posix_acl
*vfs_get_acl(struct mnt_idmap
*idmap
,
1134 struct dentry
*dentry
, const char *acl_name
)
1136 struct user_namespace
*mnt_userns
= mnt_idmap_owner(idmap
);
1137 struct inode
*inode
= d_inode(dentry
);
1138 struct posix_acl
*acl
;
1139 int acl_type
, error
;
1141 acl_type
= posix_acl_type(acl_name
);
1143 return ERR_PTR(-EINVAL
);
1146 * The VFS has no restrictions on reading POSIX ACLs so calling
1147 * something like xattr_permission() isn't needed. Only LSMs get a say.
1149 error
= security_inode_get_acl(mnt_userns
, dentry
, acl_name
);
1151 return ERR_PTR(error
);
1153 if (!IS_POSIXACL(inode
))
1154 return ERR_PTR(-EOPNOTSUPP
);
1155 if (S_ISLNK(inode
->i_mode
))
1156 return ERR_PTR(-EOPNOTSUPP
);
1158 acl
= __get_acl(idmap
, dentry
, inode
, acl_type
);
1162 return ERR_PTR(-ENODATA
);
1166 EXPORT_SYMBOL_GPL(vfs_get_acl
);
1169 * vfs_remove_acl - remove posix acls
1170 * @mnt_userns: user namespace of the mount
1171 * @dentry: the dentry based on which to retrieve the posix acls
1172 * @acl_name: the name of the posix acl
1174 * This function removes posix acls.
1176 * Return: On success 0, on error negative errno.
1178 int vfs_remove_acl(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
1179 const char *acl_name
)
1183 struct inode
*inode
= d_inode(dentry
);
1184 struct inode
*delegated_inode
= NULL
;
1186 acl_type
= posix_acl_type(acl_name
);
1194 * We only care about restrictions the inode struct itself places upon
1195 * us otherwise POSIX ACLs aren't subject to any VFS restrictions.
1197 error
= may_write_xattr(mnt_userns
, inode
);
1199 goto out_inode_unlock
;
1201 error
= security_inode_remove_acl(mnt_userns
, dentry
, acl_name
);
1203 goto out_inode_unlock
;
1205 error
= try_break_deleg(inode
, &delegated_inode
);
1207 goto out_inode_unlock
;
1209 if (inode
->i_opflags
& IOP_XATTR
)
1210 error
= set_posix_acl(mnt_userns
, dentry
, acl_type
, NULL
);
1211 else if (unlikely(is_bad_inode(inode
)))
1214 error
= -EOPNOTSUPP
;
1216 fsnotify_xattr(dentry
);
1217 evm_inode_post_remove_acl(mnt_userns
, dentry
, acl_name
);
1221 inode_unlock(inode
);
1223 if (delegated_inode
) {
1224 error
= break_deleg_wait(&delegated_inode
);
1231 EXPORT_SYMBOL_GPL(vfs_remove_acl
);
1233 int do_set_acl(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
1234 const char *acl_name
, const void *kvalue
, size_t size
)
1237 struct posix_acl
*acl
= NULL
;
1241 * Note that posix_acl_from_xattr() uses GFP_NOFS when it
1242 * probably doesn't need to here.
1244 acl
= posix_acl_from_xattr(current_user_ns(), kvalue
, size
);
1246 return PTR_ERR(acl
);
1249 error
= vfs_set_acl(mnt_idmap_owner(idmap
), dentry
, acl_name
, acl
);
1250 posix_acl_release(acl
);
1254 ssize_t
do_get_acl(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
1255 const char *acl_name
, void *kvalue
, size_t size
)
1258 struct posix_acl
*acl
;
1260 acl
= vfs_get_acl(idmap
, dentry
, acl_name
);
1262 return PTR_ERR(acl
);
1264 error
= vfs_posix_acl_to_xattr(idmap
, d_inode(dentry
),
1266 posix_acl_release(acl
);