[JFFS2] Debug code clean up - step 1
Artem B. Bityutskiy [Sun, 17 Jul 2005 06:56:26 +0000 (07:56 +0100)]
Move debug functions into a seperate source file

Signed-off-by: Artem B. Bityutskiy <dedekind@infradead.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

14 files changed:
fs/jffs2/Makefile
fs/jffs2/build.c
fs/jffs2/debug.c [new file with mode: 0644]
fs/jffs2/debug.h [new file with mode: 0644]
fs/jffs2/erase.c
fs/jffs2/fs.c
fs/jffs2/gc.c
fs/jffs2/nodelist.h
fs/jffs2/nodemgmt.c
fs/jffs2/read.c
fs/jffs2/readinode.c
fs/jffs2/scan.c
fs/jffs2/wbuf.c
fs/jffs2/write.c

index f1afe68..e6230f1 100644 (file)
@@ -1,7 +1,7 @@
 #
 # Makefile for the Linux Journalling Flash File System v2 (JFFS2)
 #
-# $Id: Makefile.common,v 1.9 2005/02/09 09:23:53 pavlov Exp $
+# $Id: Makefile.common,v 1.10 2005/07/17 06:56:20 dedekind Exp $
 #
 
 obj-$(CONFIG_JFFS2_FS) += jffs2.o
@@ -9,7 +9,7 @@ obj-$(CONFIG_JFFS2_FS) += jffs2.o
 jffs2-y        := compr.o dir.o file.o ioctl.o nodelist.o malloc.o
 jffs2-y        += read.o nodemgmt.o readinode.o write.o scan.o gc.o
 jffs2-y        += symlink.o build.o erase.o background.o fs.o writev.o
-jffs2-y        += super.o
+jffs2-y        += super.o debug.o
 
 jffs2-$(CONFIG_JFFS2_FS_WRITEBUFFER)   += wbuf.o
 jffs2-$(CONFIG_JFFS2_RUBIN)    += compr_rubin.o
index 97dc397..3a0b003 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: build.c,v 1.71 2005/07/12 16:37:08 dedekind Exp $
+ * $Id: build.c,v 1.72 2005/07/17 06:56:20 dedekind Exp $
  *
  */
 
@@ -104,7 +104,7 @@ static int jffs2_build_filesystem(struct jffs2_sb_info *c)
                goto exit;
 
        D1(printk(KERN_DEBUG "Scanned flash completely\n"));
-       D2(jffs2_dump_block_lists(c));
+       D2(jffs2_dbg_dump_block_lists(c));
 
        c->flags |= JFFS2_SB_FLAG_BUILDING;
        /* Now scan the directory tree, increasing nlink according to every dirent found. */
@@ -168,7 +168,7 @@ static int jffs2_build_filesystem(struct jffs2_sb_info *c)
        c->flags &= ~JFFS2_SB_FLAG_BUILDING;
        
        D1(printk(KERN_DEBUG "Pass 3 complete\n"));
-       D2(jffs2_dump_block_lists(c));
+       D2(jffs2_dbg_dump_block_lists(c));
 
        /* Rotate the lists by some number to ensure wear levelling */
        jffs2_rotate_lists(c);
diff --git a/fs/jffs2/debug.c b/fs/jffs2/debug.c
new file mode 100644 (file)
index 0000000..9da524c
--- /dev/null
@@ -0,0 +1,495 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2001-2003 Red Hat, Inc.
+ *
+ * Created by David Woodhouse <dwmw2@infradead.org>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ * $Id: debug.c,v 1.1 2005/07/17 06:56:20 dedekind Exp $
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/pagemap.h>
+#include "nodelist.h"
+#include "debug.h"
+
+#ifdef JFFS2_DBG_PARANOIA_CHECKS
+
+void
+jffs2_dbg_fragtree_paranoia_check(struct jffs2_inode_info *f)
+{
+       struct jffs2_node_frag *frag;
+       int bitched = 0;
+
+       for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
+               struct jffs2_full_dnode *fn = frag->node;
+
+               if (!fn || !fn->raw)
+                       continue;
+
+               if (ref_flags(fn->raw) == REF_PRISTINE) {
+                       if (fn->frags > 1) {
+                               printk(KERN_ERR "REF_PRISTINE node at 0x%08x had %d frags. Tell dwmw2\n",
+                                               ref_offset(fn->raw), fn->frags);
+                               bitched = 1;
+                       }
+
+                       /* A hole node which isn't multi-page should be garbage-collected
+                          and merged anyway, so we just check for the frag size here,
+                          rather than mucking around with actually reading the node
+                          and checking the compression type, which is the real way
+                          to tell a hole node. */
+                       if (frag->ofs & (PAGE_CACHE_SIZE-1) && frag_prev(frag)
+                                       && frag_prev(frag)->size < PAGE_CACHE_SIZE && frag_prev(frag)->node) {
+                               printk(KERN_ERR "REF_PRISTINE node at 0x%08x had a previous non-hole frag "
+                                               "in the same page. Tell dwmw2\n", ref_offset(fn->raw));
+                               bitched = 1;
+                       }
+
+                       if ((frag->ofs+frag->size) & (PAGE_CACHE_SIZE-1) && frag_next(frag)
+                                       && frag_next(frag)->size < PAGE_CACHE_SIZE && frag_next(frag)->node) {
+                               printk(KERN_ERR "REF_PRISTINE node at 0x%08x (%08x-%08x) had a following "
+                                               "non-hole frag in the same page. Tell dwmw2\n",
+                                              ref_offset(fn->raw), frag->ofs, frag->ofs+frag->size);
+                               bitched = 1;
+                       }
+               }
+       }
+
+       if (bitched) {
+               printk(KERN_ERR "Fragtree is corrupted. Fragtree dump:\n");
+               jffs2_dbg_dump_fragtree(f);
+               BUG();
+       }
+}
+
+/*
+ * Check if the flash contains all 0xFF before we start writing.
+ */
+void
+jffs2_dbg_prewrite_paranoia_check(struct jffs2_sb_info *c, uint32_t ofs, int len)
+{
+       size_t retlen;
+       int ret, i;
+       unsigned char *buf;
+
+       buf = kmalloc(len, GFP_KERNEL);
+       if (!buf)
+               return;
+
+       ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
+       if (ret || (retlen != len)) {
+               printk(KERN_WARNING "read %d bytes failed or short in %s(). ret %d, retlen %zd\n",
+                               len, __FUNCTION__, ret, retlen);
+               kfree(buf);
+               return;
+       }
+
+       ret = 0;
+       for (i = 0; i < len; i++)
+               if (buf[i] != 0xff)
+                       ret = 1;
+
+       if (ret) {
+               printk(KERN_ERR "ARGH. About to write node to %#08x on flash, but there are data "
+                               "already there. The first corrupted byte is at %#08x.\n", ofs, ofs + i);
+               jffs2_dbg_dump_buffer(buf, len, ofs);
+               kfree(buf);
+               BUG();
+       }
+
+       kfree(buf);
+}
+
+/*
+ * Check the space accounting and node_ref list correctness for the JFFS2 erasable block 'jeb'.
+ */
+void
+jffs2_dbg_acct_paranoia_check(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+{
+       uint32_t my_used_size = 0;
+       uint32_t my_unchecked_size = 0;
+       uint32_t my_dirty_size = 0;
+       struct jffs2_raw_node_ref *ref2 = jeb->first_node;
+
+       while (ref2) {
+               uint32_t totlen = ref_totlen(c, jeb, ref2);
+
+               if (ref2->flash_offset < jeb->offset ||
+                               ref2->flash_offset > jeb->offset + c->sector_size) {
+                       printk(KERN_ERR "node_ref %#08x shouldn't be in block at %#08x!\n",
+                               ref_offset(ref2), jeb->offset);
+                       jffs2_dbg_dump_node_refs(c, jeb);
+                       jffs2_dbg_dump_block_lists(c);
+                       BUG();
+
+               }
+               if (ref_flags(ref2) == REF_UNCHECKED)
+                       my_unchecked_size += totlen;
+               else if (!ref_obsolete(ref2))
+                       my_used_size += totlen;
+               else
+                       my_dirty_size += totlen;
+
+               if ((!ref2->next_phys) != (ref2 == jeb->last_node)) {
+                       printk(KERN_ERR "node_ref for node at %#08x (mem %p) has next_phys at %#08x (mem %p), "
+                                       "last_node is at %#08x (mem %p)\n",
+                                       ref_offset(ref2), ref2, ref_offset(ref2->next_phys), ref2->next_phys,
+                                       ref_offset(jeb->last_node), jeb->last_node);
+                       jffs2_dbg_dump_node_refs(c, jeb);
+                       jffs2_dbg_dump_block_lists(c);
+                       BUG();
+               }
+               ref2 = ref2->next_phys;
+       }
+
+       if (my_used_size != jeb->used_size) {
+               printk(KERN_ERR "Calculated used size %#08x != stored used size %#08x\n",
+                               my_used_size, jeb->used_size);
+               jffs2_dbg_dump_node_refs(c, jeb);
+               jffs2_dbg_dump_block_lists(c);
+               BUG();
+       }
+
+       if (my_unchecked_size != jeb->unchecked_size) {
+               printk(KERN_ERR "Calculated unchecked size %#08x != stored unchecked size %#08x\n",
+                               my_unchecked_size, jeb->unchecked_size);
+               jffs2_dbg_dump_node_refs(c, jeb);
+               jffs2_dbg_dump_block_lists(c);
+               BUG();
+       }
+
+       if (my_dirty_size != jeb->dirty_size + jeb->wasted_size) {
+               printk(KERN_ERR "Calculated dirty+wasted size %#08x != stored dirty + wasted size %#08x\n",
+                       my_dirty_size, jeb->dirty_size + jeb->wasted_size);
+               jffs2_dbg_dump_node_refs(c, jeb);
+               jffs2_dbg_dump_block_lists(c);
+               BUG();
+       }
+
+       if (jeb->free_size == 0
+               && my_used_size + my_unchecked_size + my_dirty_size != c->sector_size) {
+               printk(KERN_ERR "The sum of all nodes in block (%#x) != size of block (%#x)\n",
+                       my_used_size + my_unchecked_size + my_dirty_size,
+                       c->sector_size);
+               jffs2_dbg_dump_node_refs(c, jeb);
+               jffs2_dbg_dump_block_lists(c);
+               BUG();
+       }
+}
+#endif /* JFFS2_PARANOIA_CHECKS */
+
+#if defined(JFFS2_PARANOIA_CHECKS) || (CONFIG_JFFS2_FS_DEBUG > 0)
+/*
+ * Dump the node_refs of the 'jeb' JFFS2 eraseblock.
+ */
+void
+jffs2_dbg_dump_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
+{
+       struct jffs2_raw_node_ref *ref;
+       int i = 0;
+
+       if (!jeb->first_node) {
+               printk(KERN_DEBUG "no nodes in block %#08x\n", jeb->offset);
+               return;
+       }
+
+       printk(KERN_DEBUG);
+       for (ref = jeb->first_node; ; ref = ref->next_phys) {
+               printk("%#08x(%#x)", ref_offset(ref), ref->__totlen);
+               if (ref->next_phys)
+                       printk("->");
+               else
+                       break;
+               if (++i == 4) {
+                       i = 0;
+                       printk("\n" KERN_DEBUG);
+               }
+       }
+       printk("\n");
+}
+
+void
+jffs2_dbg_dump_block_lists(struct jffs2_sb_info *c)
+{
+       printk(KERN_DEBUG "flash_size: %#08x\n",        c->flash_size);
+       printk(KERN_DEBUG "used_size: %#08x\n",         c->used_size);
+       printk(KERN_DEBUG "dirty_size: %#08x\n",        c->dirty_size);
+       printk(KERN_DEBUG "wasted_size: %#08x\n",       c->wasted_size);
+       printk(KERN_DEBUG "unchecked_size: %#08x\n",    c->unchecked_size);
+       printk(KERN_DEBUG "free_size: %#08x\n",         c->free_size);
+       printk(KERN_DEBUG "erasing_size: %#08x\n",      c->erasing_size);
+       printk(KERN_DEBUG "bad_size: %#08x\n",          c->bad_size);
+       printk(KERN_DEBUG "sector_size: %#08x\n",       c->sector_size);
+       printk(KERN_DEBUG "jffs2_reserved_blocks size: %#08x\n",
+                               c->sector_size * c->resv_blocks_write);
+
+       if (c->nextblock)
+               printk(KERN_DEBUG "nextblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, "
+                               "unchecked %#08x, free %#08x)\n",
+                               c->nextblock->offset, c->nextblock->used_size,
+                               c->nextblock->dirty_size, c->nextblock->wasted_size,
+                               c->nextblock->unchecked_size, c->nextblock->free_size);
+       else
+               printk(KERN_DEBUG "nextblock: NULL\n");
+
+       if (c->gcblock)
+               printk(KERN_DEBUG "gcblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, "
+                               "unchecked %#08x, free %#08x)\n",
+                               c->gcblock->offset, c->gcblock->used_size, c->gcblock->dirty_size,
+                               c->gcblock->wasted_size, c->gcblock->unchecked_size, c->gcblock->free_size);
+       else
+               printk(KERN_DEBUG "gcblock: NULL\n");
+
+       if (list_empty(&c->clean_list)) {
+               printk(KERN_DEBUG "clean_list: empty\n");
+       } else {
+               struct list_head *this;
+               int numblocks = 0;
+               uint32_t dirty = 0;
+
+               list_for_each(this, &c->clean_list) {
+                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+                       numblocks ++;
+                       dirty += jeb->wasted_size;
+                       if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
+                               printk(KERN_DEBUG "clean_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);
+                       }
+               }
+
+               printk (KERN_DEBUG "Contains %d blocks with total wasted size %u, average wasted size: %u\n",
+                               numblocks, dirty, dirty / numblocks);
+       }
+
+       if (list_empty(&c->very_dirty_list)) {
+               printk(KERN_DEBUG "very_dirty_list: empty\n");
+       } else {
+               struct list_head *this;
+               int numblocks = 0;
+               uint32_t dirty = 0;
+
+               list_for_each(this, &c->very_dirty_list) {
+                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+
+                       numblocks ++;
+                       dirty += jeb->dirty_size;
+                       if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
+                               printk(KERN_DEBUG "very_dirty_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);
+                       }
+               }
+
+               printk (KERN_DEBUG "Contains %d blocks with total dirty size %u, average dirty size: %u\n",
+                               numblocks, dirty, dirty / numblocks);
+       }
+
+       if (list_empty(&c->dirty_list)) {
+               printk(KERN_DEBUG "dirty_list: empty\n");
+       } else {
+               struct list_head *this;
+               int numblocks = 0;
+               uint32_t dirty = 0;
+
+               list_for_each(this, &c->dirty_list) {
+                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+
+                       numblocks ++;
+                       dirty += jeb->dirty_size;
+                       if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
+                               printk(KERN_DEBUG "dirty_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);
+                       }
+               }
+
+               printk (KERN_DEBUG "Contains %d blocks with total dirty size %u, average dirty size: %u\n",
+                       numblocks, dirty, dirty / numblocks);
+       }
+
+       if (list_empty(&c->erasable_list)) {
+               printk(KERN_DEBUG "erasable_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->erasable_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(KERN_DEBUG "erasable_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->erasing_list)) {
+               printk(KERN_DEBUG "erasing_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->erasing_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(KERN_DEBUG "erasing_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(KERN_DEBUG "erase_pending_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->erase_pending_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(KERN_DEBUG "erase_pending_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->erasable_pending_wbuf_list)) {
+               printk(KERN_DEBUG "erasable_pending_wbuf_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->erasable_pending_wbuf_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(KERN_DEBUG "erasable_pending_wbuf_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->free_list)) {
+               printk(KERN_DEBUG "free_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->free_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(KERN_DEBUG "free_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->bad_list)) {
+               printk(KERN_DEBUG "bad_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->bad_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(KERN_DEBUG "bad_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->bad_used_list)) {
+               printk(KERN_DEBUG "bad_used_list: empty\n");
+       } else {
+               struct list_head *this;
+
+               list_for_each(this, &c->bad_used_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(KERN_DEBUG "bad_used_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);
+                       }
+               }
+       }
+}
+
+void
+jffs2_dbg_dump_fragtree(struct jffs2_inode_info *f)
+{
+       struct jffs2_node_frag *this = frag_first(&f->fragtree);
+       uint32_t lastofs = 0;
+       int buggy = 0;
+
+       printk(KERN_DEBUG "inode is ino #%u\n", f->inocache->ino);
+       while(this) {
+               if (this->node)
+                       printk(KERN_DEBUG "frag %#04x-%#04x: %#08x(%d) on flash (*%p), left (%p), "
+                                       "right (%p), parent (%p)\n",
+                                       this->ofs, this->ofs+this->size, ref_offset(this->node->raw),
+                                       ref_flags(this->node->raw), this, frag_left(this), frag_right(this),
+                                       frag_parent(this));
+               else
+                       printk(KERN_DEBUG "frag %#04x-%#04x: hole (*%p). left (%p), right (%p), parent (%p)\n",
+                                       this->ofs, this->ofs+this->size, this, frag_left(this),
+                                       frag_right(this), frag_parent(this));
+               if (this->ofs != lastofs)
+                       buggy = 1;
+               lastofs = this->ofs + this->size;
+               this = frag_next(this);
+       }
+
+       if (f->metadata)
+               printk(KERN_DEBUG "metadata at 0x%08x\n", ref_offset(f->metadata->raw));
+
+       if (buggy) {
+               printk(KERN_ERR "Error! %s(): Frag tree got a hole in it\n", __FUNCTION__);
+               BUG();
+       }
+}
+
+#define JFFS3_BUFDUMP_BYTES_PER_LINE   8
+void
+jffs2_dbg_dump_buffer(char *buf, int len, uint32_t offs)
+{
+       int i = 0;
+       int skip = offs & ~(JFFS3_BUFDUMP_BYTES_PER_LINE - 1);
+
+       while (i < len) {
+               int j = 0;
+
+               printk(KERN_DEBUG "0x#x: \n");
+               while (skip) {
+                       printk("   ");
+                       skip -= 1;
+               }
+
+               while (j < JFFS3_BUFDUMP_BYTES_PER_LINE) {
+                       if (i + j < len)
+                               printk(" %#02x", buf[i + j++]);
+               }
+
+               i += JFFS3_BUFDUMP_BYTES_PER_LINE;
+       }
+}
+#endif /* JFFS2_PARANOIA_CHECKS || CONFIG_JFFS2_FS_DEBUG > 0 */
diff --git a/fs/jffs2/debug.h b/fs/jffs2/debug.h
new file mode 100644 (file)
index 0000000..7d14f7b
--- /dev/null
@@ -0,0 +1,104 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2001-2003 Red Hat, Inc.
+ *
+ * Created by David Woodhouse <dwmw2@infradead.org>
+ *
+ * For licensing information, see the file 'LICENCE' in this directory.
+ *
+ * $Id: debug.h,v 1.1 2005/07/17 06:56:20 dedekind Exp $
+ *
+ */
+#ifndef _JFFS2_DEBUG_H_
+#define _JFFS2_DEBUG_H_
+
+#include <linux/config.h>
+
+#ifndef CONFIG_JFFS2_FS_DEBUG
+#define CONFIG_JFFS2_FS_DEBUG 1
+#endif
+
+#if CONFIG_JFFS2_FS_DEBUG > 0
+#define JFFS2_DBG_PARANOIA_CHECKS
+#define D1(x) x
+#else
+#define D1(x)
+#endif
+
+#if CONFIG_JFFS2_FS_DEBUG > 1
+#define D2(x) x
+#else
+#define D2(x)
+#endif
+
+/* Enable JFFS2 sanity checks */
+#define JFFS2_DBG_SANITY_CHECKS
+
+#if CONFIG_JFFS2_FS_DEBUG > 0
+void
+jffs2_dbg_dump_block_lists(struct jffs2_sb_info *c);
+
+void
+jffs2_dbg_dump_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
+
+void
+jffs2_dbg_dump_fragtree(struct jffs2_inode_info *f);
+
+void
+jffs2_dbg_dump_buffer(char *buf, int len, uint32_t offs);
+#endif
+
+#ifdef JFFS2_DBG_PARANOIA_CHECKS
+void
+jffs2_dbg_fragtree_paranoia_check(struct jffs2_inode_info *f);
+
+void
+jffs2_dbg_acct_paranoia_check(struct jffs2_sb_info *c,
+                             struct jffs2_eraseblock *jeb);
+
+void
+jffs2_dbg_prewrite_paranoia_check(struct jffs2_sb_info *c,
+                                 uint32_t ofs, int len);
+#else
+#define jffs2_dbg_fragtree_paranoia_check(f)
+#define jffs2_dbg_acct_paranoia_check(c, jeb)
+#define jffs2_dbg_prewrite_paranoia_check(c, ofs, len)
+#endif /* !JFFS2_PARANOIA_CHECKS */
+
+#ifdef JFFS2_DBG_SANITY_CHECKS
+/*
+ * Check the space accounting of the file system and of
+ * the JFFS3 erasable block 'jeb'.
+ */
+static inline void
+jffs2_dbg_acct_sanity_check(struct jffs2_sb_info *c,
+                           struct jffs2_eraseblock *jeb)
+{
+       if (unlikely(jeb && jeb->used_size + jeb->dirty_size +
+                       jeb->free_size + jeb->wasted_size +
+                       jeb->unchecked_size != c->sector_size)) {
+               printk(KERN_ERR "Eeep. Space accounting for block at 0x%08x is screwed\n", jeb->offset);
+               printk(KERN_ERR "free %#08x + dirty %#08x + used %#08x + wasted %#08x + unchecked "
+                               "%#08x != total %#08x\n", jeb->free_size, jeb->dirty_size, jeb->used_size,
+                               jeb->wasted_size, jeb->unchecked_size, c->sector_size);
+               BUG();
+       }
+
+       if (unlikely(c->used_size + c->dirty_size + c->free_size + c->erasing_size + c->bad_size
+                               + c->wasted_size + c->unchecked_size != c->flash_size)) {
+               printk(KERN_ERR "Eeep. Space accounting superblock info is screwed\n");
+               printk(KERN_ERR "free %#08x + dirty %#08x + used %#08x + erasing %#08x + bad %#08x + "
+                               "wasted %#08x + unchecked %#08x != total %#08x\n",
+                               c->free_size, c->dirty_size, c->used_size, c->erasing_size, c->bad_size,
+                               c->wasted_size, c->unchecked_size, c->flash_size);
+               BUG();
+       }
+}
+#else
+static inline void
+jffs2_dbg_acct_sanity_check(struct jffs2_sb_info *c,
+                           struct jffs2_eraseblock *jeb);
+#endif /* !JFFS2_DBG_SANITY_CHECKS */
+
+#endif /* _JFFS2_DEBUG_H_ */
index 787d84a..af0c7d4 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: erase.c,v 1.80 2005/07/14 19:46:24 joern Exp $
+ * $Id: erase.c,v 1.81 2005/07/17 06:56:20 dedekind Exp $
  *
  */
 
@@ -429,8 +429,8 @@ static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseb
        c->free_size += jeb->free_size;
        c->used_size += jeb->used_size;
 
-       ACCT_SANITY_CHECK(c,jeb);
-       D1(ACCT_PARANOIA_CHECK(jeb));
+       jffs2_dbg_acct_sanity_check(c,jeb);
+       jffs2_dbg_acct_paranoia_check(c, jeb);
 
        list_add_tail(&jeb->list, &c->free_list);
        c->nr_erasing_blocks--;
index 5687c3f..6c8a9d5 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: fs.c,v 1.56 2005/07/06 12:13:09 dwmw2 Exp $
+ * $Id: fs.c,v 1.57 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
@@ -203,7 +203,7 @@ int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
 
        buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 
-       D2(jffs2_dump_block_lists(c));
+       D2(jffs2_dbg_dump_block_lists(c));
 
        spin_unlock(&c->erase_completion_lock);
 
index 7086cd6..337ab49 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: gc.c,v 1.148 2005/04/09 10:47:00 dedekind Exp $
+ * $Id: gc.c,v 1.149 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
@@ -111,7 +111,7 @@ again:
                ret->wasted_size = 0;
        }
 
-       D2(jffs2_dump_block_lists(c));
+       D2(jffs2_dbg_dump_block_lists(c));
        return ret;
 }
 
@@ -142,7 +142,7 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
                if (c->checked_ino > c->highest_ino) {
                        printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
                               c->unchecked_size);
-                       D2(jffs2_dump_block_lists(c));
+                       D2(jffs2_dbg_dump_block_lists(c));
                        spin_unlock(&c->erase_completion_lock);
                        BUG();
                }
@@ -619,16 +619,16 @@ static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
 
                        D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n"));
                        
-                       ACCT_SANITY_CHECK(c,jeb);
-                       D1(ACCT_PARANOIA_CHECK(jeb));
+                       jffs2_dbg_acct_sanity_check(c,jeb);
+                       jffs2_dbg_acct_paranoia_check(c, jeb);
 
                        ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy);
 
                        if (!ret) {
                                D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs));
 
-                               ACCT_SANITY_CHECK(c,jeb);
-                               D1(ACCT_PARANOIA_CHECK(jeb));
+                               jffs2_dbg_acct_sanity_check(c,jeb);
+                               jffs2_dbg_acct_paranoia_check(c, jeb);
 
                                goto retry;
                        }
index b34c397..6802e09 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: nodelist.h,v 1.131 2005/07/05 21:03:07 dwmw2 Exp $
+ * $Id: nodelist.h,v 1.132 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
 #ifdef __ECOS
 #include "os-ecos.h"
 #else
-#include <linux/mtd/compatmac.h> /* For min/max in older kernels */
+#include <linux/mtd/compatmac.h> /* For compatibility with older kernels */
 #include "os-linux.h"
 #endif
 
-#ifndef CONFIG_JFFS2_FS_DEBUG
-#define CONFIG_JFFS2_FS_DEBUG 1
-#endif
-
-#if CONFIG_JFFS2_FS_DEBUG > 0
-#define D1(x) x
-#else
-#define D1(x)
-#endif
-
-#if CONFIG_JFFS2_FS_DEBUG > 1
-#define D2(x) x
-#else
-#define D2(x)
-#endif
-
 #define JFFS2_NATIVE_ENDIAN
 
 /* Note we handle mode bits conversion from JFFS2 (i.e. Linux) to/from
@@ -207,79 +191,6 @@ struct jffs2_eraseblock
        struct jffs2_raw_node_ref *gc_node;     /* Next node to be garbage collected */
 };
 
-#define ACCT_SANITY_CHECK(c, jeb) do { \
-               struct jffs2_eraseblock *___j = jeb; \
-               if ((___j) && ___j->used_size + ___j->dirty_size + ___j->free_size + ___j->wasted_size + ___j->unchecked_size != c->sector_size) { \
-               printk(KERN_NOTICE "Eeep. Space accounting for block at 0x%08x is screwed\n", ___j->offset); \
-               printk(KERN_NOTICE "free 0x%08x + dirty 0x%08x + used %08x + wasted %08x + unchecked %08x != total %08x\n", \
-               ___j->free_size, ___j->dirty_size, ___j->used_size, ___j->wasted_size, ___j->unchecked_size, c->sector_size); \
-               BUG(); \
-       } \
-       if (c->used_size + c->dirty_size + c->free_size + c->erasing_size + c->bad_size + c->wasted_size + c->unchecked_size != c->flash_size) { \
-               printk(KERN_NOTICE "Eeep. Space accounting superblock info is screwed\n"); \
-               printk(KERN_NOTICE "free 0x%08x + dirty 0x%08x + used %08x + erasing %08x + bad %08x + wasted %08x + unchecked %08x != total %08x\n", \
-               c->free_size, c->dirty_size, c->used_size, c->erasing_size, c->bad_size, c->wasted_size, c->unchecked_size, c->flash_size); \
-               BUG(); \
-       } \
-} while(0)
-
-static inline void paranoia_failed_dump(struct jffs2_eraseblock *jeb)
-{
-       struct jffs2_raw_node_ref *ref;
-       int i=0;
-
-       printk(KERN_NOTICE);
-       for (ref = jeb->first_node; ref; ref = ref->next_phys) {
-               printk("%08x->", ref_offset(ref));
-               if (++i == 8) {
-                       i = 0;
-                       printk("\n" KERN_NOTICE);
-               }
-       }
-       printk("\n");
-}
-
-
-#define ACCT_PARANOIA_CHECK(jeb) do { \
-               uint32_t my_used_size = 0; \
-               uint32_t my_unchecked_size = 0; \
-               struct jffs2_raw_node_ref *ref2 = jeb->first_node; \
-               while (ref2) { \
-                       if (unlikely(ref2->flash_offset < jeb->offset || \
-                                    ref2->flash_offset > jeb->offset + c->sector_size)) { \
-                               printk(KERN_NOTICE "Node %08x shouldn't be in block at %08x!\n", \
-                                      ref_offset(ref2), jeb->offset); \
-                               paranoia_failed_dump(jeb); \
-                               BUG(); \
-                       } \
-                       if (ref_flags(ref2) == REF_UNCHECKED) \
-                               my_unchecked_size += ref_totlen(c, jeb, ref2); \
-                       else if (!ref_obsolete(ref2)) \
-                               my_used_size += ref_totlen(c, jeb, ref2); \
-                       if (unlikely((!ref2->next_phys) != (ref2 == jeb->last_node))) { \
-                                if (!ref2->next_phys) \
-                                      printk("ref for node at %p (phys %08x) has next_phys->%p (----), last_node->%p (phys %08x)\n", \
-                                            ref2, ref_offset(ref2), ref2->next_phys, \
-                                            jeb->last_node, ref_offset(jeb->last_node)); \
-                                else \
-                                       printk("ref for node at %p (phys %08x) has next_phys->%p (%08x), last_node->%p (phys %08x)\n", \
-                                            ref2, ref_offset(ref2), ref2->next_phys, ref_offset(ref2->next_phys), \
-                                            jeb->last_node, ref_offset(jeb->last_node)); \
-                               paranoia_failed_dump(jeb); \
-                               BUG(); \
-                       } \
-                       ref2 = ref2->next_phys; \
-               } \
-               if (my_used_size != jeb->used_size) { \
-                       printk(KERN_NOTICE "Calculated used size %08x != stored used size %08x\n", my_used_size, jeb->used_size); \
-                       BUG(); \
-               } \
-               if (my_unchecked_size != jeb->unchecked_size) { \
-                       printk(KERN_NOTICE "Calculated unchecked size %08x != stored unchecked size %08x\n", my_unchecked_size, jeb->unchecked_size); \
-                       BUG(); \
-               } \
-       } while(0)
-
 /* Calculate totlen from surrounding nodes or eraseblock */
 static inline uint32_t __ref_totlen(struct jffs2_sb_info *c,
                                    struct jffs2_eraseblock *jeb,
@@ -306,11 +217,13 @@ static inline uint32_t ref_totlen(struct jffs2_sb_info *c,
 {
        uint32_t ret;
 
-       D1(if (jeb && jeb != &c->blocks[ref->flash_offset / c->sector_size]) {
+#if CONFIG_JFFS2_FS_DEBUG > 0
+       if (jeb && jeb != &c->blocks[ref->flash_offset / c->sector_size]) {
                printk(KERN_CRIT "ref_totlen called with wrong block -- at 0x%08x instead of 0x%08x; ref 0x%08x\n",
                       jeb->offset, c->blocks[ref->flash_offset / c->sector_size].offset, ref_offset(ref));
                BUG();
-       })
+       }
+#endif
 
 #if 1
        ret = ref->__totlen;
@@ -323,14 +236,13 @@ static inline uint32_t ref_totlen(struct jffs2_sb_info *c,
                       ret, ref->__totlen);
                if (!jeb)
                        jeb = &c->blocks[ref->flash_offset / c->sector_size];
-               paranoia_failed_dump(jeb);
+               jffs2_dbg_dump_node_refs(c, jeb);
                BUG();
        }
 #endif
        return ret;
 }
 
-
 #define ALLOC_NORMAL   0       /* Normal allocation */
 #define ALLOC_DELETION 1       /* Deletion node. Best to allow it */
 #define ALLOC_GC       2       /* Space requested for GC. Give it or die */
@@ -384,7 +296,6 @@ static inline struct jffs2_node_frag *frag_last(struct rb_root *root)
 #define frag_erase(frag, list) rb_erase(&frag->rb, list);
 
 /* nodelist.c */
-D2(void jffs2_print_frag_list(struct jffs2_inode_info *f));
 void jffs2_add_fd_to_list(struct jffs2_sb_info *c, struct jffs2_full_dirent *new, struct jffs2_full_dirent **list);
 int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                          struct rb_root *tnp, struct jffs2_full_dirent **fdp,
@@ -410,7 +321,6 @@ int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, uint32_t *
 int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *new);
 void jffs2_complete_reservation(struct jffs2_sb_info *c);
 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *raw);
-void jffs2_dump_block_lists(struct jffs2_sb_info *c);
 
 /* write.c */
 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri);
@@ -483,4 +393,6 @@ int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_erasebloc
 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
 #endif
 
+#include "debug.h"
+
 #endif /* __JFFS2_NODELIST_H__ */
index c1d8b5e..424be1e 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: nodemgmt.c,v 1.122 2005/05/06 09:30:27 dedekind Exp $
+ * $Id: nodemgmt.c,v 1.123 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
@@ -349,8 +349,8 @@ int jffs2_add_physical_node_ref(struct jffs2_sb_info *c, struct jffs2_raw_node_r
                list_add_tail(&jeb->list, &c->clean_list);
                c->nextblock = NULL;
        }
-       ACCT_SANITY_CHECK(c,jeb);
-       D1(ACCT_PARANOIA_CHECK(jeb));
+       jffs2_dbg_acct_sanity_check(c,jeb);
+       jffs2_dbg_acct_paranoia_check(c, jeb);
 
        spin_unlock(&c->erase_completion_lock);
 
@@ -466,9 +466,9 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
        }
        ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
        
-       ACCT_SANITY_CHECK(c, jeb);
+       jffs2_dbg_acct_sanity_check(c, jeb);
 
-       D1(ACCT_PARANOIA_CHECK(jeb));
+       jffs2_dbg_acct_paranoia_check(c, jeb);
 
        if (c->flags & JFFS2_SB_FLAG_SCANNING) {
                /* Flash scanning is in progress. Don't muck about with the block
@@ -649,164 +649,6 @@ void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
        up(&c->erase_free_sem);
 }
 
-#if CONFIG_JFFS2_FS_DEBUG >= 2
-void jffs2_dump_block_lists(struct jffs2_sb_info *c)
-{
-
-
-       printk(KERN_DEBUG "jffs2_dump_block_lists:\n");
-       printk(KERN_DEBUG "flash_size: %08x\n", c->flash_size);
-       printk(KERN_DEBUG "used_size: %08x\n", c->used_size);
-       printk(KERN_DEBUG "dirty_size: %08x\n", c->dirty_size);
-       printk(KERN_DEBUG "wasted_size: %08x\n", c->wasted_size);
-       printk(KERN_DEBUG "unchecked_size: %08x\n", c->unchecked_size);
-       printk(KERN_DEBUG "free_size: %08x\n", c->free_size);
-       printk(KERN_DEBUG "erasing_size: %08x\n", c->erasing_size);
-       printk(KERN_DEBUG "bad_size: %08x\n", c->bad_size);
-       printk(KERN_DEBUG "sector_size: %08x\n", c->sector_size);
-       printk(KERN_DEBUG "jffs2_reserved_blocks size: %08x\n",c->sector_size * c->resv_blocks_write);
-
-       if (c->nextblock) {
-               printk(KERN_DEBUG "nextblock: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n",
-                      c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->unchecked_size, c->nextblock->free_size);
-       } else {
-               printk(KERN_DEBUG "nextblock: NULL\n");
-       }
-       if (c->gcblock) {
-               printk(KERN_DEBUG "gcblock: %08x (used %08x, dirty %08x, wasted %08x, unchecked %08x, free %08x)\n",
-                      c->gcblock->offset, c->gcblock->used_size, c->gcblock->dirty_size, c->gcblock->wasted_size, c->gcblock->unchecked_size, c->gcblock->free_size);
-       } else {
-               printk(KERN_DEBUG "gcblock: NULL\n");
-       }
-       if (list_empty(&c->clean_list)) {
-               printk(KERN_DEBUG "clean_list: empty\n");
-       } else {
-               struct list_head *this;
-               int     numblocks = 0;
-               uint32_t dirty = 0;
-
-               list_for_each(this, &c->clean_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       numblocks ++;
-                       dirty += jeb->wasted_size;
-                       printk(KERN_DEBUG "clean_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);
-               }
-               printk (KERN_DEBUG "Contains %d blocks with total wasted size %u, average wasted size: %u\n", numblocks, dirty, dirty / numblocks);
-       }
-       if (list_empty(&c->very_dirty_list)) {
-               printk(KERN_DEBUG "very_dirty_list: empty\n");
-       } else {
-               struct list_head *this;
-               int     numblocks = 0;
-               uint32_t dirty = 0;
-
-               list_for_each(this, &c->very_dirty_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       numblocks ++;
-                       dirty += jeb->dirty_size;
-                       printk(KERN_DEBUG "very_dirty_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);
-               }
-               printk (KERN_DEBUG "Contains %d blocks with total dirty size %u, average dirty size: %u\n",
-                       numblocks, dirty, dirty / numblocks);
-       }
-       if (list_empty(&c->dirty_list)) {
-               printk(KERN_DEBUG "dirty_list: empty\n");
-       } else {
-               struct list_head *this;
-               int     numblocks = 0;
-               uint32_t dirty = 0;
-
-               list_for_each(this, &c->dirty_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       numblocks ++;
-                       dirty += jeb->dirty_size;
-                       printk(KERN_DEBUG "dirty_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);
-               }
-               printk (KERN_DEBUG "Contains %d blocks with total dirty size %u, average dirty size: %u\n",
-                       numblocks, dirty, dirty / numblocks);
-       }
-       if (list_empty(&c->erasable_list)) {
-               printk(KERN_DEBUG "erasable_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->erasable_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "erasable_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->erasing_list)) {
-               printk(KERN_DEBUG "erasing_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->erasing_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "erasing_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(KERN_DEBUG "erase_pending_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->erase_pending_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "erase_pending_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->erasable_pending_wbuf_list)) {
-               printk(KERN_DEBUG "erasable_pending_wbuf_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->erasable_pending_wbuf_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "erasable_pending_wbuf_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->free_list)) {
-               printk(KERN_DEBUG "free_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->free_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "free_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->bad_list)) {
-               printk(KERN_DEBUG "bad_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->bad_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "bad_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->bad_used_list)) {
-               printk(KERN_DEBUG "bad_used_list: empty\n");
-       } else {
-               struct list_head *this;
-
-               list_for_each(this, &c->bad_used_list) {
-                       struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
-                       printk(KERN_DEBUG "bad_used_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);
-               }
-       }
-}
-#endif /* CONFIG_JFFS2_FS_DEBUG */
-
 int jffs2_thread_should_wake(struct jffs2_sb_info *c)
 {
        int ret = 0;
index c7f9068..9706534 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: read.c,v 1.39 2005/03/01 10:34:03 dedekind Exp $
+ * $Id: read.c,v 1.40 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
@@ -174,7 +174,7 @@ int jffs2_read_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                        if (frag) {
                                D1(printk(KERN_NOTICE "Eep. Hole in ino #%u fraglist. frag->ofs = 0x%08x, offset = 0x%08x\n", f->inocache->ino, frag->ofs, offset));
                                holesize = min(holesize, frag->ofs - offset);
-                               D2(jffs2_print_frag_list(f));
+                               D2(jffs2_dbg_dump_fragtree(f));
                        }
                        D1(printk(KERN_DEBUG "Filling non-frag hole from %d-%d\n", offset, offset+holesize));
                        memset(buf, 0, holesize);
index 5b2a835..cf39bcf 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: readinode.c,v 1.125 2005/07/10 13:13:55 dedekind Exp $
+ * $Id: readinode.c,v 1.126 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
 
 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *list, struct jffs2_node_frag *newfrag);
 
-#if CONFIG_JFFS2_FS_DEBUG >= 2
-static void jffs2_print_fragtree(struct rb_root *list, int permitbug)
-{
-       struct jffs2_node_frag *this = frag_first(list);
-       uint32_t lastofs = 0;
-       int buggy = 0;
-
-       while(this) {
-               if (this->node)
-                       printk(KERN_DEBUG "frag %04x-%04x: 0x%08x(%d) on flash (*%p). left (%p), right (%p), parent (%p)\n",
-                              this->ofs, this->ofs+this->size, ref_offset(this->node->raw), ref_flags(this->node->raw),
-                              this, frag_left(this), frag_right(this), frag_parent(this));
-               else 
-                       printk(KERN_DEBUG "frag %04x-%04x: hole (*%p). left (%p} right (%p), parent (%p)\n", this->ofs, 
-                              this->ofs+this->size, this, frag_left(this), frag_right(this), frag_parent(this));
-               if (this->ofs != lastofs)
-                       buggy = 1;
-               lastofs = this->ofs+this->size;
-               this = frag_next(this);
-       }
-       if (buggy && !permitbug) {
-               printk(KERN_CRIT "Frag tree got a hole in it\n");
-               BUG();
-       }
-}
-
-void jffs2_print_frag_list(struct jffs2_inode_info *f)
-{
-       jffs2_print_fragtree(&f->fragtree, 0);
-
-       if (f->metadata) {
-               printk(KERN_DEBUG "metadata at 0x%08x\n", ref_offset(f->metadata->raw));
-       }
-}
-#endif
-
-#if CONFIG_JFFS2_FS_DEBUG >= 1
-static int jffs2_sanitycheck_fragtree(struct jffs2_inode_info *f)
-{
-       struct jffs2_node_frag *frag;
-       int bitched = 0;
-
-       for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
-
-               struct jffs2_full_dnode *fn = frag->node;
-               if (!fn || !fn->raw)
-                       continue;
-
-               if (ref_flags(fn->raw) == REF_PRISTINE) {
-
-                       if (fn->frags > 1) {
-                               printk(KERN_WARNING "REF_PRISTINE node at 0x%08x had %d frags. Tell dwmw2\n", ref_offset(fn->raw), fn->frags);
-                               bitched = 1;
-                       }
-                       /* A hole node which isn't multi-page should be garbage-collected
-                          and merged anyway, so we just check for the frag size here,
-                          rather than mucking around with actually reading the node
-                          and checking the compression type, which is the real way
-                          to tell a hole node. */
-                       if (frag->ofs & (PAGE_CACHE_SIZE-1) && frag_prev(frag) && frag_prev(frag)->size < PAGE_CACHE_SIZE && frag_prev(frag)->node) {
-                               printk(KERN_WARNING "REF_PRISTINE node at 0x%08x had a previous non-hole frag in the same page. Tell dwmw2\n",
-                                      ref_offset(fn->raw));
-                               bitched = 1;
-                       }
-
-                       if ((frag->ofs+frag->size) & (PAGE_CACHE_SIZE-1) && frag_next(frag) && frag_next(frag)->size < PAGE_CACHE_SIZE && frag_next(frag)->node) {
-                               printk(KERN_WARNING "REF_PRISTINE node at 0x%08x (%08x-%08x) had a following non-hole frag in the same page. Tell dwmw2\n",
-                                      ref_offset(fn->raw), frag->ofs, frag->ofs+frag->size);
-                               bitched = 1;
-                       }
-               }
-       }
-       
-       if (bitched) {
-               struct jffs2_node_frag *thisfrag;
-
-               printk(KERN_WARNING "Inode is #%u\n", f->inocache->ino);
-               thisfrag = frag_first(&f->fragtree);
-               while (thisfrag) {
-                       if (!thisfrag->node) {
-                               printk("Frag @0x%x-0x%x; node-less hole\n",
-                                      thisfrag->ofs, thisfrag->size + thisfrag->ofs);
-                       } else if (!thisfrag->node->raw) {
-                               printk("Frag @0x%x-0x%x; raw-less hole\n",
-                                      thisfrag->ofs, thisfrag->size + thisfrag->ofs);
-                       } else {
-                               printk("Frag @0x%x-0x%x; raw at 0x%08x(%d) (0x%x-0x%x)\n",
-                                      thisfrag->ofs, thisfrag->size + thisfrag->ofs,
-                                      ref_offset(thisfrag->node->raw), ref_flags(thisfrag->node->raw),
-                                      thisfrag->node->ofs, thisfrag->node->ofs+thisfrag->node->size);
-                       }
-                       thisfrag = frag_next(thisfrag);
-               }
-       }
-       return bitched;
-}
-#endif /* D1 */
-
 static void jffs2_obsolete_node_frag(struct jffs2_sb_info *c, struct jffs2_node_frag *this)
 {
        if (this->node) {
@@ -190,12 +92,8 @@ int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_in
                                mark_ref_normal(next->node->raw);
                }
        }
-       D2(if (jffs2_sanitycheck_fragtree(f)) {
-                  printk(KERN_WARNING "Just added node %04x-%04x @0x%08x on flash, newfrag *%p\n",
-                         fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag);
-                  return 0;
-          })
-       D2(jffs2_print_frag_list(f));
+       D2(jffs2_dbg_fragtree_paranoia_check(f));
+       D2(jffs2_dbg_dump_fragtree(f));
        return 0;
 }
 
@@ -582,7 +480,7 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
 
                jffs2_free_tmp_dnode_info(tn);
        }
-       D1(jffs2_sanitycheck_fragtree(f));
+       jffs2_dbg_fragtree_paranoia_check(f);
 
        if (!fn) {
                /* No data nodes for this inode. */
index b63160f..a2a51b7 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: scan.c,v 1.119 2005/02/17 17:51:13 dedekind Exp $
+ * $Id: scan.c,v 1.120 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 #include <linux/kernel.h>
@@ -130,7 +130,7 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
                if (ret < 0)
                        goto out;
 
-               ACCT_PARANOIA_CHECK(jeb);
+               jffs2_dbg_acct_paranoia_check(c, jeb);
 
                /* Now decide which list to put it on */
                switch(ret) {
@@ -370,7 +370,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
 scan_more:     
        while(ofs < jeb->offset + c->sector_size) {
 
-               D1(ACCT_PARANOIA_CHECK(jeb));
+               jffs2_dbg_acct_paranoia_check(c, jeb);
 
                cond_resched();
 
index 316133c..85ae51d 100644 (file)
@@ -9,7 +9,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: wbuf.c,v 1.92 2005/04/05 12:51:54 dedekind Exp $
+ * $Id: wbuf.c,v 1.93 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
@@ -139,7 +139,7 @@ static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock
 {
        D1(printk("About to refile bad block at %08x\n", jeb->offset));
 
-       D2(jffs2_dump_block_lists(c));
+       D2(jffs2_dbg_dump_block_lists(c));
        /* File the existing block on the bad_used_list.... */
        if (c->nextblock == jeb)
                c->nextblock = NULL;
@@ -156,7 +156,7 @@ static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock
                c->nr_erasing_blocks++;
                jffs2_erase_pending_trigger(c);
        }
-       D2(jffs2_dump_block_lists(c));
+       D2(jffs2_dbg_dump_block_lists(c));
 
        /* Adjust its size counts accordingly */
        c->wasted_size += jeb->free_size;
@@ -164,8 +164,8 @@ static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock
        jeb->wasted_size += jeb->free_size;
        jeb->free_size = 0;
 
-       ACCT_SANITY_CHECK(c,jeb);
-       D1(ACCT_PARANOIA_CHECK(jeb));
+       jffs2_dbg_acct_sanity_check(c,jeb);
+       jffs2_dbg_acct_paranoia_check(c, jeb);
 }
 
 /* Recover from failure to write wbuf. Recover the nodes up to the
@@ -392,11 +392,11 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
        else
                jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys);
 
-       ACCT_SANITY_CHECK(c,jeb);
-        D1(ACCT_PARANOIA_CHECK(jeb));
+       jffs2_dbg_acct_sanity_check(c,jeb);
+        jffs2_dbg_acct_paranoia_check(c, jeb);
 
-       ACCT_SANITY_CHECK(c,new_jeb);
-        D1(ACCT_PARANOIA_CHECK(new_jeb));
+       jffs2_dbg_acct_sanity_check(c,new_jeb);
+        jffs2_dbg_acct_paranoia_check(c, new_jeb);
 
        spin_unlock(&c->erase_completion_lock);
 
@@ -973,7 +973,7 @@ int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb
 
                if (buf[i] != 0xFF) {
                        D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
-                                 buf[page+i], page+i, jeb->offset));
+                                 buf[i], i, jeb->offset));
                        ret = 1; 
                        goto out;
                }
index 6910061..b6a53e5 100644 (file)
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: write.c,v 1.92 2005/04/13 13:22:35 dwmw2 Exp $
+ * $Id: write.c,v 1.93 2005/07/17 06:56:21 dedekind Exp $
  *
  */
 
@@ -54,34 +54,6 @@ int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint
        return 0;
 }
 
-#if CONFIG_JFFS2_FS_DEBUG > 0
-static void writecheck(struct jffs2_sb_info *c, uint32_t ofs)
-{
-       unsigned char buf[16];
-       size_t retlen;
-       int ret, i;
-
-       ret = jffs2_flash_read(c, ofs, 16, &retlen, buf);
-       if (ret || (retlen != 16)) {
-               D1(printk(KERN_DEBUG "read failed or short in writecheck(). ret %d, retlen %zd\n", ret, retlen));
-               return;
-       }
-       ret = 0;
-       for (i=0; i<16; i++) {
-               if (buf[i] != 0xff)
-                       ret = 1;
-       }
-       if (ret) {
-               printk(KERN_WARNING "ARGH. About to write node to 0x%08x on flash, but there are data already there:\n", ofs);
-               printk(KERN_WARNING "0x%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", 
-                      ofs,
-                      buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
-                      buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]);
-       }
-}
-#endif
-
-
 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, 
    write it to the flash, link it into the existing inode/fragment list */
 
@@ -106,7 +78,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
        vecs[1].iov_base = (unsigned char *)data;
        vecs[1].iov_len = datalen;
 
-       D1(writecheck(c, flash_ofs));
+       jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
 
        if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
                printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen);
@@ -177,8 +149,8 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
 
                        D1(printk(KERN_DEBUG "Retrying failed write.\n"));
                        
-                       ACCT_SANITY_CHECK(c,jeb);
-                       D1(ACCT_PARANOIA_CHECK(jeb));
+                       jffs2_dbg_acct_sanity_check(c,jeb);
+                       jffs2_dbg_acct_paranoia_check(c, jeb);
 
                        if (alloc_mode == ALLOC_GC) {
                                ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &flash_ofs, &dummy);
@@ -194,8 +166,8 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                        if (!ret) {
                                D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
 
-                               ACCT_SANITY_CHECK(c,jeb);
-                               D1(ACCT_PARANOIA_CHECK(jeb));
+                               jffs2_dbg_acct_sanity_check(c,jeb);
+                               jffs2_dbg_acct_paranoia_check(c, jeb);
 
                                goto retry;
                        }
@@ -232,7 +204,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                  je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
 
        if (retried) {
-               ACCT_SANITY_CHECK(c,NULL);
+               jffs2_dbg_acct_sanity_check(c,NULL);
        }
 
        return fn;
@@ -250,7 +222,8 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
        D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 
                  je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
                  je32_to_cpu(rd->name_crc)));
-       D1(writecheck(c, flash_ofs));
+
+       jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
 
        D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
                printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
@@ -322,8 +295,8 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
 
                        D1(printk(KERN_DEBUG "Retrying failed write.\n"));
 
-                       ACCT_SANITY_CHECK(c,jeb);
-                       D1(ACCT_PARANOIA_CHECK(jeb));
+                       jffs2_dbg_acct_sanity_check(c,jeb);
+                       jffs2_dbg_acct_paranoia_check(c, jeb);
 
                        if (alloc_mode == ALLOC_GC) {
                                ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &flash_ofs, &dummy);
@@ -338,8 +311,8 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
 
                        if (!ret) {
                                D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
-                               ACCT_SANITY_CHECK(c,jeb);
-                               D1(ACCT_PARANOIA_CHECK(jeb));
+                               jffs2_dbg_acct_sanity_check(c,jeb);
+                               jffs2_dbg_acct_paranoia_check(c, jeb);
                                goto retry;
                        }
                        D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
@@ -359,7 +332,7 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
        spin_unlock(&c->erase_completion_lock);
 
        if (retried) {
-               ACCT_SANITY_CHECK(c,NULL);
+               jffs2_dbg_acct_sanity_check(c,NULL);
        }
 
        return fd;