1 /* 2 * Copyright IBM Corporation, 2010 3 * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2.1 of the GNU Lesser General Public License 7 * as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 12 * 13 */ 14 15 #include <linux/module.h> 16 #include <linux/fs.h> 17 #include <net/9p/9p.h> 18 #include <net/9p/client.h> 19 #include <linux/slab.h> 20 #include <linux/sched.h> 21 #include <linux/posix_acl_xattr.h> 22 #include "xattr.h" 23 #include "acl.h" 24 #include "v9fs.h" 25 #include "v9fs_vfs.h" 26 #include "fid.h" 27 28 static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name) 29 { 30 ssize_t size; 31 void *value = NULL; 32 struct posix_acl *acl = NULL; 33 34 size = v9fs_fid_xattr_get(fid, name, NULL, 0); 35 if (size > 0) { 36 value = kzalloc(size, GFP_NOFS); 37 if (!value) 38 return ERR_PTR(-ENOMEM); 39 size = v9fs_fid_xattr_get(fid, name, value, size); 40 if (size > 0) { 41 acl = posix_acl_from_xattr(&init_user_ns, value, size); 42 if (IS_ERR(acl)) 43 goto err_out; 44 } 45 } else if (size == -ENODATA || size == 0 || 46 size == -ENOSYS || size == -EOPNOTSUPP) { 47 acl = NULL; 48 } else 49 acl = ERR_PTR(-EIO); 50 51 err_out: 52 kfree(value); 53 return acl; 54 } 55 56 int v9fs_get_acl(struct inode *inode, struct p9_fid *fid) 57 { 58 int retval = 0; 59 struct posix_acl *pacl, *dacl; 60 struct v9fs_session_info *v9ses; 61 62 v9ses = v9fs_inode2v9ses(inode); 63 if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) || 64 ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) { 65 set_cached_acl(inode, ACL_TYPE_DEFAULT, NULL); 66 set_cached_acl(inode, ACL_TYPE_ACCESS, NULL); 67 return 0; 68 } 69 /* get the default/access acl values and cache them */ 70 dacl = __v9fs_get_acl(fid, XATTR_NAME_POSIX_ACL_DEFAULT); 71 pacl = __v9fs_get_acl(fid, XATTR_NAME_POSIX_ACL_ACCESS); 72 73 if (!IS_ERR(dacl) && !IS_ERR(pacl)) { 74 set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl); 75 set_cached_acl(inode, ACL_TYPE_ACCESS, pacl); 76 } else 77 retval = -EIO; 78 79 if (!IS_ERR(dacl)) 80 posix_acl_release(dacl); 81 82 if (!IS_ERR(pacl)) 83 posix_acl_release(pacl); 84 85 return retval; 86 } 87 88 static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type) 89 { 90 struct posix_acl *acl; 91 /* 92 * 9p Always cache the acl value when 93 * instantiating the inode (v9fs_inode_from_fid) 94 */ 95 acl = get_cached_acl(inode, type); 96 BUG_ON(is_uncached_acl(acl)); 97 return acl; 98 } 99 100 struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type, bool rcu) 101 { 102 struct v9fs_session_info *v9ses; 103 104 if (rcu) 105 return ERR_PTR(-ECHILD); 106 107 v9ses = v9fs_inode2v9ses(inode); 108 if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) || 109 ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) { 110 /* 111 * On access = client and acl = on mode get the acl 112 * values from the server 113 */ 114 return NULL; 115 } 116 return v9fs_get_cached_acl(inode, type); 117 118 } 119 120 static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl) 121 { 122 int retval; 123 char *name; 124 size_t size; 125 void *buffer; 126 if (!acl) 127 return 0; 128 129 /* Set a setxattr request to server */ 130 size = posix_acl_xattr_size(acl->a_count); 131 buffer = kmalloc(size, GFP_KERNEL); 132 if (!buffer) 133 return -ENOMEM; 134 retval = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); 135 if (retval < 0) 136 goto err_free_out; 137 switch (type) { 138 case ACL_TYPE_ACCESS: 139 name = XATTR_NAME_POSIX_ACL_ACCESS; 140 break; 141 case ACL_TYPE_DEFAULT: 142 name = XATTR_NAME_POSIX_ACL_DEFAULT; 143 break; 144 default: 145 BUG(); 146 } 147 retval = v9fs_fid_xattr_set(fid, name, buffer, size, 0); 148 err_free_out: 149 kfree(buffer); 150 return retval; 151 } 152 153 int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid) 154 { 155 int retval = 0; 156 struct posix_acl *acl; 157 158 if (S_ISLNK(inode->i_mode)) 159 return -EOPNOTSUPP; 160 acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS); 161 if (acl) { 162 retval = __posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); 163 if (retval) 164 return retval; 165 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); 166 retval = v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl); 167 posix_acl_release(acl); 168 } 169 return retval; 170 } 171 172 int v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid, 173 struct posix_acl *dacl, struct posix_acl *acl) 174 { 175 set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl); 176 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); 177 v9fs_set_acl(fid, ACL_TYPE_DEFAULT, dacl); 178 v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl); 179 return 0; 180 } 181 182 void v9fs_put_acl(struct posix_acl *dacl, 183 struct posix_acl *acl) 184 { 185 posix_acl_release(dacl); 186 posix_acl_release(acl); 187 } 188 189 int v9fs_acl_mode(struct inode *dir, umode_t *modep, 190 struct posix_acl **dpacl, struct posix_acl **pacl) 191 { 192 int retval = 0; 193 umode_t mode = *modep; 194 struct posix_acl *acl = NULL; 195 196 if (!S_ISLNK(mode)) { 197 acl = v9fs_get_cached_acl(dir, ACL_TYPE_DEFAULT); 198 if (IS_ERR(acl)) 199 return PTR_ERR(acl); 200 if (!acl) 201 mode &= ~current_umask(); 202 } 203 if (acl) { 204 if (S_ISDIR(mode)) 205 *dpacl = posix_acl_dup(acl); 206 retval = __posix_acl_create(&acl, GFP_NOFS, &mode); 207 if (retval < 0) 208 return retval; 209 if (retval > 0) 210 *pacl = acl; 211 else 212 posix_acl_release(acl); 213 } 214 *modep = mode; 215 return 0; 216 } 217 218 static int v9fs_xattr_get_acl(const struct xattr_handler *handler, 219 struct dentry *dentry, struct inode *inode, 220 const char *name, void *buffer, size_t size) 221 { 222 struct v9fs_session_info *v9ses; 223 struct posix_acl *acl; 224 int error; 225 226 v9ses = v9fs_dentry2v9ses(dentry); 227 /* 228 * We allow set/get/list of acl when access=client is not specified 229 */ 230 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) 231 return v9fs_xattr_get(dentry, handler->name, buffer, size); 232 233 acl = v9fs_get_cached_acl(inode, handler->flags); 234 if (IS_ERR(acl)) 235 return PTR_ERR(acl); 236 if (acl == NULL) 237 return -ENODATA; 238 error = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); 239 posix_acl_release(acl); 240 241 return error; 242 } 243 244 static int v9fs_xattr_set_acl(const struct xattr_handler *handler, 245 struct user_namespace *mnt_userns, 246 struct dentry *dentry, struct inode *inode, 247 const char *name, const void *value, 248 size_t size, int flags) 249 { 250 int retval; 251 struct posix_acl *acl; 252 struct v9fs_session_info *v9ses; 253 254 v9ses = v9fs_dentry2v9ses(dentry); 255 /* 256 * set the attribute on the remote. Without even looking at the 257 * xattr value. We leave it to the server to validate 258 */ 259 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) 260 return v9fs_xattr_set(dentry, handler->name, value, size, 261 flags); 262 263 if (S_ISLNK(inode->i_mode)) 264 return -EOPNOTSUPP; 265 if (!inode_owner_or_capable(&init_user_ns, inode)) 266 return -EPERM; 267 if (value) { 268 /* update the cached acl value */ 269 acl = posix_acl_from_xattr(&init_user_ns, value, size); 270 if (IS_ERR(acl)) 271 return PTR_ERR(acl); 272 else if (acl) { 273 retval = posix_acl_valid(inode->i_sb->s_user_ns, acl); 274 if (retval) 275 goto err_out; 276 } 277 } else 278 acl = NULL; 279 280 switch (handler->flags) { 281 case ACL_TYPE_ACCESS: 282 if (acl) { 283 struct iattr iattr = { 0 }; 284 struct posix_acl *old_acl = acl; 285 286 retval = posix_acl_update_mode(&init_user_ns, inode, 287 &iattr.ia_mode, &acl); 288 if (retval) 289 goto err_out; 290 if (!acl) { 291 /* 292 * ACL can be represented 293 * by the mode bits. So don't 294 * update ACL. 295 */ 296 posix_acl_release(old_acl); 297 value = NULL; 298 size = 0; 299 } 300 iattr.ia_valid = ATTR_MODE; 301 /* FIXME should we update ctime ? 302 * What is the following setxattr update the 303 * mode ? 304 */ 305 v9fs_vfs_setattr_dotl(&init_user_ns, dentry, &iattr); 306 } 307 break; 308 case ACL_TYPE_DEFAULT: 309 if (!S_ISDIR(inode->i_mode)) { 310 retval = acl ? -EINVAL : 0; 311 goto err_out; 312 } 313 break; 314 default: 315 BUG(); 316 } 317 retval = v9fs_xattr_set(dentry, handler->name, value, size, flags); 318 if (!retval) 319 set_cached_acl(inode, handler->flags, acl); 320 err_out: 321 posix_acl_release(acl); 322 return retval; 323 } 324 325 const struct xattr_handler v9fs_xattr_acl_access_handler = { 326 .name = XATTR_NAME_POSIX_ACL_ACCESS, 327 .flags = ACL_TYPE_ACCESS, 328 .get = v9fs_xattr_get_acl, 329 .set = v9fs_xattr_set_acl, 330 }; 331 332 const struct xattr_handler v9fs_xattr_acl_default_handler = { 333 .name = XATTR_NAME_POSIX_ACL_DEFAULT, 334 .flags = ACL_TYPE_DEFAULT, 335 .get = v9fs_xattr_get_acl, 336 .set = v9fs_xattr_set_acl, 337 }; 338