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