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 27 static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name) 28 { 29 ssize_t size; 30 void *value = NULL; 31 struct posix_acl *acl = NULL; 32 33 size = v9fs_fid_xattr_get(fid, name, NULL, 0); 34 if (size > 0) { 35 value = kzalloc(size, GFP_NOFS); 36 if (!value) 37 return ERR_PTR(-ENOMEM); 38 size = v9fs_fid_xattr_get(fid, name, value, size); 39 if (size > 0) { 40 acl = posix_acl_from_xattr(value, size); 41 if (IS_ERR(acl)) 42 goto err_out; 43 } 44 } else if (size == -ENODATA || size == 0 || 45 size == -ENOSYS || size == -EOPNOTSUPP) { 46 acl = NULL; 47 } else 48 acl = ERR_PTR(-EIO); 49 50 err_out: 51 kfree(value); 52 return acl; 53 } 54 55 int v9fs_get_acl(struct inode *inode, struct p9_fid *fid) 56 { 57 int retval = 0; 58 struct posix_acl *pacl, *dacl; 59 struct v9fs_session_info *v9ses; 60 61 v9ses = v9fs_inode2v9ses(inode); 62 if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) || 63 ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) { 64 set_cached_acl(inode, ACL_TYPE_DEFAULT, NULL); 65 set_cached_acl(inode, ACL_TYPE_ACCESS, NULL); 66 return 0; 67 } 68 /* get the default/access acl values and cache them */ 69 dacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_DEFAULT); 70 pacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_ACCESS); 71 72 if (!IS_ERR(dacl) && !IS_ERR(pacl)) { 73 set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl); 74 set_cached_acl(inode, ACL_TYPE_ACCESS, pacl); 75 } else 76 retval = -EIO; 77 78 if (!IS_ERR(dacl)) 79 posix_acl_release(dacl); 80 81 if (!IS_ERR(pacl)) 82 posix_acl_release(pacl); 83 84 return retval; 85 } 86 87 static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type) 88 { 89 struct posix_acl *acl; 90 /* 91 * 9p Always cache the acl value when 92 * instantiating the inode (v9fs_inode_from_fid) 93 */ 94 acl = get_cached_acl(inode, type); 95 BUG_ON(acl == ACL_NOT_CACHED); 96 return acl; 97 } 98 99 struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type) 100 { 101 struct v9fs_session_info *v9ses; 102 103 v9ses = v9fs_inode2v9ses(inode); 104 if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) || 105 ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) { 106 /* 107 * On access = client and acl = on mode get the acl 108 * values from the server 109 */ 110 return NULL; 111 } 112 return v9fs_get_cached_acl(inode, type); 113 114 } 115 116 static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl) 117 { 118 int retval; 119 char *name; 120 size_t size; 121 void *buffer; 122 struct inode *inode = dentry->d_inode; 123 124 set_cached_acl(inode, type, acl); 125 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(acl, buffer, size); 135 if (retval < 0) 136 goto err_free_out; 137 switch (type) { 138 case ACL_TYPE_ACCESS: 139 name = POSIX_ACL_XATTR_ACCESS; 140 break; 141 case ACL_TYPE_DEFAULT: 142 name = POSIX_ACL_XATTR_DEFAULT; 143 break; 144 default: 145 BUG(); 146 } 147 retval = v9fs_xattr_set(dentry, name, buffer, size, 0); 148 err_free_out: 149 kfree(buffer); 150 return retval; 151 } 152 153 int v9fs_acl_chmod(struct dentry *dentry) 154 { 155 int retval = 0; 156 struct posix_acl *acl; 157 struct inode *inode = dentry->d_inode; 158 159 if (S_ISLNK(inode->i_mode)) 160 return -EOPNOTSUPP; 161 acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS); 162 if (acl) { 163 retval = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); 164 if (retval) 165 return retval; 166 retval = v9fs_set_acl(dentry, ACL_TYPE_ACCESS, acl); 167 posix_acl_release(acl); 168 } 169 return retval; 170 } 171 172 int v9fs_set_create_acl(struct dentry *dentry, 173 struct posix_acl **dpacl, struct posix_acl **pacl) 174 { 175 if (dentry) { 176 v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, *dpacl); 177 v9fs_set_acl(dentry, ACL_TYPE_ACCESS, *pacl); 178 } 179 posix_acl_release(*dpacl); 180 posix_acl_release(*pacl); 181 *dpacl = *pacl = NULL; 182 return 0; 183 } 184 185 int v9fs_acl_mode(struct inode *dir, umode_t *modep, 186 struct posix_acl **dpacl, struct posix_acl **pacl) 187 { 188 int retval = 0; 189 umode_t mode = *modep; 190 struct posix_acl *acl = NULL; 191 192 if (!S_ISLNK(mode)) { 193 acl = v9fs_get_cached_acl(dir, ACL_TYPE_DEFAULT); 194 if (IS_ERR(acl)) 195 return PTR_ERR(acl); 196 if (!acl) 197 mode &= ~current_umask(); 198 } 199 if (acl) { 200 if (S_ISDIR(mode)) 201 *dpacl = posix_acl_dup(acl); 202 retval = posix_acl_create(&acl, GFP_NOFS, &mode); 203 if (retval < 0) 204 return retval; 205 if (retval > 0) 206 *pacl = acl; 207 else 208 posix_acl_release(acl); 209 } 210 *modep = mode; 211 return 0; 212 } 213 214 static int v9fs_remote_get_acl(struct dentry *dentry, const char *name, 215 void *buffer, size_t size, int type) 216 { 217 char *full_name; 218 219 switch (type) { 220 case ACL_TYPE_ACCESS: 221 full_name = POSIX_ACL_XATTR_ACCESS; 222 break; 223 case ACL_TYPE_DEFAULT: 224 full_name = POSIX_ACL_XATTR_DEFAULT; 225 break; 226 default: 227 BUG(); 228 } 229 return v9fs_xattr_get(dentry, full_name, buffer, size); 230 } 231 232 static int v9fs_xattr_get_acl(struct dentry *dentry, const char *name, 233 void *buffer, size_t size, int type) 234 { 235 struct v9fs_session_info *v9ses; 236 struct posix_acl *acl; 237 int error; 238 239 if (strcmp(name, "") != 0) 240 return -EINVAL; 241 242 v9ses = v9fs_dentry2v9ses(dentry); 243 /* 244 * We allow set/get/list of acl when access=client is not specified 245 */ 246 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) 247 return v9fs_remote_get_acl(dentry, name, buffer, size, type); 248 249 acl = v9fs_get_cached_acl(dentry->d_inode, type); 250 if (IS_ERR(acl)) 251 return PTR_ERR(acl); 252 if (acl == NULL) 253 return -ENODATA; 254 error = posix_acl_to_xattr(acl, buffer, size); 255 posix_acl_release(acl); 256 257 return error; 258 } 259 260 static int v9fs_remote_set_acl(struct dentry *dentry, const char *name, 261 const void *value, size_t size, 262 int flags, int type) 263 { 264 char *full_name; 265 266 switch (type) { 267 case ACL_TYPE_ACCESS: 268 full_name = POSIX_ACL_XATTR_ACCESS; 269 break; 270 case ACL_TYPE_DEFAULT: 271 full_name = POSIX_ACL_XATTR_DEFAULT; 272 break; 273 default: 274 BUG(); 275 } 276 return v9fs_xattr_set(dentry, full_name, value, size, flags); 277 } 278 279 280 static int v9fs_xattr_set_acl(struct dentry *dentry, const char *name, 281 const void *value, size_t size, 282 int flags, int type) 283 { 284 int retval; 285 struct posix_acl *acl; 286 struct v9fs_session_info *v9ses; 287 struct inode *inode = dentry->d_inode; 288 289 if (strcmp(name, "") != 0) 290 return -EINVAL; 291 292 v9ses = v9fs_dentry2v9ses(dentry); 293 /* 294 * set the attribute on the remote. Without even looking at the 295 * xattr value. We leave it to the server to validate 296 */ 297 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) 298 return v9fs_remote_set_acl(dentry, name, 299 value, size, flags, type); 300 301 if (S_ISLNK(inode->i_mode)) 302 return -EOPNOTSUPP; 303 if (!inode_owner_or_capable(inode)) 304 return -EPERM; 305 if (value) { 306 /* update the cached acl value */ 307 acl = posix_acl_from_xattr(value, size); 308 if (IS_ERR(acl)) 309 return PTR_ERR(acl); 310 else if (acl) { 311 retval = posix_acl_valid(acl); 312 if (retval) 313 goto err_out; 314 } 315 } else 316 acl = NULL; 317 318 switch (type) { 319 case ACL_TYPE_ACCESS: 320 name = POSIX_ACL_XATTR_ACCESS; 321 if (acl) { 322 umode_t mode = inode->i_mode; 323 retval = posix_acl_equiv_mode(acl, &mode); 324 if (retval < 0) 325 goto err_out; 326 else { 327 struct iattr iattr; 328 if (retval == 0) { 329 /* 330 * ACL can be represented 331 * by the mode bits. So don't 332 * update ACL. 333 */ 334 acl = NULL; 335 value = NULL; 336 size = 0; 337 } 338 /* Updte the mode bits */ 339 iattr.ia_mode = ((mode & S_IALLUGO) | 340 (inode->i_mode & ~S_IALLUGO)); 341 iattr.ia_valid = ATTR_MODE; 342 /* FIXME should we update ctime ? 343 * What is the following setxattr update the 344 * mode ? 345 */ 346 v9fs_vfs_setattr_dotl(dentry, &iattr); 347 } 348 } 349 break; 350 case ACL_TYPE_DEFAULT: 351 name = POSIX_ACL_XATTR_DEFAULT; 352 if (!S_ISDIR(inode->i_mode)) { 353 retval = acl ? -EINVAL : 0; 354 goto err_out; 355 } 356 break; 357 default: 358 BUG(); 359 } 360 retval = v9fs_xattr_set(dentry, name, value, size, flags); 361 if (!retval) 362 set_cached_acl(inode, type, acl); 363 err_out: 364 posix_acl_release(acl); 365 return retval; 366 } 367 368 const struct xattr_handler v9fs_xattr_acl_access_handler = { 369 .prefix = POSIX_ACL_XATTR_ACCESS, 370 .flags = ACL_TYPE_ACCESS, 371 .get = v9fs_xattr_get_acl, 372 .set = v9fs_xattr_set_acl, 373 }; 374 375 const struct xattr_handler v9fs_xattr_acl_default_handler = { 376 .prefix = POSIX_ACL_XATTR_DEFAULT, 377 .flags = ACL_TYPE_DEFAULT, 378 .get = v9fs_xattr_get_acl, 379 .set = v9fs_xattr_set_acl, 380 }; 381