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: gc.c,v 1.149 2005/07/17 06:56:21 dedekind Exp $ 11 * 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/mtd/mtd.h> 16 #include <linux/slab.h> 17 #include <linux/pagemap.h> 18 #include <linux/crc32.h> 19 #include <linux/compiler.h> 20 #include <linux/stat.h> 21 #include "nodelist.h" 22 #include "compr.h" 23 24 static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c, 25 struct jffs2_inode_cache *ic, 26 struct jffs2_raw_node_ref *raw); 27 static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 28 struct jffs2_inode_info *f, struct jffs2_full_dnode *fd); 29 static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 30 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd); 31 static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 32 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd); 33 static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 34 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 35 uint32_t start, uint32_t end); 36 static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 37 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 38 uint32_t start, uint32_t end); 39 static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 40 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f); 41 42 /* Called with erase_completion_lock held */ 43 static struct jffs2_eraseblock *jffs2_find_gc_block(struct jffs2_sb_info *c) 44 { 45 struct jffs2_eraseblock *ret; 46 struct list_head *nextlist = NULL; 47 int n = jiffies % 128; 48 49 /* Pick an eraseblock to garbage collect next. This is where we'll 50 put the clever wear-levelling algorithms. Eventually. */ 51 /* We possibly want to favour the dirtier blocks more when the 52 number of free blocks is low. */ 53 again: 54 if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) { 55 D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n")); 56 nextlist = &c->bad_used_list; 57 } else if (n < 50 && !list_empty(&c->erasable_list)) { 58 /* Note that most of them will have gone directly to be erased. 59 So don't favour the erasable_list _too_ much. */ 60 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n")); 61 nextlist = &c->erasable_list; 62 } else if (n < 110 && !list_empty(&c->very_dirty_list)) { 63 /* Most of the time, pick one off the very_dirty list */ 64 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n")); 65 nextlist = &c->very_dirty_list; 66 } else if (n < 126 && !list_empty(&c->dirty_list)) { 67 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next\n")); 68 nextlist = &c->dirty_list; 69 } else if (!list_empty(&c->clean_list)) { 70 D1(printk(KERN_DEBUG "Picking block from clean_list to GC next\n")); 71 nextlist = &c->clean_list; 72 } else if (!list_empty(&c->dirty_list)) { 73 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next (clean_list was empty)\n")); 74 75 nextlist = &c->dirty_list; 76 } else if (!list_empty(&c->very_dirty_list)) { 77 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n")); 78 nextlist = &c->very_dirty_list; 79 } else if (!list_empty(&c->erasable_list)) { 80 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n")); 81 82 nextlist = &c->erasable_list; 83 } else if (!list_empty(&c->erasable_pending_wbuf_list)) { 84 /* There are blocks are wating for the wbuf sync */ 85 D1(printk(KERN_DEBUG "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n")); 86 spin_unlock(&c->erase_completion_lock); 87 jffs2_flush_wbuf_pad(c); 88 spin_lock(&c->erase_completion_lock); 89 goto again; 90 } else { 91 /* Eep. All were empty */ 92 D1(printk(KERN_NOTICE "jffs2: No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n")); 93 return NULL; 94 } 95 96 ret = list_entry(nextlist->next, struct jffs2_eraseblock, list); 97 list_del(&ret->list); 98 c->gcblock = ret; 99 ret->gc_node = ret->first_node; 100 if (!ret->gc_node) { 101 printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset); 102 BUG(); 103 } 104 105 /* Have we accidentally picked a clean block with wasted space ? */ 106 if (ret->wasted_size) { 107 D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size)); 108 ret->dirty_size += ret->wasted_size; 109 c->wasted_size -= ret->wasted_size; 110 c->dirty_size += ret->wasted_size; 111 ret->wasted_size = 0; 112 } 113 114 D2(jffs2_dbg_dump_block_lists(c)); 115 return ret; 116 } 117 118 /* jffs2_garbage_collect_pass 119 * Make a single attempt to progress GC. Move one node, and possibly 120 * start erasing one eraseblock. 121 */ 122 int jffs2_garbage_collect_pass(struct jffs2_sb_info *c) 123 { 124 struct jffs2_inode_info *f; 125 struct jffs2_inode_cache *ic; 126 struct jffs2_eraseblock *jeb; 127 struct jffs2_raw_node_ref *raw; 128 int ret = 0, inum, nlink; 129 130 if (down_interruptible(&c->alloc_sem)) 131 return -EINTR; 132 133 for (;;) { 134 spin_lock(&c->erase_completion_lock); 135 if (!c->unchecked_size) 136 break; 137 138 /* We can't start doing GC yet. We haven't finished checking 139 the node CRCs etc. Do it now. */ 140 141 /* checked_ino is protected by the alloc_sem */ 142 if (c->checked_ino > c->highest_ino) { 143 printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n", 144 c->unchecked_size); 145 D2(jffs2_dbg_dump_block_lists(c)); 146 spin_unlock(&c->erase_completion_lock); 147 BUG(); 148 } 149 150 spin_unlock(&c->erase_completion_lock); 151 152 spin_lock(&c->inocache_lock); 153 154 ic = jffs2_get_ino_cache(c, c->checked_ino++); 155 156 if (!ic) { 157 spin_unlock(&c->inocache_lock); 158 continue; 159 } 160 161 if (!ic->nlink) { 162 D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink zero\n", 163 ic->ino)); 164 spin_unlock(&c->inocache_lock); 165 continue; 166 } 167 switch(ic->state) { 168 case INO_STATE_CHECKEDABSENT: 169 case INO_STATE_PRESENT: 170 D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino)); 171 spin_unlock(&c->inocache_lock); 172 continue; 173 174 case INO_STATE_GC: 175 case INO_STATE_CHECKING: 176 printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state); 177 spin_unlock(&c->inocache_lock); 178 BUG(); 179 180 case INO_STATE_READING: 181 /* We need to wait for it to finish, lest we move on 182 and trigger the BUG() above while we haven't yet 183 finished checking all its nodes */ 184 D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino)); 185 up(&c->alloc_sem); 186 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 187 return 0; 188 189 default: 190 BUG(); 191 192 case INO_STATE_UNCHECKED: 193 ; 194 } 195 ic->state = INO_STATE_CHECKING; 196 spin_unlock(&c->inocache_lock); 197 198 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino)); 199 200 ret = jffs2_do_crccheck_inode(c, ic); 201 if (ret) 202 printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino); 203 204 jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT); 205 up(&c->alloc_sem); 206 return ret; 207 } 208 209 /* First, work out which block we're garbage-collecting */ 210 jeb = c->gcblock; 211 212 if (!jeb) 213 jeb = jffs2_find_gc_block(c); 214 215 if (!jeb) { 216 D1 (printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n")); 217 spin_unlock(&c->erase_completion_lock); 218 up(&c->alloc_sem); 219 return -EIO; 220 } 221 222 D1(printk(KERN_DEBUG "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n", jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size)); 223 D1(if (c->nextblock) 224 printk(KERN_DEBUG "Nextblock at %08x, used_size %08x, dirty_size %08x, wasted_size %08x, free_size %08x\n", c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->free_size)); 225 226 if (!jeb->used_size) { 227 up(&c->alloc_sem); 228 goto eraseit; 229 } 230 231 raw = jeb->gc_node; 232 233 while(ref_obsolete(raw)) { 234 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw))); 235 raw = raw->next_phys; 236 if (unlikely(!raw)) { 237 printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n"); 238 printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n", 239 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size); 240 jeb->gc_node = raw; 241 spin_unlock(&c->erase_completion_lock); 242 up(&c->alloc_sem); 243 BUG(); 244 } 245 } 246 jeb->gc_node = raw; 247 248 D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw))); 249 250 if (!raw->next_in_ino) { 251 /* Inode-less node. Clean marker, snapshot or something like that */ 252 /* FIXME: If it's something that needs to be copied, including something 253 we don't grok that has JFFS2_NODETYPE_RWCOMPAT_COPY, we should do so */ 254 spin_unlock(&c->erase_completion_lock); 255 jffs2_mark_node_obsolete(c, raw); 256 up(&c->alloc_sem); 257 goto eraseit_lock; 258 } 259 260 ic = jffs2_raw_ref_to_ic(raw); 261 262 /* We need to hold the inocache. Either the erase_completion_lock or 263 the inocache_lock are sufficient; we trade down since the inocache_lock 264 causes less contention. */ 265 spin_lock(&c->inocache_lock); 266 267 spin_unlock(&c->erase_completion_lock); 268 269 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", jeb->offset, ref_offset(raw), ref_flags(raw), ic->ino)); 270 271 /* Three possibilities: 272 1. Inode is already in-core. We must iget it and do proper 273 updating to its fragtree, etc. 274 2. Inode is not in-core, node is REF_PRISTINE. We lock the 275 inocache to prevent a read_inode(), copy the node intact. 276 3. Inode is not in-core, node is not pristine. We must iget() 277 and take the slow path. 278 */ 279 280 switch(ic->state) { 281 case INO_STATE_CHECKEDABSENT: 282 /* It's been checked, but it's not currently in-core. 283 We can just copy any pristine nodes, but have 284 to prevent anyone else from doing read_inode() while 285 we're at it, so we set the state accordingly */ 286 if (ref_flags(raw) == REF_PRISTINE) 287 ic->state = INO_STATE_GC; 288 else { 289 D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n", 290 ic->ino)); 291 } 292 break; 293 294 case INO_STATE_PRESENT: 295 /* It's in-core. GC must iget() it. */ 296 break; 297 298 case INO_STATE_UNCHECKED: 299 case INO_STATE_CHECKING: 300 case INO_STATE_GC: 301 /* Should never happen. We should have finished checking 302 by the time we actually start doing any GC, and since 303 we're holding the alloc_sem, no other garbage collection 304 can happen. 305 */ 306 printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n", 307 ic->ino, ic->state); 308 up(&c->alloc_sem); 309 spin_unlock(&c->inocache_lock); 310 BUG(); 311 312 case INO_STATE_READING: 313 /* Someone's currently trying to read it. We must wait for 314 them to finish and then go through the full iget() route 315 to do the GC. However, sometimes read_inode() needs to get 316 the alloc_sem() (for marking nodes invalid) so we must 317 drop the alloc_sem before sleeping. */ 318 319 up(&c->alloc_sem); 320 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n", 321 ic->ino, ic->state)); 322 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 323 /* And because we dropped the alloc_sem we must start again from the 324 beginning. Ponder chance of livelock here -- we're returning success 325 without actually making any progress. 326 327 Q: What are the chances that the inode is back in INO_STATE_READING 328 again by the time we next enter this function? And that this happens 329 enough times to cause a real delay? 330 331 A: Small enough that I don't care :) 332 */ 333 return 0; 334 } 335 336 /* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the 337 node intact, and we don't have to muck about with the fragtree etc. 338 because we know it's not in-core. If it _was_ in-core, we go through 339 all the iget() crap anyway */ 340 341 if (ic->state == INO_STATE_GC) { 342 spin_unlock(&c->inocache_lock); 343 344 ret = jffs2_garbage_collect_pristine(c, ic, raw); 345 346 spin_lock(&c->inocache_lock); 347 ic->state = INO_STATE_CHECKEDABSENT; 348 wake_up(&c->inocache_wq); 349 350 if (ret != -EBADFD) { 351 spin_unlock(&c->inocache_lock); 352 goto release_sem; 353 } 354 355 /* Fall through if it wanted us to, with inocache_lock held */ 356 } 357 358 /* Prevent the fairly unlikely race where the gcblock is 359 entirely obsoleted by the final close of a file which had 360 the only valid nodes in the block, followed by erasure, 361 followed by freeing of the ic because the erased block(s) 362 held _all_ the nodes of that inode.... never been seen but 363 it's vaguely possible. */ 364 365 inum = ic->ino; 366 nlink = ic->nlink; 367 spin_unlock(&c->inocache_lock); 368 369 f = jffs2_gc_fetch_inode(c, inum, nlink); 370 if (IS_ERR(f)) { 371 ret = PTR_ERR(f); 372 goto release_sem; 373 } 374 if (!f) { 375 ret = 0; 376 goto release_sem; 377 } 378 379 ret = jffs2_garbage_collect_live(c, jeb, raw, f); 380 381 jffs2_gc_release_inode(c, f); 382 383 release_sem: 384 up(&c->alloc_sem); 385 386 eraseit_lock: 387 /* If we've finished this block, start it erasing */ 388 spin_lock(&c->erase_completion_lock); 389 390 eraseit: 391 if (c->gcblock && !c->gcblock->used_size) { 392 D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset)); 393 /* We're GC'ing an empty block? */ 394 list_add_tail(&c->gcblock->list, &c->erase_pending_list); 395 c->gcblock = NULL; 396 c->nr_erasing_blocks++; 397 jffs2_erase_pending_trigger(c); 398 } 399 spin_unlock(&c->erase_completion_lock); 400 401 return ret; 402 } 403 404 static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 405 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f) 406 { 407 struct jffs2_node_frag *frag; 408 struct jffs2_full_dnode *fn = NULL; 409 struct jffs2_full_dirent *fd; 410 uint32_t start = 0, end = 0, nrfrags = 0; 411 int ret = 0; 412 413 down(&f->sem); 414 415 /* Now we have the lock for this inode. Check that it's still the one at the head 416 of the list. */ 417 418 spin_lock(&c->erase_completion_lock); 419 420 if (c->gcblock != jeb) { 421 spin_unlock(&c->erase_completion_lock); 422 D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n")); 423 goto upnout; 424 } 425 if (ref_obsolete(raw)) { 426 spin_unlock(&c->erase_completion_lock); 427 D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n")); 428 /* They'll call again */ 429 goto upnout; 430 } 431 spin_unlock(&c->erase_completion_lock); 432 433 /* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */ 434 if (f->metadata && f->metadata->raw == raw) { 435 fn = f->metadata; 436 ret = jffs2_garbage_collect_metadata(c, jeb, f, fn); 437 goto upnout; 438 } 439 440 /* FIXME. Read node and do lookup? */ 441 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) { 442 if (frag->node && frag->node->raw == raw) { 443 fn = frag->node; 444 end = frag->ofs + frag->size; 445 if (!nrfrags++) 446 start = frag->ofs; 447 if (nrfrags == frag->node->frags) 448 break; /* We've found them all */ 449 } 450 } 451 if (fn) { 452 if (ref_flags(raw) == REF_PRISTINE) { 453 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw); 454 if (!ret) { 455 /* Urgh. Return it sensibly. */ 456 frag->node->raw = f->inocache->nodes; 457 } 458 if (ret != -EBADFD) 459 goto upnout; 460 } 461 /* We found a datanode. Do the GC */ 462 if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) { 463 /* It crosses a page boundary. Therefore, it must be a hole. */ 464 ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end); 465 } else { 466 /* It could still be a hole. But we GC the page this way anyway */ 467 ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end); 468 } 469 goto upnout; 470 } 471 472 /* Wasn't a dnode. Try dirent */ 473 for (fd = f->dents; fd; fd=fd->next) { 474 if (fd->raw == raw) 475 break; 476 } 477 478 if (fd && fd->ino) { 479 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd); 480 } else if (fd) { 481 ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd); 482 } else { 483 printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n", 484 ref_offset(raw), f->inocache->ino); 485 if (ref_obsolete(raw)) { 486 printk(KERN_WARNING "But it's obsolete so we don't mind too much\n"); 487 } else { 488 ret = -EIO; 489 } 490 } 491 upnout: 492 up(&f->sem); 493 494 return ret; 495 } 496 497 static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c, 498 struct jffs2_inode_cache *ic, 499 struct jffs2_raw_node_ref *raw) 500 { 501 union jffs2_node_union *node; 502 struct jffs2_raw_node_ref *nraw; 503 size_t retlen; 504 int ret; 505 uint32_t phys_ofs, alloclen; 506 uint32_t crc, rawlen; 507 int retried = 0; 508 509 D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw))); 510 511 rawlen = ref_totlen(c, c->gcblock, raw); 512 513 /* Ask for a small amount of space (or the totlen if smaller) because we 514 don't want to force wastage of the end of a block if splitting would 515 work. */ 516 ret = jffs2_reserve_space_gc(c, min_t(uint32_t, sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN, 517 rawlen), &phys_ofs, &alloclen); 518 if (ret) 519 return ret; 520 521 if (alloclen < rawlen) { 522 /* Doesn't fit untouched. We'll go the old route and split it */ 523 return -EBADFD; 524 } 525 526 node = kmalloc(rawlen, GFP_KERNEL); 527 if (!node) 528 return -ENOMEM; 529 530 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)node); 531 if (!ret && retlen != rawlen) 532 ret = -EIO; 533 if (ret) 534 goto out_node; 535 536 crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4); 537 if (je32_to_cpu(node->u.hdr_crc) != crc) { 538 printk(KERN_WARNING "Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 539 ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc); 540 goto bail; 541 } 542 543 switch(je16_to_cpu(node->u.nodetype)) { 544 case JFFS2_NODETYPE_INODE: 545 crc = crc32(0, node, sizeof(node->i)-8); 546 if (je32_to_cpu(node->i.node_crc) != crc) { 547 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 548 ref_offset(raw), je32_to_cpu(node->i.node_crc), crc); 549 goto bail; 550 } 551 552 if (je32_to_cpu(node->i.dsize)) { 553 crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize)); 554 if (je32_to_cpu(node->i.data_crc) != crc) { 555 printk(KERN_WARNING "Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 556 ref_offset(raw), je32_to_cpu(node->i.data_crc), crc); 557 goto bail; 558 } 559 } 560 break; 561 562 case JFFS2_NODETYPE_DIRENT: 563 crc = crc32(0, node, sizeof(node->d)-8); 564 if (je32_to_cpu(node->d.node_crc) != crc) { 565 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 566 ref_offset(raw), je32_to_cpu(node->d.node_crc), crc); 567 goto bail; 568 } 569 570 if (node->d.nsize) { 571 crc = crc32(0, node->d.name, node->d.nsize); 572 if (je32_to_cpu(node->d.name_crc) != crc) { 573 printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent ode at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 574 ref_offset(raw), je32_to_cpu(node->d.name_crc), crc); 575 goto bail; 576 } 577 } 578 break; 579 default: 580 printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n", 581 ref_offset(raw), je16_to_cpu(node->u.nodetype)); 582 goto bail; 583 } 584 585 nraw = jffs2_alloc_raw_node_ref(); 586 if (!nraw) { 587 ret = -ENOMEM; 588 goto out_node; 589 } 590 591 /* OK, all the CRCs are good; this node can just be copied as-is. */ 592 retry: 593 nraw->flash_offset = phys_ofs; 594 nraw->__totlen = rawlen; 595 nraw->next_phys = NULL; 596 597 ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node); 598 599 if (ret || (retlen != rawlen)) { 600 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n", 601 rawlen, phys_ofs, ret, retlen); 602 if (retlen) { 603 /* Doesn't belong to any inode */ 604 nraw->next_in_ino = NULL; 605 606 nraw->flash_offset |= REF_OBSOLETE; 607 jffs2_add_physical_node_ref(c, nraw); 608 jffs2_mark_node_obsolete(c, nraw); 609 } else { 610 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", nraw->flash_offset); 611 jffs2_free_raw_node_ref(nraw); 612 } 613 if (!retried && (nraw = jffs2_alloc_raw_node_ref())) { 614 /* Try to reallocate space and retry */ 615 uint32_t dummy; 616 struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size]; 617 618 retried = 1; 619 620 D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n")); 621 622 jffs2_dbg_acct_sanity_check(c,jeb); 623 jffs2_dbg_acct_paranoia_check(c, jeb); 624 625 ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy); 626 627 if (!ret) { 628 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs)); 629 630 jffs2_dbg_acct_sanity_check(c,jeb); 631 jffs2_dbg_acct_paranoia_check(c, jeb); 632 633 goto retry; 634 } 635 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 636 jffs2_free_raw_node_ref(nraw); 637 } 638 639 jffs2_free_raw_node_ref(nraw); 640 if (!ret) 641 ret = -EIO; 642 goto out_node; 643 } 644 nraw->flash_offset |= REF_PRISTINE; 645 jffs2_add_physical_node_ref(c, nraw); 646 647 /* Link into per-inode list. This is safe because of the ic 648 state being INO_STATE_GC. Note that if we're doing this 649 for an inode which is in-core, the 'nraw' pointer is then 650 going to be fetched from ic->nodes by our caller. */ 651 spin_lock(&c->erase_completion_lock); 652 nraw->next_in_ino = ic->nodes; 653 ic->nodes = nraw; 654 spin_unlock(&c->erase_completion_lock); 655 656 jffs2_mark_node_obsolete(c, raw); 657 D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw))); 658 659 out_node: 660 kfree(node); 661 return ret; 662 bail: 663 ret = -EBADFD; 664 goto out_node; 665 } 666 667 static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 668 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn) 669 { 670 struct jffs2_full_dnode *new_fn; 671 struct jffs2_raw_inode ri; 672 struct jffs2_node_frag *last_frag; 673 jint16_t dev; 674 char *mdata = NULL, mdatalen = 0; 675 uint32_t alloclen, phys_ofs, ilen; 676 int ret; 677 678 if (S_ISBLK(JFFS2_F_I_MODE(f)) || 679 S_ISCHR(JFFS2_F_I_MODE(f)) ) { 680 /* For these, we don't actually need to read the old node */ 681 /* FIXME: for minor or major > 255. */ 682 dev = cpu_to_je16(((JFFS2_F_I_RDEV_MAJ(f) << 8) | 683 JFFS2_F_I_RDEV_MIN(f))); 684 mdata = (char *)&dev; 685 mdatalen = sizeof(dev); 686 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen)); 687 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) { 688 mdatalen = fn->size; 689 mdata = kmalloc(fn->size, GFP_KERNEL); 690 if (!mdata) { 691 printk(KERN_WARNING "kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n"); 692 return -ENOMEM; 693 } 694 ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen); 695 if (ret) { 696 printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret); 697 kfree(mdata); 698 return ret; 699 } 700 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen)); 701 702 } 703 704 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &phys_ofs, &alloclen); 705 if (ret) { 706 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n", 707 sizeof(ri)+ mdatalen, ret); 708 goto out; 709 } 710 711 last_frag = frag_last(&f->fragtree); 712 if (last_frag) 713 /* Fetch the inode length from the fragtree rather then 714 * from i_size since i_size may have not been updated yet */ 715 ilen = last_frag->ofs + last_frag->size; 716 else 717 ilen = JFFS2_F_I_SIZE(f); 718 719 memset(&ri, 0, sizeof(ri)); 720 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 721 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 722 ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen); 723 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 724 725 ri.ino = cpu_to_je32(f->inocache->ino); 726 ri.version = cpu_to_je32(++f->highest_version); 727 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 728 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 729 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 730 ri.isize = cpu_to_je32(ilen); 731 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 732 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 733 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 734 ri.offset = cpu_to_je32(0); 735 ri.csize = cpu_to_je32(mdatalen); 736 ri.dsize = cpu_to_je32(mdatalen); 737 ri.compr = JFFS2_COMPR_NONE; 738 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 739 ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 740 741 new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, phys_ofs, ALLOC_GC); 742 743 if (IS_ERR(new_fn)) { 744 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 745 ret = PTR_ERR(new_fn); 746 goto out; 747 } 748 jffs2_mark_node_obsolete(c, fn->raw); 749 jffs2_free_full_dnode(fn); 750 f->metadata = new_fn; 751 out: 752 if (S_ISLNK(JFFS2_F_I_MODE(f))) 753 kfree(mdata); 754 return ret; 755 } 756 757 static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 758 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd) 759 { 760 struct jffs2_full_dirent *new_fd; 761 struct jffs2_raw_dirent rd; 762 uint32_t alloclen, phys_ofs; 763 int ret; 764 765 rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 766 rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 767 rd.nsize = strlen(fd->name); 768 rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize); 769 rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4)); 770 771 rd.pino = cpu_to_je32(f->inocache->ino); 772 rd.version = cpu_to_je32(++f->highest_version); 773 rd.ino = cpu_to_je32(fd->ino); 774 rd.mctime = cpu_to_je32(max(JFFS2_F_I_MTIME(f), JFFS2_F_I_CTIME(f))); 775 rd.type = fd->type; 776 rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8)); 777 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize)); 778 779 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &phys_ofs, &alloclen); 780 if (ret) { 781 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n", 782 sizeof(rd)+rd.nsize, ret); 783 return ret; 784 } 785 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, phys_ofs, ALLOC_GC); 786 787 if (IS_ERR(new_fd)) { 788 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd)); 789 return PTR_ERR(new_fd); 790 } 791 jffs2_add_fd_to_list(c, new_fd, &f->dents); 792 return 0; 793 } 794 795 static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 796 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd) 797 { 798 struct jffs2_full_dirent **fdp = &f->dents; 799 int found = 0; 800 801 /* On a medium where we can't actually mark nodes obsolete 802 pernamently, such as NAND flash, we need to work out 803 whether this deletion dirent is still needed to actively 804 delete a 'real' dirent with the same name that's still 805 somewhere else on the flash. */ 806 if (!jffs2_can_mark_obsolete(c)) { 807 struct jffs2_raw_dirent *rd; 808 struct jffs2_raw_node_ref *raw; 809 int ret; 810 size_t retlen; 811 int name_len = strlen(fd->name); 812 uint32_t name_crc = crc32(0, fd->name, name_len); 813 uint32_t rawlen = ref_totlen(c, jeb, fd->raw); 814 815 rd = kmalloc(rawlen, GFP_KERNEL); 816 if (!rd) 817 return -ENOMEM; 818 819 /* Prevent the erase code from nicking the obsolete node refs while 820 we're looking at them. I really don't like this extra lock but 821 can't see any alternative. Suggestions on a postcard to... */ 822 down(&c->erase_free_sem); 823 824 for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) { 825 826 /* We only care about obsolete ones */ 827 if (!(ref_obsolete(raw))) 828 continue; 829 830 /* Any dirent with the same name is going to have the same length... */ 831 if (ref_totlen(c, NULL, raw) != rawlen) 832 continue; 833 834 /* Doesn't matter if there's one in the same erase block. We're going to 835 delete it too at the same time. */ 836 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset)) 837 continue; 838 839 D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw))); 840 841 /* This is an obsolete node belonging to the same directory, and it's of the right 842 length. We need to take a closer look...*/ 843 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)rd); 844 if (ret) { 845 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Read error (%d) reading obsolete node at %08x\n", ret, ref_offset(raw)); 846 /* If we can't read it, we don't need to continue to obsolete it. Continue */ 847 continue; 848 } 849 if (retlen != rawlen) { 850 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Short read (%zd not %u) reading header from obsolete node at %08x\n", 851 retlen, rawlen, ref_offset(raw)); 852 continue; 853 } 854 855 if (je16_to_cpu(rd->nodetype) != JFFS2_NODETYPE_DIRENT) 856 continue; 857 858 /* If the name CRC doesn't match, skip */ 859 if (je32_to_cpu(rd->name_crc) != name_crc) 860 continue; 861 862 /* If the name length doesn't match, or it's another deletion dirent, skip */ 863 if (rd->nsize != name_len || !je32_to_cpu(rd->ino)) 864 continue; 865 866 /* OK, check the actual name now */ 867 if (memcmp(rd->name, fd->name, name_len)) 868 continue; 869 870 /* OK. The name really does match. There really is still an older node on 871 the flash which our deletion dirent obsoletes. So we have to write out 872 a new deletion dirent to replace it */ 873 up(&c->erase_free_sem); 874 875 D1(printk(KERN_DEBUG "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n", 876 ref_offset(fd->raw), fd->name, ref_offset(raw), je32_to_cpu(rd->ino))); 877 kfree(rd); 878 879 return jffs2_garbage_collect_dirent(c, jeb, f, fd); 880 } 881 882 up(&c->erase_free_sem); 883 kfree(rd); 884 } 885 886 /* No need for it any more. Just mark it obsolete and remove it from the list */ 887 while (*fdp) { 888 if ((*fdp) == fd) { 889 found = 1; 890 *fdp = fd->next; 891 break; 892 } 893 fdp = &(*fdp)->next; 894 } 895 if (!found) { 896 printk(KERN_WARNING "Deletion dirent \"%s\" not found in list for ino #%u\n", fd->name, f->inocache->ino); 897 } 898 jffs2_mark_node_obsolete(c, fd->raw); 899 jffs2_free_full_dirent(fd); 900 return 0; 901 } 902 903 static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 904 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 905 uint32_t start, uint32_t end) 906 { 907 struct jffs2_raw_inode ri; 908 struct jffs2_node_frag *frag; 909 struct jffs2_full_dnode *new_fn; 910 uint32_t alloclen, phys_ofs, ilen; 911 int ret; 912 913 D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n", 914 f->inocache->ino, start, end)); 915 916 memset(&ri, 0, sizeof(ri)); 917 918 if(fn->frags > 1) { 919 size_t readlen; 920 uint32_t crc; 921 /* It's partially obsoleted by a later write. So we have to 922 write it out again with the _same_ version as before */ 923 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri); 924 if (readlen != sizeof(ri) || ret) { 925 printk(KERN_WARNING "Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen); 926 goto fill; 927 } 928 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) { 929 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n", 930 ref_offset(fn->raw), 931 je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE); 932 return -EIO; 933 } 934 if (je32_to_cpu(ri.totlen) != sizeof(ri)) { 935 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n", 936 ref_offset(fn->raw), 937 je32_to_cpu(ri.totlen), sizeof(ri)); 938 return -EIO; 939 } 940 crc = crc32(0, &ri, sizeof(ri)-8); 941 if (crc != je32_to_cpu(ri.node_crc)) { 942 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n", 943 ref_offset(fn->raw), 944 je32_to_cpu(ri.node_crc), crc); 945 /* FIXME: We could possibly deal with this by writing new holes for each frag */ 946 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 947 start, end, f->inocache->ino); 948 goto fill; 949 } 950 if (ri.compr != JFFS2_COMPR_ZERO) { 951 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw)); 952 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 953 start, end, f->inocache->ino); 954 goto fill; 955 } 956 } else { 957 fill: 958 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 959 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 960 ri.totlen = cpu_to_je32(sizeof(ri)); 961 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 962 963 ri.ino = cpu_to_je32(f->inocache->ino); 964 ri.version = cpu_to_je32(++f->highest_version); 965 ri.offset = cpu_to_je32(start); 966 ri.dsize = cpu_to_je32(end - start); 967 ri.csize = cpu_to_je32(0); 968 ri.compr = JFFS2_COMPR_ZERO; 969 } 970 971 frag = frag_last(&f->fragtree); 972 if (frag) 973 /* Fetch the inode length from the fragtree rather then 974 * from i_size since i_size may have not been updated yet */ 975 ilen = frag->ofs + frag->size; 976 else 977 ilen = JFFS2_F_I_SIZE(f); 978 979 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 980 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 981 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 982 ri.isize = cpu_to_je32(ilen); 983 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 984 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 985 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 986 ri.data_crc = cpu_to_je32(0); 987 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 988 989 ret = jffs2_reserve_space_gc(c, sizeof(ri), &phys_ofs, &alloclen); 990 if (ret) { 991 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n", 992 sizeof(ri), ret); 993 return ret; 994 } 995 new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, phys_ofs, ALLOC_GC); 996 997 if (IS_ERR(new_fn)) { 998 printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn)); 999 return PTR_ERR(new_fn); 1000 } 1001 if (je32_to_cpu(ri.version) == f->highest_version) { 1002 jffs2_add_full_dnode_to_inode(c, f, new_fn); 1003 if (f->metadata) { 1004 jffs2_mark_node_obsolete(c, f->metadata->raw); 1005 jffs2_free_full_dnode(f->metadata); 1006 f->metadata = NULL; 1007 } 1008 return 0; 1009 } 1010 1011 /* 1012 * We should only get here in the case where the node we are 1013 * replacing had more than one frag, so we kept the same version 1014 * number as before. (Except in case of error -- see 'goto fill;' 1015 * above.) 1016 */ 1017 D1(if(unlikely(fn->frags <= 1)) { 1018 printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n", 1019 fn->frags, je32_to_cpu(ri.version), f->highest_version, 1020 je32_to_cpu(ri.ino)); 1021 }); 1022 1023 /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */ 1024 mark_ref_normal(new_fn->raw); 1025 1026 for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs); 1027 frag; frag = frag_next(frag)) { 1028 if (frag->ofs > fn->size + fn->ofs) 1029 break; 1030 if (frag->node == fn) { 1031 frag->node = new_fn; 1032 new_fn->frags++; 1033 fn->frags--; 1034 } 1035 } 1036 if (fn->frags) { 1037 printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n"); 1038 BUG(); 1039 } 1040 if (!new_fn->frags) { 1041 printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n"); 1042 BUG(); 1043 } 1044 1045 jffs2_mark_node_obsolete(c, fn->raw); 1046 jffs2_free_full_dnode(fn); 1047 1048 return 0; 1049 } 1050 1051 static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 1052 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn, 1053 uint32_t start, uint32_t end) 1054 { 1055 struct jffs2_full_dnode *new_fn; 1056 struct jffs2_raw_inode ri; 1057 uint32_t alloclen, phys_ofs, offset, orig_end, orig_start; 1058 int ret = 0; 1059 unsigned char *comprbuf = NULL, *writebuf; 1060 unsigned long pg; 1061 unsigned char *pg_ptr; 1062 1063 memset(&ri, 0, sizeof(ri)); 1064 1065 D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n", 1066 f->inocache->ino, start, end)); 1067 1068 orig_end = end; 1069 orig_start = start; 1070 1071 if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) { 1072 /* Attempt to do some merging. But only expand to cover logically 1073 adjacent frags if the block containing them is already considered 1074 to be dirty. Otherwise we end up with GC just going round in 1075 circles dirtying the nodes it already wrote out, especially 1076 on NAND where we have small eraseblocks and hence a much higher 1077 chance of nodes having to be split to cross boundaries. */ 1078 1079 struct jffs2_node_frag *frag; 1080 uint32_t min, max; 1081 1082 min = start & ~(PAGE_CACHE_SIZE-1); 1083 max = min + PAGE_CACHE_SIZE; 1084 1085 frag = jffs2_lookup_node_frag(&f->fragtree, start); 1086 1087 /* BUG_ON(!frag) but that'll happen anyway... */ 1088 1089 BUG_ON(frag->ofs != start); 1090 1091 /* First grow down... */ 1092 while((frag = frag_prev(frag)) && frag->ofs >= min) { 1093 1094 /* If the previous frag doesn't even reach the beginning, there's 1095 excessive fragmentation. Just merge. */ 1096 if (frag->ofs > min) { 1097 D1(printk(KERN_DEBUG "Expanding down to cover partial frag (0x%x-0x%x)\n", 1098 frag->ofs, frag->ofs+frag->size)); 1099 start = frag->ofs; 1100 continue; 1101 } 1102 /* OK. This frag holds the first byte of the page. */ 1103 if (!frag->node || !frag->node->raw) { 1104 D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n", 1105 frag->ofs, frag->ofs+frag->size)); 1106 break; 1107 } else { 1108 1109 /* OK, it's a frag which extends to the beginning of the page. Does it live 1110 in a block which is still considered clean? If so, don't obsolete it. 1111 If not, cover it anyway. */ 1112 1113 struct jffs2_raw_node_ref *raw = frag->node->raw; 1114 struct jffs2_eraseblock *jeb; 1115 1116 jeb = &c->blocks[raw->flash_offset / c->sector_size]; 1117 1118 if (jeb == c->gcblock) { 1119 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n", 1120 frag->ofs, frag->ofs+frag->size, ref_offset(raw))); 1121 start = frag->ofs; 1122 break; 1123 } 1124 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 1125 D1(printk(KERN_DEBUG "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n", 1126 frag->ofs, frag->ofs+frag->size, jeb->offset)); 1127 break; 1128 } 1129 1130 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n", 1131 frag->ofs, frag->ofs+frag->size, jeb->offset)); 1132 start = frag->ofs; 1133 break; 1134 } 1135 } 1136 1137 /* ... then up */ 1138 1139 /* Find last frag which is actually part of the node we're to GC. */ 1140 frag = jffs2_lookup_node_frag(&f->fragtree, end-1); 1141 1142 while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) { 1143 1144 /* If the previous frag doesn't even reach the beginning, there's lots 1145 of fragmentation. Just merge. */ 1146 if (frag->ofs+frag->size < max) { 1147 D1(printk(KERN_DEBUG "Expanding up to cover partial frag (0x%x-0x%x)\n", 1148 frag->ofs, frag->ofs+frag->size)); 1149 end = frag->ofs + frag->size; 1150 continue; 1151 } 1152 1153 if (!frag->node || !frag->node->raw) { 1154 D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n", 1155 frag->ofs, frag->ofs+frag->size)); 1156 break; 1157 } else { 1158 1159 /* OK, it's a frag which extends to the beginning of the page. Does it live 1160 in a block which is still considered clean? If so, don't obsolete it. 1161 If not, cover it anyway. */ 1162 1163 struct jffs2_raw_node_ref *raw = frag->node->raw; 1164 struct jffs2_eraseblock *jeb; 1165 1166 jeb = &c->blocks[raw->flash_offset / c->sector_size]; 1167 1168 if (jeb == c->gcblock) { 1169 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n", 1170 frag->ofs, frag->ofs+frag->size, ref_offset(raw))); 1171 end = frag->ofs + frag->size; 1172 break; 1173 } 1174 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 1175 D1(printk(KERN_DEBUG "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n", 1176 frag->ofs, frag->ofs+frag->size, jeb->offset)); 1177 break; 1178 } 1179 1180 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n", 1181 frag->ofs, frag->ofs+frag->size, jeb->offset)); 1182 end = frag->ofs + frag->size; 1183 break; 1184 } 1185 } 1186 D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n", 1187 orig_start, orig_end, start, end)); 1188 1189 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size)); 1190 BUG_ON(end < orig_end); 1191 BUG_ON(start > orig_start); 1192 } 1193 1194 /* First, use readpage() to read the appropriate page into the page cache */ 1195 /* Q: What happens if we actually try to GC the _same_ page for which commit_write() 1196 * triggered garbage collection in the first place? 1197 * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the 1198 * page OK. We'll actually write it out again in commit_write, which is a little 1199 * suboptimal, but at least we're correct. 1200 */ 1201 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg); 1202 1203 if (IS_ERR(pg_ptr)) { 1204 printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(pg_ptr)); 1205 return PTR_ERR(pg_ptr); 1206 } 1207 1208 offset = start; 1209 while(offset < orig_end) { 1210 uint32_t datalen; 1211 uint32_t cdatalen; 1212 uint16_t comprtype = JFFS2_COMPR_NONE; 1213 1214 ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen); 1215 1216 if (ret) { 1217 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n", 1218 sizeof(ri)+ JFFS2_MIN_DATA_LEN, ret); 1219 break; 1220 } 1221 cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset); 1222 datalen = end - offset; 1223 1224 writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1)); 1225 1226 comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 1227 1228 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 1229 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 1230 ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen); 1231 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 1232 1233 ri.ino = cpu_to_je32(f->inocache->ino); 1234 ri.version = cpu_to_je32(++f->highest_version); 1235 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 1236 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 1237 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 1238 ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f)); 1239 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 1240 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 1241 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 1242 ri.offset = cpu_to_je32(offset); 1243 ri.csize = cpu_to_je32(cdatalen); 1244 ri.dsize = cpu_to_je32(datalen); 1245 ri.compr = comprtype & 0xff; 1246 ri.usercompr = (comprtype >> 8) & 0xff; 1247 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 1248 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 1249 1250 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, phys_ofs, ALLOC_GC); 1251 1252 jffs2_free_comprbuf(comprbuf, writebuf); 1253 1254 if (IS_ERR(new_fn)) { 1255 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 1256 ret = PTR_ERR(new_fn); 1257 break; 1258 } 1259 ret = jffs2_add_full_dnode_to_inode(c, f, new_fn); 1260 offset += datalen; 1261 if (f->metadata) { 1262 jffs2_mark_node_obsolete(c, f->metadata->raw); 1263 jffs2_free_full_dnode(f->metadata); 1264 f->metadata = NULL; 1265 } 1266 } 1267 1268 jffs2_gc_release_page(c, pg_ptr, &pg); 1269 return ret; 1270 } 1271 1272