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 static struct posix_acl **acl_by_type(struct inode *inode, int type)
29 case ACL_TYPE_DEFAULT:
30 return &inode->i_default_acl;
36 struct posix_acl *get_cached_acl(struct inode *inode, int type)
38 struct posix_acl **p = acl_by_type(inode, type);
39 struct posix_acl *acl;
43 acl = rcu_dereference(*p);
44 if (!acl || is_uncached_acl(acl) ||
45 atomic_inc_not_zero(&acl->a_refcount))
53 EXPORT_SYMBOL(get_cached_acl);
55 struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
57 return rcu_dereference(*acl_by_type(inode, type));
59 EXPORT_SYMBOL(get_cached_acl_rcu);
61 void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl)
63 struct posix_acl **p = acl_by_type(inode, type);
64 struct posix_acl *old;
66 old = xchg(p, posix_acl_dup(acl));
67 if (!is_uncached_acl(old))
68 posix_acl_release(old);
70 EXPORT_SYMBOL(set_cached_acl);
72 static void __forget_cached_acl(struct posix_acl **p)
74 struct posix_acl *old;
76 old = xchg(p, ACL_NOT_CACHED);
77 if (!is_uncached_acl(old))
78 posix_acl_release(old);
81 void forget_cached_acl(struct inode *inode, int type)
83 __forget_cached_acl(acl_by_type(inode, type));
85 EXPORT_SYMBOL(forget_cached_acl);
87 void forget_all_cached_acls(struct inode *inode)
89 __forget_cached_acl(&inode->i_acl);
90 __forget_cached_acl(&inode->i_default_acl);
92 EXPORT_SYMBOL(forget_all_cached_acls);
94 struct posix_acl *get_acl(struct inode *inode, int type)
98 struct posix_acl *acl;
101 * The sentinel is used to detect when another operation like
102 * set_cached_acl() or forget_cached_acl() races with get_acl().
103 * It is guaranteed that is_uncached_acl(sentinel) is true.
106 acl = get_cached_acl(inode, type);
107 if (!is_uncached_acl(acl))
110 if (!IS_POSIXACL(inode))
113 sentinel = uncached_acl_sentinel(current);
114 p = acl_by_type(inode, type);
117 * If the ACL isn't being read yet, set our sentinel. Otherwise, the
118 * current value of the ACL will not be ACL_NOT_CACHED and so our own
119 * sentinel will not be set; another task will update the cache. We
120 * could wait for that other task to complete its job, but it's easier
121 * to just call ->get_acl to fetch the ACL ourself. (This is going to
122 * be an unlikely race.)
124 if (cmpxchg(p, ACL_NOT_CACHED, sentinel) != ACL_NOT_CACHED)
128 * Normally, the ACL returned by ->get_acl will be cached.
129 * A filesystem can prevent that by calling
130 * forget_cached_acl(inode, type) in ->get_acl.
132 * If the filesystem doesn't have a get_acl() function at all, we'll
133 * just create the negative cache entry.
135 if (!inode->i_op->get_acl) {
136 set_cached_acl(inode, type, NULL);
139 acl = inode->i_op->get_acl(inode, type);
143 * Remove our sentinel so that we don't block future attempts
146 cmpxchg(p, sentinel, ACL_NOT_CACHED);
151 * Cache the result, but only if our sentinel is still in place.
154 if (unlikely(cmpxchg(p, sentinel, acl) != sentinel))
155 posix_acl_release(acl);
158 EXPORT_SYMBOL(get_acl);
161 * Init a fresh posix_acl
164 posix_acl_init(struct posix_acl *acl, int count)
166 atomic_set(&acl->a_refcount, 1);
167 acl->a_count = count;
169 EXPORT_SYMBOL(posix_acl_init);
172 * Allocate a new ACL with the specified number of entries.
175 posix_acl_alloc(int count, gfp_t flags)
177 const size_t size = sizeof(struct posix_acl) +
178 count * sizeof(struct posix_acl_entry);
179 struct posix_acl *acl = kmalloc(size, flags);
181 posix_acl_init(acl, count);
184 EXPORT_SYMBOL(posix_acl_alloc);
189 static struct posix_acl *
190 posix_acl_clone(const struct posix_acl *acl, gfp_t flags)
192 struct posix_acl *clone = NULL;
195 int size = sizeof(struct posix_acl) + acl->a_count *
196 sizeof(struct posix_acl_entry);
197 clone = kmemdup(acl, size, flags);
199 atomic_set(&clone->a_refcount, 1);
205 * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
208 posix_acl_valid(struct user_namespace *user_ns, const struct posix_acl *acl)
210 const struct posix_acl_entry *pa, *pe;
211 int state = ACL_USER_OBJ;
214 FOREACH_ACL_ENTRY(pa, acl, pe) {
215 if (pa->e_perm & ~(ACL_READ|ACL_WRITE|ACL_EXECUTE))
219 if (state == ACL_USER_OBJ) {
226 if (state != ACL_USER)
228 if (!kuid_has_mapping(user_ns, pa->e_uid))
234 if (state == ACL_USER) {
241 if (state != ACL_GROUP)
243 if (!kgid_has_mapping(user_ns, pa->e_gid))
249 if (state != ACL_GROUP)
255 if (state == ACL_OTHER ||
256 (state == ACL_GROUP && !needs_mask)) {
270 EXPORT_SYMBOL(posix_acl_valid);
273 * Returns 0 if the acl can be exactly represented in the traditional
274 * file mode permission bits, or else 1. Returns -E... on error.
277 posix_acl_equiv_mode(const struct posix_acl *acl, umode_t *mode_p)
279 const struct posix_acl_entry *pa, *pe;
284 * A null ACL can always be presented as mode bits.
289 FOREACH_ACL_ENTRY(pa, acl, pe) {
292 mode |= (pa->e_perm & S_IRWXO) << 6;
295 mode |= (pa->e_perm & S_IRWXO) << 3;
298 mode |= pa->e_perm & S_IRWXO;
301 mode = (mode & ~S_IRWXG) |
302 ((pa->e_perm & S_IRWXO) << 3);
314 *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
317 EXPORT_SYMBOL(posix_acl_equiv_mode);
320 * Create an ACL representing the file mode permission bits of an inode.
323 posix_acl_from_mode(umode_t mode, gfp_t flags)
325 struct posix_acl *acl = posix_acl_alloc(3, flags);
327 return ERR_PTR(-ENOMEM);
329 acl->a_entries[0].e_tag = ACL_USER_OBJ;
330 acl->a_entries[0].e_perm = (mode & S_IRWXU) >> 6;
332 acl->a_entries[1].e_tag = ACL_GROUP_OBJ;
333 acl->a_entries[1].e_perm = (mode & S_IRWXG) >> 3;
335 acl->a_entries[2].e_tag = ACL_OTHER;
336 acl->a_entries[2].e_perm = (mode & S_IRWXO);
339 EXPORT_SYMBOL(posix_acl_from_mode);
342 * Return 0 if current is granted want access to the inode
343 * by the acl. Returns -E... otherwise.
346 posix_acl_permission(struct inode *inode, const struct posix_acl *acl, int want)
348 const struct posix_acl_entry *pa, *pe, *mask_obj;
351 want &= MAY_READ | MAY_WRITE | MAY_EXEC | MAY_NOT_BLOCK;
353 FOREACH_ACL_ENTRY(pa, acl, pe) {
356 /* (May have been checked already) */
357 if (uid_eq(inode->i_uid, current_fsuid()))
361 if (uid_eq(pa->e_uid, current_fsuid()))
365 if (in_group_p(inode->i_gid)) {
367 if ((pa->e_perm & want) == want)
372 if (in_group_p(pa->e_gid)) {
374 if ((pa->e_perm & want) == want)
392 for (mask_obj = pa+1; mask_obj != pe; mask_obj++) {
393 if (mask_obj->e_tag == ACL_MASK) {
394 if ((pa->e_perm & mask_obj->e_perm & want) == want)
401 if ((pa->e_perm & want) == want)
407 * Modify acl when creating a new inode. The caller must ensure the acl is
408 * only referenced once.
410 * mode_p initially must contain the mode parameter to the open() / creat()
411 * system calls. All permissions that are not granted by the acl are removed.
412 * The permissions in the acl are changed to reflect the mode_p parameter.
414 static int posix_acl_create_masq(struct posix_acl *acl, umode_t *mode_p)
416 struct posix_acl_entry *pa, *pe;
417 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
418 umode_t mode = *mode_p;
421 /* assert(atomic_read(acl->a_refcount) == 1); */
423 FOREACH_ACL_ENTRY(pa, acl, pe) {
426 pa->e_perm &= (mode >> 6) | ~S_IRWXO;
427 mode &= (pa->e_perm << 6) | ~S_IRWXU;
440 pa->e_perm &= mode | ~S_IRWXO;
441 mode &= pa->e_perm | ~S_IRWXO;
455 mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
456 mode &= (mask_obj->e_perm << 3) | ~S_IRWXG;
460 group_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
461 mode &= (group_obj->e_perm << 3) | ~S_IRWXG;
464 *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
469 * Modify the ACL for the chmod syscall.
471 static int __posix_acl_chmod_masq(struct posix_acl *acl, umode_t mode)
473 struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
474 struct posix_acl_entry *pa, *pe;
476 /* assert(atomic_read(acl->a_refcount) == 1); */
478 FOREACH_ACL_ENTRY(pa, acl, pe) {
481 pa->e_perm = (mode & S_IRWXU) >> 6;
497 pa->e_perm = (mode & S_IRWXO);
506 mask_obj->e_perm = (mode & S_IRWXG) >> 3;
510 group_obj->e_perm = (mode & S_IRWXG) >> 3;
517 __posix_acl_create(struct posix_acl **acl, gfp_t gfp, umode_t *mode_p)
519 struct posix_acl *clone = posix_acl_clone(*acl, gfp);
522 err = posix_acl_create_masq(clone, mode_p);
524 posix_acl_release(clone);
528 posix_acl_release(*acl);
532 EXPORT_SYMBOL(__posix_acl_create);
535 __posix_acl_chmod(struct posix_acl **acl, gfp_t gfp, umode_t mode)
537 struct posix_acl *clone = posix_acl_clone(*acl, gfp);
540 err = __posix_acl_chmod_masq(clone, mode);
542 posix_acl_release(clone);
546 posix_acl_release(*acl);
550 EXPORT_SYMBOL(__posix_acl_chmod);
553 posix_acl_chmod(struct inode *inode, umode_t mode)
555 struct posix_acl *acl;
558 if (!IS_POSIXACL(inode))
560 if (!inode->i_op->set_acl)
563 acl = get_acl(inode, ACL_TYPE_ACCESS);
564 if (IS_ERR_OR_NULL(acl)) {
565 if (acl == ERR_PTR(-EOPNOTSUPP))
570 ret = __posix_acl_chmod(&acl, GFP_KERNEL, mode);
573 ret = inode->i_op->set_acl(inode, acl, ACL_TYPE_ACCESS);
574 posix_acl_release(acl);
577 EXPORT_SYMBOL(posix_acl_chmod);
580 posix_acl_create(struct inode *dir, umode_t *mode,
581 struct posix_acl **default_acl, struct posix_acl **acl)
584 struct posix_acl *clone;
590 if (S_ISLNK(*mode) || !IS_POSIXACL(dir))
593 p = get_acl(dir, ACL_TYPE_DEFAULT);
594 if (!p || p == ERR_PTR(-EOPNOTSUPP)) {
595 *mode &= ~current_umask();
602 clone = posix_acl_clone(p, GFP_NOFS);
606 ret = posix_acl_create_masq(clone, mode);
608 goto err_release_clone;
611 posix_acl_release(clone);
616 posix_acl_release(p);
623 posix_acl_release(clone);
625 posix_acl_release(p);
628 EXPORT_SYMBOL_GPL(posix_acl_create);
631 * Fix up the uids and gids in posix acl extended attributes in place.
633 static void posix_acl_fix_xattr_userns(
634 struct user_namespace *to, struct user_namespace *from,
635 void *value, size_t size)
637 posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
638 posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
645 if (size < sizeof(posix_acl_xattr_header))
647 if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
650 count = posix_acl_xattr_count(size);
656 for (end = entry + count; entry != end; entry++) {
657 switch(le16_to_cpu(entry->e_tag)) {
659 uid = make_kuid(from, le32_to_cpu(entry->e_id));
660 entry->e_id = cpu_to_le32(from_kuid(to, uid));
663 gid = make_kgid(from, le32_to_cpu(entry->e_id));
664 entry->e_id = cpu_to_le32(from_kgid(to, gid));
672 void posix_acl_fix_xattr_from_user(void *value, size_t size)
674 struct user_namespace *user_ns = current_user_ns();
675 if (user_ns == &init_user_ns)
677 posix_acl_fix_xattr_userns(&init_user_ns, user_ns, value, size);
680 void posix_acl_fix_xattr_to_user(void *value, size_t size)
682 struct user_namespace *user_ns = current_user_ns();
683 if (user_ns == &init_user_ns)
685 posix_acl_fix_xattr_userns(user_ns, &init_user_ns, value, size);
689 * Convert from extended attribute to in-memory representation.
692 posix_acl_from_xattr(struct user_namespace *user_ns,
693 const void *value, size_t size)
695 posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
696 posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
698 struct posix_acl *acl;
699 struct posix_acl_entry *acl_e;
703 if (size < sizeof(posix_acl_xattr_header))
704 return ERR_PTR(-EINVAL);
705 if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
706 return ERR_PTR(-EOPNOTSUPP);
708 count = posix_acl_xattr_count(size);
710 return ERR_PTR(-EINVAL);
714 acl = posix_acl_alloc(count, GFP_NOFS);
716 return ERR_PTR(-ENOMEM);
717 acl_e = acl->a_entries;
719 for (end = entry + count; entry != end; acl_e++, entry++) {
720 acl_e->e_tag = le16_to_cpu(entry->e_tag);
721 acl_e->e_perm = le16_to_cpu(entry->e_perm);
723 switch(acl_e->e_tag) {
733 le32_to_cpu(entry->e_id));
734 if (!uid_valid(acl_e->e_uid))
740 le32_to_cpu(entry->e_id));
741 if (!gid_valid(acl_e->e_gid))
752 posix_acl_release(acl);
753 return ERR_PTR(-EINVAL);
755 EXPORT_SYMBOL (posix_acl_from_xattr);
758 * Convert from in-memory to extended attribute representation.
761 posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,
762 void *buffer, size_t size)
764 posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;
765 posix_acl_xattr_entry *ext_entry;
768 real_size = posix_acl_xattr_size(acl->a_count);
771 if (real_size > size)
774 ext_entry = ext_acl->a_entries;
775 ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
777 for (n=0; n < acl->a_count; n++, ext_entry++) {
778 const struct posix_acl_entry *acl_e = &acl->a_entries[n];
779 ext_entry->e_tag = cpu_to_le16(acl_e->e_tag);
780 ext_entry->e_perm = cpu_to_le16(acl_e->e_perm);
781 switch(acl_e->e_tag) {
784 cpu_to_le32(from_kuid(user_ns, acl_e->e_uid));
788 cpu_to_le32(from_kgid(user_ns, acl_e->e_gid));
791 ext_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
797 EXPORT_SYMBOL (posix_acl_to_xattr);
800 posix_acl_xattr_get(const struct xattr_handler *handler,
801 struct dentry *unused, struct inode *inode,
802 const char *name, void *value, size_t size)
804 struct posix_acl *acl;
807 if (!IS_POSIXACL(inode))
809 if (S_ISLNK(inode->i_mode))
812 acl = get_acl(inode, handler->flags);
818 error = posix_acl_to_xattr(&init_user_ns, acl, value, size);
819 posix_acl_release(acl);
825 set_posix_acl(struct inode *inode, int type, struct posix_acl *acl)
827 if (!IS_POSIXACL(inode))
829 if (!inode->i_op->set_acl)
832 if (type == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode))
833 return acl ? -EACCES : 0;
834 if (!inode_owner_or_capable(inode))
838 int ret = posix_acl_valid(inode->i_sb->s_user_ns, acl);
842 return inode->i_op->set_acl(inode, acl, type);
844 EXPORT_SYMBOL(set_posix_acl);
847 posix_acl_xattr_set(const struct xattr_handler *handler,
848 struct dentry *unused, struct inode *inode,
849 const char *name, const void *value,
850 size_t size, int flags)
852 struct posix_acl *acl = NULL;
856 acl = posix_acl_from_xattr(&init_user_ns, value, size);
860 ret = set_posix_acl(inode, handler->flags, acl);
861 posix_acl_release(acl);
866 posix_acl_xattr_list(struct dentry *dentry)
868 return IS_POSIXACL(d_backing_inode(dentry));
871 const struct xattr_handler posix_acl_access_xattr_handler = {
872 .name = XATTR_NAME_POSIX_ACL_ACCESS,
873 .flags = ACL_TYPE_ACCESS,
874 .list = posix_acl_xattr_list,
875 .get = posix_acl_xattr_get,
876 .set = posix_acl_xattr_set,
878 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler);
880 const struct xattr_handler posix_acl_default_xattr_handler = {
881 .name = XATTR_NAME_POSIX_ACL_DEFAULT,
882 .flags = ACL_TYPE_DEFAULT,
883 .list = posix_acl_xattr_list,
884 .get = posix_acl_xattr_get,
885 .set = posix_acl_xattr_set,
887 EXPORT_SYMBOL_GPL(posix_acl_default_xattr_handler);
889 int simple_set_acl(struct inode *inode, struct posix_acl *acl, int type)
893 if (type == ACL_TYPE_ACCESS) {
894 error = posix_acl_equiv_mode(acl, &inode->i_mode);
901 inode->i_ctime = CURRENT_TIME;
902 set_cached_acl(inode, type, acl);
906 int simple_acl_create(struct inode *dir, struct inode *inode)
908 struct posix_acl *default_acl, *acl;
911 error = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
915 set_cached_acl(inode, ACL_TYPE_DEFAULT, default_acl);
916 set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
919 posix_acl_release(default_acl);
921 posix_acl_release(acl);