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