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/fs.h> 14 #include <linux/crc32.h> 15 #include <linux/slab.h> 16 #include <linux/pagemap.h> 17 #include <linux/mtd/mtd.h> 18 #include "nodelist.h" 19 #include "compr.h" 20 21 22 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri) 23 { 24 struct jffs2_inode_cache *ic; 25 26 ic = jffs2_alloc_inode_cache(); 27 if (!ic) { 28 return -ENOMEM; 29 } 30 31 memset(ic, 0, sizeof(*ic)); 32 33 f->inocache = ic; 34 f->inocache->nlink = 1; 35 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 36 f->inocache->state = INO_STATE_PRESENT; 37 38 jffs2_add_ino_cache(c, f->inocache); 39 D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino)); 40 ri->ino = cpu_to_je32(f->inocache->ino); 41 42 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 43 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 44 ri->totlen = cpu_to_je32(PAD(sizeof(*ri))); 45 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 46 ri->mode = cpu_to_jemode(mode); 47 48 f->highest_version = 1; 49 ri->version = cpu_to_je32(f->highest_version); 50 51 return 0; 52 } 53 54 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, 55 write it to the flash, link it into the existing inode/fragment list */ 56 57 struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 58 struct jffs2_raw_inode *ri, const unsigned char *data, 59 uint32_t datalen, int alloc_mode) 60 61 { 62 struct jffs2_full_dnode *fn; 63 size_t retlen; 64 uint32_t flash_ofs; 65 struct kvec vecs[2]; 66 int ret; 67 int retried = 0; 68 unsigned long cnt = 2; 69 70 D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) { 71 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n"); 72 BUG(); 73 } 74 ); 75 vecs[0].iov_base = ri; 76 vecs[0].iov_len = sizeof(*ri); 77 vecs[1].iov_base = (unsigned char *)data; 78 vecs[1].iov_len = datalen; 79 80 if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) { 81 printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen); 82 } 83 84 fn = jffs2_alloc_full_dnode(); 85 if (!fn) 86 return ERR_PTR(-ENOMEM); 87 88 /* check number of valid vecs */ 89 if (!datalen || !data) 90 cnt = 1; 91 retry: 92 flash_ofs = write_ofs(c); 93 94 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 95 96 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) { 97 BUG_ON(!retried); 98 D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, " 99 "highest version %d -> updating dnode\n", 100 je32_to_cpu(ri->version), f->highest_version)); 101 ri->version = cpu_to_je32(++f->highest_version); 102 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 103 } 104 105 ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen, 106 (alloc_mode==ALLOC_GC)?0:f->inocache->ino); 107 108 if (ret || (retlen != sizeof(*ri) + datalen)) { 109 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 110 sizeof(*ri)+datalen, flash_ofs, ret, retlen); 111 112 /* Mark the space as dirtied */ 113 if (retlen) { 114 /* Don't change raw->size to match retlen. We may have 115 written the node header already, and only the data will 116 seem corrupted, in which case the scan would skip over 117 any node we write before the original intended end of 118 this node */ 119 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL); 120 } else { 121 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 122 } 123 if (!retried && alloc_mode != ALLOC_NORETRY) { 124 /* Try to reallocate space and retry */ 125 uint32_t dummy; 126 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 127 128 retried = 1; 129 130 D1(printk(KERN_DEBUG "Retrying failed write.\n")); 131 132 jffs2_dbg_acct_sanity_check(c,jeb); 133 jffs2_dbg_acct_paranoia_check(c, jeb); 134 135 if (alloc_mode == ALLOC_GC) { 136 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy, 137 JFFS2_SUMMARY_INODE_SIZE); 138 } else { 139 /* Locking pain */ 140 up(&f->sem); 141 jffs2_complete_reservation(c); 142 143 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy, 144 alloc_mode, JFFS2_SUMMARY_INODE_SIZE); 145 down(&f->sem); 146 } 147 148 if (!ret) { 149 flash_ofs = write_ofs(c); 150 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 151 152 jffs2_dbg_acct_sanity_check(c,jeb); 153 jffs2_dbg_acct_paranoia_check(c, jeb); 154 155 goto retry; 156 } 157 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 158 } 159 /* Release the full_dnode which is now useless, and return */ 160 jffs2_free_full_dnode(fn); 161 return ERR_PTR(ret?ret:-EIO); 162 } 163 /* Mark the space used */ 164 /* If node covers at least a whole page, or if it starts at the 165 beginning of a page and runs to the end of the file, or if 166 it's a hole node, mark it REF_PRISTINE, else REF_NORMAL. 167 */ 168 if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) || 169 ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) && 170 (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) { 171 flash_ofs |= REF_PRISTINE; 172 } else { 173 flash_ofs |= REF_NORMAL; 174 } 175 fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache); 176 if (IS_ERR(fn->raw)) { 177 void *hold_err = fn->raw; 178 /* Release the full_dnode which is now useless, and return */ 179 jffs2_free_full_dnode(fn); 180 return ERR_PTR(PTR_ERR(hold_err)); 181 } 182 fn->ofs = je32_to_cpu(ri->offset); 183 fn->size = je32_to_cpu(ri->dsize); 184 fn->frags = 0; 185 186 D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n", 187 flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize), 188 je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc), 189 je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen))); 190 191 if (retried) { 192 jffs2_dbg_acct_sanity_check(c,NULL); 193 } 194 195 return fn; 196 } 197 198 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 199 struct jffs2_raw_dirent *rd, const unsigned char *name, 200 uint32_t namelen, int alloc_mode) 201 { 202 struct jffs2_full_dirent *fd; 203 size_t retlen; 204 struct kvec vecs[2]; 205 uint32_t flash_ofs; 206 int retried = 0; 207 int ret; 208 209 D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 210 je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 211 je32_to_cpu(rd->name_crc))); 212 213 D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { 214 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n"); 215 BUG(); 216 }); 217 218 vecs[0].iov_base = rd; 219 vecs[0].iov_len = sizeof(*rd); 220 vecs[1].iov_base = (unsigned char *)name; 221 vecs[1].iov_len = namelen; 222 223 fd = jffs2_alloc_full_dirent(namelen+1); 224 if (!fd) 225 return ERR_PTR(-ENOMEM); 226 227 fd->version = je32_to_cpu(rd->version); 228 fd->ino = je32_to_cpu(rd->ino); 229 fd->nhash = full_name_hash(name, strlen(name)); 230 fd->type = rd->type; 231 memcpy(fd->name, name, namelen); 232 fd->name[namelen]=0; 233 234 retry: 235 flash_ofs = write_ofs(c); 236 237 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 238 239 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) { 240 BUG_ON(!retried); 241 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, " 242 "highest version %d -> updating dirent\n", 243 je32_to_cpu(rd->version), f->highest_version)); 244 rd->version = cpu_to_je32(++f->highest_version); 245 fd->version = je32_to_cpu(rd->version); 246 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 247 } 248 249 ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen, 250 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino)); 251 if (ret || (retlen != sizeof(*rd) + namelen)) { 252 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 253 sizeof(*rd)+namelen, flash_ofs, ret, retlen); 254 /* Mark the space as dirtied */ 255 if (retlen) { 256 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL); 257 } else { 258 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 259 } 260 if (!retried) { 261 /* Try to reallocate space and retry */ 262 uint32_t dummy; 263 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 264 265 retried = 1; 266 267 D1(printk(KERN_DEBUG "Retrying failed write.\n")); 268 269 jffs2_dbg_acct_sanity_check(c,jeb); 270 jffs2_dbg_acct_paranoia_check(c, jeb); 271 272 if (alloc_mode == ALLOC_GC) { 273 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy, 274 JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 275 } else { 276 /* Locking pain */ 277 up(&f->sem); 278 jffs2_complete_reservation(c); 279 280 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy, 281 alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 282 down(&f->sem); 283 } 284 285 if (!ret) { 286 flash_ofs = write_ofs(c); 287 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 288 jffs2_dbg_acct_sanity_check(c,jeb); 289 jffs2_dbg_acct_paranoia_check(c, jeb); 290 goto retry; 291 } 292 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 293 } 294 /* Release the full_dnode which is now useless, and return */ 295 jffs2_free_full_dirent(fd); 296 return ERR_PTR(ret?ret:-EIO); 297 } 298 /* Mark the space used */ 299 fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | REF_PRISTINE, PAD(sizeof(*rd)+namelen), f->inocache); 300 if (IS_ERR(fd->raw)) { 301 void *hold_err = fd->raw; 302 /* Release the full_dirent which is now useless, and return */ 303 jffs2_free_full_dirent(fd); 304 return ERR_PTR(PTR_ERR(hold_err)); 305 } 306 307 if (retried) { 308 jffs2_dbg_acct_sanity_check(c,NULL); 309 } 310 311 return fd; 312 } 313 314 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that 315 we don't have to go digging in struct inode or its equivalent. It should set: 316 mode, uid, gid, (starting)isize, atime, ctime, mtime */ 317 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 318 struct jffs2_raw_inode *ri, unsigned char *buf, 319 uint32_t offset, uint32_t writelen, uint32_t *retlen) 320 { 321 int ret = 0; 322 uint32_t writtenlen = 0; 323 324 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n", 325 f->inocache->ino, offset, writelen)); 326 327 while(writelen) { 328 struct jffs2_full_dnode *fn; 329 unsigned char *comprbuf = NULL; 330 uint16_t comprtype = JFFS2_COMPR_NONE; 331 uint32_t alloclen; 332 uint32_t datalen, cdatalen; 333 int retried = 0; 334 335 retry: 336 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset)); 337 338 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, 339 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 340 if (ret) { 341 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret)); 342 break; 343 } 344 down(&f->sem); 345 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1))); 346 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen); 347 348 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen); 349 350 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 351 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 352 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen); 353 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 354 355 ri->ino = cpu_to_je32(f->inocache->ino); 356 ri->version = cpu_to_je32(++f->highest_version); 357 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen)); 358 ri->offset = cpu_to_je32(offset); 359 ri->csize = cpu_to_je32(cdatalen); 360 ri->dsize = cpu_to_je32(datalen); 361 ri->compr = comprtype & 0xff; 362 ri->usercompr = (comprtype >> 8 ) & 0xff; 363 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 364 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 365 366 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY); 367 368 jffs2_free_comprbuf(comprbuf, buf); 369 370 if (IS_ERR(fn)) { 371 ret = PTR_ERR(fn); 372 up(&f->sem); 373 jffs2_complete_reservation(c); 374 if (!retried) { 375 /* Write error to be retried */ 376 retried = 1; 377 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n")); 378 goto retry; 379 } 380 break; 381 } 382 ret = jffs2_add_full_dnode_to_inode(c, f, fn); 383 if (f->metadata) { 384 jffs2_mark_node_obsolete(c, f->metadata->raw); 385 jffs2_free_full_dnode(f->metadata); 386 f->metadata = NULL; 387 } 388 if (ret) { 389 /* Eep */ 390 D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret)); 391 jffs2_mark_node_obsolete(c, fn->raw); 392 jffs2_free_full_dnode(fn); 393 394 up(&f->sem); 395 jffs2_complete_reservation(c); 396 break; 397 } 398 up(&f->sem); 399 jffs2_complete_reservation(c); 400 if (!datalen) { 401 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 402 ret = -EIO; 403 break; 404 } 405 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen)); 406 writtenlen += datalen; 407 offset += datalen; 408 writelen -= datalen; 409 buf += datalen; 410 } 411 *retlen = writtenlen; 412 return ret; 413 } 414 415 int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const char *name, int namelen) 416 { 417 struct jffs2_raw_dirent *rd; 418 struct jffs2_full_dnode *fn; 419 struct jffs2_full_dirent *fd; 420 uint32_t alloclen; 421 int ret; 422 423 /* Try to reserve enough space for both node and dirent. 424 * Just the node will do for now, though 425 */ 426 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 427 JFFS2_SUMMARY_INODE_SIZE); 428 D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen)); 429 if (ret) { 430 up(&f->sem); 431 return ret; 432 } 433 434 ri->data_crc = cpu_to_je32(0); 435 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 436 437 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 438 439 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n", 440 jemode_to_cpu(ri->mode))); 441 442 if (IS_ERR(fn)) { 443 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n")); 444 /* Eeek. Wave bye bye */ 445 up(&f->sem); 446 jffs2_complete_reservation(c); 447 return PTR_ERR(fn); 448 } 449 /* No data here. Only a metadata node, which will be 450 obsoleted by the first data write 451 */ 452 f->metadata = fn; 453 454 up(&f->sem); 455 jffs2_complete_reservation(c); 456 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 457 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 458 459 if (ret) { 460 /* Eep. */ 461 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n")); 462 return ret; 463 } 464 465 rd = jffs2_alloc_raw_dirent(); 466 if (!rd) { 467 /* Argh. Now we treat it like a normal delete */ 468 jffs2_complete_reservation(c); 469 return -ENOMEM; 470 } 471 472 down(&dir_f->sem); 473 474 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 475 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 476 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 477 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 478 479 rd->pino = cpu_to_je32(dir_f->inocache->ino); 480 rd->version = cpu_to_je32(++dir_f->highest_version); 481 rd->ino = ri->ino; 482 rd->mctime = ri->ctime; 483 rd->nsize = namelen; 484 rd->type = DT_REG; 485 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 486 rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 487 488 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 489 490 jffs2_free_raw_dirent(rd); 491 492 if (IS_ERR(fd)) { 493 /* dirent failed to write. Delete the inode normally 494 as if it were the final unlink() */ 495 jffs2_complete_reservation(c); 496 up(&dir_f->sem); 497 return PTR_ERR(fd); 498 } 499 500 /* Link the fd into the inode's list, obsoleting an old 501 one if necessary. */ 502 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 503 504 jffs2_complete_reservation(c); 505 up(&dir_f->sem); 506 507 return 0; 508 } 509 510 511 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, 512 const char *name, int namelen, struct jffs2_inode_info *dead_f, 513 uint32_t time) 514 { 515 struct jffs2_raw_dirent *rd; 516 struct jffs2_full_dirent *fd; 517 uint32_t alloclen; 518 int ret; 519 520 if (!jffs2_can_mark_obsolete(c)) { 521 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */ 522 523 rd = jffs2_alloc_raw_dirent(); 524 if (!rd) 525 return -ENOMEM; 526 527 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 528 ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 529 if (ret) { 530 jffs2_free_raw_dirent(rd); 531 return ret; 532 } 533 534 down(&dir_f->sem); 535 536 /* Build a deletion node */ 537 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 538 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 539 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 540 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 541 542 rd->pino = cpu_to_je32(dir_f->inocache->ino); 543 rd->version = cpu_to_je32(++dir_f->highest_version); 544 rd->ino = cpu_to_je32(0); 545 rd->mctime = cpu_to_je32(time); 546 rd->nsize = namelen; 547 rd->type = DT_UNKNOWN; 548 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 549 rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 550 551 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION); 552 553 jffs2_free_raw_dirent(rd); 554 555 if (IS_ERR(fd)) { 556 jffs2_complete_reservation(c); 557 up(&dir_f->sem); 558 return PTR_ERR(fd); 559 } 560 561 /* File it. This will mark the old one obsolete. */ 562 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 563 up(&dir_f->sem); 564 } else { 565 struct jffs2_full_dirent **prev = &dir_f->dents; 566 uint32_t nhash = full_name_hash(name, namelen); 567 568 down(&dir_f->sem); 569 570 while ((*prev) && (*prev)->nhash <= nhash) { 571 if ((*prev)->nhash == nhash && 572 !memcmp((*prev)->name, name, namelen) && 573 !(*prev)->name[namelen]) { 574 struct jffs2_full_dirent *this = *prev; 575 576 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n", 577 this->ino, ref_offset(this->raw))); 578 579 *prev = this->next; 580 jffs2_mark_node_obsolete(c, (this->raw)); 581 jffs2_free_full_dirent(this); 582 break; 583 } 584 prev = &((*prev)->next); 585 } 586 up(&dir_f->sem); 587 } 588 589 /* dead_f is NULL if this was a rename not a real unlink */ 590 /* Also catch the !f->inocache case, where there was a dirent 591 pointing to an inode which didn't exist. */ 592 if (dead_f && dead_f->inocache) { 593 594 down(&dead_f->sem); 595 596 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) { 597 while (dead_f->dents) { 598 /* There can be only deleted ones */ 599 fd = dead_f->dents; 600 601 dead_f->dents = fd->next; 602 603 if (fd->ino) { 604 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 605 dead_f->inocache->ino, fd->name, fd->ino); 606 } else { 607 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n", 608 fd->name, dead_f->inocache->ino)); 609 } 610 jffs2_mark_node_obsolete(c, fd->raw); 611 jffs2_free_full_dirent(fd); 612 } 613 } 614 615 dead_f->inocache->nlink--; 616 /* NB: Caller must set inode nlink if appropriate */ 617 up(&dead_f->sem); 618 } 619 620 jffs2_complete_reservation(c); 621 622 return 0; 623 } 624 625 626 int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino, uint8_t type, const char *name, int namelen, uint32_t time) 627 { 628 struct jffs2_raw_dirent *rd; 629 struct jffs2_full_dirent *fd; 630 uint32_t alloclen; 631 int ret; 632 633 rd = jffs2_alloc_raw_dirent(); 634 if (!rd) 635 return -ENOMEM; 636 637 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 638 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 639 if (ret) { 640 jffs2_free_raw_dirent(rd); 641 return ret; 642 } 643 644 down(&dir_f->sem); 645 646 /* Build a deletion node */ 647 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 648 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 649 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 650 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 651 652 rd->pino = cpu_to_je32(dir_f->inocache->ino); 653 rd->version = cpu_to_je32(++dir_f->highest_version); 654 rd->ino = cpu_to_je32(ino); 655 rd->mctime = cpu_to_je32(time); 656 rd->nsize = namelen; 657 658 rd->type = type; 659 660 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 661 rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 662 663 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 664 665 jffs2_free_raw_dirent(rd); 666 667 if (IS_ERR(fd)) { 668 jffs2_complete_reservation(c); 669 up(&dir_f->sem); 670 return PTR_ERR(fd); 671 } 672 673 /* File it. This will mark the old one obsolete. */ 674 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 675 676 jffs2_complete_reservation(c); 677 up(&dir_f->sem); 678 679 return 0; 680 } 681