1 /* 2 * Copyright (c) 2008, Christoph Hellwig 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_acl.h" 20 #include "xfs_attr.h" 21 #include "xfs_bmap_btree.h" 22 #include "xfs_inode.h" 23 #include "xfs_vnodeops.h" 24 #include "xfs_sb.h" 25 #include "xfs_mount.h" 26 #include "xfs_trace.h" 27 #include <linux/slab.h> 28 #include <linux/xattr.h> 29 #include <linux/posix_acl_xattr.h> 30 31 32 /* 33 * Locking scheme: 34 * - all ACL updates are protected by inode->i_mutex, which is taken before 35 * calling into this file. 36 */ 37 38 STATIC struct posix_acl * 39 xfs_acl_from_disk( 40 struct xfs_acl *aclp, 41 int max_entries) 42 { 43 struct posix_acl_entry *acl_e; 44 struct posix_acl *acl; 45 struct xfs_acl_entry *ace; 46 unsigned int count, i; 47 48 count = be32_to_cpu(aclp->acl_cnt); 49 if (count > max_entries) 50 return ERR_PTR(-EFSCORRUPTED); 51 52 acl = posix_acl_alloc(count, GFP_KERNEL); 53 if (!acl) 54 return ERR_PTR(-ENOMEM); 55 56 for (i = 0; i < count; i++) { 57 acl_e = &acl->a_entries[i]; 58 ace = &aclp->acl_entry[i]; 59 60 /* 61 * The tag is 32 bits on disk and 16 bits in core. 62 * 63 * Because every access to it goes through the core 64 * format first this is not a problem. 65 */ 66 acl_e->e_tag = be32_to_cpu(ace->ae_tag); 67 acl_e->e_perm = be16_to_cpu(ace->ae_perm); 68 69 switch (acl_e->e_tag) { 70 case ACL_USER: 71 case ACL_GROUP: 72 acl_e->e_id = be32_to_cpu(ace->ae_id); 73 break; 74 case ACL_USER_OBJ: 75 case ACL_GROUP_OBJ: 76 case ACL_MASK: 77 case ACL_OTHER: 78 acl_e->e_id = ACL_UNDEFINED_ID; 79 break; 80 default: 81 goto fail; 82 } 83 } 84 return acl; 85 86 fail: 87 posix_acl_release(acl); 88 return ERR_PTR(-EINVAL); 89 } 90 91 STATIC void 92 xfs_acl_to_disk(struct xfs_acl *aclp, const struct posix_acl *acl) 93 { 94 const struct posix_acl_entry *acl_e; 95 struct xfs_acl_entry *ace; 96 int i; 97 98 aclp->acl_cnt = cpu_to_be32(acl->a_count); 99 for (i = 0; i < acl->a_count; i++) { 100 ace = &aclp->acl_entry[i]; 101 acl_e = &acl->a_entries[i]; 102 103 ace->ae_tag = cpu_to_be32(acl_e->e_tag); 104 ace->ae_id = cpu_to_be32(acl_e->e_id); 105 ace->ae_perm = cpu_to_be16(acl_e->e_perm); 106 } 107 } 108 109 struct posix_acl * 110 xfs_get_acl(struct inode *inode, int type) 111 { 112 struct xfs_inode *ip = XFS_I(inode); 113 struct posix_acl *acl; 114 struct xfs_acl *xfs_acl; 115 unsigned char *ea_name; 116 int error; 117 int len; 118 119 acl = get_cached_acl(inode, type); 120 if (acl != ACL_NOT_CACHED) 121 return acl; 122 123 trace_xfs_get_acl(ip); 124 125 switch (type) { 126 case ACL_TYPE_ACCESS: 127 ea_name = SGI_ACL_FILE; 128 break; 129 case ACL_TYPE_DEFAULT: 130 ea_name = SGI_ACL_DEFAULT; 131 break; 132 default: 133 BUG(); 134 } 135 136 /* 137 * If we have a cached ACLs value just return it, not need to 138 * go out to the disk. 139 */ 140 len = XFS_ACL_MAX_SIZE(ip->i_mount); 141 xfs_acl = kzalloc(len, GFP_KERNEL); 142 if (!xfs_acl) 143 return ERR_PTR(-ENOMEM); 144 145 error = -xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl, 146 &len, ATTR_ROOT); 147 if (error) { 148 /* 149 * If the attribute doesn't exist make sure we have a negative 150 * cache entry, for any other error assume it is transient and 151 * leave the cache entry as ACL_NOT_CACHED. 152 */ 153 if (error == -ENOATTR) { 154 acl = NULL; 155 goto out_update_cache; 156 } 157 goto out; 158 } 159 160 acl = xfs_acl_from_disk(xfs_acl, XFS_ACL_MAX_ENTRIES(ip->i_mount)); 161 if (IS_ERR(acl)) 162 goto out; 163 164 out_update_cache: 165 set_cached_acl(inode, type, acl); 166 out: 167 kfree(xfs_acl); 168 return acl; 169 } 170 171 STATIC int 172 xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl) 173 { 174 struct xfs_inode *ip = XFS_I(inode); 175 unsigned char *ea_name; 176 int error; 177 178 if (S_ISLNK(inode->i_mode)) 179 return -EOPNOTSUPP; 180 181 switch (type) { 182 case ACL_TYPE_ACCESS: 183 ea_name = SGI_ACL_FILE; 184 break; 185 case ACL_TYPE_DEFAULT: 186 if (!S_ISDIR(inode->i_mode)) 187 return acl ? -EACCES : 0; 188 ea_name = SGI_ACL_DEFAULT; 189 break; 190 default: 191 return -EINVAL; 192 } 193 194 if (acl) { 195 struct xfs_acl *xfs_acl; 196 int len = XFS_ACL_MAX_SIZE(ip->i_mount); 197 198 xfs_acl = kzalloc(len, GFP_KERNEL); 199 if (!xfs_acl) 200 return -ENOMEM; 201 202 xfs_acl_to_disk(xfs_acl, acl); 203 204 /* subtract away the unused acl entries */ 205 len -= sizeof(struct xfs_acl_entry) * 206 (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count); 207 208 error = -xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl, 209 len, ATTR_ROOT); 210 211 kfree(xfs_acl); 212 } else { 213 /* 214 * A NULL ACL argument means we want to remove the ACL. 215 */ 216 error = -xfs_attr_remove(ip, ea_name, ATTR_ROOT); 217 218 /* 219 * If the attribute didn't exist to start with that's fine. 220 */ 221 if (error == -ENOATTR) 222 error = 0; 223 } 224 225 if (!error) 226 set_cached_acl(inode, type, acl); 227 return error; 228 } 229 230 static int 231 xfs_set_mode(struct inode *inode, umode_t mode) 232 { 233 int error = 0; 234 235 if (mode != inode->i_mode) { 236 struct iattr iattr; 237 238 iattr.ia_valid = ATTR_MODE | ATTR_CTIME; 239 iattr.ia_mode = mode; 240 iattr.ia_ctime = current_fs_time(inode->i_sb); 241 242 error = -xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL); 243 } 244 245 return error; 246 } 247 248 static int 249 xfs_acl_exists(struct inode *inode, unsigned char *name) 250 { 251 int len = XFS_ACL_MAX_SIZE(XFS_M(inode->i_sb)); 252 253 return (xfs_attr_get(XFS_I(inode), name, NULL, &len, 254 ATTR_ROOT|ATTR_KERNOVAL) == 0); 255 } 256 257 int 258 posix_acl_access_exists(struct inode *inode) 259 { 260 return xfs_acl_exists(inode, SGI_ACL_FILE); 261 } 262 263 int 264 posix_acl_default_exists(struct inode *inode) 265 { 266 if (!S_ISDIR(inode->i_mode)) 267 return 0; 268 return xfs_acl_exists(inode, SGI_ACL_DEFAULT); 269 } 270 271 /* 272 * No need for i_mutex because the inode is not yet exposed to the VFS. 273 */ 274 int 275 xfs_inherit_acl(struct inode *inode, struct posix_acl *acl) 276 { 277 umode_t mode = inode->i_mode; 278 int error = 0, inherit = 0; 279 280 if (S_ISDIR(inode->i_mode)) { 281 error = xfs_set_acl(inode, ACL_TYPE_DEFAULT, acl); 282 if (error) 283 goto out; 284 } 285 286 error = posix_acl_create(&acl, GFP_KERNEL, &mode); 287 if (error < 0) 288 return error; 289 290 /* 291 * If posix_acl_create returns a positive value we need to 292 * inherit a permission that can't be represented using the Unix 293 * mode bits and we actually need to set an ACL. 294 */ 295 if (error > 0) 296 inherit = 1; 297 298 error = xfs_set_mode(inode, mode); 299 if (error) 300 goto out; 301 302 if (inherit) 303 error = xfs_set_acl(inode, ACL_TYPE_ACCESS, acl); 304 305 out: 306 posix_acl_release(acl); 307 return error; 308 } 309 310 int 311 xfs_acl_chmod(struct inode *inode) 312 { 313 struct posix_acl *acl; 314 int error; 315 316 if (S_ISLNK(inode->i_mode)) 317 return -EOPNOTSUPP; 318 319 acl = xfs_get_acl(inode, ACL_TYPE_ACCESS); 320 if (IS_ERR(acl) || !acl) 321 return PTR_ERR(acl); 322 323 error = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); 324 if (error) 325 return error; 326 327 error = xfs_set_acl(inode, ACL_TYPE_ACCESS, acl); 328 posix_acl_release(acl); 329 return error; 330 } 331 332 static int 333 xfs_xattr_acl_get(struct dentry *dentry, const char *name, 334 void *value, size_t size, int type) 335 { 336 struct posix_acl *acl; 337 int error; 338 339 acl = xfs_get_acl(dentry->d_inode, type); 340 if (IS_ERR(acl)) 341 return PTR_ERR(acl); 342 if (acl == NULL) 343 return -ENODATA; 344 345 error = posix_acl_to_xattr(&init_user_ns, acl, value, size); 346 posix_acl_release(acl); 347 348 return error; 349 } 350 351 static int 352 xfs_xattr_acl_set(struct dentry *dentry, const char *name, 353 const void *value, size_t size, int flags, int type) 354 { 355 struct inode *inode = dentry->d_inode; 356 struct posix_acl *acl = NULL; 357 int error = 0; 358 359 if (flags & XATTR_CREATE) 360 return -EINVAL; 361 if (type == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) 362 return value ? -EACCES : 0; 363 if ((current_fsuid() != inode->i_uid) && !capable(CAP_FOWNER)) 364 return -EPERM; 365 366 if (!value) 367 goto set_acl; 368 369 acl = posix_acl_from_xattr(&init_user_ns, value, size); 370 if (!acl) { 371 /* 372 * acl_set_file(3) may request that we set default ACLs with 373 * zero length -- defend (gracefully) against that here. 374 */ 375 goto out; 376 } 377 if (IS_ERR(acl)) { 378 error = PTR_ERR(acl); 379 goto out; 380 } 381 382 error = posix_acl_valid(acl); 383 if (error) 384 goto out_release; 385 386 error = -EINVAL; 387 if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) 388 goto out_release; 389 390 if (type == ACL_TYPE_ACCESS) { 391 umode_t mode = inode->i_mode; 392 error = posix_acl_equiv_mode(acl, &mode); 393 394 if (error <= 0) { 395 posix_acl_release(acl); 396 acl = NULL; 397 398 if (error < 0) 399 return error; 400 } 401 402 error = xfs_set_mode(inode, mode); 403 if (error) 404 goto out_release; 405 } 406 407 set_acl: 408 error = xfs_set_acl(inode, type, acl); 409 out_release: 410 posix_acl_release(acl); 411 out: 412 return error; 413 } 414 415 const struct xattr_handler xfs_xattr_acl_access_handler = { 416 .prefix = POSIX_ACL_XATTR_ACCESS, 417 .flags = ACL_TYPE_ACCESS, 418 .get = xfs_xattr_acl_get, 419 .set = xfs_xattr_acl_set, 420 }; 421 422 const struct xattr_handler xfs_xattr_acl_default_handler = { 423 .prefix = POSIX_ACL_XATTR_DEFAULT, 424 .flags = ACL_TYPE_DEFAULT, 425 .get = xfs_xattr_acl_get, 426 .set = xfs_xattr_acl_set, 427 }; 428