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