[JFFS2] Add erase_checking_list to hold blocks being marked.

Just to keep the debug code happy when it's adding all the blocks up.
Otherwise, they disappear for a while while the locks are dropped to
check them and write the cleanmarker.

Signed-off-by: David Woodhouse <dwmw2@infradead.org>

diff --git a/fs/jffs2/build.c b/fs/jffs2/build.c
index 722a6b682951b8bcdecac8107171c2d06f5d60be..d58f845ccb85984666d2e6ef0d1d6d9339c10d67 100644 (file)
--- a/fs/jffs2/build.c
+++ b/fs/jffs2/build.c
@@ -345,6 +345,7 @@ int jffs2_do_mount_fs(struct jffs2_sb_info *c)
        INIT_LIST_HEAD(&c->dirty_list);
        INIT_LIST_HEAD(&c->erasable_list);
        INIT_LIST_HEAD(&c->erasing_list);
+       INIT_LIST_HEAD(&c->erase_checking_list);
        INIT_LIST_HEAD(&c->erase_pending_list);
        INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
        INIT_LIST_HEAD(&c->erase_complete_list);

diff --git a/fs/jffs2/debug.c b/fs/jffs2/debug.c
index e198468a8c68e71d4650dd15961e02f9c3b69b72..5544d31c066be22fb25cc857df3691de8e420ea6 100644 (file)
--- a/fs/jffs2/debug.c
+++ b/fs/jffs2/debug.c
@@ -246,6 +246,10 @@ void __jffs2_dbg_superblock_counts(struct jffs2_sb_info *c)
                nr_counted++;
                erasing += c->sector_size;
        }
+       list_for_each_entry(jeb, &c->erase_checking_list, list) {
+               nr_counted++;
+               erasing += c->sector_size;
+       }
        list_for_each_entry(jeb, &c->erase_complete_list, list) {
                nr_counted++;
                erasing += c->sector_size;
@@ -582,6 +586,21 @@ __jffs2_dbg_dump_block_lists_nolock(struct jffs2_sb_info *c)
                        }
                }
        }
+       if (list_empty(&c->erase_checking_list)) {
+               printk(JFFS2_DBG "erase_checking_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->erase_checking_list) {
+                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+
+                       if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
+                               printk(JFFS2_DBG "erase_checking_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
+                                       jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
+                                       jeb->unchecked_size, jeb->free_size);
+                       }
+               }
+       }
 
        if (list_empty(&c->erase_pending_list)) {
                printk(JFFS2_DBG "erase_pending_list: empty\n");

diff --git a/fs/jffs2/erase.c b/fs/jffs2/erase.c
index 5e2719cb693036286c0de4b5df8012d801fbbdea..25a640e566d3d6d47ae9310b12b3e222f7bbed52 100644 (file)
--- a/fs/jffs2/erase.c
+++ b/fs/jffs2/erase.c
@@ -116,7 +116,7 @@ void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count)
 
                if (!list_empty(&c->erase_complete_list)) {
                        jeb = list_entry(c->erase_complete_list.next, struct jffs2_eraseblock, list);
-                       list_del(&jeb->list);
+                       list_move(&jeb->list, &c->erase_checking_list);
                        spin_unlock(&c->erase_completion_lock);
                        mutex_unlock(&c->erase_free_sem);
                        jffs2_mark_erased_block(c, jeb);
@@ -465,7 +465,7 @@ static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseb
        if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))
                jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL);
 
-       list_add_tail(&jeb->list, &c->free_list);
+       list_move_tail(&jeb->list, &c->free_list);
        c->nr_erasing_blocks--;
        c->nr_free_blocks++;
 
@@ -482,7 +482,7 @@ filebad:
        spin_lock(&c->erase_completion_lock);
        /* Stick it on a list (any list) so erase_failed can take it
           right off again.  Silly, but shouldn't happen often. */
-       list_add(&jeb->list, &c->erasing_list);
+       list_move(&jeb->list, &c->erasing_list);
        spin_unlock(&c->erase_completion_lock);
        mutex_unlock(&c->erase_free_sem);
        jffs2_erase_failed(c, jeb, bad_offset);
@@ -493,7 +493,7 @@ refile:
        jffs2_erase_pending_trigger(c);
        mutex_lock(&c->erase_free_sem);
        spin_lock(&c->erase_completion_lock);
-       list_add(&jeb->list, &c->erase_complete_list);
+       list_move(&jeb->list, &c->erase_complete_list);
        spin_unlock(&c->erase_completion_lock);
        mutex_unlock(&c->erase_free_sem);
        return;

diff --git a/fs/jffs2/jffs2_fs_sb.h b/fs/jffs2/jffs2_fs_sb.h
index d9c4b27575e8cf1293925c0921eb2e64f5748984..85ef6dbb1be7adb3dbbd3553f008a32fe1c35dfc 100644 (file)
--- a/fs/jffs2/jffs2_fs_sb.h
+++ b/fs/jffs2/jffs2_fs_sb.h
@@ -87,6 +87,7 @@ struct jffs2_sb_info {
        struct list_head erasable_list;         /* Blocks which are completely dirty, and need erasing */
        struct list_head erasable_pending_wbuf_list;    /* Blocks which need erasing but only after the current wbuf is flushed */
        struct list_head erasing_list;          /* Blocks which are currently erasing */
+       struct list_head erase_checking_list;   /* Blocks which are being checked and marked */
        struct list_head erase_pending_list;    /* Blocks which need erasing now */
        struct list_head erase_complete_list;   /* Blocks which are erased and need the clean marker written to them */
        struct list_head free_list;             /* Blocks which are free and ready to be used */