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