1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Copyright (C) 2004, 2008 Oracle. All rights reserved.
9 * Lots of code in this file is copy from linux/fs/ext3/acl.c.
10 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public
14 * License version 2 as published by the Free Software Foundation.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/string.h>
27 #include <cluster/masklog.h>
41 * Convert from xattr value to acl struct.
43 static struct posix_acl
*ocfs2_acl_from_xattr(const void *value
, size_t size
)
46 struct posix_acl
*acl
;
50 if (size
< sizeof(struct posix_acl_entry
))
51 return ERR_PTR(-EINVAL
);
53 count
= size
/ sizeof(struct posix_acl_entry
);
55 acl
= posix_acl_alloc(count
, GFP_NOFS
);
57 return ERR_PTR(-ENOMEM
);
58 for (n
= 0; n
< count
; n
++) {
59 struct ocfs2_acl_entry
*entry
=
60 (struct ocfs2_acl_entry
*)value
;
62 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
63 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
64 switch(acl
->a_entries
[n
].e_tag
) {
66 acl
->a_entries
[n
].e_uid
=
67 make_kuid(&init_user_ns
,
68 le32_to_cpu(entry
->e_id
));
71 acl
->a_entries
[n
].e_gid
=
72 make_kgid(&init_user_ns
,
73 le32_to_cpu(entry
->e_id
));
78 value
+= sizeof(struct posix_acl_entry
);
85 * Convert acl struct to xattr value.
87 static void *ocfs2_acl_to_xattr(const struct posix_acl
*acl
, size_t *size
)
89 struct ocfs2_acl_entry
*entry
= NULL
;
93 *size
= acl
->a_count
* sizeof(struct posix_acl_entry
);
95 ocfs2_acl
= kmalloc(*size
, GFP_NOFS
);
97 return ERR_PTR(-ENOMEM
);
99 entry
= (struct ocfs2_acl_entry
*)ocfs2_acl
;
100 for (n
= 0; n
< acl
->a_count
; n
++, entry
++) {
101 entry
->e_tag
= cpu_to_le16(acl
->a_entries
[n
].e_tag
);
102 entry
->e_perm
= cpu_to_le16(acl
->a_entries
[n
].e_perm
);
103 switch(acl
->a_entries
[n
].e_tag
) {
105 entry
->e_id
= cpu_to_le32(
106 from_kuid(&init_user_ns
,
107 acl
->a_entries
[n
].e_uid
));
110 entry
->e_id
= cpu_to_le32(
111 from_kgid(&init_user_ns
,
112 acl
->a_entries
[n
].e_gid
));
115 entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
122 static struct posix_acl
*ocfs2_get_acl_nolock(struct inode
*inode
,
124 struct buffer_head
*di_bh
)
128 struct posix_acl
*acl
;
132 case ACL_TYPE_ACCESS
:
133 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS
;
135 case ACL_TYPE_DEFAULT
:
136 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
;
139 return ERR_PTR(-EINVAL
);
142 retval
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
, "", NULL
, 0);
144 value
= kmalloc(retval
, GFP_NOFS
);
146 return ERR_PTR(-ENOMEM
);
147 retval
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
,
152 acl
= ocfs2_acl_from_xattr(value
, retval
);
153 else if (retval
== -ENODATA
|| retval
== 0)
156 acl
= ERR_PTR(retval
);
167 static struct posix_acl
*ocfs2_get_acl(struct inode
*inode
, int type
)
169 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
170 struct buffer_head
*di_bh
= NULL
;
171 struct posix_acl
*acl
;
174 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
177 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
184 acl
= ocfs2_get_acl_nolock(inode
, type
, di_bh
);
186 ocfs2_inode_unlock(inode
, 0);
194 * Helper function to set i_mode in memory and disk. Some call paths
195 * will not have di_bh or a journal handle to pass, in which case it
196 * will create it's own.
198 static int ocfs2_acl_set_mode(struct inode
*inode
, struct buffer_head
*di_bh
,
199 handle_t
*handle
, umode_t new_mode
)
201 int ret
, commit_handle
= 0;
202 struct ocfs2_dinode
*di
;
205 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
213 if (handle
== NULL
) {
214 handle
= ocfs2_start_trans(OCFS2_SB(inode
->i_sb
),
215 OCFS2_INODE_UPDATE_CREDITS
);
216 if (IS_ERR(handle
)) {
217 ret
= PTR_ERR(handle
);
225 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
226 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
227 OCFS2_JOURNAL_ACCESS_WRITE
);
233 inode
->i_mode
= new_mode
;
234 inode
->i_ctime
= CURRENT_TIME
;
235 di
->i_mode
= cpu_to_le16(inode
->i_mode
);
236 di
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
237 di
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
239 ocfs2_journal_dirty(handle
, di_bh
);
243 ocfs2_commit_trans(OCFS2_SB(inode
->i_sb
), handle
);
251 * Set the access or default ACL of an inode.
253 static int ocfs2_set_acl(handle_t
*handle
,
255 struct buffer_head
*di_bh
,
257 struct posix_acl
*acl
,
258 struct ocfs2_alloc_context
*meta_ac
,
259 struct ocfs2_alloc_context
*data_ac
)
266 if (S_ISLNK(inode
->i_mode
))
270 case ACL_TYPE_ACCESS
:
271 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS
;
273 umode_t mode
= inode
->i_mode
;
274 ret
= posix_acl_equiv_mode(acl
, &mode
);
281 ret
= ocfs2_acl_set_mode(inode
, di_bh
,
289 case ACL_TYPE_DEFAULT
:
290 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
;
291 if (!S_ISDIR(inode
->i_mode
))
292 return acl
? -EACCES
: 0;
299 value
= ocfs2_acl_to_xattr(acl
, &size
);
301 return (int)PTR_ERR(value
);
305 ret
= ocfs2_xattr_set_handle(handle
, inode
, di_bh
, name_index
,
309 ret
= ocfs2_xattr_set(inode
, name_index
, "", value
, size
, 0);
316 struct posix_acl
*ocfs2_iop_get_acl(struct inode
*inode
, int type
)
318 struct ocfs2_super
*osb
;
319 struct buffer_head
*di_bh
= NULL
;
320 struct posix_acl
*acl
;
323 osb
= OCFS2_SB(inode
->i_sb
);
324 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
327 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
331 acl
= ocfs2_get_acl_nolock(inode
, type
, di_bh
);
338 int ocfs2_acl_chmod(struct inode
*inode
)
340 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
341 struct posix_acl
*acl
;
344 if (S_ISLNK(inode
->i_mode
))
347 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
350 acl
= ocfs2_get_acl(inode
, ACL_TYPE_ACCESS
);
351 if (IS_ERR(acl
) || !acl
)
353 ret
= posix_acl_chmod(&acl
, GFP_KERNEL
, inode
->i_mode
);
356 ret
= ocfs2_set_acl(NULL
, inode
, NULL
, ACL_TYPE_ACCESS
,
358 posix_acl_release(acl
);
363 * Initialize the ACLs of a new inode. If parent directory has default ACL,
364 * then clone to new inode. Called from ocfs2_mknod.
366 int ocfs2_init_acl(handle_t
*handle
,
369 struct buffer_head
*di_bh
,
370 struct buffer_head
*dir_bh
,
371 struct ocfs2_alloc_context
*meta_ac
,
372 struct ocfs2_alloc_context
*data_ac
)
374 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
375 struct posix_acl
*acl
= NULL
;
379 if (!S_ISLNK(inode
->i_mode
)) {
380 if (osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
) {
381 acl
= ocfs2_get_acl_nolock(dir
, ACL_TYPE_DEFAULT
,
387 mode
= inode
->i_mode
& ~current_umask();
388 ret
= ocfs2_acl_set_mode(inode
, di_bh
, handle
, mode
);
395 if ((osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
) && acl
) {
396 if (S_ISDIR(inode
->i_mode
)) {
397 ret
= ocfs2_set_acl(handle
, inode
, di_bh
,
398 ACL_TYPE_DEFAULT
, acl
,
403 mode
= inode
->i_mode
;
404 ret
= posix_acl_create(&acl
, GFP_NOFS
, &mode
);
408 ret2
= ocfs2_acl_set_mode(inode
, di_bh
, handle
, mode
);
415 ret
= ocfs2_set_acl(handle
, inode
,
416 di_bh
, ACL_TYPE_ACCESS
,
417 acl
, meta_ac
, data_ac
);
421 posix_acl_release(acl
);
425 static size_t ocfs2_xattr_list_acl_access(struct dentry
*dentry
,
432 struct ocfs2_super
*osb
= OCFS2_SB(dentry
->d_sb
);
433 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
435 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
438 if (list
&& size
<= list_len
)
439 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
443 static size_t ocfs2_xattr_list_acl_default(struct dentry
*dentry
,
450 struct ocfs2_super
*osb
= OCFS2_SB(dentry
->d_sb
);
451 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
453 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
456 if (list
&& size
<= list_len
)
457 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
461 static int ocfs2_xattr_get_acl(struct dentry
*dentry
, const char *name
,
462 void *buffer
, size_t size
, int type
)
464 struct ocfs2_super
*osb
= OCFS2_SB(dentry
->d_sb
);
465 struct posix_acl
*acl
;
468 if (strcmp(name
, "") != 0)
470 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
473 acl
= ocfs2_get_acl(dentry
->d_inode
, type
);
478 ret
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
479 posix_acl_release(acl
);
484 static int ocfs2_xattr_set_acl(struct dentry
*dentry
, const char *name
,
485 const void *value
, size_t size
, int flags
, int type
)
487 struct inode
*inode
= dentry
->d_inode
;
488 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
489 struct posix_acl
*acl
;
492 if (strcmp(name
, "") != 0)
494 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
497 if (!inode_owner_or_capable(inode
))
501 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
505 ret
= posix_acl_valid(acl
);
512 ret
= ocfs2_set_acl(NULL
, inode
, NULL
, type
, acl
, NULL
, NULL
);
515 posix_acl_release(acl
);
519 const struct xattr_handler ocfs2_xattr_acl_access_handler
= {
520 .prefix
= POSIX_ACL_XATTR_ACCESS
,
521 .flags
= ACL_TYPE_ACCESS
,
522 .list
= ocfs2_xattr_list_acl_access
,
523 .get
= ocfs2_xattr_get_acl
,
524 .set
= ocfs2_xattr_set_acl
,
527 const struct xattr_handler ocfs2_xattr_acl_default_handler
= {
528 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
529 .flags
= ACL_TYPE_DEFAULT
,
530 .list
= ocfs2_xattr_list_acl_default
,
531 .get
= ocfs2_xattr_get_acl
,
532 .set
= ocfs2_xattr_set_acl
,