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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
17 #include <linux/sched.h>
18 #include <linux/time.h>
19 #include <linux/crc32.h>
20 #include <linux/jffs2.h>
21 #include <linux/xattr.h>
22 #include <linux/posix_acl_xattr.h>
23 #include <linux/mtd/mtd.h>
26 static size_t jffs2_acl_size(int count
)
29 return sizeof(struct jffs2_acl_header
)
30 + count
* sizeof(struct jffs2_acl_entry_short
);
32 return sizeof(struct jffs2_acl_header
)
33 + 4 * sizeof(struct jffs2_acl_entry_short
)
34 + (count
- 4) * sizeof(struct jffs2_acl_entry
);
38 static int jffs2_acl_count(size_t size
)
42 size
-= sizeof(struct jffs2_acl_header
);
43 if (size
< 4 * sizeof(struct jffs2_acl_entry_short
)) {
44 if (size
% sizeof(struct jffs2_acl_entry_short
))
46 return size
/ sizeof(struct jffs2_acl_entry_short
);
48 s
= size
- 4 * sizeof(struct jffs2_acl_entry_short
);
49 if (s
% sizeof(struct jffs2_acl_entry
))
51 return s
/ sizeof(struct jffs2_acl_entry
) + 4;
55 static struct posix_acl
*jffs2_acl_from_medium(void *value
, size_t size
)
57 void *end
= value
+ size
;
58 struct jffs2_acl_header
*header
= value
;
59 struct jffs2_acl_entry
*entry
;
60 struct posix_acl
*acl
;
66 if (size
< sizeof(struct jffs2_acl_header
))
67 return ERR_PTR(-EINVAL
);
68 ver
= je32_to_cpu(header
->a_version
);
69 if (ver
!= JFFS2_ACL_VERSION
) {
70 JFFS2_WARNING("Invalid ACL version. (=%u)\n", ver
);
71 return ERR_PTR(-EINVAL
);
74 value
+= sizeof(struct jffs2_acl_header
);
75 count
= jffs2_acl_count(size
);
77 return ERR_PTR(-EINVAL
);
81 acl
= posix_acl_alloc(count
, GFP_KERNEL
);
83 return ERR_PTR(-ENOMEM
);
85 for (i
=0; i
< count
; i
++) {
87 if (value
+ sizeof(struct jffs2_acl_entry_short
) > end
)
89 acl
->a_entries
[i
].e_tag
= je16_to_cpu(entry
->e_tag
);
90 acl
->a_entries
[i
].e_perm
= je16_to_cpu(entry
->e_perm
);
91 switch (acl
->a_entries
[i
].e_tag
) {
96 value
+= sizeof(struct jffs2_acl_entry_short
);
97 acl
->a_entries
[i
].e_id
= ACL_UNDEFINED_ID
;
102 value
+= sizeof(struct jffs2_acl_entry
);
105 acl
->a_entries
[i
].e_id
= je32_to_cpu(entry
->e_id
);
116 posix_acl_release(acl
);
117 return ERR_PTR(-EINVAL
);
120 static void *jffs2_acl_to_medium(const struct posix_acl
*acl
, size_t *size
)
122 struct jffs2_acl_header
*header
;
123 struct jffs2_acl_entry
*entry
;
127 *size
= jffs2_acl_size(acl
->a_count
);
128 header
= kmalloc(sizeof(*header
) + acl
->a_count
* sizeof(*entry
), GFP_KERNEL
);
130 return ERR_PTR(-ENOMEM
);
131 header
->a_version
= cpu_to_je32(JFFS2_ACL_VERSION
);
133 for (i
=0; i
< acl
->a_count
; i
++) {
135 entry
->e_tag
= cpu_to_je16(acl
->a_entries
[i
].e_tag
);
136 entry
->e_perm
= cpu_to_je16(acl
->a_entries
[i
].e_perm
);
137 switch(acl
->a_entries
[i
].e_tag
) {
140 entry
->e_id
= cpu_to_je32(acl
->a_entries
[i
].e_id
);
141 e
+= sizeof(struct jffs2_acl_entry
);
148 e
+= sizeof(struct jffs2_acl_entry_short
);
158 return ERR_PTR(-EINVAL
);
161 struct posix_acl
*jffs2_get_acl(struct inode
*inode
, int type
)
163 struct posix_acl
*acl
;
167 acl
= get_cached_acl(inode
, type
);
168 if (acl
!= ACL_NOT_CACHED
)
172 case ACL_TYPE_ACCESS
:
173 xprefix
= JFFS2_XPREFIX_ACL_ACCESS
;
175 case ACL_TYPE_DEFAULT
:
176 xprefix
= JFFS2_XPREFIX_ACL_DEFAULT
;
181 rc
= do_jffs2_getxattr(inode
, xprefix
, "", NULL
, 0);
183 value
= kmalloc(rc
, GFP_KERNEL
);
185 return ERR_PTR(-ENOMEM
);
186 rc
= do_jffs2_getxattr(inode
, xprefix
, "", value
, rc
);
189 acl
= jffs2_acl_from_medium(value
, rc
);
190 } else if (rc
== -ENODATA
|| rc
== -ENOSYS
) {
198 set_cached_acl(inode
, type
, acl
);
202 static int __jffs2_set_acl(struct inode
*inode
, int xprefix
, struct posix_acl
*acl
)
209 value
= jffs2_acl_to_medium(acl
, &size
);
211 return PTR_ERR(value
);
213 rc
= do_jffs2_setxattr(inode
, xprefix
, "", value
, size
, 0);
214 if (!value
&& rc
== -ENODATA
)
221 static int jffs2_set_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
225 if (S_ISLNK(inode
->i_mode
))
229 case ACL_TYPE_ACCESS
:
230 xprefix
= JFFS2_XPREFIX_ACL_ACCESS
;
232 umode_t mode
= inode
->i_mode
;
233 rc
= posix_acl_equiv_mode(acl
, &mode
);
236 if (inode
->i_mode
!= mode
) {
239 attr
.ia_valid
= ATTR_MODE
| ATTR_CTIME
;
241 attr
.ia_ctime
= CURRENT_TIME_SEC
;
242 rc
= jffs2_do_setattr(inode
, &attr
);
250 case ACL_TYPE_DEFAULT
:
251 xprefix
= JFFS2_XPREFIX_ACL_DEFAULT
;
252 if (!S_ISDIR(inode
->i_mode
))
253 return acl
? -EACCES
: 0;
258 rc
= __jffs2_set_acl(inode
, xprefix
, acl
);
260 set_cached_acl(inode
, type
, acl
);
264 int jffs2_init_acl_pre(struct inode
*dir_i
, struct inode
*inode
, umode_t
*i_mode
)
266 struct posix_acl
*acl
;
271 if (S_ISLNK(*i_mode
))
272 return 0; /* Symlink always has no-ACL */
274 acl
= jffs2_get_acl(dir_i
, ACL_TYPE_DEFAULT
);
279 *i_mode
&= ~current_umask();
281 if (S_ISDIR(*i_mode
))
282 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, acl
);
284 rc
= posix_acl_create(&acl
, GFP_KERNEL
, i_mode
);
288 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
290 posix_acl_release(acl
);
295 int jffs2_init_acl_post(struct inode
*inode
)
299 if (inode
->i_default_acl
) {
300 rc
= __jffs2_set_acl(inode
, JFFS2_XPREFIX_ACL_DEFAULT
, inode
->i_default_acl
);
306 rc
= __jffs2_set_acl(inode
, JFFS2_XPREFIX_ACL_ACCESS
, inode
->i_acl
);
314 int jffs2_acl_chmod(struct inode
*inode
)
316 struct posix_acl
*acl
;
319 if (S_ISLNK(inode
->i_mode
))
321 acl
= jffs2_get_acl(inode
, ACL_TYPE_ACCESS
);
322 if (IS_ERR(acl
) || !acl
)
324 rc
= posix_acl_chmod(&acl
, GFP_KERNEL
, inode
->i_mode
);
327 rc
= jffs2_set_acl(inode
, ACL_TYPE_ACCESS
, acl
);
328 posix_acl_release(acl
);
332 static size_t jffs2_acl_access_listxattr(struct dentry
*dentry
, char *list
,
333 size_t list_size
, const char *name
, size_t name_len
, int type
)
335 const int retlen
= sizeof(POSIX_ACL_XATTR_ACCESS
);
337 if (list
&& retlen
<= list_size
)
338 strcpy(list
, POSIX_ACL_XATTR_ACCESS
);
342 static size_t jffs2_acl_default_listxattr(struct dentry
*dentry
, char *list
,
343 size_t list_size
, const char *name
, size_t name_len
, int type
)
345 const int retlen
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
347 if (list
&& retlen
<= list_size
)
348 strcpy(list
, POSIX_ACL_XATTR_DEFAULT
);
352 static int jffs2_acl_getxattr(struct dentry
*dentry
, const char *name
,
353 void *buffer
, size_t size
, int type
)
355 struct posix_acl
*acl
;
361 acl
= jffs2_get_acl(dentry
->d_inode
, type
);
366 rc
= posix_acl_to_xattr(acl
, buffer
, size
);
367 posix_acl_release(acl
);
372 static int jffs2_acl_setxattr(struct dentry
*dentry
, const char *name
,
373 const void *value
, size_t size
, int flags
, int type
)
375 struct posix_acl
*acl
;
380 if (!inode_owner_or_capable(dentry
->d_inode
))
384 acl
= posix_acl_from_xattr(value
, size
);
388 rc
= posix_acl_valid(acl
);
395 rc
= jffs2_set_acl(dentry
->d_inode
, type
, acl
);
397 posix_acl_release(acl
);
401 const struct xattr_handler jffs2_acl_access_xattr_handler
= {
402 .prefix
= POSIX_ACL_XATTR_ACCESS
,
403 .flags
= ACL_TYPE_DEFAULT
,
404 .list
= jffs2_acl_access_listxattr
,
405 .get
= jffs2_acl_getxattr
,
406 .set
= jffs2_acl_setxattr
,
409 const struct xattr_handler jffs2_acl_default_xattr_handler
= {
410 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
411 .flags
= ACL_TYPE_DEFAULT
,
412 .list
= jffs2_acl_default_listxattr
,
413 .get
= jffs2_acl_getxattr
,
414 .set
= jffs2_acl_setxattr
,