1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright © 2001-2007 Red Hat, Inc. 5 * 6 * Created by David Woodhouse <dwmw2@infradead.org> 7 * 8 * For licensing information, see the file 'LICENCE' in this directory. 9 * 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/mtd/mtd.h> 14 #include <linux/compiler.h> 15 #include <linux/sched.h> /* For cond_resched() */ 16 #include "nodelist.h" 17 #include "debug.h" 18 19 /** 20 * jffs2_reserve_space - request physical space to write nodes to flash 21 * @c: superblock info 22 * @minsize: Minimum acceptable size of allocation 23 * @len: Returned value of allocation length 24 * @prio: Allocation type - ALLOC_{NORMAL,DELETION} 25 * 26 * Requests a block of physical space on the flash. Returns zero for success 27 * and puts 'len' into the appropriate place, or returns -ENOSPC or other 28 * error if appropriate. Doesn't return len since that's 29 * 30 * If it returns zero, jffs2_reserve_space() also downs the per-filesystem 31 * allocation semaphore, to prevent more than one allocation from being 32 * active at any time. The semaphore is later released by jffs2_commit_allocation() 33 * 34 * jffs2_reserve_space() may trigger garbage collection in order to make room 35 * for the requested allocation. 36 */ 37 38 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 39 uint32_t *len, uint32_t sumsize); 40 41 int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 42 uint32_t *len, int prio, uint32_t sumsize) 43 { 44 int ret = -EAGAIN; 45 int blocksneeded = c->resv_blocks_write; 46 /* align it */ 47 minsize = PAD(minsize); 48 49 jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 50 mutex_lock(&c->alloc_sem); 51 52 jffs2_dbg(1, "%s(): alloc sem got\n", __func__); 53 54 spin_lock(&c->erase_completion_lock); 55 56 /* this needs a little more thought (true <tglx> :)) */ 57 while(ret == -EAGAIN) { 58 while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) { 59 uint32_t dirty, avail; 60 61 /* calculate real dirty size 62 * dirty_size contains blocks on erase_pending_list 63 * those blocks are counted in c->nr_erasing_blocks. 64 * If one block is actually erased, it is not longer counted as dirty_space 65 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 66 * with c->nr_erasing_blocks * c->sector_size again. 67 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 68 * This helps us to force gc and pick eventually a clean block to spread the load. 69 * We add unchecked_size here, as we hopefully will find some space to use. 70 * This will affect the sum only once, as gc first finishes checking 71 * of nodes. 72 */ 73 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 74 if (dirty < c->nospc_dirty_size) { 75 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 76 jffs2_dbg(1, "%s(): Low on dirty space to GC, but it's a deletion. Allowing...\n", 77 __func__); 78 break; 79 } 80 jffs2_dbg(1, "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 81 dirty, c->unchecked_size, 82 c->sector_size); 83 84 spin_unlock(&c->erase_completion_lock); 85 mutex_unlock(&c->alloc_sem); 86 return -ENOSPC; 87 } 88 89 /* Calc possibly available space. Possibly available means that we 90 * don't know, if unchecked size contains obsoleted nodes, which could give us some 91 * more usable space. This will affect the sum only once, as gc first finishes checking 92 * of nodes. 93 + Return -ENOSPC, if the maximum possibly available space is less or equal than 94 * blocksneeded * sector_size. 95 * This blocks endless gc looping on a filesystem, which is nearly full, even if 96 * the check above passes. 97 */ 98 avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 99 if ( (avail / c->sector_size) <= blocksneeded) { 100 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 101 jffs2_dbg(1, "%s(): Low on possibly available space, but it's a deletion. Allowing...\n", 102 __func__); 103 break; 104 } 105 106 jffs2_dbg(1, "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 107 avail, blocksneeded * c->sector_size); 108 spin_unlock(&c->erase_completion_lock); 109 mutex_unlock(&c->alloc_sem); 110 return -ENOSPC; 111 } 112 113 mutex_unlock(&c->alloc_sem); 114 115 jffs2_dbg(1, "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, wasted_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n", 116 c->nr_free_blocks, c->nr_erasing_blocks, 117 c->free_size, c->dirty_size, c->wasted_size, 118 c->used_size, c->erasing_size, c->bad_size, 119 c->free_size + c->dirty_size + 120 c->wasted_size + c->used_size + 121 c->erasing_size + c->bad_size, 122 c->flash_size); 123 spin_unlock(&c->erase_completion_lock); 124 125 ret = jffs2_garbage_collect_pass(c); 126 127 if (ret == -EAGAIN) { 128 spin_lock(&c->erase_completion_lock); 129 if (c->nr_erasing_blocks && 130 list_empty(&c->erase_pending_list) && 131 list_empty(&c->erase_complete_list)) { 132 DECLARE_WAITQUEUE(wait, current); 133 set_current_state(TASK_UNINTERRUPTIBLE); 134 add_wait_queue(&c->erase_wait, &wait); 135 jffs2_dbg(1, "%s waiting for erase to complete\n", 136 __func__); 137 spin_unlock(&c->erase_completion_lock); 138 139 schedule(); 140 } else 141 spin_unlock(&c->erase_completion_lock); 142 } else if (ret) 143 return ret; 144 145 cond_resched(); 146 147 if (signal_pending(current)) 148 return -EINTR; 149 150 mutex_lock(&c->alloc_sem); 151 spin_lock(&c->erase_completion_lock); 152 } 153 154 ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 155 if (ret) { 156 jffs2_dbg(1, "%s(): ret is %d\n", __func__, ret); 157 } 158 } 159 spin_unlock(&c->erase_completion_lock); 160 if (!ret) 161 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 162 if (ret) 163 mutex_unlock(&c->alloc_sem); 164 return ret; 165 } 166 167 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, 168 uint32_t *len, uint32_t sumsize) 169 { 170 int ret = -EAGAIN; 171 minsize = PAD(minsize); 172 173 jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 174 175 spin_lock(&c->erase_completion_lock); 176 while(ret == -EAGAIN) { 177 ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 178 if (ret) { 179 jffs2_dbg(1, "%s(): looping, ret is %d\n", 180 __func__, ret); 181 } 182 } 183 spin_unlock(&c->erase_completion_lock); 184 if (!ret) 185 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 186 187 return ret; 188 } 189 190 191 /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */ 192 193 static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 194 { 195 196 if (c->nextblock == NULL) { 197 jffs2_dbg(1, "%s(): Erase block at 0x%08x has already been placed in a list\n", 198 __func__, jeb->offset); 199 return; 200 } 201 /* Check, if we have a dirty block now, or if it was dirty already */ 202 if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) { 203 c->dirty_size += jeb->wasted_size; 204 c->wasted_size -= jeb->wasted_size; 205 jeb->dirty_size += jeb->wasted_size; 206 jeb->wasted_size = 0; 207 if (VERYDIRTY(c, jeb->dirty_size)) { 208 jffs2_dbg(1, "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 209 jeb->offset, jeb->free_size, jeb->dirty_size, 210 jeb->used_size); 211 list_add_tail(&jeb->list, &c->very_dirty_list); 212 } else { 213 jffs2_dbg(1, "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 214 jeb->offset, jeb->free_size, jeb->dirty_size, 215 jeb->used_size); 216 list_add_tail(&jeb->list, &c->dirty_list); 217 } 218 } else { 219 jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 220 jeb->offset, jeb->free_size, jeb->dirty_size, 221 jeb->used_size); 222 list_add_tail(&jeb->list, &c->clean_list); 223 } 224 c->nextblock = NULL; 225 226 } 227 228 /* Select a new jeb for nextblock */ 229 230 static int jffs2_find_nextblock(struct jffs2_sb_info *c) 231 { 232 struct list_head *next; 233 234 /* Take the next block off the 'free' list */ 235 236 if (list_empty(&c->free_list)) { 237 238 if (!c->nr_erasing_blocks && 239 !list_empty(&c->erasable_list)) { 240 struct jffs2_eraseblock *ejeb; 241 242 ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list); 243 list_move_tail(&ejeb->list, &c->erase_pending_list); 244 c->nr_erasing_blocks++; 245 jffs2_garbage_collect_trigger(c); 246 jffs2_dbg(1, "%s(): Triggering erase of erasable block at 0x%08x\n", 247 __func__, ejeb->offset); 248 } 249 250 if (!c->nr_erasing_blocks && 251 !list_empty(&c->erasable_pending_wbuf_list)) { 252 jffs2_dbg(1, "%s(): Flushing write buffer\n", 253 __func__); 254 /* c->nextblock is NULL, no update to c->nextblock allowed */ 255 spin_unlock(&c->erase_completion_lock); 256 jffs2_flush_wbuf_pad(c); 257 spin_lock(&c->erase_completion_lock); 258 /* Have another go. It'll be on the erasable_list now */ 259 return -EAGAIN; 260 } 261 262 if (!c->nr_erasing_blocks) { 263 /* Ouch. We're in GC, or we wouldn't have got here. 264 And there's no space left. At all. */ 265 printk(KERN_CRIT "Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n", 266 c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no", 267 list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"); 268 return -ENOSPC; 269 } 270 271 spin_unlock(&c->erase_completion_lock); 272 /* Don't wait for it; just erase one right now */ 273 jffs2_erase_pending_blocks(c, 1); 274 spin_lock(&c->erase_completion_lock); 275 276 /* An erase may have failed, decreasing the 277 amount of free space available. So we must 278 restart from the beginning */ 279 return -EAGAIN; 280 } 281 282 next = c->free_list.next; 283 list_del(next); 284 c->nextblock = list_entry(next, struct jffs2_eraseblock, list); 285 c->nr_free_blocks--; 286 287 jffs2_sum_reset_collected(c->summary); /* reset collected summary */ 288 289 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 290 /* adjust write buffer offset, else we get a non contiguous write bug */ 291 if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len) 292 c->wbuf_ofs = 0xffffffff; 293 #endif 294 295 jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 296 __func__, c->nextblock->offset); 297 298 return 0; 299 } 300 301 /* Called with alloc sem _and_ erase_completion_lock */ 302 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 303 uint32_t *len, uint32_t sumsize) 304 { 305 struct jffs2_eraseblock *jeb = c->nextblock; 306 uint32_t reserved_size; /* for summary information at the end of the jeb */ 307 int ret; 308 309 restart: 310 reserved_size = 0; 311 312 if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) { 313 /* NOSUM_SIZE means not to generate summary */ 314 315 if (jeb) { 316 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 317 dbg_summary("minsize=%d , jeb->free=%d ," 318 "summary->size=%d , sumsize=%d\n", 319 minsize, jeb->free_size, 320 c->summary->sum_size, sumsize); 321 } 322 323 /* Is there enough space for writing out the current node, or we have to 324 write out summary information now, close this jeb and select new nextblock? */ 325 if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize + 326 JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) { 327 328 /* Has summary been disabled for this jeb? */ 329 if (jffs2_sum_is_disabled(c->summary)) { 330 sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 331 goto restart; 332 } 333 334 /* Writing out the collected summary information */ 335 dbg_summary("generating summary for 0x%08x.\n", jeb->offset); 336 ret = jffs2_sum_write_sumnode(c); 337 338 if (ret) 339 return ret; 340 341 if (jffs2_sum_is_disabled(c->summary)) { 342 /* jffs2_write_sumnode() couldn't write out the summary information 343 diabling summary for this jeb and free the collected information 344 */ 345 sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 346 goto restart; 347 } 348 349 jffs2_close_nextblock(c, jeb); 350 jeb = NULL; 351 /* keep always valid value in reserved_size */ 352 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 353 } 354 } else { 355 if (jeb && minsize > jeb->free_size) { 356 uint32_t waste; 357 358 /* Skip the end of this block and file it as having some dirty space */ 359 /* If there's a pending write to it, flush now */ 360 361 if (jffs2_wbuf_dirty(c)) { 362 spin_unlock(&c->erase_completion_lock); 363 jffs2_dbg(1, "%s(): Flushing write buffer\n", 364 __func__); 365 jffs2_flush_wbuf_pad(c); 366 spin_lock(&c->erase_completion_lock); 367 jeb = c->nextblock; 368 goto restart; 369 } 370 371 spin_unlock(&c->erase_completion_lock); 372 373 ret = jffs2_prealloc_raw_node_refs(c, jeb, 1); 374 if (ret) 375 return ret; 376 /* Just lock it again and continue. Nothing much can change because 377 we hold c->alloc_sem anyway. In fact, it's not entirely clear why 378 we hold c->erase_completion_lock in the majority of this function... 379 but that's a question for another (more caffeine-rich) day. */ 380 spin_lock(&c->erase_completion_lock); 381 382 waste = jeb->free_size; 383 jffs2_link_node_ref(c, jeb, 384 (jeb->offset + c->sector_size - waste) | REF_OBSOLETE, 385 waste, NULL); 386 /* FIXME: that made it count as dirty. Convert to wasted */ 387 jeb->dirty_size -= waste; 388 c->dirty_size -= waste; 389 jeb->wasted_size += waste; 390 c->wasted_size += waste; 391 392 jffs2_close_nextblock(c, jeb); 393 jeb = NULL; 394 } 395 } 396 397 if (!jeb) { 398 399 ret = jffs2_find_nextblock(c); 400 if (ret) 401 return ret; 402 403 jeb = c->nextblock; 404 405 if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 406 printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size); 407 goto restart; 408 } 409 } 410 /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has 411 enough space */ 412 *len = jeb->free_size - reserved_size; 413 414 if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size && 415 !jeb->first_node->next_in_ino) { 416 /* Only node in it beforehand was a CLEANMARKER node (we think). 417 So mark it obsolete now that there's going to be another node 418 in the block. This will reduce used_size to zero but We've 419 already set c->nextblock so that jffs2_mark_node_obsolete() 420 won't try to refile it to the dirty_list. 421 */ 422 spin_unlock(&c->erase_completion_lock); 423 jffs2_mark_node_obsolete(c, jeb->first_node); 424 spin_lock(&c->erase_completion_lock); 425 } 426 427 jffs2_dbg(1, "%s(): Giving 0x%x bytes at 0x%x\n", 428 __func__, 429 *len, jeb->offset + (c->sector_size - jeb->free_size)); 430 return 0; 431 } 432 433 /** 434 * jffs2_add_physical_node_ref - add a physical node reference to the list 435 * @c: superblock info 436 * @new: new node reference to add 437 * @len: length of this physical node 438 * 439 * Should only be used to report nodes for which space has been allocated 440 * by jffs2_reserve_space. 441 * 442 * Must be called with the alloc_sem held. 443 */ 444 445 struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, 446 uint32_t ofs, uint32_t len, 447 struct jffs2_inode_cache *ic) 448 { 449 struct jffs2_eraseblock *jeb; 450 struct jffs2_raw_node_ref *new; 451 452 jeb = &c->blocks[ofs / c->sector_size]; 453 454 jffs2_dbg(1, "%s(): Node at 0x%x(%d), size 0x%x\n", 455 __func__, ofs & ~3, ofs & 3, len); 456 #if 1 457 /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 458 if c->nextblock is set. Note that wbuf.c will file obsolete nodes 459 even after refiling c->nextblock */ 460 if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 461 && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 462 printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3); 463 if (c->nextblock) 464 printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset); 465 else 466 printk(KERN_WARNING "No nextblock"); 467 printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size)); 468 return ERR_PTR(-EINVAL); 469 } 470 #endif 471 spin_lock(&c->erase_completion_lock); 472 473 new = jffs2_link_node_ref(c, jeb, ofs, len, ic); 474 475 if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 476 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 477 jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 478 jeb->offset, jeb->free_size, jeb->dirty_size, 479 jeb->used_size); 480 if (jffs2_wbuf_dirty(c)) { 481 /* Flush the last write in the block if it's outstanding */ 482 spin_unlock(&c->erase_completion_lock); 483 jffs2_flush_wbuf_pad(c); 484 spin_lock(&c->erase_completion_lock); 485 } 486 487 list_add_tail(&jeb->list, &c->clean_list); 488 c->nextblock = NULL; 489 } 490 jffs2_dbg_acct_sanity_check_nolock(c,jeb); 491 jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 492 493 spin_unlock(&c->erase_completion_lock); 494 495 return new; 496 } 497 498 499 void jffs2_complete_reservation(struct jffs2_sb_info *c) 500 { 501 jffs2_dbg(1, "jffs2_complete_reservation()\n"); 502 spin_lock(&c->erase_completion_lock); 503 jffs2_garbage_collect_trigger(c); 504 spin_unlock(&c->erase_completion_lock); 505 mutex_unlock(&c->alloc_sem); 506 } 507 508 static inline int on_list(struct list_head *obj, struct list_head *head) 509 { 510 struct list_head *this; 511 512 list_for_each(this, head) { 513 if (this == obj) { 514 jffs2_dbg(1, "%p is on list at %p\n", obj, head); 515 return 1; 516 517 } 518 } 519 return 0; 520 } 521 522 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref) 523 { 524 struct jffs2_eraseblock *jeb; 525 int blocknr; 526 struct jffs2_unknown_node n; 527 int ret, addedsize; 528 size_t retlen; 529 uint32_t freed_len; 530 531 if(unlikely(!ref)) { 532 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 533 return; 534 } 535 if (ref_obsolete(ref)) { 536 jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n", 537 __func__, ref_offset(ref)); 538 return; 539 } 540 blocknr = ref->flash_offset / c->sector_size; 541 if (blocknr >= c->nr_blocks) { 542 printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset); 543 BUG(); 544 } 545 jeb = &c->blocks[blocknr]; 546 547 if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) && 548 !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) { 549 /* Hm. This may confuse static lock analysis. If any of the above 550 three conditions is false, we're going to return from this 551 function without actually obliterating any nodes or freeing 552 any jffs2_raw_node_refs. So we don't need to stop erases from 553 happening, or protect against people holding an obsolete 554 jffs2_raw_node_ref without the erase_completion_lock. */ 555 mutex_lock(&c->erase_free_sem); 556 } 557 558 spin_lock(&c->erase_completion_lock); 559 560 freed_len = ref_totlen(c, jeb, ref); 561 562 if (ref_flags(ref) == REF_UNCHECKED) { 563 D1(if (unlikely(jeb->unchecked_size < freed_len)) { 564 printk(KERN_NOTICE "raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n", 565 freed_len, blocknr, ref->flash_offset, jeb->used_size); 566 BUG(); 567 }) 568 jffs2_dbg(1, "Obsoleting previously unchecked node at 0x%08x of len %x\n", 569 ref_offset(ref), freed_len); 570 jeb->unchecked_size -= freed_len; 571 c->unchecked_size -= freed_len; 572 } else { 573 D1(if (unlikely(jeb->used_size < freed_len)) { 574 printk(KERN_NOTICE "raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n", 575 freed_len, blocknr, ref->flash_offset, jeb->used_size); 576 BUG(); 577 }) 578 jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ", 579 ref_offset(ref), freed_len); 580 jeb->used_size -= freed_len; 581 c->used_size -= freed_len; 582 } 583 584 // Take care, that wasted size is taken into concern 585 if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) { 586 jffs2_dbg(1, "Dirtying\n"); 587 addedsize = freed_len; 588 jeb->dirty_size += freed_len; 589 c->dirty_size += freed_len; 590 591 /* Convert wasted space to dirty, if not a bad block */ 592 if (jeb->wasted_size) { 593 if (on_list(&jeb->list, &c->bad_used_list)) { 594 jffs2_dbg(1, "Leaving block at %08x on the bad_used_list\n", 595 jeb->offset); 596 addedsize = 0; /* To fool the refiling code later */ 597 } else { 598 jffs2_dbg(1, "Converting %d bytes of wasted space to dirty in block at %08x\n", 599 jeb->wasted_size, jeb->offset); 600 addedsize += jeb->wasted_size; 601 jeb->dirty_size += jeb->wasted_size; 602 c->dirty_size += jeb->wasted_size; 603 c->wasted_size -= jeb->wasted_size; 604 jeb->wasted_size = 0; 605 } 606 } 607 } else { 608 jffs2_dbg(1, "Wasting\n"); 609 addedsize = 0; 610 jeb->wasted_size += freed_len; 611 c->wasted_size += freed_len; 612 } 613 ref->flash_offset = ref_offset(ref) | REF_OBSOLETE; 614 615 jffs2_dbg_acct_sanity_check_nolock(c, jeb); 616 jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 617 618 if (c->flags & JFFS2_SB_FLAG_SCANNING) { 619 /* Flash scanning is in progress. Don't muck about with the block 620 lists because they're not ready yet, and don't actually 621 obliterate nodes that look obsolete. If they weren't 622 marked obsolete on the flash at the time they _became_ 623 obsolete, there was probably a reason for that. */ 624 spin_unlock(&c->erase_completion_lock); 625 /* We didn't lock the erase_free_sem */ 626 return; 627 } 628 629 if (jeb == c->nextblock) { 630 jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n", 631 jeb->offset); 632 } else if (!jeb->used_size && !jeb->unchecked_size) { 633 if (jeb == c->gcblock) { 634 jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", 635 jeb->offset); 636 c->gcblock = NULL; 637 } else { 638 jffs2_dbg(1, "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", 639 jeb->offset); 640 list_del(&jeb->list); 641 } 642 if (jffs2_wbuf_dirty(c)) { 643 jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n"); 644 list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 645 } else { 646 if (jiffies & 127) { 647 /* Most of the time, we just erase it immediately. Otherwise we 648 spend ages scanning it on mount, etc. */ 649 jffs2_dbg(1, "...and adding to erase_pending_list\n"); 650 list_add_tail(&jeb->list, &c->erase_pending_list); 651 c->nr_erasing_blocks++; 652 jffs2_garbage_collect_trigger(c); 653 } else { 654 /* Sometimes, however, we leave it elsewhere so it doesn't get 655 immediately reused, and we spread the load a bit. */ 656 jffs2_dbg(1, "...and adding to erasable_list\n"); 657 list_add_tail(&jeb->list, &c->erasable_list); 658 } 659 } 660 jffs2_dbg(1, "Done OK\n"); 661 } else if (jeb == c->gcblock) { 662 jffs2_dbg(2, "Not moving gcblock 0x%08x to dirty_list\n", 663 jeb->offset); 664 } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 665 jffs2_dbg(1, "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", 666 jeb->offset); 667 list_del(&jeb->list); 668 jffs2_dbg(1, "...and adding to dirty_list\n"); 669 list_add_tail(&jeb->list, &c->dirty_list); 670 } else if (VERYDIRTY(c, jeb->dirty_size) && 671 !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 672 jffs2_dbg(1, "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", 673 jeb->offset); 674 list_del(&jeb->list); 675 jffs2_dbg(1, "...and adding to very_dirty_list\n"); 676 list_add_tail(&jeb->list, &c->very_dirty_list); 677 } else { 678 jffs2_dbg(1, "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 679 jeb->offset, jeb->free_size, jeb->dirty_size, 680 jeb->used_size); 681 } 682 683 spin_unlock(&c->erase_completion_lock); 684 685 if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) || 686 (c->flags & JFFS2_SB_FLAG_BUILDING)) { 687 /* We didn't lock the erase_free_sem */ 688 return; 689 } 690 691 /* The erase_free_sem is locked, and has been since before we marked the node obsolete 692 and potentially put its eraseblock onto the erase_pending_list. Thus, we know that 693 the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 694 by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */ 695 696 jffs2_dbg(1, "obliterating obsoleted node at 0x%08x\n", 697 ref_offset(ref)); 698 ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 699 if (ret) { 700 printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 701 goto out_erase_sem; 702 } 703 if (retlen != sizeof(n)) { 704 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 705 goto out_erase_sem; 706 } 707 if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) { 708 printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len); 709 goto out_erase_sem; 710 } 711 if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 712 jffs2_dbg(1, "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", 713 ref_offset(ref), je16_to_cpu(n.nodetype)); 714 goto out_erase_sem; 715 } 716 /* XXX FIXME: This is ugly now */ 717 n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 718 ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 719 if (ret) { 720 printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 721 goto out_erase_sem; 722 } 723 if (retlen != sizeof(n)) { 724 printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 725 goto out_erase_sem; 726 } 727 728 /* Nodes which have been marked obsolete no longer need to be 729 associated with any inode. Remove them from the per-inode list. 730 731 Note we can't do this for NAND at the moment because we need 732 obsolete dirent nodes to stay on the lists, because of the 733 horridness in jffs2_garbage_collect_deletion_dirent(). Also 734 because we delete the inocache, and on NAND we need that to 735 stay around until all the nodes are actually erased, in order 736 to stop us from giving the same inode number to another newly 737 created inode. */ 738 if (ref->next_in_ino) { 739 struct jffs2_inode_cache *ic; 740 struct jffs2_raw_node_ref **p; 741 742 spin_lock(&c->erase_completion_lock); 743 744 ic = jffs2_raw_ref_to_ic(ref); 745 for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino)) 746 ; 747 748 *p = ref->next_in_ino; 749 ref->next_in_ino = NULL; 750 751 switch (ic->class) { 752 #ifdef CONFIG_JFFS2_FS_XATTR 753 case RAWNODE_CLASS_XATTR_DATUM: 754 jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic); 755 break; 756 case RAWNODE_CLASS_XATTR_REF: 757 jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic); 758 break; 759 #endif 760 default: 761 if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 762 jffs2_del_ino_cache(c, ic); 763 break; 764 } 765 spin_unlock(&c->erase_completion_lock); 766 } 767 768 out_erase_sem: 769 mutex_unlock(&c->erase_free_sem); 770 } 771 772 int jffs2_thread_should_wake(struct jffs2_sb_info *c) 773 { 774 int ret = 0; 775 uint32_t dirty; 776 int nr_very_dirty = 0; 777 struct jffs2_eraseblock *jeb; 778 779 if (!list_empty(&c->erase_complete_list) || 780 !list_empty(&c->erase_pending_list)) 781 return 1; 782 783 if (c->unchecked_size) { 784 jffs2_dbg(1, "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 785 c->unchecked_size, c->checked_ino); 786 return 1; 787 } 788 789 /* dirty_size contains blocks on erase_pending_list 790 * those blocks are counted in c->nr_erasing_blocks. 791 * If one block is actually erased, it is not longer counted as dirty_space 792 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 793 * with c->nr_erasing_blocks * c->sector_size again. 794 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 795 * This helps us to force gc and pick eventually a clean block to spread the load. 796 */ 797 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size; 798 799 if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger && 800 (dirty > c->nospc_dirty_size)) 801 ret = 1; 802 803 list_for_each_entry(jeb, &c->very_dirty_list, list) { 804 nr_very_dirty++; 805 if (nr_very_dirty == c->vdirty_blocks_gctrigger) { 806 ret = 1; 807 /* In debug mode, actually go through and count them all */ 808 D1(continue); 809 break; 810 } 811 } 812 813 jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 814 __func__, c->nr_free_blocks, c->nr_erasing_blocks, 815 c->dirty_size, nr_very_dirty, ret ? "yes" : "no"); 816 817 return ret; 818 } 819