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>
26 static struct posix_acl
**acl_by_type(struct inode
*inode
, int type
)
31 case ACL_TYPE_DEFAULT
:
32 return &inode
->i_default_acl
;
38 struct posix_acl
*get_cached_acl(struct inode
*inode
, int type
)
40 struct posix_acl
**p
= acl_by_type(inode
, type
);
41 struct posix_acl
*acl
;
45 acl
= rcu_dereference(*p
);
46 if (!acl
|| is_uncached_acl(acl
) ||
47 refcount_inc_not_zero(&acl
->a_refcount
))
55 EXPORT_SYMBOL(get_cached_acl
);
57 struct posix_acl
*get_cached_acl_rcu(struct inode
*inode
, int type
)
59 return rcu_dereference(*acl_by_type(inode
, type
));
61 EXPORT_SYMBOL(get_cached_acl_rcu
);
63 void set_cached_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
65 struct posix_acl
**p
= acl_by_type(inode
, type
);
66 struct posix_acl
*old
;
68 old
= xchg(p
, posix_acl_dup(acl
));
69 if (!is_uncached_acl(old
))
70 posix_acl_release(old
);
72 EXPORT_SYMBOL(set_cached_acl
);
74 static void __forget_cached_acl(struct posix_acl
**p
)
76 struct posix_acl
*old
;
78 old
= xchg(p
, ACL_NOT_CACHED
);
79 if (!is_uncached_acl(old
))
80 posix_acl_release(old
);
83 void forget_cached_acl(struct inode
*inode
, int type
)
85 __forget_cached_acl(acl_by_type(inode
, type
));
87 EXPORT_SYMBOL(forget_cached_acl
);
89 void forget_all_cached_acls(struct inode
*inode
)
91 __forget_cached_acl(&inode
->i_acl
);
92 __forget_cached_acl(&inode
->i_default_acl
);
94 EXPORT_SYMBOL(forget_all_cached_acls
);
96 struct posix_acl
*get_acl(struct inode
*inode
, int type
)
100 struct posix_acl
*acl
;
103 * The sentinel is used to detect when another operation like
104 * set_cached_acl() or forget_cached_acl() races with get_acl().
105 * It is guaranteed that is_uncached_acl(sentinel) is true.
108 acl
= get_cached_acl(inode
, type
);
109 if (!is_uncached_acl(acl
))
112 if (!IS_POSIXACL(inode
))
115 sentinel
= uncached_acl_sentinel(current
);
116 p
= acl_by_type(inode
, type
);
119 * If the ACL isn't being read yet, set our sentinel. Otherwise, the
120 * current value of the ACL will not be ACL_NOT_CACHED and so our own
121 * sentinel will not be set; another task will update the cache. We
122 * could wait for that other task to complete its job, but it's easier
123 * to just call ->get_acl to fetch the ACL ourself. (This is going to
124 * be an unlikely race.)
126 if (cmpxchg(p
, ACL_NOT_CACHED
, sentinel
) != ACL_NOT_CACHED
)
130 * Normally, the ACL returned by ->get_acl will be cached.
131 * A filesystem can prevent that by calling
132 * forget_cached_acl(inode, type) in ->get_acl.
134 * If the filesystem doesn't have a get_acl() function at all, we'll
135 * just create the negative cache entry.
137 if (!inode
->i_op
->get_acl
) {
138 set_cached_acl(inode
, type
, NULL
);
141 acl
= inode
->i_op
->get_acl(inode
, type
);
145 * Remove our sentinel so that we don't block future attempts
148 cmpxchg(p
, sentinel
, ACL_NOT_CACHED
);
153 * Cache the result, but only if our sentinel is still in place.
156 if (unlikely(cmpxchg(p
, sentinel
, acl
) != sentinel
))
157 posix_acl_release(acl
);
160 EXPORT_SYMBOL(get_acl
);
163 * Init a fresh posix_acl
166 posix_acl_init(struct posix_acl
*acl
, int count
)
168 refcount_set(&acl
->a_refcount
, 1);
169 acl
->a_count
= count
;
171 EXPORT_SYMBOL(posix_acl_init
);
174 * Allocate a new ACL with the specified number of entries.
177 posix_acl_alloc(int count
, gfp_t flags
)
179 const size_t size
= sizeof(struct posix_acl
) +
180 count
* sizeof(struct posix_acl_entry
);
181 struct posix_acl
*acl
= kmalloc(size
, flags
);
183 posix_acl_init(acl
, count
);
186 EXPORT_SYMBOL(posix_acl_alloc
);
191 static struct posix_acl
*
192 posix_acl_clone(const struct posix_acl
*acl
, gfp_t flags
)
194 struct posix_acl
*clone
= NULL
;
197 int size
= sizeof(struct posix_acl
) + acl
->a_count
*
198 sizeof(struct posix_acl_entry
);
199 clone
= kmemdup(acl
, size
, flags
);
201 refcount_set(&clone
->a_refcount
, 1);
207 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
210 posix_acl_valid(struct user_namespace
*user_ns
, const struct posix_acl
*acl
)
212 const struct posix_acl_entry
*pa
, *pe
;
213 int state
= ACL_USER_OBJ
;
216 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
217 if (pa
->e_perm
& ~(ACL_READ
|ACL_WRITE
|ACL_EXECUTE
))
221 if (state
== ACL_USER_OBJ
) {
228 if (state
!= ACL_USER
)
230 if (!kuid_has_mapping(user_ns
, pa
->e_uid
))
236 if (state
== ACL_USER
) {
243 if (state
!= ACL_GROUP
)
245 if (!kgid_has_mapping(user_ns
, pa
->e_gid
))
251 if (state
!= ACL_GROUP
)
257 if (state
== ACL_OTHER
||
258 (state
== ACL_GROUP
&& !needs_mask
)) {
272 EXPORT_SYMBOL(posix_acl_valid
);
275 * Returns 0 if the acl can be exactly represented in the traditional
276 * file mode permission bits, or else 1. Returns -E... on error.
279 posix_acl_equiv_mode(const struct posix_acl
*acl
, umode_t
*mode_p
)
281 const struct posix_acl_entry
*pa
, *pe
;
286 * A null ACL can always be presented as mode bits.
291 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
294 mode
|= (pa
->e_perm
& S_IRWXO
) << 6;
297 mode
|= (pa
->e_perm
& S_IRWXO
) << 3;
300 mode
|= pa
->e_perm
& S_IRWXO
;
303 mode
= (mode
& ~S_IRWXG
) |
304 ((pa
->e_perm
& S_IRWXO
) << 3);
316 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
319 EXPORT_SYMBOL(posix_acl_equiv_mode
);
322 * Create an ACL representing the file mode permission bits of an inode.
325 posix_acl_from_mode(umode_t mode
, gfp_t flags
)
327 struct posix_acl
*acl
= posix_acl_alloc(3, flags
);
329 return ERR_PTR(-ENOMEM
);
331 acl
->a_entries
[0].e_tag
= ACL_USER_OBJ
;
332 acl
->a_entries
[0].e_perm
= (mode
& S_IRWXU
) >> 6;
334 acl
->a_entries
[1].e_tag
= ACL_GROUP_OBJ
;
335 acl
->a_entries
[1].e_perm
= (mode
& S_IRWXG
) >> 3;
337 acl
->a_entries
[2].e_tag
= ACL_OTHER
;
338 acl
->a_entries
[2].e_perm
= (mode
& S_IRWXO
);
341 EXPORT_SYMBOL(posix_acl_from_mode
);
344 * Return 0 if current is granted want access to the inode
345 * by the acl. Returns -E... otherwise.
348 posix_acl_permission(struct user_namespace
*mnt_userns
, struct inode
*inode
,
349 const struct posix_acl
*acl
, int want
)
351 const struct posix_acl_entry
*pa
, *pe
, *mask_obj
;
356 want
&= MAY_READ
| MAY_WRITE
| MAY_EXEC
;
358 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
361 /* (May have been checked already) */
362 uid
= i_uid_into_mnt(mnt_userns
, inode
);
363 if (uid_eq(uid
, current_fsuid()))
367 uid
= kuid_into_mnt(mnt_userns
, pa
->e_uid
);
368 if (uid_eq(uid
, current_fsuid()))
372 gid
= i_gid_into_mnt(mnt_userns
, inode
);
373 if (in_group_p(gid
)) {
375 if ((pa
->e_perm
& want
) == want
)
380 gid
= kgid_into_mnt(mnt_userns
, pa
->e_gid
);
381 if (in_group_p(gid
)) {
383 if ((pa
->e_perm
& want
) == want
)
401 for (mask_obj
= pa
+1; mask_obj
!= pe
; mask_obj
++) {
402 if (mask_obj
->e_tag
== ACL_MASK
) {
403 if ((pa
->e_perm
& mask_obj
->e_perm
& want
) == want
)
410 if ((pa
->e_perm
& want
) == want
)
416 * Modify acl when creating a new inode. The caller must ensure the acl is
417 * only referenced once.
419 * mode_p initially must contain the mode parameter to the open() / creat()
420 * system calls. All permissions that are not granted by the acl are removed.
421 * The permissions in the acl are changed to reflect the mode_p parameter.
423 static int posix_acl_create_masq(struct posix_acl
*acl
, umode_t
*mode_p
)
425 struct posix_acl_entry
*pa
, *pe
;
426 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
427 umode_t mode
= *mode_p
;
430 /* assert(atomic_read(acl->a_refcount) == 1); */
432 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
435 pa
->e_perm
&= (mode
>> 6) | ~S_IRWXO
;
436 mode
&= (pa
->e_perm
<< 6) | ~S_IRWXU
;
449 pa
->e_perm
&= mode
| ~S_IRWXO
;
450 mode
&= pa
->e_perm
| ~S_IRWXO
;
464 mask_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
465 mode
&= (mask_obj
->e_perm
<< 3) | ~S_IRWXG
;
469 group_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
470 mode
&= (group_obj
->e_perm
<< 3) | ~S_IRWXG
;
473 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
478 * Modify the ACL for the chmod syscall.
480 static int __posix_acl_chmod_masq(struct posix_acl
*acl
, umode_t mode
)
482 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
483 struct posix_acl_entry
*pa
, *pe
;
485 /* assert(atomic_read(acl->a_refcount) == 1); */
487 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
490 pa
->e_perm
= (mode
& S_IRWXU
) >> 6;
506 pa
->e_perm
= (mode
& S_IRWXO
);
515 mask_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
519 group_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
526 __posix_acl_create(struct posix_acl
**acl
, gfp_t gfp
, umode_t
*mode_p
)
528 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
531 err
= posix_acl_create_masq(clone
, mode_p
);
533 posix_acl_release(clone
);
537 posix_acl_release(*acl
);
541 EXPORT_SYMBOL(__posix_acl_create
);
544 __posix_acl_chmod(struct posix_acl
**acl
, gfp_t gfp
, umode_t mode
)
546 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
549 err
= __posix_acl_chmod_masq(clone
, mode
);
551 posix_acl_release(clone
);
555 posix_acl_release(*acl
);
559 EXPORT_SYMBOL(__posix_acl_chmod
);
562 * posix_acl_chmod - chmod a posix acl
564 * @mnt_userns: user namespace of the mount @inode was found from
565 * @inode: inode to check permissions on
566 * @mode: the new mode of @inode
568 * If the inode has been found through an idmapped mount the user namespace of
569 * the vfsmount must be passed through @mnt_userns. This function will then
570 * take care to map the inode according to @mnt_userns before checking
571 * permissions. On non-idmapped mounts or if permission checking is to be
572 * performed on the raw inode simply passs init_user_ns.
575 posix_acl_chmod(struct user_namespace
*mnt_userns
, struct inode
*inode
,
578 struct posix_acl
*acl
;
581 if (!IS_POSIXACL(inode
))
583 if (!inode
->i_op
->set_acl
)
586 acl
= get_acl(inode
, ACL_TYPE_ACCESS
);
587 if (IS_ERR_OR_NULL(acl
)) {
588 if (acl
== ERR_PTR(-EOPNOTSUPP
))
593 ret
= __posix_acl_chmod(&acl
, GFP_KERNEL
, mode
);
596 ret
= inode
->i_op
->set_acl(mnt_userns
, inode
, acl
, ACL_TYPE_ACCESS
);
597 posix_acl_release(acl
);
600 EXPORT_SYMBOL(posix_acl_chmod
);
603 posix_acl_create(struct inode
*dir
, umode_t
*mode
,
604 struct posix_acl
**default_acl
, struct posix_acl
**acl
)
607 struct posix_acl
*clone
;
613 if (S_ISLNK(*mode
) || !IS_POSIXACL(dir
))
616 p
= get_acl(dir
, ACL_TYPE_DEFAULT
);
617 if (!p
|| p
== ERR_PTR(-EOPNOTSUPP
)) {
618 *mode
&= ~current_umask();
625 clone
= posix_acl_clone(p
, GFP_NOFS
);
629 ret
= posix_acl_create_masq(clone
, mode
);
631 goto err_release_clone
;
634 posix_acl_release(clone
);
639 posix_acl_release(p
);
646 posix_acl_release(clone
);
648 posix_acl_release(p
);
651 EXPORT_SYMBOL_GPL(posix_acl_create
);
654 * posix_acl_update_mode - update mode in set_acl
655 * @mnt_userns: user namespace of the mount @inode was found from
656 * @inode: target inode
657 * @mode_p: mode (pointer) for update
660 * Update the file mode when setting an ACL: compute the new file permission
661 * bits based on the ACL. In addition, if the ACL is equivalent to the new
662 * file mode, set *@acl to NULL to indicate that no ACL should be set.
664 * As with chmod, clear the setgid bit if the caller is not in the owning group
665 * or capable of CAP_FSETID (see inode_change_ok).
667 * If the inode has been found through an idmapped mount the user namespace of
668 * the vfsmount must be passed through @mnt_userns. This function will then
669 * take care to map the inode according to @mnt_userns before checking
670 * permissions. On non-idmapped mounts or if permission checking is to be
671 * performed on the raw inode simply passs init_user_ns.
673 * Called from set_acl inode operations.
675 int posix_acl_update_mode(struct user_namespace
*mnt_userns
,
676 struct inode
*inode
, umode_t
*mode_p
,
677 struct posix_acl
**acl
)
679 umode_t mode
= inode
->i_mode
;
682 error
= posix_acl_equiv_mode(*acl
, &mode
);
687 if (!in_group_p(i_gid_into_mnt(mnt_userns
, inode
)) &&
688 !capable_wrt_inode_uidgid(mnt_userns
, inode
, CAP_FSETID
))
693 EXPORT_SYMBOL(posix_acl_update_mode
);
696 * Fix up the uids and gids in posix acl extended attributes in place.
698 static void posix_acl_fix_xattr_userns(
699 struct user_namespace
*to
, struct user_namespace
*from
,
700 struct user_namespace
*mnt_userns
,
701 void *value
, size_t size
, bool from_user
)
703 struct posix_acl_xattr_header
*header
= value
;
704 struct posix_acl_xattr_entry
*entry
= (void *)(header
+ 1), *end
;
711 if (size
< sizeof(struct posix_acl_xattr_header
))
713 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
716 count
= posix_acl_xattr_count(size
);
722 for (end
= entry
+ count
; entry
!= end
; entry
++) {
723 switch(le16_to_cpu(entry
->e_tag
)) {
725 uid
= make_kuid(from
, le32_to_cpu(entry
->e_id
));
727 uid
= kuid_from_mnt(mnt_userns
, uid
);
729 uid
= kuid_into_mnt(mnt_userns
, uid
);
730 entry
->e_id
= cpu_to_le32(from_kuid(to
, uid
));
733 gid
= make_kgid(from
, le32_to_cpu(entry
->e_id
));
735 gid
= kgid_from_mnt(mnt_userns
, gid
);
737 gid
= kgid_into_mnt(mnt_userns
, gid
);
738 entry
->e_id
= cpu_to_le32(from_kgid(to
, gid
));
746 void posix_acl_fix_xattr_from_user(struct user_namespace
*mnt_userns
,
747 void *value
, size_t size
)
749 struct user_namespace
*user_ns
= current_user_ns();
750 if ((user_ns
== &init_user_ns
) && (mnt_userns
== &init_user_ns
))
752 posix_acl_fix_xattr_userns(&init_user_ns
, user_ns
, mnt_userns
, value
,
756 void posix_acl_fix_xattr_to_user(struct user_namespace
*mnt_userns
,
757 void *value
, size_t size
)
759 struct user_namespace
*user_ns
= current_user_ns();
760 if ((user_ns
== &init_user_ns
) && (mnt_userns
== &init_user_ns
))
762 posix_acl_fix_xattr_userns(user_ns
, &init_user_ns
, mnt_userns
, value
,
767 * Convert from extended attribute to in-memory representation.
770 posix_acl_from_xattr(struct user_namespace
*user_ns
,
771 const void *value
, size_t size
)
773 const struct posix_acl_xattr_header
*header
= value
;
774 const struct posix_acl_xattr_entry
*entry
= (const void *)(header
+ 1), *end
;
776 struct posix_acl
*acl
;
777 struct posix_acl_entry
*acl_e
;
781 if (size
< sizeof(struct posix_acl_xattr_header
))
782 return ERR_PTR(-EINVAL
);
783 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
784 return ERR_PTR(-EOPNOTSUPP
);
786 count
= posix_acl_xattr_count(size
);
788 return ERR_PTR(-EINVAL
);
792 acl
= posix_acl_alloc(count
, GFP_NOFS
);
794 return ERR_PTR(-ENOMEM
);
795 acl_e
= acl
->a_entries
;
797 for (end
= entry
+ count
; entry
!= end
; acl_e
++, entry
++) {
798 acl_e
->e_tag
= le16_to_cpu(entry
->e_tag
);
799 acl_e
->e_perm
= le16_to_cpu(entry
->e_perm
);
801 switch(acl_e
->e_tag
) {
811 le32_to_cpu(entry
->e_id
));
812 if (!uid_valid(acl_e
->e_uid
))
818 le32_to_cpu(entry
->e_id
));
819 if (!gid_valid(acl_e
->e_gid
))
830 posix_acl_release(acl
);
831 return ERR_PTR(-EINVAL
);
833 EXPORT_SYMBOL (posix_acl_from_xattr
);
836 * Convert from in-memory to extended attribute representation.
839 posix_acl_to_xattr(struct user_namespace
*user_ns
, const struct posix_acl
*acl
,
840 void *buffer
, size_t size
)
842 struct posix_acl_xattr_header
*ext_acl
= buffer
;
843 struct posix_acl_xattr_entry
*ext_entry
;
846 real_size
= posix_acl_xattr_size(acl
->a_count
);
849 if (real_size
> size
)
852 ext_entry
= (void *)(ext_acl
+ 1);
853 ext_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
855 for (n
=0; n
< acl
->a_count
; n
++, ext_entry
++) {
856 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
857 ext_entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
858 ext_entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
859 switch(acl_e
->e_tag
) {
862 cpu_to_le32(from_kuid(user_ns
, acl_e
->e_uid
));
866 cpu_to_le32(from_kgid(user_ns
, acl_e
->e_gid
));
869 ext_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
875 EXPORT_SYMBOL (posix_acl_to_xattr
);
878 posix_acl_xattr_get(const struct xattr_handler
*handler
,
879 struct dentry
*unused
, struct inode
*inode
,
880 const char *name
, void *value
, size_t size
)
882 struct posix_acl
*acl
;
885 if (!IS_POSIXACL(inode
))
887 if (S_ISLNK(inode
->i_mode
))
890 acl
= get_acl(inode
, handler
->flags
);
896 error
= posix_acl_to_xattr(&init_user_ns
, acl
, value
, size
);
897 posix_acl_release(acl
);
903 set_posix_acl(struct user_namespace
*mnt_userns
, struct inode
*inode
,
904 int type
, struct posix_acl
*acl
)
906 if (!IS_POSIXACL(inode
))
908 if (!inode
->i_op
->set_acl
)
911 if (type
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
))
912 return acl
? -EACCES
: 0;
913 if (!inode_owner_or_capable(mnt_userns
, inode
))
917 int ret
= posix_acl_valid(inode
->i_sb
->s_user_ns
, acl
);
921 return inode
->i_op
->set_acl(mnt_userns
, inode
, acl
, type
);
923 EXPORT_SYMBOL(set_posix_acl
);
926 posix_acl_xattr_set(const struct xattr_handler
*handler
,
927 struct user_namespace
*mnt_userns
,
928 struct dentry
*unused
, struct inode
*inode
,
929 const char *name
, const void *value
, size_t size
,
932 struct posix_acl
*acl
= NULL
;
936 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
940 ret
= set_posix_acl(mnt_userns
, inode
, handler
->flags
, acl
);
941 posix_acl_release(acl
);
946 posix_acl_xattr_list(struct dentry
*dentry
)
948 return IS_POSIXACL(d_backing_inode(dentry
));
951 const struct xattr_handler posix_acl_access_xattr_handler
= {
952 .name
= XATTR_NAME_POSIX_ACL_ACCESS
,
953 .flags
= ACL_TYPE_ACCESS
,
954 .list
= posix_acl_xattr_list
,
955 .get
= posix_acl_xattr_get
,
956 .set
= posix_acl_xattr_set
,
958 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler
);
960 const struct xattr_handler posix_acl_default_xattr_handler
= {
961 .name
= XATTR_NAME_POSIX_ACL_DEFAULT
,
962 .flags
= ACL_TYPE_DEFAULT
,
963 .list
= posix_acl_xattr_list
,
964 .get
= posix_acl_xattr_get
,
965 .set
= posix_acl_xattr_set
,
967 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler
);
969 int simple_set_acl(struct user_namespace
*mnt_userns
, struct inode
*inode
,
970 struct posix_acl
*acl
, int type
)
974 if (type
== ACL_TYPE_ACCESS
) {
975 error
= posix_acl_update_mode(mnt_userns
, inode
,
976 &inode
->i_mode
, &acl
);
981 inode
->i_ctime
= current_time(inode
);
982 set_cached_acl(inode
, type
, acl
);
986 int simple_acl_create(struct inode
*dir
, struct inode
*inode
)
988 struct posix_acl
*default_acl
, *acl
;
991 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
995 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
);
996 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
999 posix_acl_release(default_acl
);
1001 posix_acl_release(acl
);