2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
12 #include <linux/kernel.h>
13 #include <linux/mtd/mtd.h>
14 #include <linux/compiler.h>
15 #include <linux/sched.h> /* For cond_resched() */
20 * jffs2_reserve_space - request physical space to write nodes to flash
22 * @minsize: Minimum acceptable size of allocation
23 * @len: Returned value of allocation length
24 * @prio: Allocation type - ALLOC_{NORMAL,DELETION}
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
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()
34 * jffs2_reserve_space() may trigger garbage collection in order to make room
35 * for the requested allocation.
38 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
39 uint32_t *len, uint32_t sumsize);
41 int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
42 uint32_t *len, int prio, uint32_t sumsize)
45 int blocksneeded = c->resv_blocks_write;
47 minsize = PAD(minsize);
49 D1(printk(KERN_DEBUG "jffs2_reserve_space(): Requested 0x%x bytes\n", minsize));
50 mutex_lock(&c->alloc_sem);
52 D1(printk(KERN_DEBUG "jffs2_reserve_space(): alloc sem got\n"));
54 spin_lock(&c->erase_completion_lock);
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;
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
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"));
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));
82 spin_unlock(&c->erase_completion_lock);
83 mutex_unlock(&c->alloc_sem);
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
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.
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"));
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);
110 mutex_unlock(&c->alloc_sem);
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);
117 ret = jffs2_garbage_collect_pass(c);
119 if (ret == -EAGAIN) {
120 spin_lock(&c->erase_completion_lock);
121 if (c->nr_erasing_blocks &&
122 list_empty(&c->erase_pending_list) &&
123 list_empty(&c->erase_complete_list)) {
124 DECLARE_WAITQUEUE(wait, current);
125 set_current_state(TASK_UNINTERRUPTIBLE);
126 add_wait_queue(&c->erase_wait, &wait);
127 D1(printk(KERN_DEBUG "%s waiting for erase to complete\n", __func__));
128 spin_unlock(&c->erase_completion_lock);
132 spin_unlock(&c->erase_completion_lock);
138 if (signal_pending(current))
141 mutex_lock(&c->alloc_sem);
142 spin_lock(&c->erase_completion_lock);
145 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
147 D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret));
150 spin_unlock(&c->erase_completion_lock);
152 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
154 mutex_unlock(&c->alloc_sem);
158 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
159 uint32_t *len, uint32_t sumsize)
162 minsize = PAD(minsize);
164 D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize));
166 spin_lock(&c->erase_completion_lock);
167 while(ret == -EAGAIN) {
168 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
170 D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
173 spin_unlock(&c->erase_completion_lock);
175 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
181 /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */
183 static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
186 if (c->nextblock == NULL) {
187 D1(printk(KERN_DEBUG "jffs2_close_nextblock: Erase block at 0x%08x has already been placed in a list\n",
191 /* Check, if we have a dirty block now, or if it was dirty already */
192 if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) {
193 c->dirty_size += jeb->wasted_size;
194 c->wasted_size -= jeb->wasted_size;
195 jeb->dirty_size += jeb->wasted_size;
196 jeb->wasted_size = 0;
197 if (VERYDIRTY(c, jeb->dirty_size)) {
198 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",
199 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
200 list_add_tail(&jeb->list, &c->very_dirty_list);
202 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
203 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
204 list_add_tail(&jeb->list, &c->dirty_list);
207 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
208 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
209 list_add_tail(&jeb->list, &c->clean_list);
215 /* Select a new jeb for nextblock */
217 static int jffs2_find_nextblock(struct jffs2_sb_info *c)
219 struct list_head *next;
221 /* Take the next block off the 'free' list */
223 if (list_empty(&c->free_list)) {
225 if (!c->nr_erasing_blocks &&
226 !list_empty(&c->erasable_list)) {
227 struct jffs2_eraseblock *ejeb;
229 ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list);
230 list_move_tail(&ejeb->list, &c->erase_pending_list);
231 c->nr_erasing_blocks++;
232 jffs2_garbage_collect_trigger(c);
233 D1(printk(KERN_DEBUG "jffs2_find_nextblock: Triggering erase of erasable block at 0x%08x\n",
237 if (!c->nr_erasing_blocks &&
238 !list_empty(&c->erasable_pending_wbuf_list)) {
239 D1(printk(KERN_DEBUG "jffs2_find_nextblock: Flushing write buffer\n"));
240 /* c->nextblock is NULL, no update to c->nextblock allowed */
241 spin_unlock(&c->erase_completion_lock);
242 jffs2_flush_wbuf_pad(c);
243 spin_lock(&c->erase_completion_lock);
244 /* Have another go. It'll be on the erasable_list now */
248 if (!c->nr_erasing_blocks) {
249 /* Ouch. We're in GC, or we wouldn't have got here.
250 And there's no space left. At all. */
251 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",
252 c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no",
253 list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no");
257 spin_unlock(&c->erase_completion_lock);
258 /* Don't wait for it; just erase one right now */
259 jffs2_erase_pending_blocks(c, 1);
260 spin_lock(&c->erase_completion_lock);
262 /* An erase may have failed, decreasing the
263 amount of free space available. So we must
264 restart from the beginning */
268 next = c->free_list.next;
270 c->nextblock = list_entry(next, struct jffs2_eraseblock, list);
273 jffs2_sum_reset_collected(c->summary); /* reset collected summary */
275 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
276 /* adjust write buffer offset, else we get a non contiguous write bug */
277 if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len)
278 c->wbuf_ofs = 0xffffffff;
281 D1(printk(KERN_DEBUG "jffs2_find_nextblock(): new nextblock = 0x%08x\n", c->nextblock->offset));
286 /* Called with alloc sem _and_ erase_completion_lock */
287 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
288 uint32_t *len, uint32_t sumsize)
290 struct jffs2_eraseblock *jeb = c->nextblock;
291 uint32_t reserved_size; /* for summary information at the end of the jeb */
297 if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) {
298 /* NOSUM_SIZE means not to generate summary */
301 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
302 dbg_summary("minsize=%d , jeb->free=%d ,"
303 "summary->size=%d , sumsize=%d\n",
304 minsize, jeb->free_size,
305 c->summary->sum_size, sumsize);
308 /* Is there enough space for writing out the current node, or we have to
309 write out summary information now, close this jeb and select new nextblock? */
310 if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize +
311 JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) {
313 /* Has summary been disabled for this jeb? */
314 if (jffs2_sum_is_disabled(c->summary)) {
315 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
319 /* Writing out the collected summary information */
320 dbg_summary("generating summary for 0x%08x.\n", jeb->offset);
321 ret = jffs2_sum_write_sumnode(c);
326 if (jffs2_sum_is_disabled(c->summary)) {
327 /* jffs2_write_sumnode() couldn't write out the summary information
328 diabling summary for this jeb and free the collected information
330 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
334 jffs2_close_nextblock(c, jeb);
336 /* keep always valid value in reserved_size */
337 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
340 if (jeb && minsize > jeb->free_size) {
343 /* Skip the end of this block and file it as having some dirty space */
344 /* If there's a pending write to it, flush now */
346 if (jffs2_wbuf_dirty(c)) {
347 spin_unlock(&c->erase_completion_lock);
348 D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n"));
349 jffs2_flush_wbuf_pad(c);
350 spin_lock(&c->erase_completion_lock);
355 spin_unlock(&c->erase_completion_lock);
357 ret = jffs2_prealloc_raw_node_refs(c, jeb, 1);
359 /* Just lock it again and continue. Nothing much can change because
360 we hold c->alloc_sem anyway. In fact, it's not entirely clear why
361 we hold c->erase_completion_lock in the majority of this function...
362 but that's a question for another (more caffeine-rich) day. */
363 spin_lock(&c->erase_completion_lock);
368 waste = jeb->free_size;
369 jffs2_link_node_ref(c, jeb,
370 (jeb->offset + c->sector_size - waste) | REF_OBSOLETE,
372 /* FIXME: that made it count as dirty. Convert to wasted */
373 jeb->dirty_size -= waste;
374 c->dirty_size -= waste;
375 jeb->wasted_size += waste;
376 c->wasted_size += waste;
378 jffs2_close_nextblock(c, jeb);
385 ret = jffs2_find_nextblock(c);
391 if (jeb->free_size != c->sector_size - c->cleanmarker_size) {
392 printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size);
396 /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
398 *len = jeb->free_size - reserved_size;
400 if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size &&
401 !jeb->first_node->next_in_ino) {
402 /* Only node in it beforehand was a CLEANMARKER node (we think).
403 So mark it obsolete now that there's going to be another node
404 in the block. This will reduce used_size to zero but We've
405 already set c->nextblock so that jffs2_mark_node_obsolete()
406 won't try to refile it to the dirty_list.
408 spin_unlock(&c->erase_completion_lock);
409 jffs2_mark_node_obsolete(c, jeb->first_node);
410 spin_lock(&c->erase_completion_lock);
413 D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n",
414 *len, jeb->offset + (c->sector_size - jeb->free_size)));
419 * jffs2_add_physical_node_ref - add a physical node reference to the list
420 * @c: superblock info
421 * @new: new node reference to add
422 * @len: length of this physical node
424 * Should only be used to report nodes for which space has been allocated
425 * by jffs2_reserve_space.
427 * Must be called with the alloc_sem held.
430 struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
431 uint32_t ofs, uint32_t len,
432 struct jffs2_inode_cache *ic)
434 struct jffs2_eraseblock *jeb;
435 struct jffs2_raw_node_ref *new;
437 jeb = &c->blocks[ofs / c->sector_size];
439 D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n",
440 ofs & ~3, ofs & 3, len));
442 /* Allow non-obsolete nodes only to be added at the end of c->nextblock,
443 if c->nextblock is set. Note that wbuf.c will file obsolete nodes
444 even after refiling c->nextblock */
445 if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
446 && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
447 printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3);
449 printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset);
451 printk(KERN_WARNING "No nextblock");
452 printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size));
453 return ERR_PTR(-EINVAL);
456 spin_lock(&c->erase_completion_lock);
458 new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
460 if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
461 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
462 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
463 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
464 if (jffs2_wbuf_dirty(c)) {
465 /* Flush the last write in the block if it's outstanding */
466 spin_unlock(&c->erase_completion_lock);
467 jffs2_flush_wbuf_pad(c);
468 spin_lock(&c->erase_completion_lock);
471 list_add_tail(&jeb->list, &c->clean_list);
474 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
475 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
477 spin_unlock(&c->erase_completion_lock);
483 void jffs2_complete_reservation(struct jffs2_sb_info *c)
485 D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n"));
486 spin_lock(&c->erase_completion_lock);
487 jffs2_garbage_collect_trigger(c);
488 spin_unlock(&c->erase_completion_lock);
489 mutex_unlock(&c->alloc_sem);
492 static inline int on_list(struct list_head *obj, struct list_head *head)
494 struct list_head *this;
496 list_for_each(this, head) {
498 D1(printk("%p is on list at %p\n", obj, head));
506 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
508 struct jffs2_eraseblock *jeb;
510 struct jffs2_unknown_node n;
516 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
519 if (ref_obsolete(ref)) {
520 D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref)));
523 blocknr = ref->flash_offset / c->sector_size;
524 if (blocknr >= c->nr_blocks) {
525 printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset);
528 jeb = &c->blocks[blocknr];
530 if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) &&
531 !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) {
532 /* Hm. This may confuse static lock analysis. If any of the above
533 three conditions is false, we're going to return from this
534 function without actually obliterating any nodes or freeing
535 any jffs2_raw_node_refs. So we don't need to stop erases from
536 happening, or protect against people holding an obsolete
537 jffs2_raw_node_ref without the erase_completion_lock. */
538 mutex_lock(&c->erase_free_sem);
541 spin_lock(&c->erase_completion_lock);
543 freed_len = ref_totlen(c, jeb, ref);
545 if (ref_flags(ref) == REF_UNCHECKED) {
546 D1(if (unlikely(jeb->unchecked_size < freed_len)) {
547 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",
548 freed_len, blocknr, ref->flash_offset, jeb->used_size);
551 D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), freed_len));
552 jeb->unchecked_size -= freed_len;
553 c->unchecked_size -= freed_len;
555 D1(if (unlikely(jeb->used_size < freed_len)) {
556 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",
557 freed_len, blocknr, ref->flash_offset, jeb->used_size);
560 D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), freed_len));
561 jeb->used_size -= freed_len;
562 c->used_size -= freed_len;
565 // Take care, that wasted size is taken into concern
566 if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
567 D1(printk("Dirtying\n"));
568 addedsize = freed_len;
569 jeb->dirty_size += freed_len;
570 c->dirty_size += freed_len;
572 /* Convert wasted space to dirty, if not a bad block */
573 if (jeb->wasted_size) {
574 if (on_list(&jeb->list, &c->bad_used_list)) {
575 D1(printk(KERN_DEBUG "Leaving block at %08x on the bad_used_list\n",
577 addedsize = 0; /* To fool the refiling code later */
579 D1(printk(KERN_DEBUG "Converting %d bytes of wasted space to dirty in block at %08x\n",
580 jeb->wasted_size, jeb->offset));
581 addedsize += jeb->wasted_size;
582 jeb->dirty_size += jeb->wasted_size;
583 c->dirty_size += jeb->wasted_size;
584 c->wasted_size -= jeb->wasted_size;
585 jeb->wasted_size = 0;
589 D1(printk("Wasting\n"));
591 jeb->wasted_size += freed_len;
592 c->wasted_size += freed_len;
594 ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
596 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
597 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
599 if (c->flags & JFFS2_SB_FLAG_SCANNING) {
600 /* Flash scanning is in progress. Don't muck about with the block
601 lists because they're not ready yet, and don't actually
602 obliterate nodes that look obsolete. If they weren't
603 marked obsolete on the flash at the time they _became_
604 obsolete, there was probably a reason for that. */
605 spin_unlock(&c->erase_completion_lock);
606 /* We didn't lock the erase_free_sem */
610 if (jeb == c->nextblock) {
611 D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
612 } else if (!jeb->used_size && !jeb->unchecked_size) {
613 if (jeb == c->gcblock) {
614 D1(printk(KERN_DEBUG "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb->offset));
617 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset));
618 list_del(&jeb->list);
620 if (jffs2_wbuf_dirty(c)) {
621 D1(printk(KERN_DEBUG "...and adding to erasable_pending_wbuf_list\n"));
622 list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list);
625 /* Most of the time, we just erase it immediately. Otherwise we
626 spend ages scanning it on mount, etc. */
627 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
628 list_add_tail(&jeb->list, &c->erase_pending_list);
629 c->nr_erasing_blocks++;
630 jffs2_garbage_collect_trigger(c);
632 /* Sometimes, however, we leave it elsewhere so it doesn't get
633 immediately reused, and we spread the load a bit. */
634 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
635 list_add_tail(&jeb->list, &c->erasable_list);
638 D1(printk(KERN_DEBUG "Done OK\n"));
639 } else if (jeb == c->gcblock) {
640 D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty_list\n", jeb->offset));
641 } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
642 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset));
643 list_del(&jeb->list);
644 D1(printk(KERN_DEBUG "...and adding to dirty_list\n"));
645 list_add_tail(&jeb->list, &c->dirty_list);
646 } else if (VERYDIRTY(c, jeb->dirty_size) &&
647 !VERYDIRTY(c, jeb->dirty_size - addedsize)) {
648 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb->offset));
649 list_del(&jeb->list);
650 D1(printk(KERN_DEBUG "...and adding to very_dirty_list\n"));
651 list_add_tail(&jeb->list, &c->very_dirty_list);
653 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n",
654 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
657 spin_unlock(&c->erase_completion_lock);
659 if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
660 (c->flags & JFFS2_SB_FLAG_BUILDING)) {
661 /* We didn't lock the erase_free_sem */
665 /* The erase_free_sem is locked, and has been since before we marked the node obsolete
666 and potentially put its eraseblock onto the erase_pending_list. Thus, we know that
667 the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet
668 by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */
670 D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref)));
671 ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
673 printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret);
676 if (retlen != sizeof(n)) {
677 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
680 if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
681 printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len);
684 if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
685 D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", ref_offset(ref), je16_to_cpu(n.nodetype)));
688 /* XXX FIXME: This is ugly now */
689 n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
690 ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
692 printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret);
695 if (retlen != sizeof(n)) {
696 printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
700 /* Nodes which have been marked obsolete no longer need to be
701 associated with any inode. Remove them from the per-inode list.
703 Note we can't do this for NAND at the moment because we need
704 obsolete dirent nodes to stay on the lists, because of the
705 horridness in jffs2_garbage_collect_deletion_dirent(). Also
706 because we delete the inocache, and on NAND we need that to
707 stay around until all the nodes are actually erased, in order
708 to stop us from giving the same inode number to another newly
710 if (ref->next_in_ino) {
711 struct jffs2_inode_cache *ic;
712 struct jffs2_raw_node_ref **p;
714 spin_lock(&c->erase_completion_lock);
716 ic = jffs2_raw_ref_to_ic(ref);
717 for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
720 *p = ref->next_in_ino;
721 ref->next_in_ino = NULL;
724 #ifdef CONFIG_JFFS2_FS_XATTR
725 case RAWNODE_CLASS_XATTR_DATUM:
726 jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic);
728 case RAWNODE_CLASS_XATTR_REF:
729 jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic);
733 if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
734 jffs2_del_ino_cache(c, ic);
737 spin_unlock(&c->erase_completion_lock);
741 mutex_unlock(&c->erase_free_sem);
744 int jffs2_thread_should_wake(struct jffs2_sb_info *c)
748 int nr_very_dirty = 0;
749 struct jffs2_eraseblock *jeb;
751 if (!list_empty(&c->erase_complete_list) ||
752 !list_empty(&c->erase_pending_list))
755 if (c->unchecked_size) {
756 D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n",
757 c->unchecked_size, c->checked_ino));
761 /* dirty_size contains blocks on erase_pending_list
762 * those blocks are counted in c->nr_erasing_blocks.
763 * If one block is actually erased, it is not longer counted as dirty_space
764 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
765 * with c->nr_erasing_blocks * c->sector_size again.
766 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
767 * This helps us to force gc and pick eventually a clean block to spread the load.
769 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
771 if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
772 (dirty > c->nospc_dirty_size))
775 list_for_each_entry(jeb, &c->very_dirty_list, list) {
777 if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
779 /* In debug mode, actually go through and count them all */
785 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",
786 c->nr_free_blocks, c->nr_erasing_blocks, c->dirty_size, nr_very_dirty, ret?"yes":"no"));