2 * Copyright (c) 2008, Christoph Hellwig
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.
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.
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
21 #include "xfs_bmap_btree.h"
22 #include "xfs_inode.h"
23 #include "xfs_vnodeops.h"
24 #include <linux/xattr.h>
25 #include <linux/posix_acl_xattr.h>
28 #define XFS_ACL_NOT_CACHED ((void *)-1)
32 * - all ACL updates are protected by inode->i_mutex, which is taken before
33 * calling into this file.
34 * - access and updates to the ip->i_acl and ip->i_default_acl pointers are
35 * protected by inode->i_lock.
38 STATIC
struct posix_acl
*
39 xfs_acl_from_disk(struct xfs_acl
*aclp
)
41 struct posix_acl_entry
*acl_e
;
42 struct posix_acl
*acl
;
43 struct xfs_acl_entry
*ace
;
46 count
= be32_to_cpu(aclp
->acl_cnt
);
48 acl
= posix_acl_alloc(count
, GFP_KERNEL
);
50 return ERR_PTR(-ENOMEM
);
52 for (i
= 0; i
< count
; i
++) {
53 acl_e
= &acl
->a_entries
[i
];
54 ace
= &aclp
->acl_entry
[i
];
57 * The tag is 32 bits on disk and 16 bits in core.
59 * Because every access to it goes through the core
60 * format first this is not a problem.
62 acl_e
->e_tag
= be32_to_cpu(ace
->ae_tag
);
63 acl_e
->e_perm
= be16_to_cpu(ace
->ae_perm
);
65 switch (acl_e
->e_tag
) {
68 acl_e
->e_id
= be32_to_cpu(ace
->ae_id
);
74 acl_e
->e_id
= ACL_UNDEFINED_ID
;
83 posix_acl_release(acl
);
84 return ERR_PTR(-EINVAL
);
88 xfs_acl_to_disk(struct xfs_acl
*aclp
, const struct posix_acl
*acl
)
90 const struct posix_acl_entry
*acl_e
;
91 struct xfs_acl_entry
*ace
;
94 aclp
->acl_cnt
= cpu_to_be32(acl
->a_count
);
95 for (i
= 0; i
< acl
->a_count
; i
++) {
96 ace
= &aclp
->acl_entry
[i
];
97 acl_e
= &acl
->a_entries
[i
];
99 ace
->ae_tag
= cpu_to_be32(acl_e
->e_tag
);
100 ace
->ae_id
= cpu_to_be32(acl_e
->e_id
);
101 ace
->ae_perm
= cpu_to_be16(acl_e
->e_perm
);
106 * Update the cached ACL pointer in the inode.
108 * Because we don't hold any locks while reading/writing the attribute
109 * from/to disk another thread could have raced and updated the cached
110 * ACL value before us. In that case we release the previous cached value
111 * and update it with our new value.
114 xfs_update_cached_acl(struct inode
*inode
, struct posix_acl
**p_acl
,
115 struct posix_acl
*acl
)
117 spin_lock(&inode
->i_lock
);
118 if (*p_acl
&& *p_acl
!= XFS_ACL_NOT_CACHED
)
119 posix_acl_release(*p_acl
);
120 *p_acl
= posix_acl_dup(acl
);
121 spin_unlock(&inode
->i_lock
);
125 xfs_get_acl(struct inode
*inode
, int type
)
127 struct xfs_inode
*ip
= XFS_I(inode
);
128 struct posix_acl
*acl
= NULL
, **p_acl
;
129 struct xfs_acl
*xfs_acl
;
130 int len
= sizeof(struct xfs_acl
);
135 case ACL_TYPE_ACCESS
:
136 ea_name
= SGI_ACL_FILE
;
139 case ACL_TYPE_DEFAULT
:
140 ea_name
= SGI_ACL_DEFAULT
;
141 p_acl
= &ip
->i_default_acl
;
144 return ERR_PTR(-EINVAL
);
147 spin_lock(&inode
->i_lock
);
148 if (*p_acl
!= XFS_ACL_NOT_CACHED
)
149 acl
= posix_acl_dup(*p_acl
);
150 spin_unlock(&inode
->i_lock
);
153 * If we have a cached ACLs value just return it, not need to
154 * go out to the disk.
159 xfs_acl
= kzalloc(sizeof(struct xfs_acl
), GFP_KERNEL
);
161 return ERR_PTR(-ENOMEM
);
163 error
= -xfs_attr_get(ip
, ea_name
, (char *)xfs_acl
, &len
, ATTR_ROOT
);
166 * If the attribute doesn't exist make sure we have a negative
167 * cache entry, for any other error assume it is transient and
168 * leave the cache entry as XFS_ACL_NOT_CACHED.
170 if (error
== -ENOATTR
) {
172 goto out_update_cache
;
177 acl
= xfs_acl_from_disk(xfs_acl
);
182 xfs_update_cached_acl(inode
, p_acl
, acl
);
189 xfs_set_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
191 struct xfs_inode
*ip
= XFS_I(inode
);
192 struct posix_acl
**p_acl
;
196 if (S_ISLNK(inode
->i_mode
))
200 case ACL_TYPE_ACCESS
:
201 ea_name
= SGI_ACL_FILE
;
204 case ACL_TYPE_DEFAULT
:
205 if (!S_ISDIR(inode
->i_mode
))
206 return acl
? -EACCES
: 0;
207 ea_name
= SGI_ACL_DEFAULT
;
208 p_acl
= &ip
->i_default_acl
;
215 struct xfs_acl
*xfs_acl
;
218 xfs_acl
= kzalloc(sizeof(struct xfs_acl
), GFP_KERNEL
);
222 xfs_acl_to_disk(xfs_acl
, acl
);
223 len
= sizeof(struct xfs_acl
) -
224 (sizeof(struct xfs_acl_entry
) *
225 (XFS_ACL_MAX_ENTRIES
- acl
->a_count
));
227 error
= -xfs_attr_set(ip
, ea_name
, (char *)xfs_acl
,
233 * A NULL ACL argument means we want to remove the ACL.
235 error
= -xfs_attr_remove(ip
, ea_name
, ATTR_ROOT
);
238 * If the attribute didn't exist to start with that's fine.
240 if (error
== -ENOATTR
)
245 xfs_update_cached_acl(inode
, p_acl
, acl
);
250 xfs_check_acl(struct inode
*inode
, int mask
)
252 struct xfs_inode
*ip
= XFS_I(inode
);
253 struct posix_acl
*acl
;
256 xfs_itrace_entry(ip
);
259 * If there is no attribute fork no ACL exists on this inode and
260 * we can skip the whole exercise.
262 if (!XFS_IFORK_Q(ip
))
265 acl
= xfs_get_acl(inode
, ACL_TYPE_ACCESS
);
269 error
= posix_acl_permission(inode
, acl
, mask
);
270 posix_acl_release(acl
);
277 xfs_set_mode(struct inode
*inode
, mode_t mode
)
281 if (mode
!= inode
->i_mode
) {
284 iattr
.ia_valid
= ATTR_MODE
;
285 iattr
.ia_mode
= mode
;
287 error
= -xfs_setattr(XFS_I(inode
), &iattr
, XFS_ATTR_NOACL
);
294 xfs_acl_exists(struct inode
*inode
, char *name
)
296 int len
= sizeof(struct xfs_acl
);
298 return (xfs_attr_get(XFS_I(inode
), name
, NULL
, &len
,
299 ATTR_ROOT
|ATTR_KERNOVAL
) == 0);
303 posix_acl_access_exists(struct inode
*inode
)
305 return xfs_acl_exists(inode
, SGI_ACL_FILE
);
309 posix_acl_default_exists(struct inode
*inode
)
311 if (!S_ISDIR(inode
->i_mode
))
313 return xfs_acl_exists(inode
, SGI_ACL_DEFAULT
);
317 * No need for i_mutex because the inode is not yet exposed to the VFS.
320 xfs_inherit_acl(struct inode
*inode
, struct posix_acl
*default_acl
)
322 struct posix_acl
*clone
;
324 int error
= 0, inherit
= 0;
326 if (S_ISDIR(inode
->i_mode
)) {
327 error
= xfs_set_acl(inode
, ACL_TYPE_DEFAULT
, default_acl
);
332 clone
= posix_acl_clone(default_acl
, GFP_KERNEL
);
336 mode
= inode
->i_mode
;
337 error
= posix_acl_create_masq(clone
, &mode
);
339 goto out_release_clone
;
342 * If posix_acl_create_masq returns a positive value we need to
343 * inherit a permission that can't be represented using the Unix
344 * mode bits and we actually need to set an ACL.
349 error
= xfs_set_mode(inode
, mode
);
351 goto out_release_clone
;
354 error
= xfs_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
357 posix_acl_release(clone
);
362 xfs_acl_chmod(struct inode
*inode
)
364 struct posix_acl
*acl
, *clone
;
367 if (S_ISLNK(inode
->i_mode
))
370 acl
= xfs_get_acl(inode
, ACL_TYPE_ACCESS
);
371 if (IS_ERR(acl
) || !acl
)
374 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
375 posix_acl_release(acl
);
379 error
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
381 error
= xfs_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
383 posix_acl_release(clone
);
388 xfs_inode_init_acls(struct xfs_inode
*ip
)
391 * No need for locking, inode is not live yet.
393 ip
->i_acl
= XFS_ACL_NOT_CACHED
;
394 ip
->i_default_acl
= XFS_ACL_NOT_CACHED
;
398 xfs_inode_clear_acls(struct xfs_inode
*ip
)
401 * No need for locking here, the inode is not live anymore
402 * and just about to be freed.
404 if (ip
->i_acl
!= XFS_ACL_NOT_CACHED
)
405 posix_acl_release(ip
->i_acl
);
406 if (ip
->i_default_acl
!= XFS_ACL_NOT_CACHED
)
407 posix_acl_release(ip
->i_default_acl
);
412 * System xattr handlers.
414 * Currently Posix ACLs are the only system namespace extended attribute
415 * handlers supported by XFS, so we just implement the handlers here.
416 * If we ever support other system extended attributes this will need
421 xfs_decode_acl(const char *name
)
423 if (strcmp(name
, "posix_acl_access") == 0)
424 return ACL_TYPE_ACCESS
;
425 else if (strcmp(name
, "posix_acl_default") == 0)
426 return ACL_TYPE_DEFAULT
;
431 xfs_xattr_system_get(struct inode
*inode
, const char *name
,
432 void *value
, size_t size
)
434 struct posix_acl
*acl
;
437 type
= xfs_decode_acl(name
);
441 acl
= xfs_get_acl(inode
, type
);
447 error
= posix_acl_to_xattr(acl
, value
, size
);
448 posix_acl_release(acl
);
454 xfs_xattr_system_set(struct inode
*inode
, const char *name
,
455 const void *value
, size_t size
, int flags
)
457 struct posix_acl
*acl
= NULL
;
460 type
= xfs_decode_acl(name
);
463 if (flags
& XATTR_CREATE
)
465 if (type
== ACL_TYPE_DEFAULT
&& !S_ISDIR(inode
->i_mode
))
466 return value
? -EACCES
: 0;
467 if ((current_fsuid() != inode
->i_uid
) && !capable(CAP_FOWNER
))
473 acl
= posix_acl_from_xattr(value
, size
);
476 * acl_set_file(3) may request that we set default ACLs with
477 * zero length -- defend (gracefully) against that here.
482 error
= PTR_ERR(acl
);
486 error
= posix_acl_valid(acl
);
491 if (acl
->a_count
> XFS_ACL_MAX_ENTRIES
)
494 if (type
== ACL_TYPE_ACCESS
) {
495 mode_t mode
= inode
->i_mode
;
496 error
= posix_acl_equiv_mode(acl
, &mode
);
499 posix_acl_release(acl
);
506 error
= xfs_set_mode(inode
, mode
);
512 error
= xfs_set_acl(inode
, type
, acl
);
514 posix_acl_release(acl
);
519 struct xattr_handler xfs_xattr_system_handler
= {
520 .prefix
= XATTR_SYSTEM_PREFIX
,
521 .get
= xfs_xattr_system_get
,
522 .set
= xfs_xattr_system_set
,