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