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