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/slab.h>
14 #include <linux/mtd/mtd.h>
15 #include <linux/compiler.h>
16 #include <linux/sched.h> /* For cond_resched() */
21 * jffs2_reserve_space - request physical space to write nodes to flash
23 * @minsize: Minimum acceptable size of allocation
24 * @len: Returned value of allocation length
25 * @prio: Allocation type - ALLOC_{NORMAL,DELETION}
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
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()
35 * jffs2_reserve_space() may trigger garbage collection in order to make room
36 * for the requested allocation.
39 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
40 uint32_t *len, uint32_t sumsize);
42 int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
43 uint32_t *len, int prio, uint32_t sumsize)
46 int blocksneeded = c->resv_blocks_write;
48 minsize = PAD(minsize);
50 D1(printk(KERN_DEBUG "jffs2_reserve_space(): Requested 0x%x bytes\n", minsize));
53 D1(printk(KERN_DEBUG "jffs2_reserve_space(): alloc sem got\n"));
55 spin_lock(&c->erase_completion_lock);
57 /* this needs a little more thought (true <tglx> :)) */
58 while(ret == -EAGAIN) {
59 while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
61 uint32_t dirty, avail;
63 /* calculate real dirty size
64 * dirty_size contains blocks on erase_pending_list
65 * those blocks are counted in c->nr_erasing_blocks.
66 * If one block is actually erased, it is not longer counted as dirty_space
67 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
68 * with c->nr_erasing_blocks * c->sector_size again.
69 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
70 * This helps us to force gc and pick eventually a clean block to spread the load.
71 * We add unchecked_size here, as we hopefully will find some space to use.
72 * This will affect the sum only once, as gc first finishes checking
75 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
76 if (dirty < c->nospc_dirty_size) {
77 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
78 D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on dirty space to GC, but it's a deletion. Allowing...\n"));
81 D1(printk(KERN_DEBUG "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n",
82 dirty, c->unchecked_size, c->sector_size));
84 spin_unlock(&c->erase_completion_lock);
89 /* Calc possibly available space. Possibly available means that we
90 * don't know, if unchecked size contains obsoleted nodes, which could give us some
91 * more usable space. This will affect the sum only once, as gc first finishes checking
93 + Return -ENOSPC, if the maximum possibly available space is less or equal than
94 * blocksneeded * sector_size.
95 * This blocks endless gc looping on a filesystem, which is nearly full, even if
96 * the check above passes.
98 avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size;
99 if ( (avail / c->sector_size) <= blocksneeded) {
100 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
101 D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on possibly available space, but it's a deletion. Allowing...\n"));
105 D1(printk(KERN_DEBUG "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n",
106 avail, blocksneeded * c->sector_size));
107 spin_unlock(&c->erase_completion_lock);
114 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",
115 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,
116 c->free_size + c->dirty_size + c->wasted_size + c->used_size + c->erasing_size + c->bad_size, c->flash_size));
117 spin_unlock(&c->erase_completion_lock);
119 ret = jffs2_garbage_collect_pass(c);
125 if (signal_pending(current))
129 spin_lock(&c->erase_completion_lock);
132 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
134 D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret));
137 spin_unlock(&c->erase_completion_lock);
139 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
145 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
146 uint32_t *len, uint32_t sumsize)
149 minsize = PAD(minsize);
151 D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize));
153 spin_lock(&c->erase_completion_lock);
154 while(ret == -EAGAIN) {
155 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
157 D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
160 spin_unlock(&c->erase_completion_lock);
162 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
168 /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */
170 static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
173 if (c->nextblock == NULL) {
174 D1(printk(KERN_DEBUG "jffs2_close_nextblock: Erase block at 0x%08x has already been placed in a list\n",
178 /* Check, if we have a dirty block now, or if it was dirty already */
179 if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) {
180 c->dirty_size += jeb->wasted_size;
181 c->wasted_size -= jeb->wasted_size;
182 jeb->dirty_size += jeb->wasted_size;
183 jeb->wasted_size = 0;
184 if (VERYDIRTY(c, jeb->dirty_size)) {
185 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",
186 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
187 list_add_tail(&jeb->list, &c->very_dirty_list);
189 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
190 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
191 list_add_tail(&jeb->list, &c->dirty_list);
194 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
195 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
196 list_add_tail(&jeb->list, &c->clean_list);
202 /* Select a new jeb for nextblock */
204 static int jffs2_find_nextblock(struct jffs2_sb_info *c)
206 struct list_head *next;
208 /* Take the next block off the 'free' list */
210 if (list_empty(&c->free_list)) {
212 if (!c->nr_erasing_blocks &&
213 !list_empty(&c->erasable_list)) {
214 struct jffs2_eraseblock *ejeb;
216 ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list);
217 list_move_tail(&ejeb->list, &c->erase_pending_list);
218 c->nr_erasing_blocks++;
219 jffs2_erase_pending_trigger(c);
220 D1(printk(KERN_DEBUG "jffs2_find_nextblock: Triggering erase of erasable block at 0x%08x\n",
224 if (!c->nr_erasing_blocks &&
225 !list_empty(&c->erasable_pending_wbuf_list)) {
226 D1(printk(KERN_DEBUG "jffs2_find_nextblock: Flushing write buffer\n"));
227 /* c->nextblock is NULL, no update to c->nextblock allowed */
228 spin_unlock(&c->erase_completion_lock);
229 jffs2_flush_wbuf_pad(c);
230 spin_lock(&c->erase_completion_lock);
231 /* Have another go. It'll be on the erasable_list now */
235 if (!c->nr_erasing_blocks) {
236 /* Ouch. We're in GC, or we wouldn't have got here.
237 And there's no space left. At all. */
238 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",
239 c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no",
240 list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no");
244 spin_unlock(&c->erase_completion_lock);
245 /* Don't wait for it; just erase one right now */
246 jffs2_erase_pending_blocks(c, 1);
247 spin_lock(&c->erase_completion_lock);
249 /* An erase may have failed, decreasing the
250 amount of free space available. So we must
251 restart from the beginning */
255 next = c->free_list.next;
257 c->nextblock = list_entry(next, struct jffs2_eraseblock, list);
260 jffs2_sum_reset_collected(c->summary); /* reset collected summary */
262 D1(printk(KERN_DEBUG "jffs2_find_nextblock(): new nextblock = 0x%08x\n", c->nextblock->offset));
267 /* Called with alloc sem _and_ erase_completion_lock */
268 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
269 uint32_t *len, uint32_t sumsize)
271 struct jffs2_eraseblock *jeb = c->nextblock;
272 uint32_t reserved_size; /* for summary information at the end of the jeb */
278 if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) {
279 /* NOSUM_SIZE means not to generate summary */
282 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
283 dbg_summary("minsize=%d , jeb->free=%d ,"
284 "summary->size=%d , sumsize=%d\n",
285 minsize, jeb->free_size,
286 c->summary->sum_size, sumsize);
289 /* Is there enough space for writing out the current node, or we have to
290 write out summary information now, close this jeb and select new nextblock? */
291 if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize +
292 JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) {
294 /* Has summary been disabled for this jeb? */
295 if (jffs2_sum_is_disabled(c->summary)) {
296 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
300 /* Writing out the collected summary information */
301 dbg_summary("generating summary for 0x%08x.\n", jeb->offset);
302 ret = jffs2_sum_write_sumnode(c);
307 if (jffs2_sum_is_disabled(c->summary)) {
308 /* jffs2_write_sumnode() couldn't write out the summary information
309 diabling summary for this jeb and free the collected information
311 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
315 jffs2_close_nextblock(c, jeb);
317 /* keep always valid value in reserved_size */
318 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
321 if (jeb && minsize > jeb->free_size) {
324 /* Skip the end of this block and file it as having some dirty space */
325 /* If there's a pending write to it, flush now */
327 if (jffs2_wbuf_dirty(c)) {
328 spin_unlock(&c->erase_completion_lock);
329 D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n"));
330 jffs2_flush_wbuf_pad(c);
331 spin_lock(&c->erase_completion_lock);
336 spin_unlock(&c->erase_completion_lock);
338 ret = jffs2_prealloc_raw_node_refs(c, jeb, 1);
341 /* Just lock it again and continue. Nothing much can change because
342 we hold c->alloc_sem anyway. In fact, it's not entirely clear why
343 we hold c->erase_completion_lock in the majority of this function...
344 but that's a question for another (more caffeine-rich) day. */
345 spin_lock(&c->erase_completion_lock);
347 waste = jeb->free_size;
348 jffs2_link_node_ref(c, jeb,
349 (jeb->offset + c->sector_size - waste) | REF_OBSOLETE,
351 /* FIXME: that made it count as dirty. Convert to wasted */
352 jeb->dirty_size -= waste;
353 c->dirty_size -= waste;
354 jeb->wasted_size += waste;
355 c->wasted_size += waste;
357 jffs2_close_nextblock(c, jeb);
364 ret = jffs2_find_nextblock(c);
370 if (jeb->free_size != c->sector_size - c->cleanmarker_size) {
371 printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size);
375 /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
377 *len = jeb->free_size - reserved_size;
379 if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size &&
380 !jeb->first_node->next_in_ino) {
381 /* Only node in it beforehand was a CLEANMARKER node (we think).
382 So mark it obsolete now that there's going to be another node
383 in the block. This will reduce used_size to zero but We've
384 already set c->nextblock so that jffs2_mark_node_obsolete()
385 won't try to refile it to the dirty_list.
387 spin_unlock(&c->erase_completion_lock);
388 jffs2_mark_node_obsolete(c, jeb->first_node);
389 spin_lock(&c->erase_completion_lock);
392 D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n",
393 *len, jeb->offset + (c->sector_size - jeb->free_size)));
398 * jffs2_add_physical_node_ref - add a physical node reference to the list
399 * @c: superblock info
400 * @new: new node reference to add
401 * @len: length of this physical node
403 * Should only be used to report nodes for which space has been allocated
404 * by jffs2_reserve_space.
406 * Must be called with the alloc_sem held.
409 struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
410 uint32_t ofs, uint32_t len,
411 struct jffs2_inode_cache *ic)
413 struct jffs2_eraseblock *jeb;
414 struct jffs2_raw_node_ref *new;
416 jeb = &c->blocks[ofs / c->sector_size];
418 D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n",
419 ofs & ~3, ofs & 3, len));
421 /* Allow non-obsolete nodes only to be added at the end of c->nextblock,
422 if c->nextblock is set. Note that wbuf.c will file obsolete nodes
423 even after refiling c->nextblock */
424 if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
425 && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
426 printk(KERN_WARNING "argh. node added in wrong place\n");
427 return ERR_PTR(-EINVAL);
430 spin_lock(&c->erase_completion_lock);
432 new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
434 if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
435 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
436 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
437 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
438 if (jffs2_wbuf_dirty(c)) {
439 /* Flush the last write in the block if it's outstanding */
440 spin_unlock(&c->erase_completion_lock);
441 jffs2_flush_wbuf_pad(c);
442 spin_lock(&c->erase_completion_lock);
445 list_add_tail(&jeb->list, &c->clean_list);
448 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
449 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
451 spin_unlock(&c->erase_completion_lock);
457 void jffs2_complete_reservation(struct jffs2_sb_info *c)
459 D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n"));
460 jffs2_garbage_collect_trigger(c);
464 static inline int on_list(struct list_head *obj, struct list_head *head)
466 struct list_head *this;
468 list_for_each(this, head) {
470 D1(printk("%p is on list at %p\n", obj, head));
478 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
480 struct jffs2_eraseblock *jeb;
482 struct jffs2_unknown_node n;
488 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
491 if (ref_obsolete(ref)) {
492 D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref)));
495 blocknr = ref->flash_offset / c->sector_size;
496 if (blocknr >= c->nr_blocks) {
497 printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset);
500 jeb = &c->blocks[blocknr];
502 if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) &&
503 !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) {
504 /* Hm. This may confuse static lock analysis. If any of the above
505 three conditions is false, we're going to return from this
506 function without actually obliterating any nodes or freeing
507 any jffs2_raw_node_refs. So we don't need to stop erases from
508 happening, or protect against people holding an obsolete
509 jffs2_raw_node_ref without the erase_completion_lock. */
510 down(&c->erase_free_sem);
513 spin_lock(&c->erase_completion_lock);
515 freed_len = ref_totlen(c, jeb, ref);
517 if (ref_flags(ref) == REF_UNCHECKED) {
518 D1(if (unlikely(jeb->unchecked_size < freed_len)) {
519 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",
520 freed_len, blocknr, ref->flash_offset, jeb->used_size);
523 D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), freed_len));
524 jeb->unchecked_size -= freed_len;
525 c->unchecked_size -= freed_len;
527 D1(if (unlikely(jeb->used_size < freed_len)) {
528 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",
529 freed_len, blocknr, ref->flash_offset, jeb->used_size);
532 D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), freed_len));
533 jeb->used_size -= freed_len;
534 c->used_size -= freed_len;
537 // Take care, that wasted size is taken into concern
538 if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
539 D1(printk("Dirtying\n"));
540 addedsize = freed_len;
541 jeb->dirty_size += freed_len;
542 c->dirty_size += freed_len;
544 /* Convert wasted space to dirty, if not a bad block */
545 if (jeb->wasted_size) {
546 if (on_list(&jeb->list, &c->bad_used_list)) {
547 D1(printk(KERN_DEBUG "Leaving block at %08x on the bad_used_list\n",
549 addedsize = 0; /* To fool the refiling code later */
551 D1(printk(KERN_DEBUG "Converting %d bytes of wasted space to dirty in block at %08x\n",
552 jeb->wasted_size, jeb->offset));
553 addedsize += jeb->wasted_size;
554 jeb->dirty_size += jeb->wasted_size;
555 c->dirty_size += jeb->wasted_size;
556 c->wasted_size -= jeb->wasted_size;
557 jeb->wasted_size = 0;
561 D1(printk("Wasting\n"));
563 jeb->wasted_size += freed_len;
564 c->wasted_size += freed_len;
566 ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
568 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
569 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
571 if (c->flags & JFFS2_SB_FLAG_SCANNING) {
572 /* Flash scanning is in progress. Don't muck about with the block
573 lists because they're not ready yet, and don't actually
574 obliterate nodes that look obsolete. If they weren't
575 marked obsolete on the flash at the time they _became_
576 obsolete, there was probably a reason for that. */
577 spin_unlock(&c->erase_completion_lock);
578 /* We didn't lock the erase_free_sem */
582 if (jeb == c->nextblock) {
583 D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
584 } else if (!jeb->used_size && !jeb->unchecked_size) {
585 if (jeb == c->gcblock) {
586 D1(printk(KERN_DEBUG "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb->offset));
589 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset));
590 list_del(&jeb->list);
592 if (jffs2_wbuf_dirty(c)) {
593 D1(printk(KERN_DEBUG "...and adding to erasable_pending_wbuf_list\n"));
594 list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list);
597 /* Most of the time, we just erase it immediately. Otherwise we
598 spend ages scanning it on mount, etc. */
599 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
600 list_add_tail(&jeb->list, &c->erase_pending_list);
601 c->nr_erasing_blocks++;
602 jffs2_erase_pending_trigger(c);
604 /* Sometimes, however, we leave it elsewhere so it doesn't get
605 immediately reused, and we spread the load a bit. */
606 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
607 list_add_tail(&jeb->list, &c->erasable_list);
610 D1(printk(KERN_DEBUG "Done OK\n"));
611 } else if (jeb == c->gcblock) {
612 D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty_list\n", jeb->offset));
613 } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
614 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset));
615 list_del(&jeb->list);
616 D1(printk(KERN_DEBUG "...and adding to dirty_list\n"));
617 list_add_tail(&jeb->list, &c->dirty_list);
618 } else if (VERYDIRTY(c, jeb->dirty_size) &&
619 !VERYDIRTY(c, jeb->dirty_size - addedsize)) {
620 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb->offset));
621 list_del(&jeb->list);
622 D1(printk(KERN_DEBUG "...and adding to very_dirty_list\n"));
623 list_add_tail(&jeb->list, &c->very_dirty_list);
625 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n",
626 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
629 spin_unlock(&c->erase_completion_lock);
631 if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
632 (c->flags & JFFS2_SB_FLAG_BUILDING)) {
633 /* We didn't lock the erase_free_sem */
637 /* The erase_free_sem is locked, and has been since before we marked the node obsolete
638 and potentially put its eraseblock onto the erase_pending_list. Thus, we know that
639 the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet
640 by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */
642 D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref)));
643 ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
645 printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret);
648 if (retlen != sizeof(n)) {
649 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
652 if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
653 printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len);
656 if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
657 D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", ref_offset(ref), je16_to_cpu(n.nodetype)));
660 /* XXX FIXME: This is ugly now */
661 n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
662 ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
664 printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret);
667 if (retlen != sizeof(n)) {
668 printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
672 /* Nodes which have been marked obsolete no longer need to be
673 associated with any inode. Remove them from the per-inode list.
675 Note we can't do this for NAND at the moment because we need
676 obsolete dirent nodes to stay on the lists, because of the
677 horridness in jffs2_garbage_collect_deletion_dirent(). Also
678 because we delete the inocache, and on NAND we need that to
679 stay around until all the nodes are actually erased, in order
680 to stop us from giving the same inode number to another newly
682 if (ref->next_in_ino) {
683 struct jffs2_inode_cache *ic;
684 struct jffs2_raw_node_ref **p;
686 spin_lock(&c->erase_completion_lock);
688 ic = jffs2_raw_ref_to_ic(ref);
689 for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
692 *p = ref->next_in_ino;
693 ref->next_in_ino = NULL;
696 #ifdef CONFIG_JFFS2_FS_XATTR
697 case RAWNODE_CLASS_XATTR_DATUM:
698 jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic);
700 case RAWNODE_CLASS_XATTR_REF:
701 jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic);
705 if (ic->nodes == (void *)ic && ic->nlink == 0)
706 jffs2_del_ino_cache(c, ic);
709 spin_unlock(&c->erase_completion_lock);
713 up(&c->erase_free_sem);
716 int jffs2_thread_should_wake(struct jffs2_sb_info *c)
721 if (c->unchecked_size) {
722 D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n",
723 c->unchecked_size, c->checked_ino));
727 /* dirty_size contains blocks on erase_pending_list
728 * those blocks are counted in c->nr_erasing_blocks.
729 * If one block is actually erased, it is not longer counted as dirty_space
730 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
731 * with c->nr_erasing_blocks * c->sector_size again.
732 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
733 * This helps us to force gc and pick eventually a clean block to spread the load.
735 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
737 if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
738 (dirty > c->nospc_dirty_size))
741 D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x: %s\n",
742 c->nr_free_blocks, c->nr_erasing_blocks, c->dirty_size, ret?"yes":"no"));