1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright © 2001-2007 Red Hat, Inc. 5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 6 * 7 * Created by David Woodhouse <dwmw2@infradead.org> 8 * 9 * For licensing information, see the file 'LICENCE' in this directory. 10 * 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <linux/kernel.h> 16 #include <linux/slab.h> 17 #include <linux/fs.h> 18 #include <linux/crc32.h> 19 #include <linux/jffs2.h> 20 #include "jffs2_fs_i.h" 21 #include "jffs2_fs_sb.h" 22 #include <linux/time.h> 23 #include "nodelist.h" 24 25 static int jffs2_readdir (struct file *, struct dir_context *); 26 27 static int jffs2_create (struct inode *,struct dentry *,umode_t, 28 bool); 29 static struct dentry *jffs2_lookup (struct inode *,struct dentry *, 30 unsigned int); 31 static int jffs2_link (struct dentry *,struct inode *,struct dentry *); 32 static int jffs2_unlink (struct inode *,struct dentry *); 33 static int jffs2_symlink (struct inode *,struct dentry *,const char *); 34 static int jffs2_mkdir (struct inode *,struct dentry *,umode_t); 35 static int jffs2_rmdir (struct inode *,struct dentry *); 36 static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t); 37 static int jffs2_rename (struct inode *, struct dentry *, 38 struct inode *, struct dentry *, 39 unsigned int); 40 41 const struct file_operations jffs2_dir_operations = 42 { 43 .read = generic_read_dir, 44 .iterate_shared=jffs2_readdir, 45 .unlocked_ioctl=jffs2_ioctl, 46 .fsync = jffs2_fsync, 47 .llseek = generic_file_llseek, 48 }; 49 50 51 const struct inode_operations jffs2_dir_inode_operations = 52 { 53 .create = jffs2_create, 54 .lookup = jffs2_lookup, 55 .link = jffs2_link, 56 .unlink = jffs2_unlink, 57 .symlink = jffs2_symlink, 58 .mkdir = jffs2_mkdir, 59 .rmdir = jffs2_rmdir, 60 .mknod = jffs2_mknod, 61 .rename = jffs2_rename, 62 .get_acl = jffs2_get_acl, 63 .set_acl = jffs2_set_acl, 64 .setattr = jffs2_setattr, 65 .setxattr = jffs2_setxattr, 66 .getxattr = jffs2_getxattr, 67 .listxattr = jffs2_listxattr, 68 .removexattr = jffs2_removexattr 69 }; 70 71 /***********************************************************************/ 72 73 74 /* We keep the dirent list sorted in increasing order of name hash, 75 and we use the same hash function as the dentries. Makes this 76 nice and simple 77 */ 78 static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, 79 unsigned int flags) 80 { 81 struct jffs2_inode_info *dir_f; 82 struct jffs2_full_dirent *fd = NULL, *fd_list; 83 uint32_t ino = 0; 84 struct inode *inode = NULL; 85 unsigned int nhash; 86 87 jffs2_dbg(1, "jffs2_lookup()\n"); 88 89 if (target->d_name.len > JFFS2_MAX_NAME_LEN) 90 return ERR_PTR(-ENAMETOOLONG); 91 92 dir_f = JFFS2_INODE_INFO(dir_i); 93 94 /* The 'nhash' on the fd_list is not the same as the dentry hash */ 95 nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len); 96 97 mutex_lock(&dir_f->sem); 98 99 /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ 100 for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) { 101 if (fd_list->nhash == nhash && 102 (!fd || fd_list->version > fd->version) && 103 strlen(fd_list->name) == target->d_name.len && 104 !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) { 105 fd = fd_list; 106 } 107 } 108 if (fd) 109 ino = fd->ino; 110 mutex_unlock(&dir_f->sem); 111 if (ino) { 112 inode = jffs2_iget(dir_i->i_sb, ino); 113 if (IS_ERR(inode)) 114 pr_warn("iget() failed for ino #%u\n", ino); 115 } 116 117 return d_splice_alias(inode, target); 118 } 119 120 /***********************************************************************/ 121 122 123 static int jffs2_readdir(struct file *file, struct dir_context *ctx) 124 { 125 struct inode *inode = file_inode(file); 126 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 127 struct jffs2_full_dirent *fd; 128 unsigned long curofs = 1; 129 130 jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino); 131 132 if (!dir_emit_dots(file, ctx)) 133 return 0; 134 135 mutex_lock(&f->sem); 136 for (fd = f->dents; fd; fd = fd->next) { 137 curofs++; 138 /* First loop: curofs = 2; pos = 2 */ 139 if (curofs < ctx->pos) { 140 jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 141 fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos); 142 continue; 143 } 144 if (!fd->ino) { 145 jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n", 146 fd->name); 147 ctx->pos++; 148 continue; 149 } 150 jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n", 151 (unsigned long)ctx->pos, fd->name, fd->ino, fd->type); 152 if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type)) 153 break; 154 ctx->pos++; 155 } 156 mutex_unlock(&f->sem); 157 return 0; 158 } 159 160 /***********************************************************************/ 161 162 163 static int jffs2_create(struct inode *dir_i, struct dentry *dentry, 164 umode_t mode, bool excl) 165 { 166 struct jffs2_raw_inode *ri; 167 struct jffs2_inode_info *f, *dir_f; 168 struct jffs2_sb_info *c; 169 struct inode *inode; 170 int ret; 171 172 ri = jffs2_alloc_raw_inode(); 173 if (!ri) 174 return -ENOMEM; 175 176 c = JFFS2_SB_INFO(dir_i->i_sb); 177 178 jffs2_dbg(1, "%s()\n", __func__); 179 180 inode = jffs2_new_inode(dir_i, mode, ri); 181 182 if (IS_ERR(inode)) { 183 jffs2_dbg(1, "jffs2_new_inode() failed\n"); 184 jffs2_free_raw_inode(ri); 185 return PTR_ERR(inode); 186 } 187 188 inode->i_op = &jffs2_file_inode_operations; 189 inode->i_fop = &jffs2_file_operations; 190 inode->i_mapping->a_ops = &jffs2_file_address_operations; 191 inode->i_mapping->nrpages = 0; 192 193 f = JFFS2_INODE_INFO(inode); 194 dir_f = JFFS2_INODE_INFO(dir_i); 195 196 /* jffs2_do_create() will want to lock it, _after_ reserving 197 space and taking c-alloc_sem. If we keep it locked here, 198 lockdep gets unhappy (although it's a false positive; 199 nothing else will be looking at this inode yet so there's 200 no chance of AB-BA deadlock involving its f->sem). */ 201 mutex_unlock(&f->sem); 202 203 ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name); 204 if (ret) 205 goto fail; 206 207 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 208 209 jffs2_free_raw_inode(ri); 210 211 jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 212 __func__, inode->i_ino, inode->i_mode, inode->i_nlink, 213 f->inocache->pino_nlink, inode->i_mapping->nrpages); 214 215 unlock_new_inode(inode); 216 d_instantiate(dentry, inode); 217 return 0; 218 219 fail: 220 iget_failed(inode); 221 jffs2_free_raw_inode(ri); 222 return ret; 223 } 224 225 /***********************************************************************/ 226 227 228 static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) 229 { 230 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 231 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 232 struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry)); 233 int ret; 234 uint32_t now = get_seconds(); 235 236 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 237 dentry->d_name.len, dead_f, now); 238 if (dead_f->inocache) 239 set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink); 240 if (!ret) 241 dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 242 return ret; 243 } 244 /***********************************************************************/ 245 246 247 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 248 { 249 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb); 250 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 251 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 252 int ret; 253 uint8_t type; 254 uint32_t now; 255 256 /* Don't let people make hard links to bad inodes. */ 257 if (!f->inocache) 258 return -EIO; 259 260 if (d_is_dir(old_dentry)) 261 return -EPERM; 262 263 /* XXX: This is ugly */ 264 type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 265 if (!type) type = DT_REG; 266 267 now = get_seconds(); 268 ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now); 269 270 if (!ret) { 271 mutex_lock(&f->sem); 272 set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink); 273 mutex_unlock(&f->sem); 274 d_instantiate(dentry, d_inode(old_dentry)); 275 dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 276 ihold(d_inode(old_dentry)); 277 } 278 return ret; 279 } 280 281 /***********************************************************************/ 282 283 static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target) 284 { 285 struct jffs2_inode_info *f, *dir_f; 286 struct jffs2_sb_info *c; 287 struct inode *inode; 288 struct jffs2_raw_inode *ri; 289 struct jffs2_raw_dirent *rd; 290 struct jffs2_full_dnode *fn; 291 struct jffs2_full_dirent *fd; 292 int namelen; 293 uint32_t alloclen; 294 int ret, targetlen = strlen(target); 295 296 /* FIXME: If you care. We'd need to use frags for the target 297 if it grows much more than this */ 298 if (targetlen > 254) 299 return -ENAMETOOLONG; 300 301 ri = jffs2_alloc_raw_inode(); 302 303 if (!ri) 304 return -ENOMEM; 305 306 c = JFFS2_SB_INFO(dir_i->i_sb); 307 308 /* Try to reserve enough space for both node and dirent. 309 * Just the node will do for now, though 310 */ 311 namelen = dentry->d_name.len; 312 ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen, 313 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 314 315 if (ret) { 316 jffs2_free_raw_inode(ri); 317 return ret; 318 } 319 320 inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); 321 322 if (IS_ERR(inode)) { 323 jffs2_free_raw_inode(ri); 324 jffs2_complete_reservation(c); 325 return PTR_ERR(inode); 326 } 327 328 inode->i_op = &jffs2_symlink_inode_operations; 329 330 f = JFFS2_INODE_INFO(inode); 331 332 inode->i_size = targetlen; 333 ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); 334 ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); 335 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 336 337 ri->compr = JFFS2_COMPR_NONE; 338 ri->data_crc = cpu_to_je32(crc32(0, target, targetlen)); 339 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 340 341 fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL); 342 343 jffs2_free_raw_inode(ri); 344 345 if (IS_ERR(fn)) { 346 /* Eeek. Wave bye bye */ 347 mutex_unlock(&f->sem); 348 jffs2_complete_reservation(c); 349 ret = PTR_ERR(fn); 350 goto fail; 351 } 352 353 /* We use f->target field to store the target path. */ 354 f->target = kmemdup(target, targetlen + 1, GFP_KERNEL); 355 if (!f->target) { 356 pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1); 357 mutex_unlock(&f->sem); 358 jffs2_complete_reservation(c); 359 ret = -ENOMEM; 360 goto fail; 361 } 362 inode->i_link = f->target; 363 364 jffs2_dbg(1, "%s(): symlink's target '%s' cached\n", 365 __func__, (char *)f->target); 366 367 /* No data here. Only a metadata node, which will be 368 obsoleted by the first data write 369 */ 370 f->metadata = fn; 371 mutex_unlock(&f->sem); 372 373 jffs2_complete_reservation(c); 374 375 ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 376 if (ret) 377 goto fail; 378 379 ret = jffs2_init_acl_post(inode); 380 if (ret) 381 goto fail; 382 383 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 384 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 385 if (ret) 386 goto fail; 387 388 rd = jffs2_alloc_raw_dirent(); 389 if (!rd) { 390 /* Argh. Now we treat it like a normal delete */ 391 jffs2_complete_reservation(c); 392 ret = -ENOMEM; 393 goto fail; 394 } 395 396 dir_f = JFFS2_INODE_INFO(dir_i); 397 mutex_lock(&dir_f->sem); 398 399 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 400 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 401 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 402 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 403 404 rd->pino = cpu_to_je32(dir_i->i_ino); 405 rd->version = cpu_to_je32(++dir_f->highest_version); 406 rd->ino = cpu_to_je32(inode->i_ino); 407 rd->mctime = cpu_to_je32(get_seconds()); 408 rd->nsize = namelen; 409 rd->type = DT_LNK; 410 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 411 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 412 413 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 414 415 if (IS_ERR(fd)) { 416 /* dirent failed to write. Delete the inode normally 417 as if it were the final unlink() */ 418 jffs2_complete_reservation(c); 419 jffs2_free_raw_dirent(rd); 420 mutex_unlock(&dir_f->sem); 421 ret = PTR_ERR(fd); 422 goto fail; 423 } 424 425 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 426 427 jffs2_free_raw_dirent(rd); 428 429 /* Link the fd into the inode's list, obsoleting an old 430 one if necessary. */ 431 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 432 433 mutex_unlock(&dir_f->sem); 434 jffs2_complete_reservation(c); 435 436 unlock_new_inode(inode); 437 d_instantiate(dentry, inode); 438 return 0; 439 440 fail: 441 iget_failed(inode); 442 return ret; 443 } 444 445 446 static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode) 447 { 448 struct jffs2_inode_info *f, *dir_f; 449 struct jffs2_sb_info *c; 450 struct inode *inode; 451 struct jffs2_raw_inode *ri; 452 struct jffs2_raw_dirent *rd; 453 struct jffs2_full_dnode *fn; 454 struct jffs2_full_dirent *fd; 455 int namelen; 456 uint32_t alloclen; 457 int ret; 458 459 mode |= S_IFDIR; 460 461 ri = jffs2_alloc_raw_inode(); 462 if (!ri) 463 return -ENOMEM; 464 465 c = JFFS2_SB_INFO(dir_i->i_sb); 466 467 /* Try to reserve enough space for both node and dirent. 468 * Just the node will do for now, though 469 */ 470 namelen = dentry->d_name.len; 471 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 472 JFFS2_SUMMARY_INODE_SIZE); 473 474 if (ret) { 475 jffs2_free_raw_inode(ri); 476 return ret; 477 } 478 479 inode = jffs2_new_inode(dir_i, mode, ri); 480 481 if (IS_ERR(inode)) { 482 jffs2_free_raw_inode(ri); 483 jffs2_complete_reservation(c); 484 return PTR_ERR(inode); 485 } 486 487 inode->i_op = &jffs2_dir_inode_operations; 488 inode->i_fop = &jffs2_dir_operations; 489 490 f = JFFS2_INODE_INFO(inode); 491 492 /* Directories get nlink 2 at start */ 493 set_nlink(inode, 2); 494 /* but ic->pino_nlink is the parent ino# */ 495 f->inocache->pino_nlink = dir_i->i_ino; 496 497 ri->data_crc = cpu_to_je32(0); 498 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 499 500 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 501 502 jffs2_free_raw_inode(ri); 503 504 if (IS_ERR(fn)) { 505 /* Eeek. Wave bye bye */ 506 mutex_unlock(&f->sem); 507 jffs2_complete_reservation(c); 508 ret = PTR_ERR(fn); 509 goto fail; 510 } 511 /* No data here. Only a metadata node, which will be 512 obsoleted by the first data write 513 */ 514 f->metadata = fn; 515 mutex_unlock(&f->sem); 516 517 jffs2_complete_reservation(c); 518 519 ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 520 if (ret) 521 goto fail; 522 523 ret = jffs2_init_acl_post(inode); 524 if (ret) 525 goto fail; 526 527 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 528 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 529 if (ret) 530 goto fail; 531 532 rd = jffs2_alloc_raw_dirent(); 533 if (!rd) { 534 /* Argh. Now we treat it like a normal delete */ 535 jffs2_complete_reservation(c); 536 ret = -ENOMEM; 537 goto fail; 538 } 539 540 dir_f = JFFS2_INODE_INFO(dir_i); 541 mutex_lock(&dir_f->sem); 542 543 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 544 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 545 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 546 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 547 548 rd->pino = cpu_to_je32(dir_i->i_ino); 549 rd->version = cpu_to_je32(++dir_f->highest_version); 550 rd->ino = cpu_to_je32(inode->i_ino); 551 rd->mctime = cpu_to_je32(get_seconds()); 552 rd->nsize = namelen; 553 rd->type = DT_DIR; 554 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 555 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 556 557 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 558 559 if (IS_ERR(fd)) { 560 /* dirent failed to write. Delete the inode normally 561 as if it were the final unlink() */ 562 jffs2_complete_reservation(c); 563 jffs2_free_raw_dirent(rd); 564 mutex_unlock(&dir_f->sem); 565 ret = PTR_ERR(fd); 566 goto fail; 567 } 568 569 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 570 inc_nlink(dir_i); 571 572 jffs2_free_raw_dirent(rd); 573 574 /* Link the fd into the inode's list, obsoleting an old 575 one if necessary. */ 576 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 577 578 mutex_unlock(&dir_f->sem); 579 jffs2_complete_reservation(c); 580 581 unlock_new_inode(inode); 582 d_instantiate(dentry, inode); 583 return 0; 584 585 fail: 586 iget_failed(inode); 587 return ret; 588 } 589 590 static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) 591 { 592 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 593 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 594 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); 595 struct jffs2_full_dirent *fd; 596 int ret; 597 uint32_t now = get_seconds(); 598 599 for (fd = f->dents ; fd; fd = fd->next) { 600 if (fd->ino) 601 return -ENOTEMPTY; 602 } 603 604 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 605 dentry->d_name.len, f, now); 606 if (!ret) { 607 dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 608 clear_nlink(d_inode(dentry)); 609 drop_nlink(dir_i); 610 } 611 return ret; 612 } 613 614 static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev) 615 { 616 struct jffs2_inode_info *f, *dir_f; 617 struct jffs2_sb_info *c; 618 struct inode *inode; 619 struct jffs2_raw_inode *ri; 620 struct jffs2_raw_dirent *rd; 621 struct jffs2_full_dnode *fn; 622 struct jffs2_full_dirent *fd; 623 int namelen; 624 union jffs2_device_node dev; 625 int devlen = 0; 626 uint32_t alloclen; 627 int ret; 628 629 ri = jffs2_alloc_raw_inode(); 630 if (!ri) 631 return -ENOMEM; 632 633 c = JFFS2_SB_INFO(dir_i->i_sb); 634 635 if (S_ISBLK(mode) || S_ISCHR(mode)) 636 devlen = jffs2_encode_dev(&dev, rdev); 637 638 /* Try to reserve enough space for both node and dirent. 639 * Just the node will do for now, though 640 */ 641 namelen = dentry->d_name.len; 642 ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen, 643 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 644 645 if (ret) { 646 jffs2_free_raw_inode(ri); 647 return ret; 648 } 649 650 inode = jffs2_new_inode(dir_i, mode, ri); 651 652 if (IS_ERR(inode)) { 653 jffs2_free_raw_inode(ri); 654 jffs2_complete_reservation(c); 655 return PTR_ERR(inode); 656 } 657 inode->i_op = &jffs2_file_inode_operations; 658 init_special_inode(inode, inode->i_mode, rdev); 659 660 f = JFFS2_INODE_INFO(inode); 661 662 ri->dsize = ri->csize = cpu_to_je32(devlen); 663 ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); 664 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 665 666 ri->compr = JFFS2_COMPR_NONE; 667 ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); 668 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 669 670 fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL); 671 672 jffs2_free_raw_inode(ri); 673 674 if (IS_ERR(fn)) { 675 /* Eeek. Wave bye bye */ 676 mutex_unlock(&f->sem); 677 jffs2_complete_reservation(c); 678 ret = PTR_ERR(fn); 679 goto fail; 680 } 681 /* No data here. Only a metadata node, which will be 682 obsoleted by the first data write 683 */ 684 f->metadata = fn; 685 mutex_unlock(&f->sem); 686 687 jffs2_complete_reservation(c); 688 689 ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 690 if (ret) 691 goto fail; 692 693 ret = jffs2_init_acl_post(inode); 694 if (ret) 695 goto fail; 696 697 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 698 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 699 if (ret) 700 goto fail; 701 702 rd = jffs2_alloc_raw_dirent(); 703 if (!rd) { 704 /* Argh. Now we treat it like a normal delete */ 705 jffs2_complete_reservation(c); 706 ret = -ENOMEM; 707 goto fail; 708 } 709 710 dir_f = JFFS2_INODE_INFO(dir_i); 711 mutex_lock(&dir_f->sem); 712 713 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 714 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 715 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 716 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 717 718 rd->pino = cpu_to_je32(dir_i->i_ino); 719 rd->version = cpu_to_je32(++dir_f->highest_version); 720 rd->ino = cpu_to_je32(inode->i_ino); 721 rd->mctime = cpu_to_je32(get_seconds()); 722 rd->nsize = namelen; 723 724 /* XXX: This is ugly. */ 725 rd->type = (mode & S_IFMT) >> 12; 726 727 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 728 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 729 730 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 731 732 if (IS_ERR(fd)) { 733 /* dirent failed to write. Delete the inode normally 734 as if it were the final unlink() */ 735 jffs2_complete_reservation(c); 736 jffs2_free_raw_dirent(rd); 737 mutex_unlock(&dir_f->sem); 738 ret = PTR_ERR(fd); 739 goto fail; 740 } 741 742 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 743 744 jffs2_free_raw_dirent(rd); 745 746 /* Link the fd into the inode's list, obsoleting an old 747 one if necessary. */ 748 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 749 750 mutex_unlock(&dir_f->sem); 751 jffs2_complete_reservation(c); 752 753 unlock_new_inode(inode); 754 d_instantiate(dentry, inode); 755 return 0; 756 757 fail: 758 iget_failed(inode); 759 return ret; 760 } 761 762 static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry, 763 struct inode *new_dir_i, struct dentry *new_dentry, 764 unsigned int flags) 765 { 766 int ret; 767 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); 768 struct jffs2_inode_info *victim_f = NULL; 769 uint8_t type; 770 uint32_t now; 771 772 if (flags & ~RENAME_NOREPLACE) 773 return -EINVAL; 774 775 /* The VFS will check for us and prevent trying to rename a 776 * file over a directory and vice versa, but if it's a directory, 777 * the VFS can't check whether the victim is empty. The filesystem 778 * needs to do that for itself. 779 */ 780 if (d_really_is_positive(new_dentry)) { 781 victim_f = JFFS2_INODE_INFO(d_inode(new_dentry)); 782 if (d_is_dir(new_dentry)) { 783 struct jffs2_full_dirent *fd; 784 785 mutex_lock(&victim_f->sem); 786 for (fd = victim_f->dents; fd; fd = fd->next) { 787 if (fd->ino) { 788 mutex_unlock(&victim_f->sem); 789 return -ENOTEMPTY; 790 } 791 } 792 mutex_unlock(&victim_f->sem); 793 } 794 } 795 796 /* XXX: We probably ought to alloc enough space for 797 both nodes at the same time. Writing the new link, 798 then getting -ENOSPC, is quite bad :) 799 */ 800 801 /* Make a hard link */ 802 803 /* XXX: This is ugly */ 804 type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 805 if (!type) type = DT_REG; 806 807 now = get_seconds(); 808 ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 809 d_inode(old_dentry)->i_ino, type, 810 new_dentry->d_name.name, new_dentry->d_name.len, now); 811 812 if (ret) 813 return ret; 814 815 if (victim_f) { 816 /* There was a victim. Kill it off nicely */ 817 if (d_is_dir(new_dentry)) 818 clear_nlink(d_inode(new_dentry)); 819 else 820 drop_nlink(d_inode(new_dentry)); 821 /* Don't oops if the victim was a dirent pointing to an 822 inode which didn't exist. */ 823 if (victim_f->inocache) { 824 mutex_lock(&victim_f->sem); 825 if (d_is_dir(new_dentry)) 826 victim_f->inocache->pino_nlink = 0; 827 else 828 victim_f->inocache->pino_nlink--; 829 mutex_unlock(&victim_f->sem); 830 } 831 } 832 833 /* If it was a directory we moved, and there was no victim, 834 increase i_nlink on its new parent */ 835 if (d_is_dir(old_dentry) && !victim_f) 836 inc_nlink(new_dir_i); 837 838 /* Unlink the original */ 839 ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), 840 old_dentry->d_name.name, old_dentry->d_name.len, NULL, now); 841 842 /* We don't touch inode->i_nlink */ 843 844 if (ret) { 845 /* Oh shit. We really ought to make a single node which can do both atomically */ 846 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 847 mutex_lock(&f->sem); 848 inc_nlink(d_inode(old_dentry)); 849 if (f->inocache && !d_is_dir(old_dentry)) 850 f->inocache->pino_nlink++; 851 mutex_unlock(&f->sem); 852 853 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n", 854 __func__, ret); 855 /* 856 * We can't keep the target in dcache after that. 857 * For one thing, we can't afford dentry aliases for directories. 858 * For another, if there was a victim, we _can't_ set new inode 859 * for that sucker and we have to trigger mount eviction - the 860 * caller won't do it on its own since we are returning an error. 861 */ 862 d_invalidate(new_dentry); 863 new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now); 864 return ret; 865 } 866 867 if (d_is_dir(old_dentry)) 868 drop_nlink(old_dir_i); 869 870 new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now); 871 872 return 0; 873 } 874 875