KaiGai Kohei | 652ecc2 | 2006-05-13 15:18:27 +0900 | [diff] [blame] | 1 | /* |
| 2 | * JFFS2 -- Journalling Flash File System, Version 2. |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 3 | * |
David Woodhouse | c00c310 | 2007-04-25 14:16:47 +0100 | [diff] [blame] | 4 | * Copyright © 2006 NEC Corporation |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 5 | * |
KaiGai Kohei | 652ecc2 | 2006-05-13 15:18:27 +0900 | [diff] [blame] | 6 | * Created by KaiGai Kohei <kaigai@ak.jp.nec.com> |
| 7 | * |
| 8 | * For licensing information, see the file 'LICENCE' in this directory. |
| 9 | * |
| 10 | */ |
David Woodhouse | c00c310 | 2007-04-25 14:16:47 +0100 | [diff] [blame] | 11 | |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 12 | #include <linux/kernel.h> |
| 13 | #include <linux/slab.h> |
| 14 | #include <linux/fs.h> |
Al Viro | 914e263 | 2006-10-18 13:55:46 -0400 | [diff] [blame] | 15 | #include <linux/sched.h> |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 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> |
| 22 | #include "nodelist.h" |
| 23 | |
| 24 | static size_t jffs2_acl_size(int count) |
| 25 | { |
| 26 | if (count <= 4) { |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 27 | return sizeof(struct jffs2_acl_header) |
| 28 | + count * sizeof(struct jffs2_acl_entry_short); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 29 | } else { |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 30 | return sizeof(struct jffs2_acl_header) |
| 31 | + 4 * sizeof(struct jffs2_acl_entry_short) |
| 32 | + (count - 4) * sizeof(struct jffs2_acl_entry); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 33 | } |
| 34 | } |
| 35 | |
| 36 | static int jffs2_acl_count(size_t size) |
| 37 | { |
| 38 | size_t s; |
| 39 | |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 40 | size -= sizeof(struct jffs2_acl_header); |
Roel Kluin | fc371a2 | 2009-03-04 12:01:41 -0800 | [diff] [blame] | 41 | if (size < 4 * sizeof(struct jffs2_acl_entry_short)) { |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 42 | if (size % sizeof(struct jffs2_acl_entry_short)) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 43 | return -1; |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 44 | return size / sizeof(struct jffs2_acl_entry_short); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 45 | } else { |
Roel Kluin | fc371a2 | 2009-03-04 12:01:41 -0800 | [diff] [blame] | 46 | s = size - 4 * sizeof(struct jffs2_acl_entry_short); |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 47 | if (s % sizeof(struct jffs2_acl_entry)) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 48 | return -1; |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 49 | return s / sizeof(struct jffs2_acl_entry) + 4; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 50 | } |
| 51 | } |
| 52 | |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 53 | static struct posix_acl *jffs2_acl_from_medium(void *value, size_t size) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 54 | { |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 55 | void *end = value + size; |
| 56 | struct jffs2_acl_header *header = value; |
| 57 | struct jffs2_acl_entry *entry; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 58 | struct posix_acl *acl; |
| 59 | uint32_t ver; |
| 60 | int i, count; |
| 61 | |
| 62 | if (!value) |
| 63 | return NULL; |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 64 | if (size < sizeof(struct jffs2_acl_header)) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 65 | return ERR_PTR(-EINVAL); |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 66 | ver = je32_to_cpu(header->a_version); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 67 | if (ver != JFFS2_ACL_VERSION) { |
| 68 | JFFS2_WARNING("Invalid ACL version. (=%u)\n", ver); |
| 69 | return ERR_PTR(-EINVAL); |
| 70 | } |
| 71 | |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 72 | value += sizeof(struct jffs2_acl_header); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 73 | count = jffs2_acl_count(size); |
| 74 | if (count < 0) |
| 75 | return ERR_PTR(-EINVAL); |
| 76 | if (count == 0) |
| 77 | return NULL; |
| 78 | |
| 79 | acl = posix_acl_alloc(count, GFP_KERNEL); |
| 80 | if (!acl) |
| 81 | return ERR_PTR(-ENOMEM); |
| 82 | |
| 83 | for (i=0; i < count; i++) { |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 84 | entry = value; |
| 85 | if (value + sizeof(struct jffs2_acl_entry_short) > end) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 86 | goto fail; |
| 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) { |
| 90 | case ACL_USER_OBJ: |
| 91 | case ACL_GROUP_OBJ: |
| 92 | case ACL_MASK: |
| 93 | case ACL_OTHER: |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 94 | value += sizeof(struct jffs2_acl_entry_short); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 95 | acl->a_entries[i].e_id = ACL_UNDEFINED_ID; |
| 96 | break; |
| 97 | |
| 98 | case ACL_USER: |
| 99 | case ACL_GROUP: |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 100 | value += sizeof(struct jffs2_acl_entry); |
| 101 | if (value > end) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 102 | goto fail; |
| 103 | acl->a_entries[i].e_id = je32_to_cpu(entry->e_id); |
| 104 | break; |
| 105 | |
| 106 | default: |
| 107 | goto fail; |
| 108 | } |
| 109 | } |
| 110 | if (value != end) |
| 111 | goto fail; |
| 112 | return acl; |
| 113 | fail: |
| 114 | posix_acl_release(acl); |
| 115 | return ERR_PTR(-EINVAL); |
| 116 | } |
| 117 | |
| 118 | static void *jffs2_acl_to_medium(const struct posix_acl *acl, size_t *size) |
| 119 | { |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 120 | struct jffs2_acl_header *header; |
| 121 | struct jffs2_acl_entry *entry; |
| 122 | void *e; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 123 | size_t i; |
| 124 | |
| 125 | *size = jffs2_acl_size(acl->a_count); |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 126 | header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL); |
| 127 | if (!header) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 128 | return ERR_PTR(-ENOMEM); |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 129 | header->a_version = cpu_to_je32(JFFS2_ACL_VERSION); |
| 130 | e = header + 1; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 131 | for (i=0; i < acl->a_count; i++) { |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 132 | entry = e; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 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) { |
| 136 | case ACL_USER: |
| 137 | case ACL_GROUP: |
| 138 | entry->e_id = cpu_to_je32(acl->a_entries[i].e_id); |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 139 | e += sizeof(struct jffs2_acl_entry); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 140 | break; |
| 141 | |
| 142 | case ACL_USER_OBJ: |
| 143 | case ACL_GROUP_OBJ: |
| 144 | case ACL_MASK: |
| 145 | case ACL_OTHER: |
KaiGai Kohei | de1f72f | 2006-05-13 15:13:27 +0900 | [diff] [blame] | 146 | e += sizeof(struct jffs2_acl_entry_short); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 147 | break; |
| 148 | |
| 149 | default: |
| 150 | goto fail; |
| 151 | } |
| 152 | } |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 153 | return header; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 154 | fail: |
KaiGai Kohei | dea8013 | 2006-05-13 15:20:24 +0900 | [diff] [blame] | 155 | kfree(header); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 156 | return ERR_PTR(-EINVAL); |
| 157 | } |
| 158 | |
Adrian Bunk | 050416e | 2007-11-06 08:36:49 +0000 | [diff] [blame] | 159 | static struct posix_acl *jffs2_get_acl(struct inode *inode, int type) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 160 | { |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 161 | struct posix_acl *acl; |
| 162 | char *value = NULL; |
| 163 | int rc, xprefix; |
| 164 | |
Al Viro | 073aaa1 | 2009-06-09 12:11:54 -0400 | [diff] [blame] | 165 | acl = get_cached_acl(inode, type); |
| 166 | if (acl != ACL_NOT_CACHED) |
| 167 | return acl; |
| 168 | |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 169 | switch (type) { |
| 170 | case ACL_TYPE_ACCESS: |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 171 | xprefix = JFFS2_XPREFIX_ACL_ACCESS; |
| 172 | break; |
| 173 | case ACL_TYPE_DEFAULT: |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 174 | xprefix = JFFS2_XPREFIX_ACL_DEFAULT; |
| 175 | break; |
| 176 | default: |
Al Viro | 073aaa1 | 2009-06-09 12:11:54 -0400 | [diff] [blame] | 177 | BUG(); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 178 | } |
| 179 | rc = do_jffs2_getxattr(inode, xprefix, "", NULL, 0); |
| 180 | if (rc > 0) { |
| 181 | value = kmalloc(rc, GFP_KERNEL); |
| 182 | if (!value) |
| 183 | return ERR_PTR(-ENOMEM); |
| 184 | rc = do_jffs2_getxattr(inode, xprefix, "", value, rc); |
| 185 | } |
| 186 | if (rc > 0) { |
| 187 | acl = jffs2_acl_from_medium(value, rc); |
| 188 | } else if (rc == -ENODATA || rc == -ENOSYS) { |
| 189 | acl = NULL; |
| 190 | } else { |
| 191 | acl = ERR_PTR(rc); |
| 192 | } |
| 193 | if (value) |
| 194 | kfree(value); |
Al Viro | 073aaa1 | 2009-06-09 12:11:54 -0400 | [diff] [blame] | 195 | if (!IS_ERR(acl)) |
| 196 | set_cached_acl(inode, type, acl); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 197 | return acl; |
| 198 | } |
| 199 | |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 200 | static int __jffs2_set_acl(struct inode *inode, int xprefix, struct posix_acl *acl) |
| 201 | { |
| 202 | char *value = NULL; |
| 203 | size_t size = 0; |
| 204 | int rc; |
| 205 | |
| 206 | if (acl) { |
| 207 | value = jffs2_acl_to_medium(acl, &size); |
| 208 | if (IS_ERR(value)) |
| 209 | return PTR_ERR(value); |
| 210 | } |
| 211 | rc = do_jffs2_setxattr(inode, xprefix, "", value, size, 0); |
| 212 | if (!value && rc == -ENODATA) |
| 213 | rc = 0; |
| 214 | kfree(value); |
| 215 | |
| 216 | return rc; |
| 217 | } |
| 218 | |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 219 | static int jffs2_set_acl(struct inode *inode, int type, struct posix_acl *acl) |
| 220 | { |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 221 | int rc, xprefix; |
| 222 | |
| 223 | if (S_ISLNK(inode->i_mode)) |
| 224 | return -EOPNOTSUPP; |
| 225 | |
| 226 | switch (type) { |
| 227 | case ACL_TYPE_ACCESS: |
| 228 | xprefix = JFFS2_XPREFIX_ACL_ACCESS; |
| 229 | if (acl) { |
| 230 | mode_t mode = inode->i_mode; |
| 231 | rc = posix_acl_equiv_mode(acl, &mode); |
| 232 | if (rc < 0) |
| 233 | return rc; |
| 234 | if (inode->i_mode != mode) { |
David Woodhouse | 9ed437c | 2007-08-22 12:39:19 +0100 | [diff] [blame] | 235 | struct iattr attr; |
| 236 | |
| 237 | attr.ia_valid = ATTR_MODE; |
| 238 | attr.ia_mode = mode; |
| 239 | rc = jffs2_do_setattr(inode, &attr); |
| 240 | if (rc < 0) |
| 241 | return rc; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 242 | } |
| 243 | if (rc == 0) |
| 244 | acl = NULL; |
| 245 | } |
| 246 | break; |
| 247 | case ACL_TYPE_DEFAULT: |
| 248 | xprefix = JFFS2_XPREFIX_ACL_DEFAULT; |
| 249 | if (!S_ISDIR(inode->i_mode)) |
| 250 | return acl ? -EACCES : 0; |
| 251 | break; |
| 252 | default: |
| 253 | return -EINVAL; |
| 254 | } |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 255 | rc = __jffs2_set_acl(inode, xprefix, acl); |
Al Viro | 073aaa1 | 2009-06-09 12:11:54 -0400 | [diff] [blame] | 256 | if (!rc) |
| 257 | set_cached_acl(inode, type, acl); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 258 | return rc; |
| 259 | } |
| 260 | |
Linus Torvalds | 18f4c64 | 2009-08-28 12:29:03 -0700 | [diff] [blame] | 261 | int jffs2_check_acl(struct inode *inode, int mask) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 262 | { |
| 263 | struct posix_acl *acl; |
| 264 | int rc; |
| 265 | |
| 266 | acl = jffs2_get_acl(inode, ACL_TYPE_ACCESS); |
| 267 | if (IS_ERR(acl)) |
| 268 | return PTR_ERR(acl); |
| 269 | if (acl) { |
| 270 | rc = posix_acl_permission(inode, acl, mask); |
| 271 | posix_acl_release(acl); |
| 272 | return rc; |
| 273 | } |
| 274 | return -EAGAIN; |
| 275 | } |
| 276 | |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 277 | int jffs2_init_acl_pre(struct inode *dir_i, struct inode *inode, int *i_mode) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 278 | { |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 279 | struct posix_acl *acl, *clone; |
| 280 | int rc; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 281 | |
Al Viro | 72c0490 | 2009-06-24 16:58:48 -0400 | [diff] [blame] | 282 | cache_no_acl(inode); |
David Woodhouse | 9ed437c | 2007-08-22 12:39:19 +0100 | [diff] [blame] | 283 | |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 284 | if (S_ISLNK(*i_mode)) |
| 285 | return 0; /* Symlink always has no-ACL */ |
| 286 | |
| 287 | acl = jffs2_get_acl(dir_i, ACL_TYPE_DEFAULT); |
| 288 | if (IS_ERR(acl)) |
| 289 | return PTR_ERR(acl); |
| 290 | |
| 291 | if (!acl) { |
Al Viro | ce3b0f8 | 2009-03-29 19:08:22 -0400 | [diff] [blame] | 292 | *i_mode &= ~current_umask(); |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 293 | } else { |
| 294 | if (S_ISDIR(*i_mode)) |
Al Viro | 073aaa1 | 2009-06-09 12:11:54 -0400 | [diff] [blame] | 295 | set_cached_acl(inode, ACL_TYPE_DEFAULT, acl); |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 296 | |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 297 | clone = posix_acl_clone(acl, GFP_KERNEL); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 298 | if (!clone) |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 299 | return -ENOMEM; |
| 300 | rc = posix_acl_create_masq(clone, (mode_t *)i_mode); |
Julia Lawall | 36f97bc | 2008-01-06 17:50:34 +0100 | [diff] [blame] | 301 | if (rc < 0) { |
| 302 | posix_acl_release(clone); |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 303 | return rc; |
Julia Lawall | 36f97bc | 2008-01-06 17:50:34 +0100 | [diff] [blame] | 304 | } |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 305 | if (rc > 0) |
Al Viro | 073aaa1 | 2009-06-09 12:11:54 -0400 | [diff] [blame] | 306 | set_cached_acl(inode, ACL_TYPE_ACCESS, clone); |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 307 | |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 308 | posix_acl_release(clone); |
| 309 | } |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 310 | return 0; |
| 311 | } |
| 312 | |
| 313 | int jffs2_init_acl_post(struct inode *inode) |
| 314 | { |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 315 | int rc; |
| 316 | |
Al Viro | 290c263 | 2009-06-08 19:55:12 -0400 | [diff] [blame] | 317 | if (inode->i_default_acl) { |
| 318 | rc = __jffs2_set_acl(inode, JFFS2_XPREFIX_ACL_DEFAULT, inode->i_default_acl); |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 319 | if (rc) |
| 320 | return rc; |
| 321 | } |
| 322 | |
Al Viro | 290c263 | 2009-06-08 19:55:12 -0400 | [diff] [blame] | 323 | if (inode->i_acl) { |
| 324 | rc = __jffs2_set_acl(inode, JFFS2_XPREFIX_ACL_ACCESS, inode->i_acl); |
KaiGai Kohei | cfc8dc6 | 2007-09-14 15:16:35 +0900 | [diff] [blame] | 325 | if (rc) |
| 326 | return rc; |
| 327 | } |
| 328 | |
David Woodhouse | 8d6ea58 | 2007-10-27 10:36:44 -0400 | [diff] [blame] | 329 | return 0; |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 330 | } |
| 331 | |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 332 | int jffs2_acl_chmod(struct inode *inode) |
| 333 | { |
| 334 | struct posix_acl *acl, *clone; |
| 335 | int rc; |
| 336 | |
| 337 | if (S_ISLNK(inode->i_mode)) |
| 338 | return -EOPNOTSUPP; |
| 339 | acl = jffs2_get_acl(inode, ACL_TYPE_ACCESS); |
| 340 | if (IS_ERR(acl) || !acl) |
| 341 | return PTR_ERR(acl); |
| 342 | clone = posix_acl_clone(acl, GFP_KERNEL); |
| 343 | posix_acl_release(acl); |
| 344 | if (!clone) |
| 345 | return -ENOMEM; |
| 346 | rc = posix_acl_chmod_masq(clone, inode->i_mode); |
| 347 | if (!rc) |
| 348 | rc = jffs2_set_acl(inode, ACL_TYPE_ACCESS, clone); |
| 349 | posix_acl_release(clone); |
| 350 | return rc; |
| 351 | } |
| 352 | |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 353 | static size_t jffs2_acl_access_listxattr(struct dentry *dentry, char *list, |
| 354 | size_t list_size, const char *name, size_t name_len, int type) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 355 | { |
| 356 | const int retlen = sizeof(POSIX_ACL_XATTR_ACCESS); |
| 357 | |
| 358 | if (list && retlen <= list_size) |
| 359 | strcpy(list, POSIX_ACL_XATTR_ACCESS); |
| 360 | return retlen; |
| 361 | } |
| 362 | |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 363 | static size_t jffs2_acl_default_listxattr(struct dentry *dentry, char *list, |
| 364 | size_t list_size, const char *name, size_t name_len, int type) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 365 | { |
| 366 | const int retlen = sizeof(POSIX_ACL_XATTR_DEFAULT); |
| 367 | |
| 368 | if (list && retlen <= list_size) |
| 369 | strcpy(list, POSIX_ACL_XATTR_DEFAULT); |
| 370 | return retlen; |
| 371 | } |
| 372 | |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 373 | static int jffs2_acl_getxattr(struct dentry *dentry, const char *name, |
| 374 | void *buffer, size_t size, int type) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 375 | { |
| 376 | struct posix_acl *acl; |
| 377 | int rc; |
| 378 | |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 379 | if (name[0] != '\0') |
| 380 | return -EINVAL; |
| 381 | |
| 382 | acl = jffs2_get_acl(dentry->d_inode, type); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 383 | if (IS_ERR(acl)) |
| 384 | return PTR_ERR(acl); |
| 385 | if (!acl) |
| 386 | return -ENODATA; |
| 387 | rc = posix_acl_to_xattr(acl, buffer, size); |
| 388 | posix_acl_release(acl); |
| 389 | |
| 390 | return rc; |
| 391 | } |
| 392 | |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 393 | static int jffs2_acl_setxattr(struct dentry *dentry, const char *name, |
| 394 | const void *value, size_t size, int flags, int type) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 395 | { |
| 396 | struct posix_acl *acl; |
| 397 | int rc; |
| 398 | |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 399 | if (name[0] != '\0') |
| 400 | return -EINVAL; |
| 401 | if (!is_owner_or_cap(dentry->d_inode)) |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 402 | return -EPERM; |
| 403 | |
| 404 | if (value) { |
| 405 | acl = posix_acl_from_xattr(value, size); |
| 406 | if (IS_ERR(acl)) |
| 407 | return PTR_ERR(acl); |
| 408 | if (acl) { |
| 409 | rc = posix_acl_valid(acl); |
| 410 | if (rc) |
| 411 | goto out; |
| 412 | } |
| 413 | } else { |
| 414 | acl = NULL; |
| 415 | } |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 416 | rc = jffs2_set_acl(dentry->d_inode, type, acl); |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 417 | out: |
| 418 | posix_acl_release(acl); |
| 419 | return rc; |
| 420 | } |
| 421 | |
Stephen Hemminger | 365f0cb | 2010-05-13 17:53:21 -0700 | [diff] [blame^] | 422 | const struct xattr_handler jffs2_acl_access_xattr_handler = { |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 423 | .prefix = POSIX_ACL_XATTR_ACCESS, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 424 | .flags = ACL_TYPE_DEFAULT, |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 425 | .list = jffs2_acl_access_listxattr, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 426 | .get = jffs2_acl_getxattr, |
| 427 | .set = jffs2_acl_setxattr, |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 428 | }; |
| 429 | |
Stephen Hemminger | 365f0cb | 2010-05-13 17:53:21 -0700 | [diff] [blame^] | 430 | const struct xattr_handler jffs2_acl_default_xattr_handler = { |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 431 | .prefix = POSIX_ACL_XATTR_DEFAULT, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 432 | .flags = ACL_TYPE_DEFAULT, |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 433 | .list = jffs2_acl_default_listxattr, |
Christoph Hellwig | 431547b | 2009-11-13 09:52:56 +0000 | [diff] [blame] | 434 | .get = jffs2_acl_getxattr, |
| 435 | .set = jffs2_acl_setxattr, |
KaiGai Kohei | aa98d7c | 2006-05-13 15:09:47 +0900 | [diff] [blame] | 436 | }; |