2 * Copyright (C) 2002,2003 by Andreas Gruenbacher <a.gruenbacher@computer.org>
4 * Fixes from William Schumacher incorporated on 15 March 2001.
5 * (Reported by Charles Bertsch, <CBertsch@microtest.com>).
9 * This file contains generic functions for manipulating
10 * POSIX 1003.1e draft standard 17 ACLs.
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/atomic.h>
17 #include <linux/sched.h>
18 #include <linux/posix_acl.h>
19 #include <linux/posix_acl_xattr.h>
20 #include <linux/xattr.h>
21 #include <linux/export.h>
22 #include <linux/user_namespace.h>
24 struct posix_acl
**acl_by_type(struct inode
*inode
, int type
)
29 case ACL_TYPE_DEFAULT
:
30 return &inode
->i_default_acl
;
35 EXPORT_SYMBOL(acl_by_type
);
37 struct posix_acl
*get_cached_acl(struct inode
*inode
, int type
)
39 struct posix_acl
**p
= acl_by_type(inode
, type
);
40 struct posix_acl
*acl
= ACCESS_ONCE(*p
);
42 spin_lock(&inode
->i_lock
);
44 if (acl
!= ACL_NOT_CACHED
)
45 acl
= posix_acl_dup(acl
);
46 spin_unlock(&inode
->i_lock
);
50 EXPORT_SYMBOL(get_cached_acl
);
52 struct posix_acl
*get_cached_acl_rcu(struct inode
*inode
, int type
)
54 return rcu_dereference(*acl_by_type(inode
, type
));
56 EXPORT_SYMBOL(get_cached_acl_rcu
);
58 void set_cached_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
60 struct posix_acl
**p
= acl_by_type(inode
, type
);
61 struct posix_acl
*old
;
62 spin_lock(&inode
->i_lock
);
64 rcu_assign_pointer(*p
, posix_acl_dup(acl
));
65 spin_unlock(&inode
->i_lock
);
66 if (old
!= ACL_NOT_CACHED
)
67 posix_acl_release(old
);
69 EXPORT_SYMBOL(set_cached_acl
);
71 void forget_cached_acl(struct inode
*inode
, int type
)
73 struct posix_acl
**p
= acl_by_type(inode
, type
);
74 struct posix_acl
*old
;
75 spin_lock(&inode
->i_lock
);
78 spin_unlock(&inode
->i_lock
);
79 if (old
!= ACL_NOT_CACHED
)
80 posix_acl_release(old
);
82 EXPORT_SYMBOL(forget_cached_acl
);
84 void forget_all_cached_acls(struct inode
*inode
)
86 struct posix_acl
*old_access
, *old_default
;
87 spin_lock(&inode
->i_lock
);
88 old_access
= inode
->i_acl
;
89 old_default
= inode
->i_default_acl
;
90 inode
->i_acl
= inode
->i_default_acl
= ACL_NOT_CACHED
;
91 spin_unlock(&inode
->i_lock
);
92 if (old_access
!= ACL_NOT_CACHED
)
93 posix_acl_release(old_access
);
94 if (old_default
!= ACL_NOT_CACHED
)
95 posix_acl_release(old_default
);
97 EXPORT_SYMBOL(forget_all_cached_acls
);
99 struct posix_acl
*get_acl(struct inode
*inode
, int type
)
101 struct posix_acl
*acl
;
103 acl
= get_cached_acl(inode
, type
);
104 if (acl
!= ACL_NOT_CACHED
)
107 if (!IS_POSIXACL(inode
))
111 * A filesystem can force a ACL callback by just never filling the
112 * ACL cache. But normally you'd fill the cache either at inode
113 * instantiation time, or on the first ->get_acl call.
115 * If the filesystem doesn't have a get_acl() function at all, we'll
116 * just create the negative cache entry.
118 if (!inode
->i_op
->get_acl
) {
119 set_cached_acl(inode
, type
, NULL
);
122 return inode
->i_op
->get_acl(inode
, type
);
124 EXPORT_SYMBOL(get_acl
);
127 * Init a fresh posix_acl
130 posix_acl_init(struct posix_acl
*acl
, int count
)
132 atomic_set(&acl
->a_refcount
, 1);
133 acl
->a_count
= count
;
135 EXPORT_SYMBOL(posix_acl_init
);
138 * Allocate a new ACL with the specified number of entries.
141 posix_acl_alloc(int count
, gfp_t flags
)
143 const size_t size
= sizeof(struct posix_acl
) +
144 count
* sizeof(struct posix_acl_entry
);
145 struct posix_acl
*acl
= kmalloc(size
, flags
);
147 posix_acl_init(acl
, count
);
150 EXPORT_SYMBOL(posix_acl_alloc
);
155 static struct posix_acl
*
156 posix_acl_clone(const struct posix_acl
*acl
, gfp_t flags
)
158 struct posix_acl
*clone
= NULL
;
161 int size
= sizeof(struct posix_acl
) + acl
->a_count
*
162 sizeof(struct posix_acl_entry
);
163 clone
= kmemdup(acl
, size
, flags
);
165 atomic_set(&clone
->a_refcount
, 1);
171 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
174 posix_acl_valid(const struct posix_acl
*acl
)
176 const struct posix_acl_entry
*pa
, *pe
;
177 int state
= ACL_USER_OBJ
;
180 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
181 if (pa
->e_perm
& ~(ACL_READ
|ACL_WRITE
|ACL_EXECUTE
))
185 if (state
== ACL_USER_OBJ
) {
192 if (state
!= ACL_USER
)
194 if (!uid_valid(pa
->e_uid
))
200 if (state
== ACL_USER
) {
207 if (state
!= ACL_GROUP
)
209 if (!gid_valid(pa
->e_gid
))
215 if (state
!= ACL_GROUP
)
221 if (state
== ACL_OTHER
||
222 (state
== ACL_GROUP
&& !needs_mask
)) {
236 EXPORT_SYMBOL(posix_acl_valid
);
239 * Returns 0 if the acl can be exactly represented in the traditional
240 * file mode permission bits, or else 1. Returns -E... on error.
243 posix_acl_equiv_mode(const struct posix_acl
*acl
, umode_t
*mode_p
)
245 const struct posix_acl_entry
*pa
, *pe
;
249 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
252 mode
|= (pa
->e_perm
& S_IRWXO
) << 6;
255 mode
|= (pa
->e_perm
& S_IRWXO
) << 3;
258 mode
|= pa
->e_perm
& S_IRWXO
;
261 mode
= (mode
& ~S_IRWXG
) |
262 ((pa
->e_perm
& S_IRWXO
) << 3);
274 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
277 EXPORT_SYMBOL(posix_acl_equiv_mode
);
280 * Create an ACL representing the file mode permission bits of an inode.
283 posix_acl_from_mode(umode_t mode
, gfp_t flags
)
285 struct posix_acl
*acl
= posix_acl_alloc(3, flags
);
287 return ERR_PTR(-ENOMEM
);
289 acl
->a_entries
[0].e_tag
= ACL_USER_OBJ
;
290 acl
->a_entries
[0].e_perm
= (mode
& S_IRWXU
) >> 6;
292 acl
->a_entries
[1].e_tag
= ACL_GROUP_OBJ
;
293 acl
->a_entries
[1].e_perm
= (mode
& S_IRWXG
) >> 3;
295 acl
->a_entries
[2].e_tag
= ACL_OTHER
;
296 acl
->a_entries
[2].e_perm
= (mode
& S_IRWXO
);
299 EXPORT_SYMBOL(posix_acl_from_mode
);
302 * Return 0 if current is granted want access to the inode
303 * by the acl. Returns -E... otherwise.
306 posix_acl_permission(struct inode
*inode
, const struct posix_acl
*acl
, int want
)
308 const struct posix_acl_entry
*pa
, *pe
, *mask_obj
;
311 want
&= MAY_READ
| MAY_WRITE
| MAY_EXEC
| MAY_NOT_BLOCK
;
313 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
316 /* (May have been checked already) */
317 if (uid_eq(inode
->i_uid
, current_fsuid()))
321 if (uid_eq(pa
->e_uid
, current_fsuid()))
325 if (in_group_p(inode
->i_gid
)) {
327 if ((pa
->e_perm
& want
) == want
)
332 if (in_group_p(pa
->e_gid
)) {
334 if ((pa
->e_perm
& want
) == want
)
352 for (mask_obj
= pa
+1; mask_obj
!= pe
; mask_obj
++) {
353 if (mask_obj
->e_tag
== ACL_MASK
) {
354 if ((pa
->e_perm
& mask_obj
->e_perm
& want
) == want
)
361 if ((pa
->e_perm
& want
) == want
)
367 * Modify acl when creating a new inode. The caller must ensure the acl is
368 * only referenced once.
370 * mode_p initially must contain the mode parameter to the open() / creat()
371 * system calls. All permissions that are not granted by the acl are removed.
372 * The permissions in the acl are changed to reflect the mode_p parameter.
374 static int posix_acl_create_masq(struct posix_acl
*acl
, umode_t
*mode_p
)
376 struct posix_acl_entry
*pa
, *pe
;
377 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
378 umode_t mode
= *mode_p
;
381 /* assert(atomic_read(acl->a_refcount) == 1); */
383 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
386 pa
->e_perm
&= (mode
>> 6) | ~S_IRWXO
;
387 mode
&= (pa
->e_perm
<< 6) | ~S_IRWXU
;
400 pa
->e_perm
&= mode
| ~S_IRWXO
;
401 mode
&= pa
->e_perm
| ~S_IRWXO
;
415 mask_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
416 mode
&= (mask_obj
->e_perm
<< 3) | ~S_IRWXG
;
420 group_obj
->e_perm
&= (mode
>> 3) | ~S_IRWXO
;
421 mode
&= (group_obj
->e_perm
<< 3) | ~S_IRWXG
;
424 *mode_p
= (*mode_p
& ~S_IRWXUGO
) | mode
;
429 * Modify the ACL for the chmod syscall.
431 static int __posix_acl_chmod_masq(struct posix_acl
*acl
, umode_t mode
)
433 struct posix_acl_entry
*group_obj
= NULL
, *mask_obj
= NULL
;
434 struct posix_acl_entry
*pa
, *pe
;
436 /* assert(atomic_read(acl->a_refcount) == 1); */
438 FOREACH_ACL_ENTRY(pa
, acl
, pe
) {
441 pa
->e_perm
= (mode
& S_IRWXU
) >> 6;
457 pa
->e_perm
= (mode
& S_IRWXO
);
466 mask_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
470 group_obj
->e_perm
= (mode
& S_IRWXG
) >> 3;
477 __posix_acl_create(struct posix_acl
**acl
, gfp_t gfp
, umode_t
*mode_p
)
479 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
482 err
= posix_acl_create_masq(clone
, mode_p
);
484 posix_acl_release(clone
);
488 posix_acl_release(*acl
);
492 EXPORT_SYMBOL(__posix_acl_create
);
495 __posix_acl_chmod(struct posix_acl
**acl
, gfp_t gfp
, umode_t mode
)
497 struct posix_acl
*clone
= posix_acl_clone(*acl
, gfp
);
500 err
= __posix_acl_chmod_masq(clone
, mode
);
502 posix_acl_release(clone
);
506 posix_acl_release(*acl
);
510 EXPORT_SYMBOL(__posix_acl_chmod
);
513 posix_acl_chmod(struct inode
*inode
, umode_t mode
)
515 struct posix_acl
*acl
;
518 if (!IS_POSIXACL(inode
))
520 if (!inode
->i_op
->set_acl
)
523 acl
= get_acl(inode
, ACL_TYPE_ACCESS
);
524 if (IS_ERR_OR_NULL(acl
))
527 ret
= __posix_acl_chmod(&acl
, GFP_KERNEL
, mode
);
530 ret
= inode
->i_op
->set_acl(inode
, acl
, ACL_TYPE_ACCESS
);
531 posix_acl_release(acl
);
534 EXPORT_SYMBOL(posix_acl_chmod
);
537 posix_acl_create(struct inode
*dir
, umode_t
*mode
,
538 struct posix_acl
**default_acl
, struct posix_acl
**acl
)
543 if (S_ISLNK(*mode
) || !IS_POSIXACL(dir
))
546 p
= get_acl(dir
, ACL_TYPE_DEFAULT
);
551 *mode
&= ~current_umask();
555 *acl
= posix_acl_clone(p
, GFP_NOFS
);
559 ret
= posix_acl_create_masq(*acl
, mode
);
561 posix_acl_release(*acl
);
566 posix_acl_release(*acl
);
570 if (!S_ISDIR(*mode
)) {
571 posix_acl_release(p
);
583 EXPORT_SYMBOL_GPL(posix_acl_create
);
586 * Fix up the uids and gids in posix acl extended attributes in place.
588 static void posix_acl_fix_xattr_userns(
589 struct user_namespace
*to
, struct user_namespace
*from
,
590 void *value
, size_t size
)
592 posix_acl_xattr_header
*header
= (posix_acl_xattr_header
*)value
;
593 posix_acl_xattr_entry
*entry
= (posix_acl_xattr_entry
*)(header
+1), *end
;
600 if (size
< sizeof(posix_acl_xattr_header
))
602 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
605 count
= posix_acl_xattr_count(size
);
611 for (end
= entry
+ count
; entry
!= end
; entry
++) {
612 switch(le16_to_cpu(entry
->e_tag
)) {
614 uid
= make_kuid(from
, le32_to_cpu(entry
->e_id
));
615 entry
->e_id
= cpu_to_le32(from_kuid(to
, uid
));
618 gid
= make_kgid(from
, le32_to_cpu(entry
->e_id
));
619 entry
->e_id
= cpu_to_le32(from_kgid(to
, gid
));
627 void posix_acl_fix_xattr_from_user(void *value
, size_t size
)
629 struct user_namespace
*user_ns
= current_user_ns();
630 if (user_ns
== &init_user_ns
)
632 posix_acl_fix_xattr_userns(&init_user_ns
, user_ns
, value
, size
);
635 void posix_acl_fix_xattr_to_user(void *value
, size_t size
)
637 struct user_namespace
*user_ns
= current_user_ns();
638 if (user_ns
== &init_user_ns
)
640 posix_acl_fix_xattr_userns(user_ns
, &init_user_ns
, value
, size
);
644 * Convert from extended attribute to in-memory representation.
647 posix_acl_from_xattr(struct user_namespace
*user_ns
,
648 const void *value
, size_t size
)
650 posix_acl_xattr_header
*header
= (posix_acl_xattr_header
*)value
;
651 posix_acl_xattr_entry
*entry
= (posix_acl_xattr_entry
*)(header
+1), *end
;
653 struct posix_acl
*acl
;
654 struct posix_acl_entry
*acl_e
;
658 if (size
< sizeof(posix_acl_xattr_header
))
659 return ERR_PTR(-EINVAL
);
660 if (header
->a_version
!= cpu_to_le32(POSIX_ACL_XATTR_VERSION
))
661 return ERR_PTR(-EOPNOTSUPP
);
663 count
= posix_acl_xattr_count(size
);
665 return ERR_PTR(-EINVAL
);
669 acl
= posix_acl_alloc(count
, GFP_NOFS
);
671 return ERR_PTR(-ENOMEM
);
672 acl_e
= acl
->a_entries
;
674 for (end
= entry
+ count
; entry
!= end
; acl_e
++, entry
++) {
675 acl_e
->e_tag
= le16_to_cpu(entry
->e_tag
);
676 acl_e
->e_perm
= le16_to_cpu(entry
->e_perm
);
678 switch(acl_e
->e_tag
) {
688 le32_to_cpu(entry
->e_id
));
689 if (!uid_valid(acl_e
->e_uid
))
695 le32_to_cpu(entry
->e_id
));
696 if (!gid_valid(acl_e
->e_gid
))
707 posix_acl_release(acl
);
708 return ERR_PTR(-EINVAL
);
710 EXPORT_SYMBOL (posix_acl_from_xattr
);
713 * Convert from in-memory to extended attribute representation.
716 posix_acl_to_xattr(struct user_namespace
*user_ns
, const struct posix_acl
*acl
,
717 void *buffer
, size_t size
)
719 posix_acl_xattr_header
*ext_acl
= (posix_acl_xattr_header
*)buffer
;
720 posix_acl_xattr_entry
*ext_entry
= ext_acl
->a_entries
;
723 real_size
= posix_acl_xattr_size(acl
->a_count
);
726 if (real_size
> size
)
729 ext_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
731 for (n
=0; n
< acl
->a_count
; n
++, ext_entry
++) {
732 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
733 ext_entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
734 ext_entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
735 switch(acl_e
->e_tag
) {
738 cpu_to_le32(from_kuid(user_ns
, acl_e
->e_uid
));
742 cpu_to_le32(from_kgid(user_ns
, acl_e
->e_gid
));
745 ext_entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
751 EXPORT_SYMBOL (posix_acl_to_xattr
);
754 posix_acl_xattr_get(struct dentry
*dentry
, const char *name
,
755 void *value
, size_t size
, int type
)
757 struct posix_acl
*acl
;
760 if (!IS_POSIXACL(dentry
->d_inode
))
762 if (S_ISLNK(dentry
->d_inode
->i_mode
))
765 acl
= get_acl(dentry
->d_inode
, type
);
771 error
= posix_acl_to_xattr(&init_user_ns
, acl
, value
, size
);
772 posix_acl_release(acl
);
778 posix_acl_xattr_set(struct dentry
*dentry
, const char *name
,
779 const void *value
, size_t size
, int flags
, int type
)
781 struct inode
*inode
= dentry
->d_inode
;
782 struct posix_acl
*acl
= NULL
;
785 if (!IS_POSIXACL(inode
))
787 if (!inode
->i_op
->set_acl
)
790 if (type
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
))
791 return value
? -EACCES
: 0;
792 if (!inode_owner_or_capable(inode
))
796 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
801 ret
= posix_acl_valid(acl
);
807 ret
= inode
->i_op
->set_acl(inode
, acl
, type
);
809 posix_acl_release(acl
);
814 posix_acl_xattr_list(struct dentry
*dentry
, char *list
, size_t list_size
,
815 const char *name
, size_t name_len
, int type
)
820 if (!IS_POSIXACL(dentry
->d_inode
))
822 if (S_ISLNK(dentry
->d_inode
->i_mode
))
825 if (type
== ACL_TYPE_ACCESS
)
826 xname
= POSIX_ACL_XATTR_ACCESS
;
828 xname
= POSIX_ACL_XATTR_DEFAULT
;
830 size
= strlen(xname
) + 1;
831 if (list
&& size
<= list_size
)
832 memcpy(list
, xname
, size
);
836 const struct xattr_handler posix_acl_access_xattr_handler
= {
837 .prefix
= POSIX_ACL_XATTR_ACCESS
,
838 .flags
= ACL_TYPE_ACCESS
,
839 .list
= posix_acl_xattr_list
,
840 .get
= posix_acl_xattr_get
,
841 .set
= posix_acl_xattr_set
,
843 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler
);
845 const struct xattr_handler posix_acl_default_xattr_handler
= {
846 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
847 .flags
= ACL_TYPE_DEFAULT
,
848 .list
= posix_acl_xattr_list
,
849 .get
= posix_acl_xattr_get
,
850 .set
= posix_acl_xattr_set
,
852 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler
);
854 int simple_set_acl(struct inode
*inode
, struct posix_acl
*acl
, int type
)
858 if (type
== ACL_TYPE_ACCESS
) {
859 error
= posix_acl_equiv_mode(acl
, &inode
->i_mode
);
866 inode
->i_ctime
= CURRENT_TIME
;
867 set_cached_acl(inode
, type
, acl
);
871 int simple_acl_create(struct inode
*dir
, struct inode
*inode
)
873 struct posix_acl
*default_acl
, *acl
;
876 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
880 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
);
881 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
884 posix_acl_release(default_acl
);
886 posix_acl_release(acl
);