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>
28 static struct posix_acl
**acl_by_type(struct inode
*inode
, int type
)
33 case ACL_TYPE_DEFAULT
:
34 return &inode
->i_default_acl
;
40 struct posix_acl
*get_cached_acl(struct inode
*inode
, int type
)
42 struct posix_acl
**p
= acl_by_type(inode
, type
);
43 struct posix_acl
*acl
;
47 acl
= rcu_dereference(*p
);
48 if (!acl
|| is_uncached_acl(acl
) ||
49 refcount_inc_not_zero(&acl
->a_refcount
))
57 EXPORT_SYMBOL(get_cached_acl
);
59 struct posix_acl
*get_cached_acl_rcu(struct inode
*inode
, int type
)
61 struct posix_acl
*acl
= rcu_dereference(*acl_by_type(inode
, type
));
63 if (acl
== ACL_DONT_CACHE
) {
64 struct posix_acl
*ret
;
66 ret
= inode
->i_op
->get_acl(inode
, type
, LOOKUP_RCU
);
73 EXPORT_SYMBOL(get_cached_acl_rcu
);
75 void set_cached_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
77 struct posix_acl
**p
= acl_by_type(inode
, type
);
78 struct posix_acl
*old
;
80 old
= xchg(p
, posix_acl_dup(acl
));
81 if (!is_uncached_acl(old
))
82 posix_acl_release(old
);
84 EXPORT_SYMBOL(set_cached_acl
);
86 static void __forget_cached_acl(struct posix_acl
**p
)
88 struct posix_acl
*old
;
90 old
= xchg(p
, ACL_NOT_CACHED
);
91 if (!is_uncached_acl(old
))
92 posix_acl_release(old
);
95 void forget_cached_acl(struct inode
*inode
, int type
)
97 __forget_cached_acl(acl_by_type(inode
, type
));
99 EXPORT_SYMBOL(forget_cached_acl
);
101 void forget_all_cached_acls(struct inode
*inode
)
103 __forget_cached_acl(&inode
->i_acl
);
104 __forget_cached_acl(&inode
->i_default_acl
);
106 EXPORT_SYMBOL(forget_all_cached_acls
);
108 struct posix_acl
*get_acl(struct inode
*inode
, int type
)
111 struct posix_acl
**p
;
112 struct posix_acl
*acl
;
115 * The sentinel is used to detect when another operation like
116 * set_cached_acl() or forget_cached_acl() races with get_acl().
117 * It is guaranteed that is_uncached_acl(sentinel) is true.
120 acl
= get_cached_acl(inode
, type
);
121 if (!is_uncached_acl(acl
))
124 if (!IS_POSIXACL(inode
))
127 sentinel
= uncached_acl_sentinel(current
);
128 p
= acl_by_type(inode
, type
);
131 * If the ACL isn't being read yet, set our sentinel. Otherwise, the
132 * current value of the ACL will not be ACL_NOT_CACHED and so our own
133 * sentinel will not be set; another task will update the cache. We
134 * could wait for that other task to complete its job, but it's easier
135 * to just call ->get_acl to fetch the ACL ourself. (This is going to
136 * be an unlikely race.)
138 cmpxchg(p
, ACL_NOT_CACHED
, sentinel
);
141 * Normally, the ACL returned by ->get_acl will be cached.
142 * A filesystem can prevent that by calling
143 * forget_cached_acl(inode, type) in ->get_acl.
145 * If the filesystem doesn't have a get_acl() function at all, we'll
146 * just create the negative cache entry.
148 if (!inode
->i_op
->get_acl
) {
149 set_cached_acl(inode
, type
, NULL
);
152 acl
= inode
->i_op
->get_acl(inode
, type
, false);
156 * Remove our sentinel so that we don't block future attempts
159 cmpxchg(p
, sentinel
, ACL_NOT_CACHED
);
164 * Cache the result, but only if our sentinel is still in place.
167 if (unlikely(cmpxchg(p
, sentinel
, acl
) != sentinel
))
168 posix_acl_release(acl
);
171 EXPORT_SYMBOL(get_acl
);
174 * Init a fresh posix_acl
177 posix_acl_init(struct posix_acl
*acl
, int count
)
179 refcount_set(&acl
->a_refcount
, 1);
180 acl
->a_count
= count
;
182 EXPORT_SYMBOL(posix_acl_init
);
185 * Allocate a new ACL with the specified number of entries.
188 posix_acl_alloc(int count
, gfp_t flags
)
190 const size_t size
= sizeof(struct posix_acl
) +
191 count
* sizeof(struct posix_acl_entry
);
192 struct posix_acl
*acl
= kmalloc(size
, flags
);
194 posix_acl_init(acl
, count
);
197 EXPORT_SYMBOL(posix_acl_alloc
);
202 static struct posix_acl
*
203 posix_acl_clone(const struct posix_acl
*acl
, gfp_t flags
)
205 struct posix_acl
*clone
= NULL
;
208 int size
= sizeof(struct posix_acl
) + acl
->a_count
*
209 sizeof(struct posix_acl_entry
);
210 clone
= kmemdup(acl
, size
, flags
);
212 refcount_set(&clone
->a_refcount
, 1);
218 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
221 posix_acl_valid(struct user_namespace
*user_ns
, const struct posix_acl
*acl
)
223 const struct posix_acl_entry
*pa
, *pe
;
224 int state
= ACL_USER_OBJ
;
227 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
228 if (pa
->e_perm
& ~(ACL_READ
|ACL_WRITE
|ACL_EXECUTE
))
232 if (state
== ACL_USER_OBJ
) {
239 if (state
!= ACL_USER
)
241 if (!kuid_has_mapping(user_ns
, pa
->e_uid
))
247 if (state
== ACL_USER
) {
254 if (state
!= ACL_GROUP
)
256 if (!kgid_has_mapping(user_ns
, pa
->e_gid
))
262 if (state
!= ACL_GROUP
)
268 if (state
== ACL_OTHER
||
269 (state
== ACL_GROUP
&& !needs_mask
)) {
283 EXPORT_SYMBOL(posix_acl_valid
);
286 * Returns 0 if the acl can be exactly represented in the traditional
287 * file mode permission bits, or else 1. Returns -E... on error.
290 posix_acl_equiv_mode(const struct posix_acl
*acl
, umode_t
*mode_p
)
292 const struct posix_acl_entry
*pa
, *pe
;
297 * A null ACL can always be presented as mode bits.
302 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
305 mode
|= (pa
->e_perm
& S_IRWXO
) << 6;
308 mode
|= (pa
->e_perm
& S_IRWXO
) << 3;
311 mode
|= pa
->e_perm
& S_IRWXO
;
314 mode
= (mode
& ~S_IRWXG
) |
315 ((pa
->e_perm
& S_IRWXO
) << 3);
327 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
330 EXPORT_SYMBOL(posix_acl_equiv_mode
);
333 * Create an ACL representing the file mode permission bits of an inode.
336 posix_acl_from_mode(umode_t mode
, gfp_t flags
)
338 struct posix_acl
*acl
= posix_acl_alloc(3, flags
);
340 return ERR_PTR(-ENOMEM
);
342 acl
->a_entries
[0].e_tag
= ACL_USER_OBJ
;
343 acl
->a_entries
[0].e_perm
= (mode
& S_IRWXU
) >> 6;
345 acl
->a_entries
[1].e_tag
= ACL_GROUP_OBJ
;
346 acl
->a_entries
[1].e_perm
= (mode
& S_IRWXG
) >> 3;
348 acl
->a_entries
[2].e_tag
= ACL_OTHER
;
349 acl
->a_entries
[2].e_perm
= (mode
& S_IRWXO
);
352 EXPORT_SYMBOL(posix_acl_from_mode
);
355 * Return 0 if current is granted want access to the inode
356 * by the acl. Returns -E... otherwise.
359 posix_acl_permission(struct user_namespace
*mnt_userns
, struct inode
*inode
,
360 const struct posix_acl
*acl
, int want
)
362 const struct posix_acl_entry
*pa
, *pe
, *mask_obj
;
367 want
&= MAY_READ
| MAY_WRITE
| MAY_EXEC
;
369 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
372 /* (May have been checked already) */
373 uid
= i_uid_into_mnt(mnt_userns
, inode
);
374 if (uid_eq(uid
, current_fsuid()))
378 uid
= mapped_kuid_fs(mnt_userns
,
381 if (uid_eq(uid
, current_fsuid()))
385 gid
= i_gid_into_mnt(mnt_userns
, inode
);
386 if (in_group_p(gid
)) {
388 if ((pa
->e_perm
& want
) == want
)
393 gid
= mapped_kgid_fs(mnt_userns
,
396 if (in_group_p(gid
)) {
398 if ((pa
->e_perm
& want
) == want
)
416 for (mask_obj
= pa
+1; mask_obj
!= pe
; mask_obj
++) {
417 if (mask_obj
->e_tag
== ACL_MASK
) {
418 if ((pa
->e_perm
& mask_obj
->e_perm
& want
) == want
)
425 if ((pa
->e_perm
& want
) == want
)
431 * Modify acl when creating a new inode. The caller must ensure the acl is
432 * only referenced once.
434 * mode_p initially must contain the mode parameter to the open() / creat()
435 * system calls. All permissions that are not granted by the acl are removed.
436 * The permissions in the acl are changed to reflect the mode_p parameter.
438 static int posix_acl_create_masq(struct posix_acl
*acl
, umode_t
*mode_p
)
440 struct posix_acl_entry
*pa
, *pe
;
441 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
442 umode_t mode
= *mode_p
;
445 /* assert(atomic_read(acl->a_refcount) == 1); */
447 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
450 pa
->e_perm
&= (mode
>> 6) | ~S_IRWXO
;
451 mode
&= (pa
->e_perm
<< 6) | ~S_IRWXU
;
464 pa
->e_perm
&= mode
| ~S_IRWXO
;
465 mode
&= pa
->e_perm
| ~S_IRWXO
;
479 mask_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
480 mode
&= (mask_obj
->e_perm
<< 3) | ~S_IRWXG
;
484 group_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
485 mode
&= (group_obj
->e_perm
<< 3) | ~S_IRWXG
;
488 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
493 * Modify the ACL for the chmod syscall.
495 static int __posix_acl_chmod_masq(struct posix_acl
*acl
, umode_t mode
)
497 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
498 struct posix_acl_entry
*pa
, *pe
;
500 /* assert(atomic_read(acl->a_refcount) == 1); */
502 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
505 pa
->e_perm
= (mode
& S_IRWXU
) >> 6;
521 pa
->e_perm
= (mode
& S_IRWXO
);
530 mask_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
534 group_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
541 __posix_acl_create(struct posix_acl
**acl
, gfp_t gfp
, umode_t
*mode_p
)
543 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
546 err
= posix_acl_create_masq(clone
, mode_p
);
548 posix_acl_release(clone
);
552 posix_acl_release(*acl
);
556 EXPORT_SYMBOL(__posix_acl_create
);
559 __posix_acl_chmod(struct posix_acl
**acl
, gfp_t gfp
, umode_t mode
)
561 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
564 err
= __posix_acl_chmod_masq(clone
, mode
);
566 posix_acl_release(clone
);
570 posix_acl_release(*acl
);
574 EXPORT_SYMBOL(__posix_acl_chmod
);
577 * posix_acl_chmod - chmod a posix acl
579 * @mnt_userns: user namespace of the mount @inode was found from
580 * @inode: inode to check permissions on
581 * @mode: the new mode of @inode
583 * If the inode has been found through an idmapped mount the user namespace of
584 * the vfsmount must be passed through @mnt_userns. This function will then
585 * take care to map the inode according to @mnt_userns before checking
586 * permissions. On non-idmapped mounts or if permission checking is to be
587 * performed on the raw inode simply passs init_user_ns.
590 posix_acl_chmod(struct user_namespace
*mnt_userns
, struct inode
*inode
,
593 struct posix_acl
*acl
;
596 if (!IS_POSIXACL(inode
))
598 if (!inode
->i_op
->set_acl
)
601 acl
= get_acl(inode
, ACL_TYPE_ACCESS
);
602 if (IS_ERR_OR_NULL(acl
)) {
603 if (acl
== ERR_PTR(-EOPNOTSUPP
))
608 ret
= __posix_acl_chmod(&acl
, GFP_KERNEL
, mode
);
611 ret
= inode
->i_op
->set_acl(mnt_userns
, inode
, acl
, ACL_TYPE_ACCESS
);
612 posix_acl_release(acl
);
615 EXPORT_SYMBOL(posix_acl_chmod
);
618 posix_acl_create(struct inode
*dir
, umode_t
*mode
,
619 struct posix_acl
**default_acl
, struct posix_acl
**acl
)
622 struct posix_acl
*clone
;
628 if (S_ISLNK(*mode
) || !IS_POSIXACL(dir
))
631 p
= get_acl(dir
, ACL_TYPE_DEFAULT
);
632 if (!p
|| p
== ERR_PTR(-EOPNOTSUPP
)) {
633 *mode
&= ~current_umask();
640 clone
= posix_acl_clone(p
, GFP_NOFS
);
644 ret
= posix_acl_create_masq(clone
, mode
);
646 goto err_release_clone
;
649 posix_acl_release(clone
);
654 posix_acl_release(p
);
661 posix_acl_release(clone
);
663 posix_acl_release(p
);
666 EXPORT_SYMBOL_GPL(posix_acl_create
);
669 * posix_acl_update_mode - update mode in set_acl
670 * @mnt_userns: user namespace of the mount @inode was found from
671 * @inode: target inode
672 * @mode_p: mode (pointer) for update
675 * Update the file mode when setting an ACL: compute the new file permission
676 * bits based on the ACL. In addition, if the ACL is equivalent to the new
677 * file mode, set *@acl to NULL to indicate that no ACL should be set.
679 * As with chmod, clear the setgid bit if the caller is not in the owning group
680 * or capable of CAP_FSETID (see inode_change_ok).
682 * If the inode has been found through an idmapped mount the user namespace of
683 * the vfsmount must be passed through @mnt_userns. This function will then
684 * take care to map the inode according to @mnt_userns before checking
685 * permissions. On non-idmapped mounts or if permission checking is to be
686 * performed on the raw inode simply passs init_user_ns.
688 * Called from set_acl inode operations.
690 int posix_acl_update_mode(struct user_namespace
*mnt_userns
,
691 struct inode
*inode
, umode_t
*mode_p
,
692 struct posix_acl
**acl
)
694 umode_t mode
= inode
->i_mode
;
697 error
= posix_acl_equiv_mode(*acl
, &mode
);
702 if (!in_group_p(i_gid_into_mnt(mnt_userns
, inode
)) &&
703 !capable_wrt_inode_uidgid(mnt_userns
, inode
, CAP_FSETID
))
708 EXPORT_SYMBOL(posix_acl_update_mode
);
711 * Fix up the uids and gids in posix acl extended attributes in place.
713 static void posix_acl_fix_xattr_userns(
714 struct user_namespace
*to
, struct user_namespace
*from
,
715 struct user_namespace
*mnt_userns
,
716 void *value
, size_t size
, bool from_user
)
718 struct posix_acl_xattr_header
*header
= value
;
719 struct posix_acl_xattr_entry
*entry
= (void *)(header
+ 1), *end
;
726 if (size
< sizeof(struct posix_acl_xattr_header
))
728 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
731 count
= posix_acl_xattr_count(size
);
737 for (end
= entry
+ count
; entry
!= end
; entry
++) {
738 switch(le16_to_cpu(entry
->e_tag
)) {
740 uid
= make_kuid(from
, le32_to_cpu(entry
->e_id
));
742 uid
= mapped_kuid_user(mnt_userns
, &init_user_ns
, uid
);
744 uid
= mapped_kuid_fs(mnt_userns
, &init_user_ns
, uid
);
745 entry
->e_id
= cpu_to_le32(from_kuid(to
, uid
));
748 gid
= make_kgid(from
, le32_to_cpu(entry
->e_id
));
750 gid
= mapped_kgid_user(mnt_userns
, &init_user_ns
, gid
);
752 gid
= mapped_kgid_fs(mnt_userns
, &init_user_ns
, gid
);
753 entry
->e_id
= cpu_to_le32(from_kgid(to
, gid
));
761 void posix_acl_fix_xattr_from_user(struct user_namespace
*mnt_userns
,
763 void *value
, size_t size
)
765 struct user_namespace
*user_ns
= current_user_ns();
767 /* Leave ids untouched on non-idmapped mounts. */
768 if (no_idmapping(mnt_userns
, i_user_ns(inode
)))
769 mnt_userns
= &init_user_ns
;
770 if ((user_ns
== &init_user_ns
) && (mnt_userns
== &init_user_ns
))
772 posix_acl_fix_xattr_userns(&init_user_ns
, user_ns
, mnt_userns
, value
,
776 void posix_acl_fix_xattr_to_user(struct user_namespace
*mnt_userns
,
778 void *value
, size_t size
)
780 struct user_namespace
*user_ns
= current_user_ns();
782 /* Leave ids untouched on non-idmapped mounts. */
783 if (no_idmapping(mnt_userns
, i_user_ns(inode
)))
784 mnt_userns
= &init_user_ns
;
785 if ((user_ns
== &init_user_ns
) && (mnt_userns
== &init_user_ns
))
787 posix_acl_fix_xattr_userns(user_ns
, &init_user_ns
, mnt_userns
, value
,
792 * Convert from extended attribute to in-memory representation.
795 posix_acl_from_xattr(struct user_namespace
*user_ns
,
796 const void *value
, size_t size
)
798 const struct posix_acl_xattr_header
*header
= value
;
799 const struct posix_acl_xattr_entry
*entry
= (const void *)(header
+ 1), *end
;
801 struct posix_acl
*acl
;
802 struct posix_acl_entry
*acl_e
;
806 if (size
< sizeof(struct posix_acl_xattr_header
))
807 return ERR_PTR(-EINVAL
);
808 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
809 return ERR_PTR(-EOPNOTSUPP
);
811 count
= posix_acl_xattr_count(size
);
813 return ERR_PTR(-EINVAL
);
817 acl
= posix_acl_alloc(count
, GFP_NOFS
);
819 return ERR_PTR(-ENOMEM
);
820 acl_e
= acl
->a_entries
;
822 for (end
= entry
+ count
; entry
!= end
; acl_e
++, entry
++) {
823 acl_e
->e_tag
= le16_to_cpu(entry
->e_tag
);
824 acl_e
->e_perm
= le16_to_cpu(entry
->e_perm
);
826 switch(acl_e
->e_tag
) {
836 le32_to_cpu(entry
->e_id
));
837 if (!uid_valid(acl_e
->e_uid
))
843 le32_to_cpu(entry
->e_id
));
844 if (!gid_valid(acl_e
->e_gid
))
855 posix_acl_release(acl
);
856 return ERR_PTR(-EINVAL
);
858 EXPORT_SYMBOL (posix_acl_from_xattr
);
861 * Convert from in-memory to extended attribute representation.
864 posix_acl_to_xattr(struct user_namespace
*user_ns
, const struct posix_acl
*acl
,
865 void *buffer
, size_t size
)
867 struct posix_acl_xattr_header
*ext_acl
= buffer
;
868 struct posix_acl_xattr_entry
*ext_entry
;
871 real_size
= posix_acl_xattr_size(acl
->a_count
);
874 if (real_size
> size
)
877 ext_entry
= (void *)(ext_acl
+ 1);
878 ext_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
880 for (n
=0; n
< acl
->a_count
; n
++, ext_entry
++) {
881 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
882 ext_entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
883 ext_entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
884 switch(acl_e
->e_tag
) {
887 cpu_to_le32(from_kuid(user_ns
, acl_e
->e_uid
));
891 cpu_to_le32(from_kgid(user_ns
, acl_e
->e_gid
));
894 ext_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
900 EXPORT_SYMBOL (posix_acl_to_xattr
);
903 posix_acl_xattr_get(const struct xattr_handler
*handler
,
904 struct dentry
*unused
, struct inode
*inode
,
905 const char *name
, void *value
, size_t size
)
907 struct posix_acl
*acl
;
910 if (!IS_POSIXACL(inode
))
912 if (S_ISLNK(inode
->i_mode
))
915 acl
= get_acl(inode
, handler
->flags
);
921 error
= posix_acl_to_xattr(&init_user_ns
, acl
, value
, size
);
922 posix_acl_release(acl
);
928 set_posix_acl(struct user_namespace
*mnt_userns
, struct inode
*inode
,
929 int type
, struct posix_acl
*acl
)
931 if (!IS_POSIXACL(inode
))
933 if (!inode
->i_op
->set_acl
)
936 if (type
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
))
937 return acl
? -EACCES
: 0;
938 if (!inode_owner_or_capable(mnt_userns
, inode
))
942 int ret
= posix_acl_valid(inode
->i_sb
->s_user_ns
, acl
);
946 return inode
->i_op
->set_acl(mnt_userns
, inode
, acl
, type
);
948 EXPORT_SYMBOL(set_posix_acl
);
951 posix_acl_xattr_set(const struct xattr_handler
*handler
,
952 struct user_namespace
*mnt_userns
,
953 struct dentry
*unused
, struct inode
*inode
,
954 const char *name
, const void *value
, size_t size
,
957 struct posix_acl
*acl
= NULL
;
961 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
965 ret
= set_posix_acl(mnt_userns
, inode
, handler
->flags
, acl
);
966 posix_acl_release(acl
);
971 posix_acl_xattr_list(struct dentry
*dentry
)
973 return IS_POSIXACL(d_backing_inode(dentry
));
976 const struct xattr_handler posix_acl_access_xattr_handler
= {
977 .name
= XATTR_NAME_POSIX_ACL_ACCESS
,
978 .flags
= ACL_TYPE_ACCESS
,
979 .list
= posix_acl_xattr_list
,
980 .get
= posix_acl_xattr_get
,
981 .set
= posix_acl_xattr_set
,
983 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler
);
985 const struct xattr_handler posix_acl_default_xattr_handler
= {
986 .name
= XATTR_NAME_POSIX_ACL_DEFAULT
,
987 .flags
= ACL_TYPE_DEFAULT
,
988 .list
= posix_acl_xattr_list
,
989 .get
= posix_acl_xattr_get
,
990 .set
= posix_acl_xattr_set
,
992 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler
);
994 int simple_set_acl(struct user_namespace
*mnt_userns
, struct inode
*inode
,
995 struct posix_acl
*acl
, int type
)
999 if (type
== ACL_TYPE_ACCESS
) {
1000 error
= posix_acl_update_mode(mnt_userns
, inode
,
1001 &inode
->i_mode
, &acl
);
1006 inode
->i_ctime
= current_time(inode
);
1007 set_cached_acl(inode
, type
, acl
);
1011 int simple_acl_create(struct inode
*dir
, struct inode
*inode
)
1013 struct posix_acl
*default_acl
, *acl
;
1016 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
1020 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
);
1021 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
1024 posix_acl_release(default_acl
);
1026 posix_acl_release(acl
);