2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2006 NEC Corporation
6 * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
8 * For licensing information, see the file 'LICENCE' in this directory.
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
15 #include <linux/sched.h>
16 #include <linux/time.h>
17 #include <linux/crc32.h>
18 #include <linux/jffs2.h>
19 #include <linux/xattr.h>
20 #include <linux/posix_acl_xattr.h>
21 #include <linux/mtd/mtd.h>
24 static size_t jffs2_acl_size(int count
)
27 return sizeof(struct jffs2_acl_header
)
28 + count
* sizeof(struct jffs2_acl_entry_short
);
30 return sizeof(struct jffs2_acl_header
)
31 + 4 * sizeof(struct jffs2_acl_entry_short
)
32 + (count
- 4) * sizeof(struct jffs2_acl_entry
);
36 static int jffs2_acl_count(size_t size
)
40 size
-= sizeof(struct jffs2_acl_header
);
41 if (size
< 4 * sizeof(struct jffs2_acl_entry_short
)) {
42 if (size
% sizeof(struct jffs2_acl_entry_short
))
44 return size
/ sizeof(struct jffs2_acl_entry_short
);
46 s
= size
- 4 * sizeof(struct jffs2_acl_entry_short
);
47 if (s
% sizeof(struct jffs2_acl_entry
))
49 return s
/ sizeof(struct jffs2_acl_entry
) + 4;
53 static struct posix_acl
*jffs2_acl_from_medium(void *value
, size_t size
)
55 void *end
= value
+ size
;
56 struct jffs2_acl_header
*header
= value
;
57 struct jffs2_acl_entry
*entry
;
58 struct posix_acl
*acl
;
64 if (size
< sizeof(struct jffs2_acl_header
))
65 return ERR_PTR(-EINVAL
);
66 ver
= je32_to_cpu(header
->a_version
);
67 if (ver
!= JFFS2_ACL_VERSION
) {
68 JFFS2_WARNING("Invalid ACL version. (=%u)\n", ver
);
69 return ERR_PTR(-EINVAL
);
72 value
+= sizeof(struct jffs2_acl_header
);
73 count
= jffs2_acl_count(size
);
75 return ERR_PTR(-EINVAL
);
79 acl
= posix_acl_alloc(count
, GFP_KERNEL
);
81 return ERR_PTR(-ENOMEM
);
83 for (i
=0; i
< count
; i
++) {
85 if (value
+ sizeof(struct jffs2_acl_entry_short
) > end
)
87 acl
->a_entries
[i
].e_tag
= je16_to_cpu(entry
->e_tag
);
88 acl
->a_entries
[i
].e_perm
= je16_to_cpu(entry
->e_perm
);
89 switch (acl
->a_entries
[i
].e_tag
) {
94 value
+= sizeof(struct jffs2_acl_entry_short
);
95 acl
->a_entries
[i
].e_id
= ACL_UNDEFINED_ID
;
100 value
+= sizeof(struct jffs2_acl_entry
);
103 acl
->a_entries
[i
].e_id
= je32_to_cpu(entry
->e_id
);
114 posix_acl_release(acl
);
115 return ERR_PTR(-EINVAL
);
118 static void *jffs2_acl_to_medium(const struct posix_acl
*acl
, size_t *size
)
120 struct jffs2_acl_header
*header
;
121 struct jffs2_acl_entry
*entry
;
125 *size
= jffs2_acl_size(acl
->a_count
);
126 header
= kmalloc(sizeof(*header
) + acl
->a_count
* sizeof(*entry
), GFP_KERNEL
);
128 return ERR_PTR(-ENOMEM
);
129 header
->a_version
= cpu_to_je32(JFFS2_ACL_VERSION
);
131 for (i
=0; i
< acl
->a_count
; i
++) {
133 entry
->e_tag
= cpu_to_je16(acl
->a_entries
[i
].e_tag
);
134 entry
->e_perm
= cpu_to_je16(acl
->a_entries
[i
].e_perm
);
135 switch(acl
->a_entries
[i
].e_tag
) {
138 entry
->e_id
= cpu_to_je32(acl
->a_entries
[i
].e_id
);
139 e
+= sizeof(struct jffs2_acl_entry
);
146 e
+= sizeof(struct jffs2_acl_entry_short
);
156 return ERR_PTR(-EINVAL
);
159 static struct posix_acl
*jffs2_get_acl(struct inode
*inode
, int type
)
161 struct posix_acl
*acl
;
165 acl
= get_cached_acl(inode
, type
);
166 if (acl
!= ACL_NOT_CACHED
)
170 case ACL_TYPE_ACCESS
:
171 xprefix
= JFFS2_XPREFIX_ACL_ACCESS
;
173 case ACL_TYPE_DEFAULT
:
174 xprefix
= JFFS2_XPREFIX_ACL_DEFAULT
;
179 rc
= do_jffs2_getxattr(inode
, xprefix
, "", NULL
, 0);
181 value
= kmalloc(rc
, GFP_KERNEL
);
183 return ERR_PTR(-ENOMEM
);
184 rc
= do_jffs2_getxattr(inode
, xprefix
, "", value
, rc
);
187 acl
= jffs2_acl_from_medium(value
, rc
);
188 } else if (rc
== -ENODATA
|| rc
== -ENOSYS
) {
196 set_cached_acl(inode
, type
, acl
);
200 static int __jffs2_set_acl(struct inode
*inode
, int xprefix
, struct posix_acl
*acl
)
207 value
= jffs2_acl_to_medium(acl
, &size
);
209 return PTR_ERR(value
);
211 rc
= do_jffs2_setxattr(inode
, xprefix
, "", value
, size
, 0);
212 if (!value
&& rc
== -ENODATA
)
219 static int jffs2_set_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
223 if (S_ISLNK(inode
->i_mode
))
227 case ACL_TYPE_ACCESS
:
228 xprefix
= JFFS2_XPREFIX_ACL_ACCESS
;
230 mode_t mode
= inode
->i_mode
;
231 rc
= posix_acl_equiv_mode(acl
, &mode
);
234 if (inode
->i_mode
!= mode
) {
237 attr
.ia_valid
= ATTR_MODE
| ATTR_CTIME
;
239 attr
.ia_ctime
= CURRENT_TIME_SEC
;
240 rc
= jffs2_do_setattr(inode
, &attr
);
248 case ACL_TYPE_DEFAULT
:
249 xprefix
= JFFS2_XPREFIX_ACL_DEFAULT
;
250 if (!S_ISDIR(inode
->i_mode
))
251 return acl
? -EACCES
: 0;
256 rc
= __jffs2_set_acl(inode
, xprefix
, acl
);
258 set_cached_acl(inode
, type
, acl
);
262 int jffs2_check_acl(struct inode
*inode
, int mask
, unsigned int flags
)
264 struct posix_acl
*acl
;
267 if (flags
& IPERM_FLAG_RCU
)
270 acl
= jffs2_get_acl(inode
, ACL_TYPE_ACCESS
);
274 rc
= posix_acl_permission(inode
, acl
, mask
);
275 posix_acl_release(acl
);
281 int jffs2_init_acl_pre(struct inode
*dir_i
, struct inode
*inode
, int *i_mode
)
283 struct posix_acl
*acl
, *clone
;
288 if (S_ISLNK(*i_mode
))
289 return 0; /* Symlink always has no-ACL */
291 acl
= jffs2_get_acl(dir_i
, ACL_TYPE_DEFAULT
);
296 *i_mode
&= ~current_umask();
298 if (S_ISDIR(*i_mode
))
299 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, acl
);
301 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
304 rc
= posix_acl_create_masq(clone
, (mode_t
*)i_mode
);
306 posix_acl_release(clone
);
310 set_cached_acl(inode
, ACL_TYPE_ACCESS
, clone
);
312 posix_acl_release(clone
);
317 int jffs2_init_acl_post(struct inode
*inode
)
321 if (inode
->i_default_acl
) {
322 rc
= __jffs2_set_acl(inode
, JFFS2_XPREFIX_ACL_DEFAULT
, inode
->i_default_acl
);
328 rc
= __jffs2_set_acl(inode
, JFFS2_XPREFIX_ACL_ACCESS
, inode
->i_acl
);
336 int jffs2_acl_chmod(struct inode
*inode
)
338 struct posix_acl
*acl
, *clone
;
341 if (S_ISLNK(inode
->i_mode
))
343 acl
= jffs2_get_acl(inode
, ACL_TYPE_ACCESS
);
344 if (IS_ERR(acl
) || !acl
)
346 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
347 posix_acl_release(acl
);
350 rc
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
352 rc
= jffs2_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
353 posix_acl_release(clone
);
357 static size_t jffs2_acl_access_listxattr(struct dentry
*dentry
, char *list
,
358 size_t list_size
, const char *name
, size_t name_len
, int type
)
360 const int retlen
= sizeof(POSIX_ACL_XATTR_ACCESS
);
362 if (list
&& retlen
<= list_size
)
363 strcpy(list
, POSIX_ACL_XATTR_ACCESS
);
367 static size_t jffs2_acl_default_listxattr(struct dentry
*dentry
, char *list
,
368 size_t list_size
, const char *name
, size_t name_len
, int type
)
370 const int retlen
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
372 if (list
&& retlen
<= list_size
)
373 strcpy(list
, POSIX_ACL_XATTR_DEFAULT
);
377 static int jffs2_acl_getxattr(struct dentry
*dentry
, const char *name
,
378 void *buffer
, size_t size
, int type
)
380 struct posix_acl
*acl
;
386 acl
= jffs2_get_acl(dentry
->d_inode
, type
);
391 rc
= posix_acl_to_xattr(acl
, buffer
, size
);
392 posix_acl_release(acl
);
397 static int jffs2_acl_setxattr(struct dentry
*dentry
, const char *name
,
398 const void *value
, size_t size
, int flags
, int type
)
400 struct posix_acl
*acl
;
405 if (!is_owner_or_cap(dentry
->d_inode
))
409 acl
= posix_acl_from_xattr(value
, size
);
413 rc
= posix_acl_valid(acl
);
420 rc
= jffs2_set_acl(dentry
->d_inode
, type
, acl
);
422 posix_acl_release(acl
);
426 const struct xattr_handler jffs2_acl_access_xattr_handler
= {
427 .prefix
= POSIX_ACL_XATTR_ACCESS
,
428 .flags
= ACL_TYPE_DEFAULT
,
429 .list
= jffs2_acl_access_listxattr
,
430 .get
= jffs2_acl_getxattr
,
431 .set
= jffs2_acl_setxattr
,
434 const struct xattr_handler jffs2_acl_default_xattr_handler
= {
435 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
436 .flags
= ACL_TYPE_DEFAULT
,
437 .list
= jffs2_acl_default_listxattr
,
438 .get
= jffs2_acl_getxattr
,
439 .set
= jffs2_acl_setxattr
,