1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright © 2006 NEC Corporation 5 * 6 * Created by KaiGai Kohei <kaigai@ak.jp.nec.com> 7 * 8 * For licensing information, see the file 'LICENCE' in this directory. 9 * 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/kernel.h> 15 #include <linux/slab.h> 16 #include <linux/fs.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> 24 #include "nodelist.h" 25 26 static size_t jffs2_acl_size(int count) 27 { 28 if (count <= 4) { 29 return sizeof(struct jffs2_acl_header) 30 + count * sizeof(struct jffs2_acl_entry_short); 31 } else { 32 return sizeof(struct jffs2_acl_header) 33 + 4 * sizeof(struct jffs2_acl_entry_short) 34 + (count - 4) * sizeof(struct jffs2_acl_entry); 35 } 36 } 37 38 static int jffs2_acl_count(size_t size) 39 { 40 size_t s; 41 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)) 45 return -1; 46 return size / sizeof(struct jffs2_acl_entry_short); 47 } else { 48 s = size - 4 * sizeof(struct jffs2_acl_entry_short); 49 if (s % sizeof(struct jffs2_acl_entry)) 50 return -1; 51 return s / sizeof(struct jffs2_acl_entry) + 4; 52 } 53 } 54 55 static struct posix_acl *jffs2_acl_from_medium(void *value, size_t size) 56 { 57 void *end = value + size; 58 struct jffs2_acl_header *header = value; 59 struct jffs2_acl_entry *entry; 60 struct posix_acl *acl; 61 uint32_t ver; 62 int i, count; 63 64 if (!value) 65 return NULL; 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); 72 } 73 74 value += sizeof(struct jffs2_acl_header); 75 count = jffs2_acl_count(size); 76 if (count < 0) 77 return ERR_PTR(-EINVAL); 78 if (count == 0) 79 return NULL; 80 81 acl = posix_acl_alloc(count, GFP_KERNEL); 82 if (!acl) 83 return ERR_PTR(-ENOMEM); 84 85 for (i=0; i < count; i++) { 86 entry = value; 87 if (value + sizeof(struct jffs2_acl_entry_short) > end) 88 goto fail; 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) { 92 case ACL_USER_OBJ: 93 case ACL_GROUP_OBJ: 94 case ACL_MASK: 95 case ACL_OTHER: 96 value += sizeof(struct jffs2_acl_entry_short); 97 acl->a_entries[i].e_id = ACL_UNDEFINED_ID; 98 break; 99 100 case ACL_USER: 101 case ACL_GROUP: 102 value += sizeof(struct jffs2_acl_entry); 103 if (value > end) 104 goto fail; 105 acl->a_entries[i].e_id = je32_to_cpu(entry->e_id); 106 break; 107 108 default: 109 goto fail; 110 } 111 } 112 if (value != end) 113 goto fail; 114 return acl; 115 fail: 116 posix_acl_release(acl); 117 return ERR_PTR(-EINVAL); 118 } 119 120 static void *jffs2_acl_to_medium(const struct posix_acl *acl, size_t *size) 121 { 122 struct jffs2_acl_header *header; 123 struct jffs2_acl_entry *entry; 124 void *e; 125 size_t i; 126 127 *size = jffs2_acl_size(acl->a_count); 128 header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL); 129 if (!header) 130 return ERR_PTR(-ENOMEM); 131 header->a_version = cpu_to_je32(JFFS2_ACL_VERSION); 132 e = header + 1; 133 for (i=0; i < acl->a_count; i++) { 134 entry = e; 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) { 138 case ACL_USER: 139 case ACL_GROUP: 140 entry->e_id = cpu_to_je32(acl->a_entries[i].e_id); 141 e += sizeof(struct jffs2_acl_entry); 142 break; 143 144 case ACL_USER_OBJ: 145 case ACL_GROUP_OBJ: 146 case ACL_MASK: 147 case ACL_OTHER: 148 e += sizeof(struct jffs2_acl_entry_short); 149 break; 150 151 default: 152 goto fail; 153 } 154 } 155 return header; 156 fail: 157 kfree(header); 158 return ERR_PTR(-EINVAL); 159 } 160 161 struct posix_acl *jffs2_get_acl(struct inode *inode, int type) 162 { 163 struct posix_acl *acl; 164 char *value = NULL; 165 int rc, xprefix; 166 167 acl = get_cached_acl(inode, type); 168 if (acl != ACL_NOT_CACHED) 169 return acl; 170 171 switch (type) { 172 case ACL_TYPE_ACCESS: 173 xprefix = JFFS2_XPREFIX_ACL_ACCESS; 174 break; 175 case ACL_TYPE_DEFAULT: 176 xprefix = JFFS2_XPREFIX_ACL_DEFAULT; 177 break; 178 default: 179 BUG(); 180 } 181 rc = do_jffs2_getxattr(inode, xprefix, "", NULL, 0); 182 if (rc > 0) { 183 value = kmalloc(rc, GFP_KERNEL); 184 if (!value) 185 return ERR_PTR(-ENOMEM); 186 rc = do_jffs2_getxattr(inode, xprefix, "", value, rc); 187 } 188 if (rc > 0) { 189 acl = jffs2_acl_from_medium(value, rc); 190 } else if (rc == -ENODATA || rc == -ENOSYS) { 191 acl = NULL; 192 } else { 193 acl = ERR_PTR(rc); 194 } 195 if (value) 196 kfree(value); 197 if (!IS_ERR(acl)) 198 set_cached_acl(inode, type, acl); 199 return acl; 200 } 201 202 static int __jffs2_set_acl(struct inode *inode, int xprefix, struct posix_acl *acl) 203 { 204 char *value = NULL; 205 size_t size = 0; 206 int rc; 207 208 if (acl) { 209 value = jffs2_acl_to_medium(acl, &size); 210 if (IS_ERR(value)) 211 return PTR_ERR(value); 212 } 213 rc = do_jffs2_setxattr(inode, xprefix, "", value, size, 0); 214 if (!value && rc == -ENODATA) 215 rc = 0; 216 kfree(value); 217 218 return rc; 219 } 220 221 static int jffs2_set_acl(struct inode *inode, int type, struct posix_acl *acl) 222 { 223 int rc, xprefix; 224 225 if (S_ISLNK(inode->i_mode)) 226 return -EOPNOTSUPP; 227 228 switch (type) { 229 case ACL_TYPE_ACCESS: 230 xprefix = JFFS2_XPREFIX_ACL_ACCESS; 231 if (acl) { 232 umode_t mode = inode->i_mode; 233 rc = posix_acl_equiv_mode(acl, &mode); 234 if (rc < 0) 235 return rc; 236 if (inode->i_mode != mode) { 237 struct iattr attr; 238 239 attr.ia_valid = ATTR_MODE | ATTR_CTIME; 240 attr.ia_mode = mode; 241 attr.ia_ctime = CURRENT_TIME_SEC; 242 rc = jffs2_do_setattr(inode, &attr); 243 if (rc < 0) 244 return rc; 245 } 246 if (rc == 0) 247 acl = NULL; 248 } 249 break; 250 case ACL_TYPE_DEFAULT: 251 xprefix = JFFS2_XPREFIX_ACL_DEFAULT; 252 if (!S_ISDIR(inode->i_mode)) 253 return acl ? -EACCES : 0; 254 break; 255 default: 256 return -EINVAL; 257 } 258 rc = __jffs2_set_acl(inode, xprefix, acl); 259 if (!rc) 260 set_cached_acl(inode, type, acl); 261 return rc; 262 } 263 264 int jffs2_init_acl_pre(struct inode *dir_i, struct inode *inode, umode_t *i_mode) 265 { 266 struct posix_acl *acl; 267 int rc; 268 269 cache_no_acl(inode); 270 271 if (S_ISLNK(*i_mode)) 272 return 0; /* Symlink always has no-ACL */ 273 274 acl = jffs2_get_acl(dir_i, ACL_TYPE_DEFAULT); 275 if (IS_ERR(acl)) 276 return PTR_ERR(acl); 277 278 if (!acl) { 279 *i_mode &= ~current_umask(); 280 } else { 281 if (S_ISDIR(*i_mode)) 282 set_cached_acl(inode, ACL_TYPE_DEFAULT, acl); 283 284 rc = posix_acl_create(&acl, GFP_KERNEL, i_mode); 285 if (rc < 0) 286 return rc; 287 if (rc > 0) 288 set_cached_acl(inode, ACL_TYPE_ACCESS, acl); 289 290 posix_acl_release(acl); 291 } 292 return 0; 293 } 294 295 int jffs2_init_acl_post(struct inode *inode) 296 { 297 int rc; 298 299 if (inode->i_default_acl) { 300 rc = __jffs2_set_acl(inode, JFFS2_XPREFIX_ACL_DEFAULT, inode->i_default_acl); 301 if (rc) 302 return rc; 303 } 304 305 if (inode->i_acl) { 306 rc = __jffs2_set_acl(inode, JFFS2_XPREFIX_ACL_ACCESS, inode->i_acl); 307 if (rc) 308 return rc; 309 } 310 311 return 0; 312 } 313 314 int jffs2_acl_chmod(struct inode *inode) 315 { 316 struct posix_acl *acl; 317 int rc; 318 319 if (S_ISLNK(inode->i_mode)) 320 return -EOPNOTSUPP; 321 acl = jffs2_get_acl(inode, ACL_TYPE_ACCESS); 322 if (IS_ERR(acl) || !acl) 323 return PTR_ERR(acl); 324 rc = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); 325 if (rc) 326 return rc; 327 rc = jffs2_set_acl(inode, ACL_TYPE_ACCESS, acl); 328 posix_acl_release(acl); 329 return rc; 330 } 331 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) 334 { 335 const int retlen = sizeof(POSIX_ACL_XATTR_ACCESS); 336 337 if (list && retlen <= list_size) 338 strcpy(list, POSIX_ACL_XATTR_ACCESS); 339 return retlen; 340 } 341 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) 344 { 345 const int retlen = sizeof(POSIX_ACL_XATTR_DEFAULT); 346 347 if (list && retlen <= list_size) 348 strcpy(list, POSIX_ACL_XATTR_DEFAULT); 349 return retlen; 350 } 351 352 static int jffs2_acl_getxattr(struct dentry *dentry, const char *name, 353 void *buffer, size_t size, int type) 354 { 355 struct posix_acl *acl; 356 int rc; 357 358 if (name[0] != '\0') 359 return -EINVAL; 360 361 acl = jffs2_get_acl(dentry->d_inode, type); 362 if (IS_ERR(acl)) 363 return PTR_ERR(acl); 364 if (!acl) 365 return -ENODATA; 366 rc = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); 367 posix_acl_release(acl); 368 369 return rc; 370 } 371 372 static int jffs2_acl_setxattr(struct dentry *dentry, const char *name, 373 const void *value, size_t size, int flags, int type) 374 { 375 struct posix_acl *acl; 376 int rc; 377 378 if (name[0] != '\0') 379 return -EINVAL; 380 if (!inode_owner_or_capable(dentry->d_inode)) 381 return -EPERM; 382 383 if (value) { 384 acl = posix_acl_from_xattr(&init_user_ns, value, size); 385 if (IS_ERR(acl)) 386 return PTR_ERR(acl); 387 if (acl) { 388 rc = posix_acl_valid(acl); 389 if (rc) 390 goto out; 391 } 392 } else { 393 acl = NULL; 394 } 395 rc = jffs2_set_acl(dentry->d_inode, type, acl); 396 out: 397 posix_acl_release(acl); 398 return rc; 399 } 400 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, 407 }; 408 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, 415 }; 416