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 return ERR_PTR(-EINVAL
);
59 acl
= posix_acl_alloc(count
, GFP_NOFS
);
61 return ERR_PTR(-ENOMEM
);
62 for (n
= 0; n
< count
; n
++) {
63 struct ocfs2_acl_entry
*entry
=
64 (struct ocfs2_acl_entry
*)value
;
66 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
67 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
68 switch(acl
->a_entries
[n
].e_tag
) {
70 acl
->a_entries
[n
].e_uid
=
71 make_kuid(&init_user_ns
,
72 le32_to_cpu(entry
->e_id
));
75 acl
->a_entries
[n
].e_gid
=
76 make_kgid(&init_user_ns
,
77 le32_to_cpu(entry
->e_id
));
82 value
+= sizeof(struct posix_acl_entry
);
89 * Convert acl struct to xattr value.
91 static void *ocfs2_acl_to_xattr(const struct posix_acl
*acl
, size_t *size
)
93 struct ocfs2_acl_entry
*entry
= NULL
;
97 *size
= acl
->a_count
* sizeof(struct posix_acl_entry
);
99 ocfs2_acl
= kmalloc(*size
, GFP_NOFS
);
101 return ERR_PTR(-ENOMEM
);
103 entry
= (struct ocfs2_acl_entry
*)ocfs2_acl
;
104 for (n
= 0; n
< acl
->a_count
; n
++, entry
++) {
105 entry
->e_tag
= cpu_to_le16(acl
->a_entries
[n
].e_tag
);
106 entry
->e_perm
= cpu_to_le16(acl
->a_entries
[n
].e_perm
);
107 switch(acl
->a_entries
[n
].e_tag
) {
109 entry
->e_id
= cpu_to_le32(
110 from_kuid(&init_user_ns
,
111 acl
->a_entries
[n
].e_uid
));
114 entry
->e_id
= cpu_to_le32(
115 from_kgid(&init_user_ns
,
116 acl
->a_entries
[n
].e_gid
));
119 entry
->e_id
= cpu_to_le32(ACL_UNDEFINED_ID
);
126 static struct posix_acl
*ocfs2_get_acl_nolock(struct inode
*inode
,
128 struct buffer_head
*di_bh
)
132 struct posix_acl
*acl
;
136 case ACL_TYPE_ACCESS
:
137 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS
;
139 case ACL_TYPE_DEFAULT
:
140 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
;
143 return ERR_PTR(-EINVAL
);
146 retval
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
, "", NULL
, 0);
148 value
= kmalloc(retval
, GFP_NOFS
);
150 return ERR_PTR(-ENOMEM
);
151 retval
= ocfs2_xattr_get_nolock(inode
, di_bh
, name_index
,
156 acl
= ocfs2_acl_from_xattr(value
, retval
);
157 else if (retval
== -ENODATA
|| retval
== 0)
160 acl
= ERR_PTR(retval
);
171 static struct posix_acl
*ocfs2_get_acl(struct inode
*inode
, int type
)
173 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
174 struct buffer_head
*di_bh
= NULL
;
175 struct posix_acl
*acl
;
178 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
181 ret
= ocfs2_inode_lock(inode
, &di_bh
, 0);
188 acl
= ocfs2_get_acl_nolock(inode
, type
, di_bh
);
190 ocfs2_inode_unlock(inode
, 0);
198 * Helper function to set i_mode in memory and disk. Some call paths
199 * will not have di_bh or a journal handle to pass, in which case it
200 * will create it's own.
202 static int ocfs2_acl_set_mode(struct inode
*inode
, struct buffer_head
*di_bh
,
203 handle_t
*handle
, umode_t new_mode
)
205 int ret
, commit_handle
= 0;
206 struct ocfs2_dinode
*di
;
209 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
217 if (handle
== NULL
) {
218 handle
= ocfs2_start_trans(OCFS2_SB(inode
->i_sb
),
219 OCFS2_INODE_UPDATE_CREDITS
);
220 if (IS_ERR(handle
)) {
221 ret
= PTR_ERR(handle
);
229 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
230 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
231 OCFS2_JOURNAL_ACCESS_WRITE
);
237 inode
->i_mode
= new_mode
;
238 inode
->i_ctime
= CURRENT_TIME
;
239 di
->i_mode
= cpu_to_le16(inode
->i_mode
);
240 di
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
241 di
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
243 ocfs2_journal_dirty(handle
, di_bh
);
247 ocfs2_commit_trans(OCFS2_SB(inode
->i_sb
), handle
);
255 * Set the access or default ACL of an inode.
257 static int ocfs2_set_acl(handle_t
*handle
,
259 struct buffer_head
*di_bh
,
261 struct posix_acl
*acl
,
262 struct ocfs2_alloc_context
*meta_ac
,
263 struct ocfs2_alloc_context
*data_ac
)
270 if (S_ISLNK(inode
->i_mode
))
274 case ACL_TYPE_ACCESS
:
275 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS
;
277 umode_t mode
= inode
->i_mode
;
278 ret
= posix_acl_update_mode(inode
, &mode
, &acl
);
281 ret
= ocfs2_acl_set_mode(inode
, di_bh
,
287 case ACL_TYPE_DEFAULT
:
288 name_index
= OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT
;
289 if (!S_ISDIR(inode
->i_mode
))
290 return acl
? -EACCES
: 0;
297 value
= ocfs2_acl_to_xattr(acl
, &size
);
299 return (int)PTR_ERR(value
);
303 ret
= ocfs2_xattr_set_handle(handle
, inode
, di_bh
, name_index
,
307 ret
= ocfs2_xattr_set(inode
, name_index
, "", value
, size
, 0);
314 struct posix_acl
*ocfs2_iop_get_acl(struct inode
*inode
, int type
)
316 struct ocfs2_super
*osb
;
317 struct buffer_head
*di_bh
= NULL
;
318 struct posix_acl
*acl
;
321 osb
= OCFS2_SB(inode
->i_sb
);
322 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
325 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
329 acl
= ocfs2_get_acl_nolock(inode
, type
, di_bh
);
336 int ocfs2_acl_chmod(struct inode
*inode
)
338 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
339 struct posix_acl
*acl
;
342 if (S_ISLNK(inode
->i_mode
))
345 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
348 acl
= ocfs2_get_acl(inode
, ACL_TYPE_ACCESS
);
349 if (IS_ERR(acl
) || !acl
)
351 ret
= posix_acl_chmod(&acl
, GFP_KERNEL
, inode
->i_mode
);
354 ret
= ocfs2_set_acl(NULL
, inode
, NULL
, ACL_TYPE_ACCESS
,
356 posix_acl_release(acl
);
361 * Initialize the ACLs of a new inode. If parent directory has default ACL,
362 * then clone to new inode. Called from ocfs2_mknod.
364 int ocfs2_init_acl(handle_t
*handle
,
367 struct buffer_head
*di_bh
,
368 struct buffer_head
*dir_bh
,
369 struct ocfs2_alloc_context
*meta_ac
,
370 struct ocfs2_alloc_context
*data_ac
)
372 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
373 struct posix_acl
*acl
= NULL
;
377 if (!S_ISLNK(inode
->i_mode
)) {
378 if (osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
) {
379 acl
= ocfs2_get_acl_nolock(dir
, ACL_TYPE_DEFAULT
,
385 mode
= inode
->i_mode
& ~current_umask();
386 ret
= ocfs2_acl_set_mode(inode
, di_bh
, handle
, mode
);
393 if ((osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
) && acl
) {
394 if (S_ISDIR(inode
->i_mode
)) {
395 ret
= ocfs2_set_acl(handle
, inode
, di_bh
,
396 ACL_TYPE_DEFAULT
, acl
,
401 mode
= inode
->i_mode
;
402 ret
= posix_acl_create(&acl
, GFP_NOFS
, &mode
);
406 ret2
= ocfs2_acl_set_mode(inode
, di_bh
, handle
, mode
);
413 ret
= ocfs2_set_acl(handle
, inode
,
414 di_bh
, ACL_TYPE_ACCESS
,
415 acl
, meta_ac
, data_ac
);
419 posix_acl_release(acl
);
423 static size_t ocfs2_xattr_list_acl_access(struct dentry
*dentry
,
430 struct ocfs2_super
*osb
= OCFS2_SB(dentry
->d_sb
);
431 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
433 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
436 if (list
&& size
<= list_len
)
437 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
441 static size_t ocfs2_xattr_list_acl_default(struct dentry
*dentry
,
448 struct ocfs2_super
*osb
= OCFS2_SB(dentry
->d_sb
);
449 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
451 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
454 if (list
&& size
<= list_len
)
455 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
459 static int ocfs2_xattr_get_acl(struct dentry
*dentry
, const char *name
,
460 void *buffer
, size_t size
, int type
)
462 struct ocfs2_super
*osb
= OCFS2_SB(dentry
->d_sb
);
463 struct posix_acl
*acl
;
466 if (strcmp(name
, "") != 0)
468 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
471 acl
= ocfs2_get_acl(dentry
->d_inode
, type
);
476 ret
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
477 posix_acl_release(acl
);
482 static int ocfs2_xattr_set_acl(struct dentry
*dentry
, const char *name
,
483 const void *value
, size_t size
, int flags
, int type
)
485 struct inode
*inode
= dentry
->d_inode
;
486 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
487 struct posix_acl
*acl
;
490 if (strcmp(name
, "") != 0)
492 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_POSIX_ACL
))
495 if (!inode_owner_or_capable(inode
))
499 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
503 ret
= posix_acl_valid(acl
);
510 ret
= ocfs2_set_acl(NULL
, inode
, NULL
, type
, acl
, NULL
, NULL
);
513 posix_acl_release(acl
);
517 const struct xattr_handler ocfs2_xattr_acl_access_handler
= {
518 .prefix
= POSIX_ACL_XATTR_ACCESS
,
519 .flags
= ACL_TYPE_ACCESS
,
520 .list
= ocfs2_xattr_list_acl_access
,
521 .get
= ocfs2_xattr_get_acl
,
522 .set
= ocfs2_xattr_set_acl
,
525 const struct xattr_handler ocfs2_xattr_acl_default_handler
= {
526 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
527 .flags
= ACL_TYPE_DEFAULT
,
528 .list
= ocfs2_xattr_list_acl_default
,
529 .get
= ocfs2_xattr_get_acl
,
530 .set
= ocfs2_xattr_set_acl
,