2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: nodemgmt.c,v 1.127 2005/09/20 15:49:12 dedekind Exp $
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/compiler.h>
18 #include <linux/sched.h> /* For cond_resched() */
23 * jffs2_reserve_space - request physical space to write nodes to flash
25 * @minsize: Minimum acceptable size of allocation
26 * @len: Returned value of allocation length
27 * @prio: Allocation type - ALLOC_{NORMAL,DELETION}
29 * Requests a block of physical space on the flash. Returns zero for success
30 * and puts 'len' into the appropriate place, or returns -ENOSPC or other
31 * error if appropriate. Doesn't return len since that's
33 * If it returns zero, jffs2_reserve_space() also downs the per-filesystem
34 * allocation semaphore, to prevent more than one allocation from being
35 * active at any time. The semaphore is later released by jffs2_commit_allocation()
37 * jffs2_reserve_space() may trigger garbage collection in order to make room
38 * for the requested allocation.
41 static int jffs2_do_reserve_space(struct jffs2_sb_info
*c
, uint32_t minsize
,
42 uint32_t *len
, uint32_t sumsize
);
44 int jffs2_reserve_space(struct jffs2_sb_info
*c
, uint32_t minsize
,
45 uint32_t *len
, int prio
, uint32_t sumsize
)
48 int blocksneeded
= c
->resv_blocks_write
;
50 minsize
= PAD(minsize
);
52 D1(printk(KERN_DEBUG
"jffs2_reserve_space(): Requested 0x%x bytes\n", minsize
));
55 D1(printk(KERN_DEBUG
"jffs2_reserve_space(): alloc sem got\n"));
57 spin_lock(&c
->erase_completion_lock
);
59 /* this needs a little more thought (true <tglx> :)) */
60 while(ret
== -EAGAIN
) {
61 while(c
->nr_free_blocks
+ c
->nr_erasing_blocks
< blocksneeded
) {
63 uint32_t dirty
, avail
;
65 /* calculate real dirty size
66 * dirty_size contains blocks on erase_pending_list
67 * those blocks are counted in c->nr_erasing_blocks.
68 * If one block is actually erased, it is not longer counted as dirty_space
69 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
70 * with c->nr_erasing_blocks * c->sector_size again.
71 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
72 * This helps us to force gc and pick eventually a clean block to spread the load.
73 * We add unchecked_size here, as we hopefully will find some space to use.
74 * This will affect the sum only once, as gc first finishes checking
77 dirty
= c
->dirty_size
+ c
->erasing_size
- c
->nr_erasing_blocks
* c
->sector_size
+ c
->unchecked_size
;
78 if (dirty
< c
->nospc_dirty_size
) {
79 if (prio
== ALLOC_DELETION
&& c
->nr_free_blocks
+ c
->nr_erasing_blocks
>= c
->resv_blocks_deletion
) {
80 D1(printk(KERN_NOTICE
"jffs2_reserve_space(): Low on dirty space to GC, but it's a deletion. Allowing...\n"));
83 D1(printk(KERN_DEBUG
"dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n",
84 dirty
, c
->unchecked_size
, c
->sector_size
));
86 spin_unlock(&c
->erase_completion_lock
);
91 /* Calc possibly available space. Possibly available means that we
92 * don't know, if unchecked size contains obsoleted nodes, which could give us some
93 * more usable space. This will affect the sum only once, as gc first finishes checking
95 + Return -ENOSPC, if the maximum possibly available space is less or equal than
96 * blocksneeded * sector_size.
97 * This blocks endless gc looping on a filesystem, which is nearly full, even if
98 * the check above passes.
100 avail
= c
->free_size
+ c
->dirty_size
+ c
->erasing_size
+ c
->unchecked_size
;
101 if ( (avail
/ c
->sector_size
) <= blocksneeded
) {
102 if (prio
== ALLOC_DELETION
&& c
->nr_free_blocks
+ c
->nr_erasing_blocks
>= c
->resv_blocks_deletion
) {
103 D1(printk(KERN_NOTICE
"jffs2_reserve_space(): Low on possibly available space, but it's a deletion. Allowing...\n"));
107 D1(printk(KERN_DEBUG
"max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n",
108 avail
, blocksneeded
* c
->sector_size
));
109 spin_unlock(&c
->erase_completion_lock
);
116 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",
117 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
,
118 c
->free_size
+ c
->dirty_size
+ c
->wasted_size
+ c
->used_size
+ c
->erasing_size
+ c
->bad_size
, c
->flash_size
));
119 spin_unlock(&c
->erase_completion_lock
);
121 ret
= jffs2_garbage_collect_pass(c
);
127 if (signal_pending(current
))
131 spin_lock(&c
->erase_completion_lock
);
134 ret
= jffs2_do_reserve_space(c
, minsize
, len
, sumsize
);
136 D1(printk(KERN_DEBUG
"jffs2_reserve_space: ret is %d\n", ret
));
139 spin_unlock(&c
->erase_completion_lock
);
141 ret
= jffs2_prealloc_raw_node_refs(c
, 1);
147 int jffs2_reserve_space_gc(struct jffs2_sb_info
*c
, uint32_t minsize
,
148 uint32_t *len
, uint32_t sumsize
)
151 minsize
= PAD(minsize
);
153 D1(printk(KERN_DEBUG
"jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize
));
155 spin_lock(&c
->erase_completion_lock
);
156 while(ret
== -EAGAIN
) {
157 ret
= jffs2_do_reserve_space(c
, minsize
, len
, sumsize
);
159 D1(printk(KERN_DEBUG
"jffs2_reserve_space_gc: looping, ret is %d\n", ret
));
162 spin_unlock(&c
->erase_completion_lock
);
164 ret
= jffs2_prealloc_raw_node_refs(c
, 1);
170 /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */
172 static void jffs2_close_nextblock(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
175 /* Check, if we have a dirty block now, or if it was dirty already */
176 if (ISDIRTY (jeb
->wasted_size
+ jeb
->dirty_size
)) {
177 c
->dirty_size
+= jeb
->wasted_size
;
178 c
->wasted_size
-= jeb
->wasted_size
;
179 jeb
->dirty_size
+= jeb
->wasted_size
;
180 jeb
->wasted_size
= 0;
181 if (VERYDIRTY(c
, jeb
->dirty_size
)) {
182 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",
183 jeb
->offset
, jeb
->free_size
, jeb
->dirty_size
, jeb
->used_size
));
184 list_add_tail(&jeb
->list
, &c
->very_dirty_list
);
186 D1(printk(KERN_DEBUG
"Adding full erase block at 0x%08x to 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
->dirty_list
);
191 D1(printk(KERN_DEBUG
"Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
192 jeb
->offset
, jeb
->free_size
, jeb
->dirty_size
, jeb
->used_size
));
193 list_add_tail(&jeb
->list
, &c
->clean_list
);
199 /* Select a new jeb for nextblock */
201 static int jffs2_find_nextblock(struct jffs2_sb_info
*c
)
203 struct list_head
*next
;
205 /* Take the next block off the 'free' list */
207 if (list_empty(&c
->free_list
)) {
209 if (!c
->nr_erasing_blocks
&&
210 !list_empty(&c
->erasable_list
)) {
211 struct jffs2_eraseblock
*ejeb
;
213 ejeb
= list_entry(c
->erasable_list
.next
, struct jffs2_eraseblock
, list
);
214 list_del(&ejeb
->list
);
215 list_add_tail(&ejeb
->list
, &c
->erase_pending_list
);
216 c
->nr_erasing_blocks
++;
217 jffs2_erase_pending_trigger(c
);
218 D1(printk(KERN_DEBUG
"jffs2_find_nextblock: Triggering erase of erasable block at 0x%08x\n",
222 if (!c
->nr_erasing_blocks
&&
223 !list_empty(&c
->erasable_pending_wbuf_list
)) {
224 D1(printk(KERN_DEBUG
"jffs2_find_nextblock: Flushing write buffer\n"));
225 /* c->nextblock is NULL, no update to c->nextblock allowed */
226 spin_unlock(&c
->erase_completion_lock
);
227 jffs2_flush_wbuf_pad(c
);
228 spin_lock(&c
->erase_completion_lock
);
229 /* Have another go. It'll be on the erasable_list now */
233 if (!c
->nr_erasing_blocks
) {
234 /* Ouch. We're in GC, or we wouldn't have got here.
235 And there's no space left. At all. */
236 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",
237 c
->nr_erasing_blocks
, c
->nr_free_blocks
, list_empty(&c
->erasable_list
)?"yes":"no",
238 list_empty(&c
->erasing_list
)?"yes":"no", list_empty(&c
->erase_pending_list
)?"yes":"no");
242 spin_unlock(&c
->erase_completion_lock
);
243 /* Don't wait for it; just erase one right now */
244 jffs2_erase_pending_blocks(c
, 1);
245 spin_lock(&c
->erase_completion_lock
);
247 /* An erase may have failed, decreasing the
248 amount of free space available. So we must
249 restart from the beginning */
253 next
= c
->free_list
.next
;
255 c
->nextblock
= list_entry(next
, struct jffs2_eraseblock
, list
);
258 jffs2_sum_reset_collected(c
->summary
); /* reset collected summary */
260 D1(printk(KERN_DEBUG
"jffs2_find_nextblock(): new nextblock = 0x%08x\n", c
->nextblock
->offset
));
265 /* Called with alloc sem _and_ erase_completion_lock */
266 static int jffs2_do_reserve_space(struct jffs2_sb_info
*c
, uint32_t minsize
,
267 uint32_t *len
, uint32_t sumsize
)
269 struct jffs2_eraseblock
*jeb
= c
->nextblock
;
270 uint32_t reserved_size
; /* for summary information at the end of the jeb */
276 if (jffs2_sum_active() && (sumsize
!= JFFS2_SUMMARY_NOSUM_SIZE
)) {
277 /* NOSUM_SIZE means not to generate summary */
280 reserved_size
= PAD(sumsize
+ c
->summary
->sum_size
+ JFFS2_SUMMARY_FRAME_SIZE
);
281 dbg_summary("minsize=%d , jeb->free=%d ,"
282 "summary->size=%d , sumsize=%d\n",
283 minsize
, jeb
->free_size
,
284 c
->summary
->sum_size
, sumsize
);
287 /* Is there enough space for writing out the current node, or we have to
288 write out summary information now, close this jeb and select new nextblock? */
289 if (jeb
&& (PAD(minsize
) + PAD(c
->summary
->sum_size
+ sumsize
+
290 JFFS2_SUMMARY_FRAME_SIZE
) > jeb
->free_size
)) {
292 /* Has summary been disabled for this jeb? */
293 if (jffs2_sum_is_disabled(c
->summary
)) {
294 sumsize
= JFFS2_SUMMARY_NOSUM_SIZE
;
298 /* Writing out the collected summary information */
299 dbg_summary("generating summary for 0x%08x.\n", jeb
->offset
);
300 ret
= jffs2_sum_write_sumnode(c
);
305 if (jffs2_sum_is_disabled(c
->summary
)) {
306 /* jffs2_write_sumnode() couldn't write out the summary information
307 diabling summary for this jeb and free the collected information
309 sumsize
= JFFS2_SUMMARY_NOSUM_SIZE
;
313 jffs2_close_nextblock(c
, jeb
);
315 /* keep always valid value in reserved_size */
316 reserved_size
= PAD(sumsize
+ c
->summary
->sum_size
+ JFFS2_SUMMARY_FRAME_SIZE
);
319 if (jeb
&& minsize
> jeb
->free_size
) {
320 /* Skip the end of this block and file it as having some dirty space */
321 /* If there's a pending write to it, flush now */
323 if (jffs2_wbuf_dirty(c
)) {
324 spin_unlock(&c
->erase_completion_lock
);
325 D1(printk(KERN_DEBUG
"jffs2_do_reserve_space: Flushing write buffer\n"));
326 jffs2_flush_wbuf_pad(c
);
327 spin_lock(&c
->erase_completion_lock
);
332 c
->wasted_size
+= jeb
->free_size
;
333 c
->free_size
-= jeb
->free_size
;
334 jeb
->wasted_size
+= jeb
->free_size
;
337 jffs2_close_nextblock(c
, jeb
);
344 ret
= jffs2_find_nextblock(c
);
350 if (jeb
->free_size
!= c
->sector_size
- c
->cleanmarker_size
) {
351 printk(KERN_WARNING
"Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb
->offset
, jeb
->free_size
);
355 /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
357 *len
= jeb
->free_size
- reserved_size
;
359 if (c
->cleanmarker_size
&& jeb
->used_size
== c
->cleanmarker_size
&&
360 !jeb
->first_node
->next_in_ino
) {
361 /* Only node in it beforehand was a CLEANMARKER node (we think).
362 So mark it obsolete now that there's going to be another node
363 in the block. This will reduce used_size to zero but We've
364 already set c->nextblock so that jffs2_mark_node_obsolete()
365 won't try to refile it to the dirty_list.
367 spin_unlock(&c
->erase_completion_lock
);
368 jffs2_mark_node_obsolete(c
, jeb
->first_node
);
369 spin_lock(&c
->erase_completion_lock
);
372 D1(printk(KERN_DEBUG
"jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n",
373 *len
, jeb
->offset
+ (c
->sector_size
- jeb
->free_size
)));
378 * jffs2_add_physical_node_ref - add a physical node reference to the list
379 * @c: superblock info
380 * @new: new node reference to add
381 * @len: length of this physical node
383 * Should only be used to report nodes for which space has been allocated
384 * by jffs2_reserve_space.
386 * Must be called with the alloc_sem held.
389 struct jffs2_raw_node_ref
*jffs2_add_physical_node_ref(struct jffs2_sb_info
*c
,
390 uint32_t ofs
, uint32_t len
,
391 struct jffs2_inode_cache
*ic
)
393 struct jffs2_eraseblock
*jeb
;
394 struct jffs2_raw_node_ref
*new;
396 jeb
= &c
->blocks
[ofs
/ c
->sector_size
];
398 D1(printk(KERN_DEBUG
"jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n",
399 ofs
& ~3, ofs
& 3, len
));
401 /* Allow non-obsolete nodes only to be added at the end of c->nextblock,
402 if c->nextblock is set. Note that wbuf.c will file obsolete nodes
403 even after refiling c->nextblock */
404 if ((c
->nextblock
|| ((ofs
& 3) != REF_OBSOLETE
))
405 && (jeb
!= c
->nextblock
|| (ofs
& ~3) != jeb
->offset
+ (c
->sector_size
- jeb
->free_size
))) {
406 printk(KERN_WARNING
"argh. node added in wrong place\n");
407 return ERR_PTR(-EINVAL
);
410 spin_lock(&c
->erase_completion_lock
);
412 new = jffs2_link_node_ref(c
, jeb
, ofs
, len
, ic
);
414 if (!jeb
->free_size
&& !jeb
->dirty_size
&& !ISDIRTY(jeb
->wasted_size
)) {
415 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
416 D1(printk(KERN_DEBUG
"Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
417 jeb
->offset
, jeb
->free_size
, jeb
->dirty_size
, jeb
->used_size
));
418 if (jffs2_wbuf_dirty(c
)) {
419 /* Flush the last write in the block if it's outstanding */
420 spin_unlock(&c
->erase_completion_lock
);
421 jffs2_flush_wbuf_pad(c
);
422 spin_lock(&c
->erase_completion_lock
);
425 list_add_tail(&jeb
->list
, &c
->clean_list
);
428 jffs2_dbg_acct_sanity_check_nolock(c
,jeb
);
429 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
431 spin_unlock(&c
->erase_completion_lock
);
437 void jffs2_complete_reservation(struct jffs2_sb_info
*c
)
439 D1(printk(KERN_DEBUG
"jffs2_complete_reservation()\n"));
440 jffs2_garbage_collect_trigger(c
);
444 static inline int on_list(struct list_head
*obj
, struct list_head
*head
)
446 struct list_head
*this;
448 list_for_each(this, head
) {
450 D1(printk("%p is on list at %p\n", obj
, head
));
458 void jffs2_mark_node_obsolete(struct jffs2_sb_info
*c
, struct jffs2_raw_node_ref
*ref
)
460 struct jffs2_eraseblock
*jeb
;
462 struct jffs2_unknown_node n
;
468 printk(KERN_NOTICE
"EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
471 if (ref_obsolete(ref
)) {
472 D1(printk(KERN_DEBUG
"jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref
)));
475 blocknr
= ref
->flash_offset
/ c
->sector_size
;
476 if (blocknr
>= c
->nr_blocks
) {
477 printk(KERN_NOTICE
"raw node at 0x%08x is off the end of device!\n", ref
->flash_offset
);
480 jeb
= &c
->blocks
[blocknr
];
482 if (jffs2_can_mark_obsolete(c
) && !jffs2_is_readonly(c
) &&
483 !(c
->flags
& (JFFS2_SB_FLAG_SCANNING
| JFFS2_SB_FLAG_BUILDING
))) {
484 /* Hm. This may confuse static lock analysis. If any of the above
485 three conditions is false, we're going to return from this
486 function without actually obliterating any nodes or freeing
487 any jffs2_raw_node_refs. So we don't need to stop erases from
488 happening, or protect against people holding an obsolete
489 jffs2_raw_node_ref without the erase_completion_lock. */
490 down(&c
->erase_free_sem
);
493 spin_lock(&c
->erase_completion_lock
);
495 freed_len
= ref_totlen(c
, jeb
, ref
);
497 if (ref_flags(ref
) == REF_UNCHECKED
) {
498 D1(if (unlikely(jeb
->unchecked_size
< freed_len
)) {
499 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",
500 freed_len
, blocknr
, ref
->flash_offset
, jeb
->used_size
);
503 D1(printk(KERN_DEBUG
"Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref
), freed_len
));
504 jeb
->unchecked_size
-= freed_len
;
505 c
->unchecked_size
-= freed_len
;
507 D1(if (unlikely(jeb
->used_size
< freed_len
)) {
508 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",
509 freed_len
, blocknr
, ref
->flash_offset
, jeb
->used_size
);
512 D1(printk(KERN_DEBUG
"Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref
), freed_len
));
513 jeb
->used_size
-= freed_len
;
514 c
->used_size
-= freed_len
;
517 // Take care, that wasted size is taken into concern
518 if ((jeb
->dirty_size
|| ISDIRTY(jeb
->wasted_size
+ freed_len
)) && jeb
!= c
->nextblock
) {
519 D1(printk(KERN_DEBUG
"Dirtying\n"));
520 addedsize
= freed_len
;
521 jeb
->dirty_size
+= freed_len
;
522 c
->dirty_size
+= freed_len
;
524 /* Convert wasted space to dirty, if not a bad block */
525 if (jeb
->wasted_size
) {
526 if (on_list(&jeb
->list
, &c
->bad_used_list
)) {
527 D1(printk(KERN_DEBUG
"Leaving block at %08x on the bad_used_list\n",
529 addedsize
= 0; /* To fool the refiling code later */
531 D1(printk(KERN_DEBUG
"Converting %d bytes of wasted space to dirty in block at %08x\n",
532 jeb
->wasted_size
, jeb
->offset
));
533 addedsize
+= jeb
->wasted_size
;
534 jeb
->dirty_size
+= jeb
->wasted_size
;
535 c
->dirty_size
+= jeb
->wasted_size
;
536 c
->wasted_size
-= jeb
->wasted_size
;
537 jeb
->wasted_size
= 0;
541 D1(printk(KERN_DEBUG
"Wasting\n"));
543 jeb
->wasted_size
+= freed_len
;
544 c
->wasted_size
+= freed_len
;
546 ref
->flash_offset
= ref_offset(ref
) | REF_OBSOLETE
;
548 jffs2_dbg_acct_sanity_check_nolock(c
, jeb
);
549 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
551 if (c
->flags
& JFFS2_SB_FLAG_SCANNING
) {
552 /* Flash scanning is in progress. Don't muck about with the block
553 lists because they're not ready yet, and don't actually
554 obliterate nodes that look obsolete. If they weren't
555 marked obsolete on the flash at the time they _became_
556 obsolete, there was probably a reason for that. */
557 spin_unlock(&c
->erase_completion_lock
);
558 /* We didn't lock the erase_free_sem */
562 if (jeb
== c
->nextblock
) {
563 D2(printk(KERN_DEBUG
"Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb
->offset
));
564 } else if (!jeb
->used_size
&& !jeb
->unchecked_size
) {
565 if (jeb
== c
->gcblock
) {
566 D1(printk(KERN_DEBUG
"gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb
->offset
));
569 D1(printk(KERN_DEBUG
"Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb
->offset
));
570 list_del(&jeb
->list
);
572 if (jffs2_wbuf_dirty(c
)) {
573 D1(printk(KERN_DEBUG
"...and adding to erasable_pending_wbuf_list\n"));
574 list_add_tail(&jeb
->list
, &c
->erasable_pending_wbuf_list
);
577 /* Most of the time, we just erase it immediately. Otherwise we
578 spend ages scanning it on mount, etc. */
579 D1(printk(KERN_DEBUG
"...and adding to erase_pending_list\n"));
580 list_add_tail(&jeb
->list
, &c
->erase_pending_list
);
581 c
->nr_erasing_blocks
++;
582 jffs2_erase_pending_trigger(c
);
584 /* Sometimes, however, we leave it elsewhere so it doesn't get
585 immediately reused, and we spread the load a bit. */
586 D1(printk(KERN_DEBUG
"...and adding to erasable_list\n"));
587 list_add_tail(&jeb
->list
, &c
->erasable_list
);
590 D1(printk(KERN_DEBUG
"Done OK\n"));
591 } else if (jeb
== c
->gcblock
) {
592 D2(printk(KERN_DEBUG
"Not moving gcblock 0x%08x to dirty_list\n", jeb
->offset
));
593 } else if (ISDIRTY(jeb
->dirty_size
) && !ISDIRTY(jeb
->dirty_size
- addedsize
)) {
594 D1(printk(KERN_DEBUG
"Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb
->offset
));
595 list_del(&jeb
->list
);
596 D1(printk(KERN_DEBUG
"...and adding to dirty_list\n"));
597 list_add_tail(&jeb
->list
, &c
->dirty_list
);
598 } else if (VERYDIRTY(c
, jeb
->dirty_size
) &&
599 !VERYDIRTY(c
, jeb
->dirty_size
- addedsize
)) {
600 D1(printk(KERN_DEBUG
"Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb
->offset
));
601 list_del(&jeb
->list
);
602 D1(printk(KERN_DEBUG
"...and adding to very_dirty_list\n"));
603 list_add_tail(&jeb
->list
, &c
->very_dirty_list
);
605 D1(printk(KERN_DEBUG
"Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n",
606 jeb
->offset
, jeb
->free_size
, jeb
->dirty_size
, jeb
->used_size
));
609 spin_unlock(&c
->erase_completion_lock
);
611 if (!jffs2_can_mark_obsolete(c
) || jffs2_is_readonly(c
) ||
612 (c
->flags
& JFFS2_SB_FLAG_BUILDING
)) {
613 /* We didn't lock the erase_free_sem */
617 /* The erase_free_sem is locked, and has been since before we marked the node obsolete
618 and potentially put its eraseblock onto the erase_pending_list. Thus, we know that
619 the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet
620 by jffs2_free_all_node_refs() in erase.c. Which is nice. */
622 D1(printk(KERN_DEBUG
"obliterating obsoleted node at 0x%08x\n", ref_offset(ref
)));
623 ret
= jffs2_flash_read(c
, ref_offset(ref
), sizeof(n
), &retlen
, (char *)&n
);
625 printk(KERN_WARNING
"Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref
), ret
);
628 if (retlen
!= sizeof(n
)) {
629 printk(KERN_WARNING
"Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref
), retlen
);
632 if (PAD(je32_to_cpu(n
.totlen
)) != PAD(freed_len
)) {
633 printk(KERN_WARNING
"Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n
.totlen
), freed_len
);
636 if (!(je16_to_cpu(n
.nodetype
) & JFFS2_NODE_ACCURATE
)) {
637 D1(printk(KERN_DEBUG
"Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", ref_offset(ref
), je16_to_cpu(n
.nodetype
)));
640 /* XXX FIXME: This is ugly now */
641 n
.nodetype
= cpu_to_je16(je16_to_cpu(n
.nodetype
) & ~JFFS2_NODE_ACCURATE
);
642 ret
= jffs2_flash_write(c
, ref_offset(ref
), sizeof(n
), &retlen
, (char *)&n
);
644 printk(KERN_WARNING
"Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref
), ret
);
647 if (retlen
!= sizeof(n
)) {
648 printk(KERN_WARNING
"Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref
), retlen
);
652 /* Nodes which have been marked obsolete no longer need to be
653 associated with any inode. Remove them from the per-inode list.
655 Note we can't do this for NAND at the moment because we need
656 obsolete dirent nodes to stay on the lists, because of the
657 horridness in jffs2_garbage_collect_deletion_dirent(). Also
658 because we delete the inocache, and on NAND we need that to
659 stay around until all the nodes are actually erased, in order
660 to stop us from giving the same inode number to another newly
662 if (ref
->next_in_ino
) {
663 struct jffs2_inode_cache
*ic
;
664 struct jffs2_raw_node_ref
**p
;
666 spin_lock(&c
->erase_completion_lock
);
668 ic
= jffs2_raw_ref_to_ic(ref
);
669 /* It seems we should never call jffs2_mark_node_obsolete() for
670 XATTR nodes.... yet. Make sure we notice if/when we change
672 BUG_ON(ic
->class != RAWNODE_CLASS_INODE_CACHE
);
673 for (p
= &ic
->nodes
; (*p
) != ref
; p
= &((*p
)->next_in_ino
))
676 *p
= ref
->next_in_ino
;
677 ref
->next_in_ino
= NULL
;
679 if (ic
->nodes
== (void *)ic
&& ic
->nlink
== 0)
680 jffs2_del_ino_cache(c
, ic
);
682 spin_unlock(&c
->erase_completion_lock
);
686 /* Merge with the next node in the physical list, if there is one
687 and if it's also obsolete and if it doesn't belong to any inode */
688 if (ref
->next_phys
&& ref_obsolete(ref
->next_phys
) &&
689 !ref
->next_phys
->next_in_ino
) {
690 struct jffs2_raw_node_ref
*n
= ref
->next_phys
;
692 spin_lock(&c
->erase_completion_lock
);
695 ref
->__totlen
+= n
->__totlen
;
697 ref
->next_phys
= n
->next_phys
;
698 if (jeb
->last_node
== n
) jeb
->last_node
= ref
;
699 if (jeb
->gc_node
== n
) {
700 /* gc will be happy continuing gc on this node */
703 spin_unlock(&c
->erase_completion_lock
);
705 __jffs2_free_raw_node_ref(n
);
708 /* Also merge with the previous node in the list, if there is one
709 and that one is obsolete */
710 if (ref
!= jeb
->first_node
) {
711 struct jffs2_raw_node_ref
*p
= jeb
->first_node
;
713 spin_lock(&c
->erase_completion_lock
);
715 while (p
->next_phys
!= ref
)
718 if (ref_obsolete(p
) && !ref
->next_in_ino
) {
720 p
->__totlen
+= ref
->__totlen
;
722 if (jeb
->last_node
== ref
) {
725 if (jeb
->gc_node
== ref
) {
726 /* gc will be happy continuing gc on this node */
729 p
->next_phys
= ref
->next_phys
;
730 __jffs2_free_raw_node_ref(ref
);
732 spin_unlock(&c
->erase_completion_lock
);
735 up(&c
->erase_free_sem
);
738 int jffs2_thread_should_wake(struct jffs2_sb_info
*c
)
743 if (c
->unchecked_size
) {
744 D1(printk(KERN_DEBUG
"jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n",
745 c
->unchecked_size
, c
->checked_ino
));
749 /* dirty_size contains blocks on erase_pending_list
750 * those blocks are counted in c->nr_erasing_blocks.
751 * If one block is actually erased, it is not longer counted as dirty_space
752 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
753 * with c->nr_erasing_blocks * c->sector_size again.
754 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
755 * This helps us to force gc and pick eventually a clean block to spread the load.
757 dirty
= c
->dirty_size
+ c
->erasing_size
- c
->nr_erasing_blocks
* c
->sector_size
;
759 if (c
->nr_free_blocks
+ c
->nr_erasing_blocks
< c
->resv_blocks_gctrigger
&&
760 (dirty
> c
->nospc_dirty_size
))
763 D1(printk(KERN_DEBUG
"jffs2_thread_should_wake(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x: %s\n",
764 c
->nr_free_blocks
, c
->nr_erasing_blocks
, c
->dirty_size
, ret
?"yes":"no"));