fs/jffs2/debug.c - LeafOS-Devices/android_kernel_realme_mt6785 - Gitiles

 /*
  * 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 */
	/*
	* 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 */