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