1/* 2 * mm/shmem_acl.c 3 * 4 * (C) 2005 Andreas Gruenbacher <agruen@suse.de> 5 * 6 * This file is released under the GPL. 7 */ 8 9#include <linux/fs.h> 10#include <linux/shmem_fs.h> 11#include <linux/xattr.h> 12#include <linux/generic_acl.h> 13 14/** 15 * shmem_get_acl - generic_acl_operations->getacl() operation 16 */ 17static struct posix_acl * 18shmem_get_acl(struct inode *inode, int type) 19{ 20 struct posix_acl *acl = NULL; 21 22 spin_lock(&inode->i_lock); 23 switch(type) { 24 case ACL_TYPE_ACCESS: 25 acl = posix_acl_dup(SHMEM_I(inode)->i_acl); 26 break; 27 28 case ACL_TYPE_DEFAULT: 29 acl = posix_acl_dup(SHMEM_I(inode)->i_default_acl); 30 break; 31 } 32 spin_unlock(&inode->i_lock); 33 34 return acl; 35} 36 37/** 38 * shmem_set_acl - generic_acl_operations->setacl() operation 39 */ 40static void 41shmem_set_acl(struct inode *inode, int type, struct posix_acl *acl) 42{ 43 struct posix_acl *free = NULL; 44 45 spin_lock(&inode->i_lock); 46 switch(type) { 47 case ACL_TYPE_ACCESS: 48 free = SHMEM_I(inode)->i_acl; 49 SHMEM_I(inode)->i_acl = posix_acl_dup(acl); 50 break; 51 52 case ACL_TYPE_DEFAULT: 53 free = SHMEM_I(inode)->i_default_acl; 54 SHMEM_I(inode)->i_default_acl = posix_acl_dup(acl); 55 break; 56 } 57 spin_unlock(&inode->i_lock); 58 posix_acl_release(free); 59} 60 61struct generic_acl_operations shmem_acl_ops = { 62 .getacl = shmem_get_acl, 63 .setacl = shmem_set_acl, 64}; 65 66/** 67 * shmem_list_acl_access, shmem_get_acl_access, shmem_set_acl_access, 68 * shmem_xattr_acl_access_handler - plumbing code to implement the 69 * system.posix_acl_access xattr using the generic acl functions. 70 */ 71 72static size_t 73shmem_list_acl_access(struct inode *inode, char *list, size_t list_size, 74 const char *name, size_t name_len) 75{ 76 return generic_acl_list(inode, &shmem_acl_ops, ACL_TYPE_ACCESS, 77 list, list_size); 78} 79 80static int 81shmem_get_acl_access(struct inode *inode, const char *name, void *buffer, 82 size_t size) 83{ 84 if (strcmp(name, "") != 0) 85 return -EINVAL; 86 return generic_acl_get(inode, &shmem_acl_ops, ACL_TYPE_ACCESS, buffer, 87 size); 88} 89 90static int 91shmem_set_acl_access(struct inode *inode, const char *name, const void *value, 92 size_t size, int flags) 93{ 94 if (strcmp(name, "") != 0) 95 return -EINVAL; 96 return generic_acl_set(inode, &shmem_acl_ops, ACL_TYPE_ACCESS, value, 97 size); 98} 99 100struct xattr_handler shmem_xattr_acl_access_handler = { 101 .prefix = POSIX_ACL_XATTR_ACCESS, 102 .list = shmem_list_acl_access, 103 .get = shmem_get_acl_access, 104 .set = shmem_set_acl_access, 105}; 106 107/** 108 * shmem_list_acl_default, shmem_get_acl_default, shmem_set_acl_default, 109 * shmem_xattr_acl_default_handler - plumbing code to implement the 110 * system.posix_acl_default xattr using the generic acl functions. 111 */ 112 113static size_t 114shmem_list_acl_default(struct inode *inode, char *list, size_t list_size, 115 const char *name, size_t name_len) 116{ 117 return generic_acl_list(inode, &shmem_acl_ops, ACL_TYPE_DEFAULT, 118 list, list_size); 119} 120 121static int 122shmem_get_acl_default(struct inode *inode, const char *name, void *buffer, 123 size_t size) 124{ 125 if (strcmp(name, "") != 0) 126 return -EINVAL; 127 return generic_acl_get(inode, &shmem_acl_ops, ACL_TYPE_DEFAULT, buffer, 128 size); 129} 130 131static int 132shmem_set_acl_default(struct inode *inode, const char *name, const void *value, 133 size_t size, int flags) 134{ 135 if (strcmp(name, "") != 0) 136 return -EINVAL; 137 return generic_acl_set(inode, &shmem_acl_ops, ACL_TYPE_DEFAULT, value, 138 size); 139} 140 141struct xattr_handler shmem_xattr_acl_default_handler = { 142 .prefix = POSIX_ACL_XATTR_DEFAULT, 143 .list = shmem_list_acl_default, 144 .get = shmem_get_acl_default, 145 .set = shmem_set_acl_default, 146}; 147 148/** 149 * shmem_acl_init - Inizialize the acl(s) of a new inode 150 */ 151int 152shmem_acl_init(struct inode *inode, struct inode *dir) 153{ 154 return generic_acl_init(inode, dir, &shmem_acl_ops); 155} 156 157/** 158 * shmem_acl_destroy_inode - destroy acls hanging off the in-memory inode 159 * 160 * This is done before destroying the actual inode. 161 */ 162 163void 164shmem_acl_destroy_inode(struct inode *inode) 165{ 166 if (SHMEM_I(inode)->i_acl) 167 posix_acl_release(SHMEM_I(inode)->i_acl); 168 SHMEM_I(inode)->i_acl = NULL; 169 if (SHMEM_I(inode)->i_default_acl) 170 posix_acl_release(SHMEM_I(inode)->i_default_acl); 171 SHMEM_I(inode)->i_default_acl = NULL; 172} 173 174/** 175 * shmem_check_acl - check_acl() callback for generic_permission() 176 */ 177static int 178shmem_check_acl(struct inode *inode, int mask) 179{ 180 struct posix_acl *acl = shmem_get_acl(inode, ACL_TYPE_ACCESS); 181 182 if (acl) { 183 int error = posix_acl_permission(inode, acl, mask); 184 posix_acl_release(acl); 185 return error; 186 } 187 return -EAGAIN; 188} 189 190/** 191 * shmem_permission - permission() inode operation 192 */ 193int 194shmem_permission(struct inode *inode, int mask, struct nameidata *nd) 195{ 196 return generic_permission(inode, mask, shmem_check_acl); 197} 198