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