Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 730554d9 authored by Artem B. Bityutskiy's avatar Artem B. Bityutskiy Committed by Thomas Gleixner
Browse files

[JFFS2] Debug code clean up - step 1 



Move debug functions into a seperate source file

Signed-off-by: default avatarArtem B. Bityutskiy <dedekind@infradead.org>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
parent dae6227f

fs/jffs2/Makefile

+2 −2
Original line number Diff line number Diff line 
#

# 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

fs/jffs2/build.c

+3 −3
Original line number Diff line number Diff line
@@ -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);

fs/jffs2/debug.c

0 → 100644
+495 −0
Original line number Diff line number Diff line 
/*

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

fs/jffs2/debug.h

0 → 100644
+104 −0
Original line number Diff line number Diff line 
/*

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

fs/jffs2/erase.c

+3 −3
Original line number Diff line number Diff line
@@ -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--;