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 if (cmpxchg(p
, ACL_NOT_CACHED
, sentinel
) != ACL_NOT_CACHED
)
142 * Normally, the ACL returned by ->get_acl will be cached.
143 * A filesystem can prevent that by calling
144 * forget_cached_acl(inode, type) in ->get_acl.
146 * If the filesystem doesn't have a get_acl() function at all, we'll
147 * just create the negative cache entry.
149 if (!inode
->i_op
->get_acl
) {
150 set_cached_acl(inode
, type
, NULL
);
153 acl
= inode
->i_op
->get_acl(inode
, type
, false);
157 * Remove our sentinel so that we don't block future attempts
160 cmpxchg(p
, sentinel
, ACL_NOT_CACHED
);
165 * Cache the result, but only if our sentinel is still in place.
168 if (unlikely(cmpxchg(p
, sentinel
, acl
) != sentinel
))
169 posix_acl_release(acl
);
172 EXPORT_SYMBOL(get_acl
);
175 * Init a fresh posix_acl
178 posix_acl_init(struct posix_acl
*acl
, int count
)
180 refcount_set(&acl
->a_refcount
, 1);
181 acl
->a_count
= count
;
183 EXPORT_SYMBOL(posix_acl_init
);
186 * Allocate a new ACL with the specified number of entries.
189 posix_acl_alloc(int count
, gfp_t flags
)
191 const size_t size
= sizeof(struct posix_acl
) +
192 count
* sizeof(struct posix_acl_entry
);
193 struct posix_acl
*acl
= kmalloc(size
, flags
);
195 posix_acl_init(acl
, count
);
198 EXPORT_SYMBOL(posix_acl_alloc
);
203 static struct posix_acl
*
204 posix_acl_clone(const struct posix_acl
*acl
, gfp_t flags
)
206 struct posix_acl
*clone
= NULL
;
209 int size
= sizeof(struct posix_acl
) + acl
->a_count
*
210 sizeof(struct posix_acl_entry
);
211 clone
= kmemdup(acl
, size
, flags
);
213 refcount_set(&clone
->a_refcount
, 1);
219 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
222 posix_acl_valid(struct user_namespace
*user_ns
, const struct posix_acl
*acl
)
224 const struct posix_acl_entry
*pa
, *pe
;
225 int state
= ACL_USER_OBJ
;
228 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
229 if (pa
->e_perm
& ~(ACL_READ
|ACL_WRITE
|ACL_EXECUTE
))
233 if (state
== ACL_USER_OBJ
) {
240 if (state
!= ACL_USER
)
242 if (!kuid_has_mapping(user_ns
, pa
->e_uid
))
248 if (state
== ACL_USER
) {
255 if (state
!= ACL_GROUP
)
257 if (!kgid_has_mapping(user_ns
, pa
->e_gid
))
263 if (state
!= ACL_GROUP
)
269 if (state
== ACL_OTHER
||
270 (state
== ACL_GROUP
&& !needs_mask
)) {
284 EXPORT_SYMBOL(posix_acl_valid
);
287 * Returns 0 if the acl can be exactly represented in the traditional
288 * file mode permission bits, or else 1. Returns -E... on error.
291 posix_acl_equiv_mode(const struct posix_acl
*acl
, umode_t
*mode_p
)
293 const struct posix_acl_entry
*pa
, *pe
;
298 * A null ACL can always be presented as mode bits.
303 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
306 mode
|= (pa
->e_perm
& S_IRWXO
) << 6;
309 mode
|= (pa
->e_perm
& S_IRWXO
) << 3;
312 mode
|= pa
->e_perm
& S_IRWXO
;
315 mode
= (mode
& ~S_IRWXG
) |
316 ((pa
->e_perm
& S_IRWXO
) << 3);
328 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
331 EXPORT_SYMBOL(posix_acl_equiv_mode
);
334 * Create an ACL representing the file mode permission bits of an inode.
337 posix_acl_from_mode(umode_t mode
, gfp_t flags
)
339 struct posix_acl
*acl
= posix_acl_alloc(3, flags
);
341 return ERR_PTR(-ENOMEM
);
343 acl
->a_entries
[0].e_tag
= ACL_USER_OBJ
;
344 acl
->a_entries
[0].e_perm
= (mode
& S_IRWXU
) >> 6;
346 acl
->a_entries
[1].e_tag
= ACL_GROUP_OBJ
;
347 acl
->a_entries
[1].e_perm
= (mode
& S_IRWXG
) >> 3;
349 acl
->a_entries
[2].e_tag
= ACL_OTHER
;
350 acl
->a_entries
[2].e_perm
= (mode
& S_IRWXO
);
353 EXPORT_SYMBOL(posix_acl_from_mode
);
356 * Return 0 if current is granted want access to the inode
357 * by the acl. Returns -E... otherwise.
360 posix_acl_permission(struct user_namespace
*mnt_userns
, struct inode
*inode
,
361 const struct posix_acl
*acl
, int want
)
363 const struct posix_acl_entry
*pa
, *pe
, *mask_obj
;
368 want
&= MAY_READ
| MAY_WRITE
| MAY_EXEC
;
370 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
373 /* (May have been checked already) */
374 uid
= i_uid_into_mnt(mnt_userns
, inode
);
375 if (uid_eq(uid
, current_fsuid()))
379 uid
= mapped_kuid_fs(mnt_userns
,
382 if (uid_eq(uid
, current_fsuid()))
386 gid
= i_gid_into_mnt(mnt_userns
, inode
);
387 if (in_group_p(gid
)) {
389 if ((pa
->e_perm
& want
) == want
)
394 gid
= mapped_kgid_fs(mnt_userns
,
397 if (in_group_p(gid
)) {
399 if ((pa
->e_perm
& want
) == want
)
417 for (mask_obj
= pa
+1; mask_obj
!= pe
; mask_obj
++) {
418 if (mask_obj
->e_tag
== ACL_MASK
) {
419 if ((pa
->e_perm
& mask_obj
->e_perm
& want
) == want
)
426 if ((pa
->e_perm
& want
) == want
)
432 * Modify acl when creating a new inode. The caller must ensure the acl is
433 * only referenced once.
435 * mode_p initially must contain the mode parameter to the open() / creat()
436 * system calls. All permissions that are not granted by the acl are removed.
437 * The permissions in the acl are changed to reflect the mode_p parameter.
439 static int posix_acl_create_masq(struct posix_acl
*acl
, umode_t
*mode_p
)
441 struct posix_acl_entry
*pa
, *pe
;
442 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
443 umode_t mode
= *mode_p
;
446 /* assert(atomic_read(acl->a_refcount) == 1); */
448 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
451 pa
->e_perm
&= (mode
>> 6) | ~S_IRWXO
;
452 mode
&= (pa
->e_perm
<< 6) | ~S_IRWXU
;
465 pa
->e_perm
&= mode
| ~S_IRWXO
;
466 mode
&= pa
->e_perm
| ~S_IRWXO
;
480 mask_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
481 mode
&= (mask_obj
->e_perm
<< 3) | ~S_IRWXG
;
485 group_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
486 mode
&= (group_obj
->e_perm
<< 3) | ~S_IRWXG
;
489 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
494 * Modify the ACL for the chmod syscall.
496 static int __posix_acl_chmod_masq(struct posix_acl
*acl
, umode_t mode
)
498 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
499 struct posix_acl_entry
*pa
, *pe
;
501 /* assert(atomic_read(acl->a_refcount) == 1); */
503 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
506 pa
->e_perm
= (mode
& S_IRWXU
) >> 6;
522 pa
->e_perm
= (mode
& S_IRWXO
);
531 mask_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
535 group_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
542 __posix_acl_create(struct posix_acl
**acl
, gfp_t gfp
, umode_t
*mode_p
)
544 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
547 err
= posix_acl_create_masq(clone
, mode_p
);
549 posix_acl_release(clone
);
553 posix_acl_release(*acl
);
557 EXPORT_SYMBOL(__posix_acl_create
);
560 __posix_acl_chmod(struct posix_acl
**acl
, gfp_t gfp
, umode_t mode
)
562 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
565 err
= __posix_acl_chmod_masq(clone
, mode
);
567 posix_acl_release(clone
);
571 posix_acl_release(*acl
);
575 EXPORT_SYMBOL(__posix_acl_chmod
);
578 * posix_acl_chmod - chmod a posix acl
580 * @mnt_userns: user namespace of the mount @inode was found from
581 * @inode: inode to check permissions on
582 * @mode: the new mode of @inode
584 * If the inode has been found through an idmapped mount the user namespace of
585 * the vfsmount must be passed through @mnt_userns. This function will then
586 * take care to map the inode according to @mnt_userns before checking
587 * permissions. On non-idmapped mounts or if permission checking is to be
588 * performed on the raw inode simply passs init_user_ns.
591 posix_acl_chmod(struct user_namespace
*mnt_userns
, struct inode
*inode
,
594 struct posix_acl
*acl
;
597 if (!IS_POSIXACL(inode
))
599 if (!inode
->i_op
->set_acl
)
602 acl
= get_acl(inode
, ACL_TYPE_ACCESS
);
603 if (IS_ERR_OR_NULL(acl
)) {
604 if (acl
== ERR_PTR(-EOPNOTSUPP
))
609 ret
= __posix_acl_chmod(&acl
, GFP_KERNEL
, mode
);
612 ret
= inode
->i_op
->set_acl(mnt_userns
, inode
, acl
, ACL_TYPE_ACCESS
);
613 posix_acl_release(acl
);
616 EXPORT_SYMBOL(posix_acl_chmod
);
619 posix_acl_create(struct inode
*dir
, umode_t
*mode
,
620 struct posix_acl
**default_acl
, struct posix_acl
**acl
)
623 struct posix_acl
*clone
;
629 if (S_ISLNK(*mode
) || !IS_POSIXACL(dir
))
632 p
= get_acl(dir
, ACL_TYPE_DEFAULT
);
633 if (!p
|| p
== ERR_PTR(-EOPNOTSUPP
)) {
634 *mode
&= ~current_umask();
641 clone
= posix_acl_clone(p
, GFP_NOFS
);
645 ret
= posix_acl_create_masq(clone
, mode
);
647 goto err_release_clone
;
650 posix_acl_release(clone
);
655 posix_acl_release(p
);
662 posix_acl_release(clone
);
664 posix_acl_release(p
);
667 EXPORT_SYMBOL_GPL(posix_acl_create
);
670 * posix_acl_update_mode - update mode in set_acl
671 * @mnt_userns: user namespace of the mount @inode was found from
672 * @inode: target inode
673 * @mode_p: mode (pointer) for update
676 * Update the file mode when setting an ACL: compute the new file permission
677 * bits based on the ACL. In addition, if the ACL is equivalent to the new
678 * file mode, set *@acl to NULL to indicate that no ACL should be set.
680 * As with chmod, clear the setgid bit if the caller is not in the owning group
681 * or capable of CAP_FSETID (see inode_change_ok).
683 * If the inode has been found through an idmapped mount the user namespace of
684 * the vfsmount must be passed through @mnt_userns. This function will then
685 * take care to map the inode according to @mnt_userns before checking
686 * permissions. On non-idmapped mounts or if permission checking is to be
687 * performed on the raw inode simply passs init_user_ns.
689 * Called from set_acl inode operations.
691 int posix_acl_update_mode(struct user_namespace
*mnt_userns
,
692 struct inode
*inode
, umode_t
*mode_p
,
693 struct posix_acl
**acl
)
695 umode_t mode
= inode
->i_mode
;
698 error
= posix_acl_equiv_mode(*acl
, &mode
);
703 if (!in_group_p(i_gid_into_mnt(mnt_userns
, inode
)) &&
704 !capable_wrt_inode_uidgid(mnt_userns
, inode
, CAP_FSETID
))
709 EXPORT_SYMBOL(posix_acl_update_mode
);
712 * Fix up the uids and gids in posix acl extended attributes in place.
714 static void posix_acl_fix_xattr_userns(
715 struct user_namespace
*to
, struct user_namespace
*from
,
716 struct user_namespace
*mnt_userns
,
717 void *value
, size_t size
, bool from_user
)
719 struct posix_acl_xattr_header
*header
= value
;
720 struct posix_acl_xattr_entry
*entry
= (void *)(header
+ 1), *end
;
727 if (size
< sizeof(struct posix_acl_xattr_header
))
729 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
732 count
= posix_acl_xattr_count(size
);
738 for (end
= entry
+ count
; entry
!= end
; entry
++) {
739 switch(le16_to_cpu(entry
->e_tag
)) {
741 uid
= make_kuid(from
, le32_to_cpu(entry
->e_id
));
743 uid
= mapped_kuid_user(mnt_userns
, &init_user_ns
, uid
);
745 uid
= mapped_kuid_fs(mnt_userns
, &init_user_ns
, uid
);
746 entry
->e_id
= cpu_to_le32(from_kuid(to
, uid
));
749 gid
= make_kgid(from
, le32_to_cpu(entry
->e_id
));
751 gid
= mapped_kgid_user(mnt_userns
, &init_user_ns
, gid
);
753 gid
= mapped_kgid_fs(mnt_userns
, &init_user_ns
, gid
);
754 entry
->e_id
= cpu_to_le32(from_kgid(to
, gid
));
762 void posix_acl_fix_xattr_from_user(struct user_namespace
*mnt_userns
,
764 void *value
, size_t size
)
766 struct user_namespace
*user_ns
= current_user_ns();
768 /* Leave ids untouched on non-idmapped mounts. */
769 if (no_idmapping(mnt_userns
, i_user_ns(inode
)))
770 mnt_userns
= &init_user_ns
;
771 if ((user_ns
== &init_user_ns
) && (mnt_userns
== &init_user_ns
))
773 posix_acl_fix_xattr_userns(&init_user_ns
, user_ns
, mnt_userns
, value
,
777 void posix_acl_fix_xattr_to_user(struct user_namespace
*mnt_userns
,
779 void *value
, size_t size
)
781 struct user_namespace
*user_ns
= current_user_ns();
783 /* Leave ids untouched on non-idmapped mounts. */
784 if (no_idmapping(mnt_userns
, i_user_ns(inode
)))
785 mnt_userns
= &init_user_ns
;
786 if ((user_ns
== &init_user_ns
) && (mnt_userns
== &init_user_ns
))
788 posix_acl_fix_xattr_userns(user_ns
, &init_user_ns
, mnt_userns
, value
,
793 * Convert from extended attribute to in-memory representation.
796 posix_acl_from_xattr(struct user_namespace
*user_ns
,
797 const void *value
, size_t size
)
799 const struct posix_acl_xattr_header
*header
= value
;
800 const struct posix_acl_xattr_entry
*entry
= (const void *)(header
+ 1), *end
;
802 struct posix_acl
*acl
;
803 struct posix_acl_entry
*acl_e
;
807 if (size
< sizeof(struct posix_acl_xattr_header
))
808 return ERR_PTR(-EINVAL
);
809 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
810 return ERR_PTR(-EOPNOTSUPP
);
812 count
= posix_acl_xattr_count(size
);
814 return ERR_PTR(-EINVAL
);
818 acl
= posix_acl_alloc(count
, GFP_NOFS
);
820 return ERR_PTR(-ENOMEM
);
821 acl_e
= acl
->a_entries
;
823 for (end
= entry
+ count
; entry
!= end
; acl_e
++, entry
++) {
824 acl_e
->e_tag
= le16_to_cpu(entry
->e_tag
);
825 acl_e
->e_perm
= le16_to_cpu(entry
->e_perm
);
827 switch(acl_e
->e_tag
) {
837 le32_to_cpu(entry
->e_id
));
838 if (!uid_valid(acl_e
->e_uid
))
844 le32_to_cpu(entry
->e_id
));
845 if (!gid_valid(acl_e
->e_gid
))
856 posix_acl_release(acl
);
857 return ERR_PTR(-EINVAL
);
859 EXPORT_SYMBOL (posix_acl_from_xattr
);
862 * Convert from in-memory to extended attribute representation.
865 posix_acl_to_xattr(struct user_namespace
*user_ns
, const struct posix_acl
*acl
,
866 void *buffer
, size_t size
)
868 struct posix_acl_xattr_header
*ext_acl
= buffer
;
869 struct posix_acl_xattr_entry
*ext_entry
;
872 real_size
= posix_acl_xattr_size(acl
->a_count
);
875 if (real_size
> size
)
878 ext_entry
= (void *)(ext_acl
+ 1);
879 ext_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
881 for (n
=0; n
< acl
->a_count
; n
++, ext_entry
++) {
882 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
883 ext_entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
884 ext_entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
885 switch(acl_e
->e_tag
) {
888 cpu_to_le32(from_kuid(user_ns
, acl_e
->e_uid
));
892 cpu_to_le32(from_kgid(user_ns
, acl_e
->e_gid
));
895 ext_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
901 EXPORT_SYMBOL (posix_acl_to_xattr
);
904 posix_acl_xattr_get(const struct xattr_handler
*handler
,
905 struct dentry
*unused
, struct inode
*inode
,
906 const char *name
, void *value
, size_t size
)
908 struct posix_acl
*acl
;
911 if (!IS_POSIXACL(inode
))
913 if (S_ISLNK(inode
->i_mode
))
916 acl
= get_acl(inode
, handler
->flags
);
922 error
= posix_acl_to_xattr(&init_user_ns
, acl
, value
, size
);
923 posix_acl_release(acl
);
929 set_posix_acl(struct user_namespace
*mnt_userns
, struct inode
*inode
,
930 int type
, struct posix_acl
*acl
)
932 if (!IS_POSIXACL(inode
))
934 if (!inode
->i_op
->set_acl
)
937 if (type
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
))
938 return acl
? -EACCES
: 0;
939 if (!inode_owner_or_capable(mnt_userns
, inode
))
943 int ret
= posix_acl_valid(inode
->i_sb
->s_user_ns
, acl
);
947 return inode
->i_op
->set_acl(mnt_userns
, inode
, acl
, type
);
949 EXPORT_SYMBOL(set_posix_acl
);
952 posix_acl_xattr_set(const struct xattr_handler
*handler
,
953 struct user_namespace
*mnt_userns
,
954 struct dentry
*unused
, struct inode
*inode
,
955 const char *name
, const void *value
, size_t size
,
958 struct posix_acl
*acl
= NULL
;
962 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
966 ret
= set_posix_acl(mnt_userns
, inode
, handler
->flags
, acl
);
967 posix_acl_release(acl
);
972 posix_acl_xattr_list(struct dentry
*dentry
)
974 return IS_POSIXACL(d_backing_inode(dentry
));
977 const struct xattr_handler posix_acl_access_xattr_handler
= {
978 .name
= XATTR_NAME_POSIX_ACL_ACCESS
,
979 .flags
= ACL_TYPE_ACCESS
,
980 .list
= posix_acl_xattr_list
,
981 .get
= posix_acl_xattr_get
,
982 .set
= posix_acl_xattr_set
,
984 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler
);
986 const struct xattr_handler posix_acl_default_xattr_handler
= {
987 .name
= XATTR_NAME_POSIX_ACL_DEFAULT
,
988 .flags
= ACL_TYPE_DEFAULT
,
989 .list
= posix_acl_xattr_list
,
990 .get
= posix_acl_xattr_get
,
991 .set
= posix_acl_xattr_set
,
993 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler
);
995 int simple_set_acl(struct user_namespace
*mnt_userns
, struct inode
*inode
,
996 struct posix_acl
*acl
, int type
)
1000 if (type
== ACL_TYPE_ACCESS
) {
1001 error
= posix_acl_update_mode(mnt_userns
, inode
,
1002 &inode
->i_mode
, &acl
);
1007 inode
->i_ctime
= current_time(inode
);
1008 set_cached_acl(inode
, type
, acl
);
1012 int simple_acl_create(struct inode
*dir
, struct inode
*inode
)
1014 struct posix_acl
*default_acl
, *acl
;
1017 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
1021 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
);
1022 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
1025 posix_acl_release(default_acl
);
1027 posix_acl_release(acl
);