2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2006 NEC Corporation
6 * Created by KaiGai Kohei <kaigai@ak.jp.nec.com>
8 * For licensing information, see the file 'LICENCE' in this directory.
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
14 #include <linux/time.h>
15 #include <linux/crc32.h>
16 #include <linux/jffs2.h>
17 #include <linux/xattr.h>
18 #include <linux/posix_acl_xattr.h>
19 #include <linux/mtd/mtd.h>
22 static size_t jffs2_acl_size(int count
)
25 return sizeof(struct jffs2_acl_header
)
26 + count
* sizeof(struct jffs2_acl_entry_short
);
28 return sizeof(struct jffs2_acl_header
)
29 + 4 * sizeof(struct jffs2_acl_entry_short
)
30 + (count
- 4) * sizeof(struct jffs2_acl_entry
);
34 static int jffs2_acl_count(size_t size
)
38 size
-= sizeof(struct jffs2_acl_header
);
39 s
= size
- 4 * sizeof(struct jffs2_acl_entry_short
);
41 if (size
% sizeof(struct jffs2_acl_entry_short
))
43 return size
/ sizeof(struct jffs2_acl_entry_short
);
45 if (s
% sizeof(struct jffs2_acl_entry
))
47 return s
/ sizeof(struct jffs2_acl_entry
) + 4;
51 static struct posix_acl
*jffs2_acl_from_medium(const void *value
, size_t size
)
53 const char *end
= (char *)value
+ size
;
54 struct posix_acl
*acl
;
60 if (size
< sizeof(struct jffs2_acl_header
))
61 return ERR_PTR(-EINVAL
);
62 ver
= je32_to_cpu(((struct jffs2_acl_header
*)value
)->a_version
);
63 if (ver
!= JFFS2_ACL_VERSION
) {
64 JFFS2_WARNING("Invalid ACL version. (=%u)\n", ver
);
65 return ERR_PTR(-EINVAL
);
68 value
= (char *)value
+ sizeof(struct jffs2_acl_header
);
69 count
= jffs2_acl_count(size
);
71 return ERR_PTR(-EINVAL
);
75 acl
= posix_acl_alloc(count
, GFP_KERNEL
);
77 return ERR_PTR(-ENOMEM
);
79 for (i
=0; i
< count
; i
++) {
80 struct jffs2_acl_entry
*entry
= (struct jffs2_acl_entry
*)value
;
81 if ((char *)value
+ sizeof(struct jffs2_acl_entry_short
) > end
)
83 acl
->a_entries
[i
].e_tag
= je16_to_cpu(entry
->e_tag
);
84 acl
->a_entries
[i
].e_perm
= je16_to_cpu(entry
->e_perm
);
85 switch (acl
->a_entries
[i
].e_tag
) {
90 value
= (char *)value
+ sizeof(struct jffs2_acl_entry_short
);
91 acl
->a_entries
[i
].e_id
= ACL_UNDEFINED_ID
;
96 value
= (char *)value
+ sizeof(struct jffs2_acl_entry
);
97 if ((char *)value
> end
)
99 acl
->a_entries
[i
].e_id
= je32_to_cpu(entry
->e_id
);
110 posix_acl_release(acl
);
111 return ERR_PTR(-EINVAL
);
114 static void *jffs2_acl_to_medium(const struct posix_acl
*acl
, size_t *size
)
116 struct jffs2_acl_header
*jffs2_acl
;
120 *size
= jffs2_acl_size(acl
->a_count
);
121 jffs2_acl
= kmalloc(sizeof(struct jffs2_acl_header
)
122 + acl
->a_count
* sizeof(struct jffs2_acl_entry
),
125 return ERR_PTR(-ENOMEM
);
126 jffs2_acl
->a_version
= cpu_to_je32(JFFS2_ACL_VERSION
);
127 e
= (char *)jffs2_acl
+ sizeof(struct jffs2_acl_header
);
128 for (i
=0; i
< acl
->a_count
; i
++) {
129 struct jffs2_acl_entry
*entry
= (struct jffs2_acl_entry
*)e
;
130 entry
->e_tag
= cpu_to_je16(acl
->a_entries
[i
].e_tag
);
131 entry
->e_perm
= cpu_to_je16(acl
->a_entries
[i
].e_perm
);
132 switch(acl
->a_entries
[i
].e_tag
) {
135 entry
->e_id
= cpu_to_je32(acl
->a_entries
[i
].e_id
);
136 e
+= sizeof(struct jffs2_acl_entry
);
143 e
+= sizeof(struct jffs2_acl_entry_short
);
150 return (char *)jffs2_acl
;
153 return ERR_PTR(-EINVAL
);
156 static struct posix_acl
*jffs2_iget_acl(struct inode
*inode
, struct posix_acl
**i_acl
)
158 struct posix_acl
*acl
= JFFS2_ACL_NOT_CACHED
;
160 spin_lock(&inode
->i_lock
);
161 if (*i_acl
!= JFFS2_ACL_NOT_CACHED
)
162 acl
= posix_acl_dup(*i_acl
);
163 spin_unlock(&inode
->i_lock
);
167 static void jffs2_iset_acl(struct inode
*inode
, struct posix_acl
**i_acl
, struct posix_acl
*acl
)
169 spin_lock(&inode
->i_lock
);
170 if (*i_acl
!= JFFS2_ACL_NOT_CACHED
)
171 posix_acl_release(*i_acl
);
172 *i_acl
= posix_acl_dup(acl
);
173 spin_unlock(&inode
->i_lock
);
176 static struct posix_acl
*jffs2_get_acl(struct inode
*inode
, int type
)
178 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
179 struct posix_acl
*acl
;
184 case ACL_TYPE_ACCESS
:
185 acl
= jffs2_iget_acl(inode
, &f
->i_acl_access
);
186 if (acl
!= JFFS2_ACL_NOT_CACHED
)
188 xprefix
= JFFS2_XPREFIX_ACL_ACCESS
;
190 case ACL_TYPE_DEFAULT
:
191 acl
= jffs2_iget_acl(inode
, &f
->i_acl_default
);
192 if (acl
!= JFFS2_ACL_NOT_CACHED
)
194 xprefix
= JFFS2_XPREFIX_ACL_DEFAULT
;
197 return ERR_PTR(-EINVAL
);
199 rc
= do_jffs2_getxattr(inode
, xprefix
, "", NULL
, 0);
201 value
= kmalloc(rc
, GFP_KERNEL
);
203 return ERR_PTR(-ENOMEM
);
204 rc
= do_jffs2_getxattr(inode
, xprefix
, "", value
, rc
);
207 acl
= jffs2_acl_from_medium(value
, rc
);
208 } else if (rc
== -ENODATA
|| rc
== -ENOSYS
) {
217 case ACL_TYPE_ACCESS
:
218 jffs2_iset_acl(inode
, &f
->i_acl_access
, acl
);
220 case ACL_TYPE_DEFAULT
:
221 jffs2_iset_acl(inode
, &f
->i_acl_default
, acl
);
228 static int jffs2_set_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
230 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
235 if (S_ISLNK(inode
->i_mode
))
239 case ACL_TYPE_ACCESS
:
240 xprefix
= JFFS2_XPREFIX_ACL_ACCESS
;
242 mode_t mode
= inode
->i_mode
;
243 rc
= posix_acl_equiv_mode(acl
, &mode
);
246 if (inode
->i_mode
!= mode
) {
247 inode
->i_mode
= mode
;
248 jffs2_dirty_inode(inode
);
254 case ACL_TYPE_DEFAULT
:
255 xprefix
= JFFS2_XPREFIX_ACL_DEFAULT
;
256 if (!S_ISDIR(inode
->i_mode
))
257 return acl
? -EACCES
: 0;
263 value
= jffs2_acl_to_medium(acl
, &size
);
265 return PTR_ERR(value
);
268 rc
= do_jffs2_setxattr(inode
, xprefix
, "", value
, size
, 0);
273 case ACL_TYPE_ACCESS
:
274 jffs2_iset_acl(inode
, &f
->i_acl_access
, acl
);
276 case ACL_TYPE_DEFAULT
:
277 jffs2_iset_acl(inode
, &f
->i_acl_default
, acl
);
284 static int jffs2_check_acl(struct inode
*inode
, int mask
)
286 struct posix_acl
*acl
;
289 acl
= jffs2_get_acl(inode
, ACL_TYPE_ACCESS
);
293 rc
= posix_acl_permission(inode
, acl
, mask
);
294 posix_acl_release(acl
);
300 int jffs2_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
302 return generic_permission(inode
, mask
, jffs2_check_acl
);
305 int jffs2_init_acl(struct inode
*inode
, struct inode
*dir
)
307 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
308 struct posix_acl
*acl
= NULL
, *clone
;
312 f
->i_acl_access
= JFFS2_ACL_NOT_CACHED
;
313 f
->i_acl_default
= JFFS2_ACL_NOT_CACHED
;
314 if (!S_ISLNK(inode
->i_mode
)) {
315 acl
= jffs2_get_acl(dir
, ACL_TYPE_DEFAULT
);
319 inode
->i_mode
&= ~current
->fs
->umask
;
322 if (S_ISDIR(inode
->i_mode
)) {
323 rc
= jffs2_set_acl(inode
, ACL_TYPE_DEFAULT
, acl
);
327 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
331 mode
= inode
->i_mode
;
332 rc
= posix_acl_create_masq(clone
, &mode
);
334 inode
->i_mode
= mode
;
336 rc
= jffs2_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
338 posix_acl_release(clone
);
341 posix_acl_release(acl
);
345 void jffs2_clear_acl(struct inode
*inode
)
347 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
349 if (f
->i_acl_access
&& f
->i_acl_access
!= JFFS2_ACL_NOT_CACHED
) {
350 posix_acl_release(f
->i_acl_access
);
351 f
->i_acl_access
= JFFS2_ACL_NOT_CACHED
;
353 if (f
->i_acl_default
&& f
->i_acl_default
!= JFFS2_ACL_NOT_CACHED
) {
354 posix_acl_release(f
->i_acl_default
);
355 f
->i_acl_default
= JFFS2_ACL_NOT_CACHED
;
359 int jffs2_acl_chmod(struct inode
*inode
)
361 struct posix_acl
*acl
, *clone
;
364 if (S_ISLNK(inode
->i_mode
))
366 acl
= jffs2_get_acl(inode
, ACL_TYPE_ACCESS
);
367 if (IS_ERR(acl
) || !acl
)
369 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
370 posix_acl_release(acl
);
373 rc
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
375 rc
= jffs2_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
376 posix_acl_release(clone
);
380 static size_t jffs2_acl_access_listxattr(struct inode
*inode
, char *list
, size_t list_size
,
381 const char *name
, size_t name_len
)
383 const int retlen
= sizeof(POSIX_ACL_XATTR_ACCESS
);
385 if (list
&& retlen
<= list_size
)
386 strcpy(list
, POSIX_ACL_XATTR_ACCESS
);
390 static size_t jffs2_acl_default_listxattr(struct inode
*inode
, char *list
, size_t list_size
,
391 const char *name
, size_t name_len
)
393 const int retlen
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
395 if (list
&& retlen
<= list_size
)
396 strcpy(list
, POSIX_ACL_XATTR_DEFAULT
);
400 static int jffs2_acl_getxattr(struct inode
*inode
, int type
, void *buffer
, size_t size
)
402 struct posix_acl
*acl
;
405 acl
= jffs2_get_acl(inode
, type
);
410 rc
= posix_acl_to_xattr(acl
, buffer
, size
);
411 posix_acl_release(acl
);
416 static int jffs2_acl_access_getxattr(struct inode
*inode
, const char *name
, void *buffer
, size_t size
)
420 return jffs2_acl_getxattr(inode
, ACL_TYPE_ACCESS
, buffer
, size
);
423 static int jffs2_acl_default_getxattr(struct inode
*inode
, const char *name
, void *buffer
, size_t size
)
427 return jffs2_acl_getxattr(inode
, ACL_TYPE_DEFAULT
, buffer
, size
);
430 static int jffs2_acl_setxattr(struct inode
*inode
, int type
, const void *value
, size_t size
)
432 struct posix_acl
*acl
;
435 if ((current
->fsuid
!= inode
->i_uid
) && !capable(CAP_FOWNER
))
439 acl
= posix_acl_from_xattr(value
, size
);
443 rc
= posix_acl_valid(acl
);
450 rc
= jffs2_set_acl(inode
, type
, acl
);
452 posix_acl_release(acl
);
456 static int jffs2_acl_access_setxattr(struct inode
*inode
, const char *name
,
457 const void *buffer
, size_t size
, int flags
)
461 return jffs2_acl_setxattr(inode
, ACL_TYPE_ACCESS
, buffer
, size
);
464 static int jffs2_acl_default_setxattr(struct inode
*inode
, const char *name
,
465 const void *buffer
, size_t size
, int flags
)
469 return jffs2_acl_setxattr(inode
, ACL_TYPE_DEFAULT
, buffer
, size
);
472 struct xattr_handler jffs2_acl_access_xattr_handler
= {
473 .prefix
= POSIX_ACL_XATTR_ACCESS
,
474 .list
= jffs2_acl_access_listxattr
,
475 .get
= jffs2_acl_access_getxattr
,
476 .set
= jffs2_acl_access_setxattr
,
479 struct xattr_handler jffs2_acl_default_xattr_handler
= {
480 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
481 .list
= jffs2_acl_default_listxattr
,
482 .get
= jffs2_acl_default_getxattr
,
483 .set
= jffs2_acl_default_setxattr
,