Eric Lee / smarc-fsl-linux-kernel

Commit e2bc322bf05936ec7160d62bc3fd45cbf4aa405a

Authored by David Woodhouse 17 years ago

Exists in master and in 39 other branches

[JFFS2] Add erase_checking_list to hold blocks being marked.

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

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

Showing 4 changed files with 25 additions and 4 deletions Inline Diff

fs/jffs2/build.c
fs/jffs2/debug.c
fs/jffs2/erase.c
fs/jffs2/jffs2_fs_sb.h

fs/jffs2/build.c

Diff comments View file @ e2bc322

 /*
  * JFFS2 -- Journalling Flash File System, Version 2.
  *
  * Copyright © 2001-2007 Red Hat, Inc.
  *
  * Created by David Woodhouse <dwmw2@infradead.org>
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
  */
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/mtd/mtd.h>
 #include "nodelist.h"
 static void jffs2_build_remove_unlinked_inode(struct jffs2_sb_info *,
 		struct jffs2_inode_cache *, struct jffs2_full_dirent **);
 static inline struct jffs2_inode_cache *
 first_inode_chain(int *i, struct jffs2_sb_info *c)
 {
 	for (; *i < INOCACHE_HASHSIZE; (*i)++) {
 		if (c->inocache_list[*i])
 			return c->inocache_list[*i];
 	}
 	return NULL;
 }
 static inline struct jffs2_inode_cache *
 next_inode(int *i, struct jffs2_inode_cache *ic, struct jffs2_sb_info *c)
 {
 	/* More in this chain? */
 	if (ic->next)
 		return ic->next;
 	(*i)++;
 	return first_inode_chain(i, c);
 }
 #define for_each_inode(i, c, ic)			\
 	for (i = 0, ic = first_inode_chain(&i, (c));	\
 	     ic;					\
 	     ic = next_inode(&i, ic, (c)))
 static void jffs2_build_inode_pass1(struct jffs2_sb_info *c,
 					struct jffs2_inode_cache *ic)
 {
 	struct jffs2_full_dirent *fd;
 	dbg_fsbuild("building directory inode #%u\n", ic->ino);
 	/* For each child, increase nlink */
 	for(fd = ic->scan_dents; fd; fd = fd->next) {
 		struct jffs2_inode_cache *child_ic;
 		if (!fd->ino)
 			continue;
 		/* we can get high latency here with huge directories */
 		child_ic = jffs2_get_ino_cache(c, fd->ino);
 		if (!child_ic) {
 			dbg_fsbuild("child \"%s\" (ino #%u) of dir ino #%u doesn't exist!\n",
 				  fd->name, fd->ino, ic->ino);
 			jffs2_mark_node_obsolete(c, fd->raw);
 			continue;
 		}
 		if (child_ic->nlink++ && fd->type == DT_DIR) {
 			JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u appears to be a hard link\n",
 				fd->name, fd->ino, ic->ino);
 			/* TODO: What do we do about it? */
 		}
 		dbg_fsbuild("increased nlink for child \"%s\" (ino #%u)\n", fd->name, fd->ino);
 		/* Can't free scan_dents so far. We might need them in pass 2 */
 	}
 }
 /* Scan plan:
  - Scan physical nodes. Build map of inodes/dirents. Allocate inocaches as we go
  - Scan directory tree from top down, setting nlink in inocaches
  - Scan inocaches for inodes with nlink==0
 */
 static int jffs2_build_filesystem(struct jffs2_sb_info *c)
 {
 	int ret;
 	int i;
 	struct jffs2_inode_cache *ic;
 	struct jffs2_full_dirent *fd;
 	struct jffs2_full_dirent *dead_fds = NULL;
 	dbg_fsbuild("build FS data structures\n");
 	/* First, scan the medium and build all the inode caches with
 	   lists of physical nodes */
 	c->flags |= JFFS2_SB_FLAG_SCANNING;
 	ret = jffs2_scan_medium(c);
 	c->flags &= ~JFFS2_SB_FLAG_SCANNING;
 	if (ret)
 		goto exit;
 	dbg_fsbuild("scanned flash completely\n");
 	jffs2_dbg_dump_block_lists_nolock(c);
 	dbg_fsbuild("pass 1 starting\n");
 	c->flags |= JFFS2_SB_FLAG_BUILDING;
 	/* Now scan the directory tree, increasing nlink according to every dirent found. */
 	for_each_inode(i, c, ic) {
 		if (ic->scan_dents) {
 			jffs2_build_inode_pass1(c, ic);
 			cond_resched();
 		}
 	}
 	dbg_fsbuild("pass 1 complete\n");
 	/* Next, scan for inodes with nlink == 0 and remove them. If
 	   they were directories, then decrement the nlink of their
 	   children too, and repeat the scan. As that's going to be
 	   a fairly uncommon occurrence, it's not so evil to do it this
 	   way. Recursion bad. */
 	dbg_fsbuild("pass 2 starting\n");
 	for_each_inode(i, c, ic) {
 		if (ic->nlink)
 			continue;
 		jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
 		cond_resched();
 	}
 	dbg_fsbuild("pass 2a starting\n");
 	while (dead_fds) {
 		fd = dead_fds;
 		dead_fds = fd->next;
 		ic = jffs2_get_ino_cache(c, fd->ino);
 		if (ic)
 			jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
 		jffs2_free_full_dirent(fd);
 	}
 	dbg_fsbuild("pass 2a complete\n");
 	dbg_fsbuild("freeing temporary data structures\n");
 	/* Finally, we can scan again and free the dirent structs */
 	for_each_inode(i, c, ic) {
 		while(ic->scan_dents) {
 			fd = ic->scan_dents;
 			ic->scan_dents = fd->next;
 			jffs2_free_full_dirent(fd);
 		}
 		ic->scan_dents = NULL;
 		cond_resched();
 	}
 	jffs2_build_xattr_subsystem(c);
 	c->flags &= ~JFFS2_SB_FLAG_BUILDING;
 	dbg_fsbuild("FS build complete\n");
 	/* Rotate the lists by some number to ensure wear levelling */
 	jffs2_rotate_lists(c);
 	ret = 0;
 exit:
 	if (ret) {
 		for_each_inode(i, c, ic) {
 			while(ic->scan_dents) {
 				fd = ic->scan_dents;
 				ic->scan_dents = fd->next;
 				jffs2_free_full_dirent(fd);
 			}
 		}
 		jffs2_clear_xattr_subsystem(c);
 	}
 	return ret;
 }
 static void jffs2_build_remove_unlinked_inode(struct jffs2_sb_info *c,
 					struct jffs2_inode_cache *ic,
 					struct jffs2_full_dirent **dead_fds)
 {
 	struct jffs2_raw_node_ref *raw;
 	struct jffs2_full_dirent *fd;
 	dbg_fsbuild("removing ino #%u with nlink == zero.\n", ic->ino);
 	raw = ic->nodes;
 	while (raw != (void *)ic) {
 		struct jffs2_raw_node_ref *next = raw->next_in_ino;
 		dbg_fsbuild("obsoleting node at 0x%08x\n", ref_offset(raw));
 		jffs2_mark_node_obsolete(c, raw);
 		raw = next;
 	}
 	if (ic->scan_dents) {
 		int whinged = 0;
 		dbg_fsbuild("inode #%u was a directory which may have children...\n", ic->ino);
 		while(ic->scan_dents) {
 			struct jffs2_inode_cache *child_ic;
 			fd = ic->scan_dents;
 			ic->scan_dents = fd->next;
 			if (!fd->ino) {
 				/* It's a deletion dirent. Ignore it */
 				dbg_fsbuild("child \"%s\" is a deletion dirent, skipping...\n", fd->name);
 				jffs2_free_full_dirent(fd);
 				continue;
 			}
 			if (!whinged)
 				whinged = 1;
 			dbg_fsbuild("removing child \"%s\", ino #%u\n", fd->name, fd->ino);
 			child_ic = jffs2_get_ino_cache(c, fd->ino);
 			if (!child_ic) {
 				dbg_fsbuild("cannot remove child \"%s\", ino #%u, because it doesn't exist\n",
 						fd->name, fd->ino);
 				jffs2_free_full_dirent(fd);
 				continue;
 			}
 			/* Reduce nlink of the child. If it's now zero, stick it on the
 			   dead_fds list to be cleaned up later. Else just free the fd */
 			child_ic->nlink--;
 			if (!child_ic->nlink) {
 				dbg_fsbuild("inode #%u (\"%s\") has now got zero nlink, adding to dead_fds list.\n",
 					  fd->ino, fd->name);
 				fd->next = *dead_fds;
 				*dead_fds = fd;
 			} else {
 				dbg_fsbuild("inode #%u (\"%s\") has now got nlink %d. Ignoring.\n",
 					  fd->ino, fd->name, child_ic->nlink);
 				jffs2_free_full_dirent(fd);
 			}
 		}
 	}
 	/*
 	   We don't delete the inocache from the hash list and free it yet.
 	   The erase code will do that, when all the nodes are completely gone.
 	*/
 }
 static void jffs2_calc_trigger_levels(struct jffs2_sb_info *c)
 {
 	uint32_t size;
 	/* Deletion should almost _always_ be allowed. We're fairly
 	   buggered once we stop allowing people to delete stuff
 	   because there's not enough free space... */
 	c->resv_blocks_deletion = 2;
 	/* Be conservative about how much space we need before we allow writes.
 	   On top of that which is required for deletia, require an extra 2%
 	   of the medium to be available, for overhead caused by nodes being
 	   split across blocks, etc. */
 	size = c->flash_size / 50; /* 2% of flash size */
 	size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */
 	size += c->sector_size - 1; /* ... and round up */
 	c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
 	/* When do we let the GC thread run in the background */
 	c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
 	/* When do we allow garbage collection to merge nodes to make
 	   long-term progress at the expense of short-term space exhaustion? */
 	c->resv_blocks_gcmerge = c->resv_blocks_deletion + 1;
 	/* When do we allow garbage collection to eat from bad blocks rather
 	   than actually making progress? */
 	c->resv_blocks_gcbad = 0;//c->resv_blocks_deletion + 2;
 	/* What number of 'very dirty' eraseblocks do we allow before we
 	   trigger the GC thread even if we don't _need_ the space. When we
 	   can't mark nodes obsolete on the medium, the old dirty nodes cause
 	   performance problems because we have to inspect and discard them. */
 	c->vdirty_blocks_gctrigger = c->resv_blocks_gctrigger;
 	if (jffs2_can_mark_obsolete(c))
 		c->vdirty_blocks_gctrigger *= 10;
 	/* If there's less than this amount of dirty space, don't bother
 	   trying to GC to make more space. It'll be a fruitless task */
 	c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
 	dbg_fsbuild("JFFS2 trigger levels (size %d KiB, block size %d KiB, %d blocks)\n",
 		  c->flash_size / 1024, c->sector_size / 1024, c->nr_blocks);
 	dbg_fsbuild("Blocks required to allow deletion:    %d (%d KiB)\n",
 		  c->resv_blocks_deletion, c->resv_blocks_deletion*c->sector_size/1024);
 	dbg_fsbuild("Blocks required to allow writes:      %d (%d KiB)\n",
 		  c->resv_blocks_write, c->resv_blocks_write*c->sector_size/1024);
 	dbg_fsbuild("Blocks required to quiesce GC thread: %d (%d KiB)\n",
 		  c->resv_blocks_gctrigger, c->resv_blocks_gctrigger*c->sector_size/1024);
 	dbg_fsbuild("Blocks required to allow GC merges:   %d (%d KiB)\n",
 		  c->resv_blocks_gcmerge, c->resv_blocks_gcmerge*c->sector_size/1024);
 	dbg_fsbuild("Blocks required to GC bad blocks:     %d (%d KiB)\n",
 		  c->resv_blocks_gcbad, c->resv_blocks_gcbad*c->sector_size/1024);
 	dbg_fsbuild("Amount of dirty space required to GC: %d bytes\n",
 		  c->nospc_dirty_size);
 	dbg_fsbuild("Very dirty blocks before GC triggered: %d\n",
 		  c->vdirty_blocks_gctrigger);
 }
 int jffs2_do_mount_fs(struct jffs2_sb_info *c)
 {
 	int ret;
 	int i;
 	int size;
 	c->free_size = c->flash_size;
 	c->nr_blocks = c->flash_size / c->sector_size;
 	size = sizeof(struct jffs2_eraseblock) * c->nr_blocks;
 #ifndef __ECOS
 	if (jffs2_blocks_use_vmalloc(c))
 		c->blocks = vmalloc(size);
 	else
 #endif
 		c->blocks = kmalloc(size, GFP_KERNEL);
 	if (!c->blocks)
 		return -ENOMEM;
 	memset(c->blocks, 0, size);
 	for (i=0; i<c->nr_blocks; i++) {
 		INIT_LIST_HEAD(&c->blocks[i].list);
 		c->blocks[i].offset = i * c->sector_size;
 		c->blocks[i].free_size = c->sector_size;
 	}
 	INIT_LIST_HEAD(&c->clean_list);
 	INIT_LIST_HEAD(&c->very_dirty_list);
 	INIT_LIST_HEAD(&c->dirty_list);
 	INIT_LIST_HEAD(&c->erasable_list);
 	INIT_LIST_HEAD(&c->erasing_list);
+	INIT_LIST_HEAD(&c->erase_checking_list);
 	INIT_LIST_HEAD(&c->erase_pending_list);
 	INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
 	INIT_LIST_HEAD(&c->erase_complete_list);
 	INIT_LIST_HEAD(&c->free_list);
 	INIT_LIST_HEAD(&c->bad_list);
 	INIT_LIST_HEAD(&c->bad_used_list);
 	c->highest_ino = 1;
 	c->summary = NULL;
 	ret = jffs2_sum_init(c);
 	if (ret)
 		goto out_free;
 	if (jffs2_build_filesystem(c)) {
 		dbg_fsbuild("build_fs failed\n");
 		jffs2_free_ino_caches(c);
 		jffs2_free_raw_node_refs(c);
 		ret = -EIO;
 		goto out_free;
 	}
 	jffs2_calc_trigger_levels(c);
 	return 0;
  out_free:
 #ifndef __ECOS
 	if (jffs2_blocks_use_vmalloc(c))
 		vfree(c->blocks);
 	else
 #endif
 		kfree(c->blocks);
 	return ret;
 }

fs/jffs2/debug.c

Diff comments View file @ e2bc322

 /*
  * JFFS2 -- Journalling Flash File System, Version 2.
  *
  * Copyright © 2001-2007 Red Hat, Inc.
  *
  * Created by David Woodhouse <dwmw2@infradead.org>
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
  */
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/pagemap.h>
 #include <linux/crc32.h>
 #include <linux/jffs2.h>
 #include <linux/mtd/mtd.h>
 #include "nodelist.h"
 #include "debug.h"
 #ifdef JFFS2_DBG_SANITY_CHECKS
 void
 __jffs2_dbg_acct_sanity_check_nolock(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)) {
 		JFFS2_ERROR("eeep, space accounting for block at 0x%08x is screwed.\n", jeb->offset);
 		JFFS2_ERROR("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)) {
 		JFFS2_ERROR("eeep, space accounting superblock info is screwed.\n");
 		JFFS2_ERROR("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();
 	}
 }
 void
 __jffs2_dbg_acct_sanity_check(struct jffs2_sb_info *c,
 			      struct jffs2_eraseblock *jeb)
 {
 	spin_lock(&c->erase_completion_lock);
 	jffs2_dbg_acct_sanity_check_nolock(c, jeb);
 	spin_unlock(&c->erase_completion_lock);
 }
 #endif /* JFFS2_DBG_SANITY_CHECKS */
 #ifdef JFFS2_DBG_PARANOIA_CHECKS
 /*
  * Check the fragtree.
  */
 void
 __jffs2_dbg_fragtree_paranoia_check(struct jffs2_inode_info *f)
 {
 	mutex_lock(&f->sem);
 	__jffs2_dbg_fragtree_paranoia_check_nolock(f);
 	mutex_unlock(&f->sem);
 }
 void
 __jffs2_dbg_fragtree_paranoia_check_nolock(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) {
 				JFFS2_ERROR("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) {
 				JFFS2_ERROR("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) {
 				JFFS2_ERROR("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) {
 		JFFS2_ERROR("fragtree is corrupted.\n");
 		__jffs2_dbg_dump_fragtree_nolock(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)) {
 		JFFS2_WARNING("read %d bytes failed or short. ret %d, retlen %zd.\n",
 				len, ret, retlen);
 		kfree(buf);
 		return;
 	}
 	ret = 0;
 	for (i = 0; i < len; i++)
 		if (buf[i] != 0xff)
 			ret = 1;
 	if (ret) {
 		JFFS2_ERROR("argh, about to write node to %#08x on flash, but there are data already there. The first corrupted byte is at %#08x offset.\n",
 			ofs, ofs + i);
 		__jffs2_dbg_dump_buffer(buf, len, ofs);
 		kfree(buf);
 		BUG();
 	}
 	kfree(buf);
 }
 void __jffs2_dbg_superblock_counts(struct jffs2_sb_info *c)
 {
 	struct jffs2_eraseblock *jeb;
 	uint32_t free = 0, dirty = 0, used = 0, wasted = 0,
 		erasing = 0, bad = 0, unchecked = 0;
 	int nr_counted = 0;
 	int dump = 0;
 	if (c->gcblock) {
 		nr_counted++;
 		free += c->gcblock->free_size;
 		dirty += c->gcblock->dirty_size;
 		used += c->gcblock->used_size;
 		wasted += c->gcblock->wasted_size;
 		unchecked += c->gcblock->unchecked_size;
 	}
 	if (c->nextblock) {
 		nr_counted++;
 		free += c->nextblock->free_size;
 		dirty += c->nextblock->dirty_size;
 		used += c->nextblock->used_size;
 		wasted += c->nextblock->wasted_size;
 		unchecked += c->nextblock->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->clean_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->very_dirty_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->dirty_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->erasable_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->erasable_pending_wbuf_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->erase_pending_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->free_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->bad_used_list, list) {
 		nr_counted++;
 		free += jeb->free_size;
 		dirty += jeb->dirty_size;
 		used += jeb->used_size;
 		wasted += jeb->wasted_size;
 		unchecked += jeb->unchecked_size;
 	}
 	list_for_each_entry(jeb, &c->erasing_list, list) {
 		nr_counted++;
 		erasing += c->sector_size;
 	}
+	list_for_each_entry(jeb, &c->erase_checking_list, list) {
+		nr_counted++;
+		erasing += c->sector_size;
+	}
 	list_for_each_entry(jeb, &c->erase_complete_list, list) {
 		nr_counted++;
 		erasing += c->sector_size;
 	}
 	list_for_each_entry(jeb, &c->bad_list, list) {
 		nr_counted++;
 		bad += c->sector_size;
 	}
 #define check(sz) \
 	if (sz != c->sz##_size) {			\
 		printk(KERN_WARNING #sz "_size mismatch counted 0x%x, c->" #sz "_size 0x%x\n", \
 		       sz, c->sz##_size);		\
 		dump = 1;				\
 	}
 	check(free);
 	check(dirty);
 	check(used);
 	check(wasted);
 	check(unchecked);
 	check(bad);
 	check(erasing);
 #undef check
 	if (nr_counted != c->nr_blocks) {
 		printk(KERN_WARNING "%s counted only 0x%x blocks of 0x%x. Where are the others?\n",
 		       __func__, nr_counted, c->nr_blocks);
 		dump = 1;
 	}
 	if (dump) {
 		__jffs2_dbg_dump_block_lists_nolock(c);
 		BUG();
 	}
 }
 /*
  * 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)
 {
 	spin_lock(&c->erase_completion_lock);
 	__jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 	spin_unlock(&c->erase_completion_lock);
 }
 void
 __jffs2_dbg_acct_paranoia_check_nolock(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 (ref_offset(ref2) < jeb->offset ||
 				ref_offset(ref2) > jeb->offset + c->sector_size) {
 			JFFS2_ERROR("node_ref %#08x shouldn't be in block at %#08x.\n",
 				ref_offset(ref2), jeb->offset);
 			goto error;
 		}
 		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 ((!ref_next(ref2)) != (ref2 == jeb->last_node)) {
 			JFFS2_ERROR("node_ref for node at %#08x (mem %p) has next at %#08x (mem %p), last_node is at %#08x (mem %p).\n",
 				    ref_offset(ref2), ref2, ref_offset(ref_next(ref2)), ref_next(ref2),
 				    ref_offset(jeb->last_node), jeb->last_node);
 			goto error;
 		}
 		ref2 = ref_next(ref2);
 	}
 	if (my_used_size != jeb->used_size) {
 		JFFS2_ERROR("Calculated used size %#08x != stored used size %#08x.\n",
 			my_used_size, jeb->used_size);
 		goto error;
 	}
 	if (my_unchecked_size != jeb->unchecked_size) {
 		JFFS2_ERROR("Calculated unchecked size %#08x != stored unchecked size %#08x.\n",
 			my_unchecked_size, jeb->unchecked_size);
 		goto error;
 	}
 #if 0
 	/* This should work when we implement ref->__totlen elemination */
 	if (my_dirty_size != jeb->dirty_size + jeb->wasted_size) {
 		JFFS2_ERROR("Calculated dirty+wasted size %#08x != stored dirty + wasted size %#08x\n",
 			my_dirty_size, jeb->dirty_size + jeb->wasted_size);
 		goto error;
 	}
 	if (jeb->free_size == 0
 		&& my_used_size + my_unchecked_size + my_dirty_size != c->sector_size) {
 		JFFS2_ERROR("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);
 		goto error;
 	}
 #endif
 	if (!(c->flags & (JFFS2_SB_FLAG_BUILDING|JFFS2_SB_FLAG_SCANNING)))
 		__jffs2_dbg_superblock_counts(c);
 	return;
 error:
 	__jffs2_dbg_dump_node_refs_nolock(c, jeb);
 	__jffs2_dbg_dump_jeb_nolock(jeb);
 	__jffs2_dbg_dump_block_lists_nolock(c);
 	BUG();
 }
 #endif /* JFFS2_DBG_PARANOIA_CHECKS */
 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
 /*
  * Dump the node_refs of the 'jeb' JFFS2 eraseblock.
  */
 void
 __jffs2_dbg_dump_node_refs(struct jffs2_sb_info *c,
 			   struct jffs2_eraseblock *jeb)
 {
 	spin_lock(&c->erase_completion_lock);
 	__jffs2_dbg_dump_node_refs_nolock(c, jeb);
 	spin_unlock(&c->erase_completion_lock);
 }
 void
 __jffs2_dbg_dump_node_refs_nolock(struct jffs2_sb_info *c,
 				  struct jffs2_eraseblock *jeb)
 {
 	struct jffs2_raw_node_ref *ref;
 	int i = 0;
 	printk(JFFS2_DBG_MSG_PREFIX " Dump node_refs of the eraseblock %#08x\n", jeb->offset);
 	if (!jeb->first_node) {
 		printk(JFFS2_DBG_MSG_PREFIX " no nodes in the eraseblock %#08x\n", jeb->offset);
 		return;
 	}
 	printk(JFFS2_DBG);
 	for (ref = jeb->first_node; ; ref = ref_next(ref)) {
 		printk("%#08x", ref_offset(ref));
 #ifdef TEST_TOTLEN
 		printk("(%x)", ref->__totlen);
 #endif
 		if (ref_next(ref))
 			printk("->");
 		else
 			break;
 		if (++i == 4) {
 			i = 0;
 			printk("\n" JFFS2_DBG);
 		}
 	}
 	printk("\n");
 }
 /*
  * Dump an eraseblock's space accounting.
  */
 void
 __jffs2_dbg_dump_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 {
 	spin_lock(&c->erase_completion_lock);
 	__jffs2_dbg_dump_jeb_nolock(jeb);
 	spin_unlock(&c->erase_completion_lock);
 }
 void
 __jffs2_dbg_dump_jeb_nolock(struct jffs2_eraseblock *jeb)
 {
 	if (!jeb)
 		return;
 	printk(JFFS2_DBG_MSG_PREFIX " dump space accounting for the eraseblock at %#08x:\n",
 			jeb->offset);
 	printk(JFFS2_DBG "used_size: %#08x\n",		jeb->used_size);
 	printk(JFFS2_DBG "dirty_size: %#08x\n",		jeb->dirty_size);
 	printk(JFFS2_DBG "wasted_size: %#08x\n",	jeb->wasted_size);
 	printk(JFFS2_DBG "unchecked_size: %#08x\n",	jeb->unchecked_size);
 	printk(JFFS2_DBG "free_size: %#08x\n",		jeb->free_size);
 }
 void
 __jffs2_dbg_dump_block_lists(struct jffs2_sb_info *c)
 {
 	spin_lock(&c->erase_completion_lock);
 	__jffs2_dbg_dump_block_lists_nolock(c);
 	spin_unlock(&c->erase_completion_lock);
 }
 void
 __jffs2_dbg_dump_block_lists_nolock(struct jffs2_sb_info *c)
 {
 	printk(JFFS2_DBG_MSG_PREFIX " dump JFFS2 blocks lists:\n");
 	printk(JFFS2_DBG "flash_size: %#08x\n",		c->flash_size);
 	printk(JFFS2_DBG "used_size: %#08x\n",		c->used_size);
 	printk(JFFS2_DBG "dirty_size: %#08x\n",		c->dirty_size);
 	printk(JFFS2_DBG "wasted_size: %#08x\n",	c->wasted_size);
 	printk(JFFS2_DBG "unchecked_size: %#08x\n",	c->unchecked_size);
 	printk(JFFS2_DBG "free_size: %#08x\n",		c->free_size);
 	printk(JFFS2_DBG "erasing_size: %#08x\n",	c->erasing_size);
 	printk(JFFS2_DBG "bad_size: %#08x\n",		c->bad_size);
 	printk(JFFS2_DBG "sector_size: %#08x\n",	c->sector_size);
 	printk(JFFS2_DBG "jffs2_reserved_blocks size: %#08x\n",
 				c->sector_size * c->resv_blocks_write);
 	if (c->nextblock)
 		printk(JFFS2_DBG "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(JFFS2_DBG "nextblock: NULL\n");
 	if (c->gcblock)
 		printk(JFFS2_DBG "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(JFFS2_DBG "gcblock: NULL\n");
 	if (list_empty(&c->clean_list)) {
 		printk(JFFS2_DBG "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(JFFS2_DBG "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 (JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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 (JFFS2_DBG "Contains %d blocks with total dirty size %u, average dirty size: %u\n",
 			numblocks, dirty, dirty / numblocks);
 	}
 	if (list_empty(&c->dirty_list)) {
 		printk(JFFS2_DBG "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(JFFS2_DBG "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 (JFFS2_DBG "contains %d blocks with total dirty size %u, average dirty size: %u\n",
 			numblocks, dirty, dirty / numblocks);
 	}
 	if (list_empty(&c->erasable_list)) {
 		printk(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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_checking_list)) {
+		printk(JFFS2_DBG "erase_checking_list: empty\n");
+	} else {
+		struct list_head *this;
+		list_for_each(this, &c->erase_checking_list) {
+			struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
+			if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
+				printk(JFFS2_DBG "erase_checking_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 					jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 					jeb->unchecked_size, jeb->free_size);
 			}
 		}
 	}
 	if (list_empty(&c->erase_pending_list)) {
 		printk(JFFS2_DBG "erase_pending_list: empty\n");
 	} 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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "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)
 {
 	mutex_lock(&f->sem);
 	jffs2_dbg_dump_fragtree_nolock(f);
 	mutex_unlock(&f->sem);
 }
 void
 __jffs2_dbg_dump_fragtree_nolock(struct jffs2_inode_info *f)
 {
 	struct jffs2_node_frag *this = frag_first(&f->fragtree);
 	uint32_t lastofs = 0;
 	int buggy = 0;
 	printk(JFFS2_DBG_MSG_PREFIX " dump fragtree of ino #%u\n", f->inocache->ino);
 	while(this) {
 		if (this->node)
 			printk(JFFS2_DBG "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(JFFS2_DBG "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(JFFS2_DBG "metadata at 0x%08x\n", ref_offset(f->metadata->raw));
 	if (buggy) {
 		JFFS2_ERROR("frag tree got a hole in it.\n");
 		BUG();
 	}
 }
 #define JFFS2_BUFDUMP_BYTES_PER_LINE	32
 void
 __jffs2_dbg_dump_buffer(unsigned char *buf, int len, uint32_t offs)
 {
 	int skip;
 	int i;
 	printk(JFFS2_DBG_MSG_PREFIX " dump from offset %#08x to offset %#08x (%x bytes).\n",
 		offs, offs + len, len);
 	i = skip = offs % JFFS2_BUFDUMP_BYTES_PER_LINE;
 	offs = offs & ~(JFFS2_BUFDUMP_BYTES_PER_LINE - 1);
 	if (skip != 0)
 		printk(JFFS2_DBG "%#08x: ", offs);
 	while (skip--)
 		printk("   ");
 	while (i < len) {
 		if ((i % JFFS2_BUFDUMP_BYTES_PER_LINE) == 0 && i != len -1) {
 			if (i != 0)
 				printk("\n");
 			offs += JFFS2_BUFDUMP_BYTES_PER_LINE;
 			printk(JFFS2_DBG "%0#8x: ", offs);
 		}
 		printk("%02x ", buf[i]);
 		i += 1;
 	}
 	printk("\n");
 }
 /*
  * Dump a JFFS2 node.
  */
 void
 __jffs2_dbg_dump_node(struct jffs2_sb_info *c, uint32_t ofs)
 {
 	union jffs2_node_union node;
 	int len = sizeof(union jffs2_node_union);
 	size_t retlen;
 	uint32_t crc;
 	int ret;
 	printk(JFFS2_DBG_MSG_PREFIX " dump node at offset %#08x.\n", ofs);
 	ret = jffs2_flash_read(c, ofs, len, &retlen, (unsigned char *)&node);
 	if (ret || (retlen != len)) {
 		JFFS2_ERROR("read %d bytes failed or short. ret %d, retlen %zd.\n",
 			len, ret, retlen);
 		return;
 	}
 	printk(JFFS2_DBG "magic:\t%#04x\n", je16_to_cpu(node.u.magic));
 	printk(JFFS2_DBG "nodetype:\t%#04x\n", je16_to_cpu(node.u.nodetype));
 	printk(JFFS2_DBG "totlen:\t%#08x\n", je32_to_cpu(node.u.totlen));
 	printk(JFFS2_DBG "hdr_crc:\t%#08x\n", je32_to_cpu(node.u.hdr_crc));
 	crc = crc32(0, &node.u, sizeof(node.u) - 4);
 	if (crc != je32_to_cpu(node.u.hdr_crc)) {
 		JFFS2_ERROR("wrong common header CRC.\n");
 		return;
 	}
 	if (je16_to_cpu(node.u.magic) != JFFS2_MAGIC_BITMASK &&
 		je16_to_cpu(node.u.magic) != JFFS2_OLD_MAGIC_BITMASK)
 	{
 		JFFS2_ERROR("wrong node magic: %#04x instead of %#04x.\n",
 			je16_to_cpu(node.u.magic), JFFS2_MAGIC_BITMASK);
 		return;
 	}
 	switch(je16_to_cpu(node.u.nodetype)) {
 	case JFFS2_NODETYPE_INODE:
 		printk(JFFS2_DBG "the node is inode node\n");
 		printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.i.ino));
 		printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.i.version));
 		printk(JFFS2_DBG "mode:\t%#08x\n", node.i.mode.m);
 		printk(JFFS2_DBG "uid:\t%#04x\n", je16_to_cpu(node.i.uid));
 		printk(JFFS2_DBG "gid:\t%#04x\n", je16_to_cpu(node.i.gid));
 		printk(JFFS2_DBG "isize:\t%#08x\n", je32_to_cpu(node.i.isize));
 		printk(JFFS2_DBG "atime:\t%#08x\n", je32_to_cpu(node.i.atime));
 		printk(JFFS2_DBG "mtime:\t%#08x\n", je32_to_cpu(node.i.mtime));
 		printk(JFFS2_DBG "ctime:\t%#08x\n", je32_to_cpu(node.i.ctime));
 		printk(JFFS2_DBG "offset:\t%#08x\n", je32_to_cpu(node.i.offset));
 		printk(JFFS2_DBG "csize:\t%#08x\n", je32_to_cpu(node.i.csize));
 		printk(JFFS2_DBG "dsize:\t%#08x\n", je32_to_cpu(node.i.dsize));
 		printk(JFFS2_DBG "compr:\t%#02x\n", node.i.compr);
 		printk(JFFS2_DBG "usercompr:\t%#02x\n", node.i.usercompr);
 		printk(JFFS2_DBG "flags:\t%#04x\n", je16_to_cpu(node.i.flags));
 		printk(JFFS2_DBG "data_crc:\t%#08x\n", je32_to_cpu(node.i.data_crc));
 		printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.i.node_crc));
 		crc = crc32(0, &node.i, sizeof(node.i) - 8);
 		if (crc != je32_to_cpu(node.i.node_crc)) {
 			JFFS2_ERROR("wrong node header CRC.\n");
 			return;
 		}
 		break;
 	case JFFS2_NODETYPE_DIRENT:
 		printk(JFFS2_DBG "the node is dirent node\n");
 		printk(JFFS2_DBG "pino:\t%#08x\n", je32_to_cpu(node.d.pino));
 		printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.d.version));
 		printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.d.ino));
 		printk(JFFS2_DBG "mctime:\t%#08x\n", je32_to_cpu(node.d.mctime));
 		printk(JFFS2_DBG "nsize:\t%#02x\n", node.d.nsize);
 		printk(JFFS2_DBG "type:\t%#02x\n", node.d.type);
 		printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.d.node_crc));
 		printk(JFFS2_DBG "name_crc:\t%#08x\n", je32_to_cpu(node.d.name_crc));
 		node.d.name[node.d.nsize] = '\0';
 		printk(JFFS2_DBG "name:\t\"%s\"\n", node.d.name);
 		crc = crc32(0, &node.d, sizeof(node.d) - 8);
 		if (crc != je32_to_cpu(node.d.node_crc)) {
 			JFFS2_ERROR("wrong node header CRC.\n");
 			return;
 		}
 		break;
 	default:
 		printk(JFFS2_DBG "node type is unknown\n");
 		break;
 	}
 }
 #endif /* JFFS2_DBG_DUMPS || JFFS2_DBG_PARANOIA_CHECKS */

fs/jffs2/erase.c

Diff comments View file @ e2bc322

1	/*	1	/*
2	* JFFS2 -- Journalling Flash File System, Version 2.	2	* JFFS2 -- Journalling Flash File System, Version 2.
3	*	3	*
4	* Copyright © 2001-2007 Red Hat, Inc.	4	* Copyright © 2001-2007 Red Hat, Inc.
5	*	5	*
6	* Created by David Woodhouse <dwmw2@infradead.org>	6	* Created by David Woodhouse <dwmw2@infradead.org>
7	*	7	*
8	* For licensing information, see the file 'LICENCE' in this directory.	8	* For licensing information, see the file 'LICENCE' in this directory.
9	*	9	*
10	*/	10	*/
11		11
12	#include <linux/kernel.h>	12	#include <linux/kernel.h>
13	#include <linux/slab.h>	13	#include <linux/slab.h>
14	#include <linux/mtd/mtd.h>	14	#include <linux/mtd/mtd.h>
15	#include <linux/compiler.h>	15	#include <linux/compiler.h>
16	#include <linux/crc32.h>	16	#include <linux/crc32.h>
17	#include <linux/sched.h>	17	#include <linux/sched.h>
18	#include <linux/pagemap.h>	18	#include <linux/pagemap.h>
19	#include "nodelist.h"	19	#include "nodelist.h"
20		20
21	struct erase_priv_struct {	21	struct erase_priv_struct {
22	struct jffs2_eraseblock *jeb;	22	struct jffs2_eraseblock *jeb;
23	struct jffs2_sb_info *c;	23	struct jffs2_sb_info *c;
24	};	24	};
25		25
26	#ifndef __ECOS	26	#ifndef __ECOS
27	static void jffs2_erase_callback(struct erase_info *);	27	static void jffs2_erase_callback(struct erase_info *);
28	#endif	28	#endif
29	static void jffs2_erase_failed(struct jffs2_sb_info c, struct jffs2_eraseblock jeb, uint32_t bad_offset);	29	static void jffs2_erase_failed(struct jffs2_sb_info c, struct jffs2_eraseblock jeb, uint32_t bad_offset);
30	static void jffs2_erase_succeeded(struct jffs2_sb_info c, struct jffs2_eraseblock jeb);	30	static void jffs2_erase_succeeded(struct jffs2_sb_info c, struct jffs2_eraseblock jeb);
31	static void jffs2_mark_erased_block(struct jffs2_sb_info c, struct jffs2_eraseblock jeb);	31	static void jffs2_mark_erased_block(struct jffs2_sb_info c, struct jffs2_eraseblock jeb);
32		32
33	static void jffs2_erase_block(struct jffs2_sb_info *c,	33	static void jffs2_erase_block(struct jffs2_sb_info *c,
34	struct jffs2_eraseblock *jeb)	34	struct jffs2_eraseblock *jeb)
35	{	35	{
36	int ret;	36	int ret;
37	uint32_t bad_offset;	37	uint32_t bad_offset;
38	#ifdef __ECOS	38	#ifdef __ECOS
39	ret = jffs2_flash_erase(c, jeb);	39	ret = jffs2_flash_erase(c, jeb);
40	if (!ret) {	40	if (!ret) {
41	jffs2_erase_succeeded(c, jeb);	41	jffs2_erase_succeeded(c, jeb);
42	return;	42	return;
43	}	43	}
44	bad_offset = jeb->offset;	44	bad_offset = jeb->offset;
45	#else /* Linux */	45	#else /* Linux */
46	struct erase_info *instr;	46	struct erase_info *instr;
47		47
48	D1(printk(KERN_DEBUG "jffs2_erase_block(): erase block %#08x (range %#08x-%#08x)\n",	48	D1(printk(KERN_DEBUG "jffs2_erase_block(): erase block %#08x (range %#08x-%#08x)\n",
49	jeb->offset, jeb->offset, jeb->offset + c->sector_size));	49	jeb->offset, jeb->offset, jeb->offset + c->sector_size));
50	instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);	50	instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);
51	if (!instr) {	51	if (!instr) {
52	printk(KERN_WARNING "kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n");	52	printk(KERN_WARNING "kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n");
53	mutex_lock(&c->erase_free_sem);	53	mutex_lock(&c->erase_free_sem);
54	spin_lock(&c->erase_completion_lock);	54	spin_lock(&c->erase_completion_lock);
55	list_move(&jeb->list, &c->erase_pending_list);	55	list_move(&jeb->list, &c->erase_pending_list);
56	c->erasing_size -= c->sector_size;	56	c->erasing_size -= c->sector_size;
57	c->dirty_size += c->sector_size;	57	c->dirty_size += c->sector_size;
58	jeb->dirty_size = c->sector_size;	58	jeb->dirty_size = c->sector_size;
59	spin_unlock(&c->erase_completion_lock);	59	spin_unlock(&c->erase_completion_lock);
60	mutex_unlock(&c->erase_free_sem);	60	mutex_unlock(&c->erase_free_sem);
61	return;	61	return;
62	}	62	}
63		63
64	memset(instr, 0, sizeof(*instr));	64	memset(instr, 0, sizeof(*instr));
65		65
66	instr->mtd = c->mtd;	66	instr->mtd = c->mtd;
67	instr->addr = jeb->offset;	67	instr->addr = jeb->offset;
68	instr->len = c->sector_size;	68	instr->len = c->sector_size;
69	instr->callback = jffs2_erase_callback;	69	instr->callback = jffs2_erase_callback;
70	instr->priv = (unsigned long)(&instr[1]);	70	instr->priv = (unsigned long)(&instr[1]);
71	instr->fail_addr = 0xffffffff;	71	instr->fail_addr = 0xffffffff;
72		72
73	((struct erase_priv_struct *)instr->priv)->jeb = jeb;	73	((struct erase_priv_struct *)instr->priv)->jeb = jeb;
74	((struct erase_priv_struct *)instr->priv)->c = c;	74	((struct erase_priv_struct *)instr->priv)->c = c;
75		75
76	ret = c->mtd->erase(c->mtd, instr);	76	ret = c->mtd->erase(c->mtd, instr);
77	if (!ret)	77	if (!ret)
78	return;	78	return;
79		79
80	bad_offset = instr->fail_addr;	80	bad_offset = instr->fail_addr;
81	kfree(instr);	81	kfree(instr);
82	#endif /* __ECOS */	82	#endif /* __ECOS */
83		83
84	if (ret == -ENOMEM \|\| ret == -EAGAIN) {	84	if (ret == -ENOMEM \|\| ret == -EAGAIN) {
85	/* Erase failed immediately. Refile it on the list */	85	/* Erase failed immediately. Refile it on the list */
86	D1(printk(KERN_DEBUG "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", jeb->offset, ret));	86	D1(printk(KERN_DEBUG "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", jeb->offset, ret));
87	mutex_lock(&c->erase_free_sem);	87	mutex_lock(&c->erase_free_sem);
88	spin_lock(&c->erase_completion_lock);	88	spin_lock(&c->erase_completion_lock);
89	list_move(&jeb->list, &c->erase_pending_list);	89	list_move(&jeb->list, &c->erase_pending_list);
90	c->erasing_size -= c->sector_size;	90	c->erasing_size -= c->sector_size;
91	c->dirty_size += c->sector_size;	91	c->dirty_size += c->sector_size;
92	jeb->dirty_size = c->sector_size;	92	jeb->dirty_size = c->sector_size;
93	spin_unlock(&c->erase_completion_lock);	93	spin_unlock(&c->erase_completion_lock);
94	mutex_unlock(&c->erase_free_sem);	94	mutex_unlock(&c->erase_free_sem);
95	return;	95	return;
96	}	96	}
97		97
98	if (ret == -EROFS)	98	if (ret == -EROFS)
99	printk(KERN_WARNING "Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n", jeb->offset);	99	printk(KERN_WARNING "Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n", jeb->offset);
100	else	100	else
101	printk(KERN_WARNING "Erase at 0x%08x failed immediately: errno %d\n", jeb->offset, ret);	101	printk(KERN_WARNING "Erase at 0x%08x failed immediately: errno %d\n", jeb->offset, ret);
102		102
103	jffs2_erase_failed(c, jeb, bad_offset);	103	jffs2_erase_failed(c, jeb, bad_offset);
104	}	104	}
105		105
106	void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count)	106	void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count)
107	{	107	{
108	struct jffs2_eraseblock *jeb;	108	struct jffs2_eraseblock *jeb;
109		109
110	mutex_lock(&c->erase_free_sem);	110	mutex_lock(&c->erase_free_sem);
111		111
112	spin_lock(&c->erase_completion_lock);	112	spin_lock(&c->erase_completion_lock);
113		113
114	while (!list_empty(&c->erase_complete_list) \|\|	114	while (!list_empty(&c->erase_complete_list) \|\|
115	!list_empty(&c->erase_pending_list)) {	115	!list_empty(&c->erase_pending_list)) {
116		116
117	if (!list_empty(&c->erase_complete_list)) {	117	if (!list_empty(&c->erase_complete_list)) {
118	jeb = list_entry(c->erase_complete_list.next, struct jffs2_eraseblock, list);	118	jeb = list_entry(c->erase_complete_list.next, struct jffs2_eraseblock, list);
119	list_del(&jeb->list);	119	list_move(&jeb->list, &c->erase_checking_list);
120	spin_unlock(&c->erase_completion_lock);	120	spin_unlock(&c->erase_completion_lock);
121	mutex_unlock(&c->erase_free_sem);	121	mutex_unlock(&c->erase_free_sem);
122	jffs2_mark_erased_block(c, jeb);	122	jffs2_mark_erased_block(c, jeb);
123		123
124	if (!--count) {	124	if (!--count) {
125	D1(printk(KERN_DEBUG "Count reached. jffs2_erase_pending_blocks leaving\n"));	125	D1(printk(KERN_DEBUG "Count reached. jffs2_erase_pending_blocks leaving\n"));
126	goto done;	126	goto done;
127	}	127	}
128		128
129	} else if (!list_empty(&c->erase_pending_list)) {	129	} else if (!list_empty(&c->erase_pending_list)) {
130	jeb = list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list);	130	jeb = list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list);
131	D1(printk(KERN_DEBUG "Starting erase of pending block 0x%08x\n", jeb->offset));	131	D1(printk(KERN_DEBUG "Starting erase of pending block 0x%08x\n", jeb->offset));
132	list_del(&jeb->list);	132	list_del(&jeb->list);
133	c->erasing_size += c->sector_size;	133	c->erasing_size += c->sector_size;
134	c->wasted_size -= jeb->wasted_size;	134	c->wasted_size -= jeb->wasted_size;
135	c->free_size -= jeb->free_size;	135	c->free_size -= jeb->free_size;
136	c->used_size -= jeb->used_size;	136	c->used_size -= jeb->used_size;
137	c->dirty_size -= jeb->dirty_size;	137	c->dirty_size -= jeb->dirty_size;
138	jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;	138	jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;
139	jffs2_free_jeb_node_refs(c, jeb);	139	jffs2_free_jeb_node_refs(c, jeb);
140	list_add(&jeb->list, &c->erasing_list);	140	list_add(&jeb->list, &c->erasing_list);
141	spin_unlock(&c->erase_completion_lock);	141	spin_unlock(&c->erase_completion_lock);
142	mutex_unlock(&c->erase_free_sem);	142	mutex_unlock(&c->erase_free_sem);
143		143
144	jffs2_erase_block(c, jeb);	144	jffs2_erase_block(c, jeb);
145		145
146	} else {	146	} else {
147	BUG();	147	BUG();
148	}	148	}
149		149
150	/* Be nice */	150	/* Be nice */
151	yield();	151	yield();
152	mutex_lock(&c->erase_free_sem);	152	mutex_lock(&c->erase_free_sem);
153	spin_lock(&c->erase_completion_lock);	153	spin_lock(&c->erase_completion_lock);
154	}	154	}
155		155
156	spin_unlock(&c->erase_completion_lock);	156	spin_unlock(&c->erase_completion_lock);
157	mutex_unlock(&c->erase_free_sem);	157	mutex_unlock(&c->erase_free_sem);
158	done:	158	done:
159	D1(printk(KERN_DEBUG "jffs2_erase_pending_blocks completed\n"));	159	D1(printk(KERN_DEBUG "jffs2_erase_pending_blocks completed\n"));
160	}	160	}
161		161
162	static void jffs2_erase_succeeded(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)	162	static void jffs2_erase_succeeded(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)
163	{	163	{
164	D1(printk(KERN_DEBUG "Erase completed successfully at 0x%08x\n", jeb->offset));	164	D1(printk(KERN_DEBUG "Erase completed successfully at 0x%08x\n", jeb->offset));
165	mutex_lock(&c->erase_free_sem);	165	mutex_lock(&c->erase_free_sem);
166	spin_lock(&c->erase_completion_lock);	166	spin_lock(&c->erase_completion_lock);
167	list_move_tail(&jeb->list, &c->erase_complete_list);	167	list_move_tail(&jeb->list, &c->erase_complete_list);
168	spin_unlock(&c->erase_completion_lock);	168	spin_unlock(&c->erase_completion_lock);
169	mutex_unlock(&c->erase_free_sem);	169	mutex_unlock(&c->erase_free_sem);
170	/* Ensure that kupdated calls us again to mark them clean */	170	/* Ensure that kupdated calls us again to mark them clean */
171	jffs2_erase_pending_trigger(c);	171	jffs2_erase_pending_trigger(c);
172	}	172	}
173		173
174	static void jffs2_erase_failed(struct jffs2_sb_info c, struct jffs2_eraseblock jeb, uint32_t bad_offset)	174	static void jffs2_erase_failed(struct jffs2_sb_info c, struct jffs2_eraseblock jeb, uint32_t bad_offset)
175	{	175	{
176	/* For NAND, if the failure did not occur at the device level for a	176	/* For NAND, if the failure did not occur at the device level for a
177	specific physical page, don't bother updating the bad block table. */	177	specific physical page, don't bother updating the bad block table. */
178	if (jffs2_cleanmarker_oob(c) && (bad_offset != 0xffffffff)) {	178	if (jffs2_cleanmarker_oob(c) && (bad_offset != 0xffffffff)) {
179	/* We had a device-level failure to erase. Let's see if we've	179	/* We had a device-level failure to erase. Let's see if we've
180	failed too many times. */	180	failed too many times. */
181	if (!jffs2_write_nand_badblock(c, jeb, bad_offset)) {	181	if (!jffs2_write_nand_badblock(c, jeb, bad_offset)) {
182	/* We'd like to give this block another try. */	182	/* We'd like to give this block another try. */
183	mutex_lock(&c->erase_free_sem);	183	mutex_lock(&c->erase_free_sem);
184	spin_lock(&c->erase_completion_lock);	184	spin_lock(&c->erase_completion_lock);
185	list_move(&jeb->list, &c->erase_pending_list);	185	list_move(&jeb->list, &c->erase_pending_list);
186	c->erasing_size -= c->sector_size;	186	c->erasing_size -= c->sector_size;
187	c->dirty_size += c->sector_size;	187	c->dirty_size += c->sector_size;
188	jeb->dirty_size = c->sector_size;	188	jeb->dirty_size = c->sector_size;
189	spin_unlock(&c->erase_completion_lock);	189	spin_unlock(&c->erase_completion_lock);
190	mutex_unlock(&c->erase_free_sem);	190	mutex_unlock(&c->erase_free_sem);
191	return;	191	return;
192	}	192	}
193	}	193	}
194		194
195	mutex_lock(&c->erase_free_sem);	195	mutex_lock(&c->erase_free_sem);
196	spin_lock(&c->erase_completion_lock);	196	spin_lock(&c->erase_completion_lock);
197	c->erasing_size -= c->sector_size;	197	c->erasing_size -= c->sector_size;
198	c->bad_size += c->sector_size;	198	c->bad_size += c->sector_size;
199	list_move(&jeb->list, &c->bad_list);	199	list_move(&jeb->list, &c->bad_list);
200	c->nr_erasing_blocks--;	200	c->nr_erasing_blocks--;
201	spin_unlock(&c->erase_completion_lock);	201	spin_unlock(&c->erase_completion_lock);
202	mutex_unlock(&c->erase_free_sem);	202	mutex_unlock(&c->erase_free_sem);
203	wake_up(&c->erase_wait);	203	wake_up(&c->erase_wait);
204	}	204	}
205		205
206	#ifndef __ECOS	206	#ifndef __ECOS
207	static void jffs2_erase_callback(struct erase_info *instr)	207	static void jffs2_erase_callback(struct erase_info *instr)
208	{	208	{
209	struct erase_priv_struct priv = (void )instr->priv;	209	struct erase_priv_struct priv = (void )instr->priv;
210		210
211	if(instr->state != MTD_ERASE_DONE) {	211	if(instr->state != MTD_ERASE_DONE) {
212	printk(KERN_WARNING "Erase at 0x%08x finished, but state != MTD_ERASE_DONE. State is 0x%x instead.\n", instr->addr, instr->state);	212	printk(KERN_WARNING "Erase at 0x%08x finished, but state != MTD_ERASE_DONE. State is 0x%x instead.\n", instr->addr, instr->state);
213	jffs2_erase_failed(priv->c, priv->jeb, instr->fail_addr);	213	jffs2_erase_failed(priv->c, priv->jeb, instr->fail_addr);
214	} else {	214	} else {
215	jffs2_erase_succeeded(priv->c, priv->jeb);	215	jffs2_erase_succeeded(priv->c, priv->jeb);
216	}	216	}
217	kfree(instr);	217	kfree(instr);
218	}	218	}
219	#endif /* !__ECOS */	219	#endif /* !__ECOS */
220		220
221	/* Hmmm. Maybe we should accept the extra space it takes and make	221	/* Hmmm. Maybe we should accept the extra space it takes and make
222	this a standard doubly-linked list? */	222	this a standard doubly-linked list? */
223	static inline void jffs2_remove_node_refs_from_ino_list(struct jffs2_sb_info *c,	223	static inline void jffs2_remove_node_refs_from_ino_list(struct jffs2_sb_info *c,
224	struct jffs2_raw_node_ref ref, struct jffs2_eraseblock jeb)	224	struct jffs2_raw_node_ref ref, struct jffs2_eraseblock jeb)
225	{	225	{
226	struct jffs2_inode_cache *ic = NULL;	226	struct jffs2_inode_cache *ic = NULL;
227	struct jffs2_raw_node_ref **prev;	227	struct jffs2_raw_node_ref **prev;
228		228
229	prev = &ref->next_in_ino;	229	prev = &ref->next_in_ino;
230		230
231	/* Walk the inode's list once, removing any nodes from this eraseblock */	231	/* Walk the inode's list once, removing any nodes from this eraseblock */
232	while (1) {	232	while (1) {
233	if (!(*prev)->next_in_ino) {	233	if (!(*prev)->next_in_ino) {
234	/* We're looking at the jffs2_inode_cache, which is	234	/* We're looking at the jffs2_inode_cache, which is
235	at the end of the linked list. Stash it and continue	235	at the end of the linked list. Stash it and continue
236	from the beginning of the list */	236	from the beginning of the list */
237	ic = (struct jffs2_inode_cache )(prev);	237	ic = (struct jffs2_inode_cache )(prev);
238	prev = &ic->nodes;	238	prev = &ic->nodes;
239	continue;	239	continue;
240	}	240	}
241		241
242	if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {	242	if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
243	/* It's in the block we're erasing */	243	/* It's in the block we're erasing */
244	struct jffs2_raw_node_ref *this;	244	struct jffs2_raw_node_ref *this;
245		245
246	this = *prev;	246	this = *prev;
247	*prev = this->next_in_ino;	247	*prev = this->next_in_ino;
248	this->next_in_ino = NULL;	248	this->next_in_ino = NULL;
249		249
250	if (this == ref)	250	if (this == ref)
251	break;	251	break;
252		252
253	continue;	253	continue;
254	}	254	}
255	/* Not to be deleted. Skip */	255	/* Not to be deleted. Skip */
256	prev = &((*prev)->next_in_ino);	256	prev = &((*prev)->next_in_ino);
257	}	257	}
258		258
259	/* PARANOIA */	259	/* PARANOIA */
260	if (!ic) {	260	if (!ic) {
261	JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"	261	JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
262	" not found in remove_node_refs()!!\n");	262	" not found in remove_node_refs()!!\n");
263	return;	263	return;
264	}	264	}
265		265
266	D1(printk(KERN_DEBUG "Removed nodes in range 0x%08x-0x%08x from ino #%u\n",	266	D1(printk(KERN_DEBUG "Removed nodes in range 0x%08x-0x%08x from ino #%u\n",
267	jeb->offset, jeb->offset + c->sector_size, ic->ino));	267	jeb->offset, jeb->offset + c->sector_size, ic->ino));
268		268
269	D2({	269	D2({
270	int i=0;	270	int i=0;
271	struct jffs2_raw_node_ref *this;	271	struct jffs2_raw_node_ref *this;
272	printk(KERN_DEBUG "After remove_node_refs_from_ino_list: \n" KERN_DEBUG);	272	printk(KERN_DEBUG "After remove_node_refs_from_ino_list: \n" KERN_DEBUG);
273		273
274	this = ic->nodes;	274	this = ic->nodes;
275		275
276	while(this) {	276	while(this) {
277	printk( "0x%08x(%d)->", ref_offset(this), ref_flags(this));	277	printk( "0x%08x(%d)->", ref_offset(this), ref_flags(this));
278	if (++i == 5) {	278	if (++i == 5) {
279	printk("\n" KERN_DEBUG);	279	printk("\n" KERN_DEBUG);
280	i=0;	280	i=0;
281	}	281	}
282	this = this->next_in_ino;	282	this = this->next_in_ino;
283	}	283	}
284	printk("\n");	284	printk("\n");
285	});	285	});
286		286
287	switch (ic->class) {	287	switch (ic->class) {
288	#ifdef CONFIG_JFFS2_FS_XATTR	288	#ifdef CONFIG_JFFS2_FS_XATTR
289	case RAWNODE_CLASS_XATTR_DATUM:	289	case RAWNODE_CLASS_XATTR_DATUM:
290	jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic);	290	jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic);
291	break;	291	break;
292	case RAWNODE_CLASS_XATTR_REF:	292	case RAWNODE_CLASS_XATTR_REF:
293	jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic);	293	jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic);
294	break;	294	break;
295	#endif	295	#endif
296	default:	296	default:
297	if (ic->nodes == (void *)ic && ic->nlink == 0)	297	if (ic->nodes == (void *)ic && ic->nlink == 0)
298	jffs2_del_ino_cache(c, ic);	298	jffs2_del_ino_cache(c, ic);
299	}	299	}
300	}	300	}
301		301
302	void jffs2_free_jeb_node_refs(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)	302	void jffs2_free_jeb_node_refs(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)
303	{	303	{
304	struct jffs2_raw_node_ref block, ref;	304	struct jffs2_raw_node_ref block, ref;
305	D1(printk(KERN_DEBUG "Freeing all node refs for eraseblock offset 0x%08x\n", jeb->offset));	305	D1(printk(KERN_DEBUG "Freeing all node refs for eraseblock offset 0x%08x\n", jeb->offset));
306		306
307	block = ref = jeb->first_node;	307	block = ref = jeb->first_node;
308		308
309	while (ref) {	309	while (ref) {
310	if (ref->flash_offset == REF_LINK_NODE) {	310	if (ref->flash_offset == REF_LINK_NODE) {
311	ref = ref->next_in_ino;	311	ref = ref->next_in_ino;
312	jffs2_free_refblock(block);	312	jffs2_free_refblock(block);
313	block = ref;	313	block = ref;
314	continue;	314	continue;
315	}	315	}
316	if (ref->flash_offset != REF_EMPTY_NODE && ref->next_in_ino)	316	if (ref->flash_offset != REF_EMPTY_NODE && ref->next_in_ino)
317	jffs2_remove_node_refs_from_ino_list(c, ref, jeb);	317	jffs2_remove_node_refs_from_ino_list(c, ref, jeb);
318	/* else it was a non-inode node or already removed, so don't bother */	318	/* else it was a non-inode node or already removed, so don't bother */
319		319
320	ref++;	320	ref++;
321	}	321	}
322	jeb->first_node = jeb->last_node = NULL;	322	jeb->first_node = jeb->last_node = NULL;
323	}	323	}
324		324
325	static int jffs2_block_check_erase(struct jffs2_sb_info c, struct jffs2_eraseblock jeb, uint32_t *bad_offset)	325	static int jffs2_block_check_erase(struct jffs2_sb_info c, struct jffs2_eraseblock jeb, uint32_t *bad_offset)
326	{	326	{
327	void *ebuf;	327	void *ebuf;
328	uint32_t ofs;	328	uint32_t ofs;
329	size_t retlen;	329	size_t retlen;
330	int ret = -EIO;	330	int ret = -EIO;
331		331
332	if (c->mtd->point) {	332	if (c->mtd->point) {
333	unsigned long *wordebuf;	333	unsigned long *wordebuf;
334		334
335	ret = c->mtd->point(c->mtd, jeb->offset, c->sector_size, &retlen, (unsigned char **)&ebuf);	335	ret = c->mtd->point(c->mtd, jeb->offset, c->sector_size, &retlen, (unsigned char **)&ebuf);
336	if (ret) {	336	if (ret) {
337	D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));	337	D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));
338	goto do_flash_read;	338	goto do_flash_read;
339	}	339	}
340	if (retlen < c->sector_size) {	340	if (retlen < c->sector_size) {
341	/* Don't muck about if it won't let us point to the whole erase sector */	341	/* Don't muck about if it won't let us point to the whole erase sector */
342	D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", retlen));	342	D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", retlen));
343	c->mtd->unpoint(c->mtd, ebuf, jeb->offset, retlen);	343	c->mtd->unpoint(c->mtd, ebuf, jeb->offset, retlen);
344	goto do_flash_read;	344	goto do_flash_read;
345	}	345	}
346	wordebuf = ebuf-sizeof(*wordebuf);	346	wordebuf = ebuf-sizeof(*wordebuf);
347	retlen /= sizeof(*wordebuf);	347	retlen /= sizeof(*wordebuf);
348	do {	348	do {
349	if (*++wordebuf != ~0)	349	if (*++wordebuf != ~0)
350	break;	350	break;
351	} while(--retlen);	351	} while(--retlen);
352	c->mtd->unpoint(c->mtd, ebuf, jeb->offset, c->sector_size);	352	c->mtd->unpoint(c->mtd, ebuf, jeb->offset, c->sector_size);
353	if (retlen) {	353	if (retlen) {
354	printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08tx\n",	354	printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08tx\n",
355	wordebuf, jeb->offset + c->sector_size-retlensizeof(*wordebuf));	355	wordebuf, jeb->offset + c->sector_size-retlensizeof(*wordebuf));
356	return -EIO;	356	return -EIO;
357	}	357	}
358	return 0;	358	return 0;
359	}	359	}
360	do_flash_read:	360	do_flash_read:
361	ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);	361	ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
362	if (!ebuf) {	362	if (!ebuf) {
363	printk(KERN_WARNING "Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", jeb->offset);	363	printk(KERN_WARNING "Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", jeb->offset);
364	return -EAGAIN;	364	return -EAGAIN;
365	}	365	}
366		366
367	D1(printk(KERN_DEBUG "Verifying erase at 0x%08x\n", jeb->offset));	367	D1(printk(KERN_DEBUG "Verifying erase at 0x%08x\n", jeb->offset));
368		368
369	for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {	369	for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
370	uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);	370	uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);
371	int i;	371	int i;
372		372
373	*bad_offset = ofs;	373	*bad_offset = ofs;
374		374
375	ret = c->mtd->read(c->mtd, ofs, readlen, &retlen, ebuf);	375	ret = c->mtd->read(c->mtd, ofs, readlen, &retlen, ebuf);
376	if (ret) {	376	if (ret) {
377	printk(KERN_WARNING "Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", ofs, ret);	377	printk(KERN_WARNING "Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", ofs, ret);
378	ret = -EIO;	378	ret = -EIO;
379	goto fail;	379	goto fail;
380	}	380	}
381	if (retlen != readlen) {	381	if (retlen != readlen) {
382	printk(KERN_WARNING "Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", ofs, readlen, retlen);	382	printk(KERN_WARNING "Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", ofs, readlen, retlen);
383	ret = -EIO;	383	ret = -EIO;
384	goto fail;	384	goto fail;
385	}	385	}
386	for (i=0; i<readlen; i += sizeof(unsigned long)) {	386	for (i=0; i<readlen; i += sizeof(unsigned long)) {
387	/* It's OK. We know it's properly aligned */	387	/* It's OK. We know it's properly aligned */
388	unsigned long *datum = ebuf + i;	388	unsigned long *datum = ebuf + i;
389	if (*datum + 1) {	389	if (*datum + 1) {
390	*bad_offset += i;	390	*bad_offset += i;
391	printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08x\n", datum, bad_offset);	391	printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08x\n", datum, bad_offset);
392	ret = -EIO;	392	ret = -EIO;
393	goto fail;	393	goto fail;
394	}	394	}
395	}	395	}
396	ofs += readlen;	396	ofs += readlen;
397	cond_resched();	397	cond_resched();
398	}	398	}
399	ret = 0;	399	ret = 0;
400	fail:	400	fail:
401	kfree(ebuf);	401	kfree(ebuf);
402	return ret;	402	return ret;
403	}	403	}
404		404
405	static void jffs2_mark_erased_block(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)	405	static void jffs2_mark_erased_block(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)
406	{	406	{
407	size_t retlen;	407	size_t retlen;
408	int ret;	408	int ret;
409	uint32_t uninitialized_var(bad_offset);	409	uint32_t uninitialized_var(bad_offset);
410		410
411	switch (jffs2_block_check_erase(c, jeb, &bad_offset)) {	411	switch (jffs2_block_check_erase(c, jeb, &bad_offset)) {
412	case -EAGAIN: goto refile;	412	case -EAGAIN: goto refile;
413	case -EIO: goto filebad;	413	case -EIO: goto filebad;
414	}	414	}
415		415
416	/* Write the erase complete marker */	416	/* Write the erase complete marker */
417	D1(printk(KERN_DEBUG "Writing erased marker to block at 0x%08x\n", jeb->offset));	417	D1(printk(KERN_DEBUG "Writing erased marker to block at 0x%08x\n", jeb->offset));
418	bad_offset = jeb->offset;	418	bad_offset = jeb->offset;
419		419
420	/* Cleanmarker in oob area or no cleanmarker at all ? */	420	/* Cleanmarker in oob area or no cleanmarker at all ? */
421	if (jffs2_cleanmarker_oob(c) \|\| c->cleanmarker_size == 0) {	421	if (jffs2_cleanmarker_oob(c) \|\| c->cleanmarker_size == 0) {
422		422
423	if (jffs2_cleanmarker_oob(c)) {	423	if (jffs2_cleanmarker_oob(c)) {
424	if (jffs2_write_nand_cleanmarker(c, jeb))	424	if (jffs2_write_nand_cleanmarker(c, jeb))
425	goto filebad;	425	goto filebad;
426	}	426	}
427	} else {	427	} else {
428		428
429	struct kvec vecs[1];	429	struct kvec vecs[1];
430	struct jffs2_unknown_node marker = {	430	struct jffs2_unknown_node marker = {
431	.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK),	431	.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK),
432	.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),	432	.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
433	.totlen = cpu_to_je32(c->cleanmarker_size)	433	.totlen = cpu_to_je32(c->cleanmarker_size)
434	};	434	};
435		435
436	jffs2_prealloc_raw_node_refs(c, jeb, 1);	436	jffs2_prealloc_raw_node_refs(c, jeb, 1);
437		437
438	marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));	438	marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
439		439
440	vecs[0].iov_base = (unsigned char *) &marker;	440	vecs[0].iov_base = (unsigned char *) &marker;
441	vecs[0].iov_len = sizeof(marker);	441	vecs[0].iov_len = sizeof(marker);
442	ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);	442	ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
443		443
444	if (ret \|\| retlen != sizeof(marker)) {	444	if (ret \|\| retlen != sizeof(marker)) {
445	if (ret)	445	if (ret)
446	printk(KERN_WARNING "Write clean marker to block at 0x%08x failed: %d\n",	446	printk(KERN_WARNING "Write clean marker to block at 0x%08x failed: %d\n",
447	jeb->offset, ret);	447	jeb->offset, ret);
448	else	448	else
449	printk(KERN_WARNING "Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n",	449	printk(KERN_WARNING "Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n",
450	jeb->offset, sizeof(marker), retlen);	450	jeb->offset, sizeof(marker), retlen);
451		451
452	goto filebad;	452	goto filebad;
453	}	453	}
454	}	454	}
455	/* Everything else got zeroed before the erase */	455	/* Everything else got zeroed before the erase */
456	jeb->free_size = c->sector_size;	456	jeb->free_size = c->sector_size;
457		457
458	mutex_lock(&c->erase_free_sem);	458	mutex_lock(&c->erase_free_sem);
459	spin_lock(&c->erase_completion_lock);	459	spin_lock(&c->erase_completion_lock);
460		460
461	c->erasing_size -= c->sector_size;	461	c->erasing_size -= c->sector_size;
462	c->free_size += c->sector_size;	462	c->free_size += c->sector_size;
463		463
464	/* Account for cleanmarker now, if it's in-band */	464	/* Account for cleanmarker now, if it's in-band */
465	if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))	465	if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))
466	jffs2_link_node_ref(c, jeb, jeb->offset \| REF_NORMAL, c->cleanmarker_size, NULL);	466	jffs2_link_node_ref(c, jeb, jeb->offset \| REF_NORMAL, c->cleanmarker_size, NULL);
467		467
468	list_add_tail(&jeb->list, &c->free_list);	468	list_move_tail(&jeb->list, &c->free_list);
469	c->nr_erasing_blocks--;	469	c->nr_erasing_blocks--;
470	c->nr_free_blocks++;	470	c->nr_free_blocks++;
471		471
472	jffs2_dbg_acct_sanity_check_nolock(c, jeb);	472	jffs2_dbg_acct_sanity_check_nolock(c, jeb);
473	jffs2_dbg_acct_paranoia_check_nolock(c, jeb);	473	jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
474		474
475	spin_unlock(&c->erase_completion_lock);	475	spin_unlock(&c->erase_completion_lock);
476	mutex_unlock(&c->erase_free_sem);	476	mutex_unlock(&c->erase_free_sem);
477	wake_up(&c->erase_wait);	477	wake_up(&c->erase_wait);
478	return;	478	return;
479		479
480	filebad:	480	filebad:
481	mutex_lock(&c->erase_free_sem);	481	mutex_lock(&c->erase_free_sem);
482	spin_lock(&c->erase_completion_lock);	482	spin_lock(&c->erase_completion_lock);
483	/* Stick it on a list (any list) so erase_failed can take it	483	/* Stick it on a list (any list) so erase_failed can take it
484	right off again. Silly, but shouldn't happen often. */	484	right off again. Silly, but shouldn't happen often. */
485	list_add(&jeb->list, &c->erasing_list);	485	list_move(&jeb->list, &c->erasing_list);
486	spin_unlock(&c->erase_completion_lock);	486	spin_unlock(&c->erase_completion_lock);
487	mutex_unlock(&c->erase_free_sem);	487	mutex_unlock(&c->erase_free_sem);
488	jffs2_erase_failed(c, jeb, bad_offset);	488	jffs2_erase_failed(c, jeb, bad_offset);
489	return;	489	return;
490		490
491	refile:	491	refile:
492	/* Stick it back on the list from whence it came and come back later */	492	/* Stick it back on the list from whence it came and come back later */
493	jffs2_erase_pending_trigger(c);	493	jffs2_erase_pending_trigger(c);
494	mutex_lock(&c->erase_free_sem);	494	mutex_lock(&c->erase_free_sem);
495	spin_lock(&c->erase_completion_lock);	495	spin_lock(&c->erase_completion_lock);
496	list_add(&jeb->list, &c->erase_complete_list);	496	list_move(&jeb->list, &c->erase_complete_list);
497	spin_unlock(&c->erase_completion_lock);	497	spin_unlock(&c->erase_completion_lock);
498	mutex_unlock(&c->erase_free_sem);	498	mutex_unlock(&c->erase_free_sem);
499	return;	499	return;
500	}	500	}
501		501

fs/jffs2/jffs2_fs_sb.h

Diff comments View file @ e2bc322

 /*
  * JFFS2 -- Journalling Flash File System, Version 2.
  *
  * Copyright © 2001-2007 Red Hat, Inc.
  *
  * Created by David Woodhouse <dwmw2@infradead.org>
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
  */
 #ifndef _JFFS2_FS_SB
 #define _JFFS2_FS_SB
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <linux/timer.h>
 #include <linux/wait.h>
 #include <linux/list.h>
 #include <linux/rwsem.h>
 #define JFFS2_SB_FLAG_RO 1
 #define JFFS2_SB_FLAG_SCANNING 2 /* Flash scanning is in progress */
 #define JFFS2_SB_FLAG_BUILDING 4 /* File system building is in progress */
 struct jffs2_inodirty;
 /* A struct for the overall file system control.  Pointers to
    jffs2_sb_info structs are named `c' in the source code.
    Nee jffs_control
 */
 struct jffs2_sb_info {
 	struct mtd_info *mtd;
 	uint32_t highest_ino;
 	uint32_t checked_ino;
 	unsigned int flags;
 	struct task_struct *gc_task;	/* GC task struct */
 	struct completion gc_thread_start; /* GC thread start completion */
 	struct completion gc_thread_exit; /* GC thread exit completion port */
 	struct mutex alloc_sem;		/* Used to protect all the following
 					   fields, and also to protect against
 					   out-of-order writing of nodes. And GC. */
 	uint32_t cleanmarker_size;	/* Size of an _inline_ CLEANMARKER
 					 (i.e. zero for OOB CLEANMARKER */
 	uint32_t flash_size;
 	uint32_t used_size;
 	uint32_t dirty_size;
 	uint32_t wasted_size;
 	uint32_t free_size;
 	uint32_t erasing_size;
 	uint32_t bad_size;
 	uint32_t sector_size;
 	uint32_t unchecked_size;
 	uint32_t nr_free_blocks;
 	uint32_t nr_erasing_blocks;
 	/* Number of free blocks there must be before we... */
 	uint8_t resv_blocks_write;	/* ... allow a normal filesystem write */
 	uint8_t resv_blocks_deletion;	/* ... allow a normal filesystem deletion */
 	uint8_t resv_blocks_gctrigger;	/* ... wake up the GC thread */
 	uint8_t resv_blocks_gcbad;	/* ... pick a block from the bad_list to GC */
 	uint8_t resv_blocks_gcmerge;	/* ... merge pages when garbage collecting */
 	/* Number of 'very dirty' blocks before we trigger immediate GC */
 	uint8_t vdirty_blocks_gctrigger;
 	uint32_t nospc_dirty_size;
 	uint32_t nr_blocks;
 	struct jffs2_eraseblock *blocks;	/* The whole array of blocks. Used for getting blocks
 						 * from the offset (blocks[ofs / sector_size]) */
 	struct jffs2_eraseblock *nextblock;	/* The block we're currently filling */
 	struct jffs2_eraseblock *gcblock;	/* The block we're currently garbage-collecting */
 	struct list_head clean_list;		/* Blocks 100% full of clean data */
 	struct list_head very_dirty_list;	/* Blocks with lots of dirty space */
 	struct list_head dirty_list;		/* Blocks with some dirty space */
 	struct list_head erasable_list;		/* Blocks which are completely dirty, and need erasing */
 	struct list_head erasable_pending_wbuf_list;	/* Blocks which need erasing but only after the current wbuf is flushed */
 	struct list_head erasing_list;		/* Blocks which are currently erasing */
+	struct list_head erase_checking_list;	/* Blocks which are being checked and marked */
 	struct list_head erase_pending_list;	/* Blocks which need erasing now */
 	struct list_head erase_complete_list;	/* Blocks which are erased and need the clean marker written to them */
 	struct list_head free_list;		/* Blocks which are free and ready to be used */
 	struct list_head bad_list;		/* Bad blocks. */
 	struct list_head bad_used_list;		/* Bad blocks with valid data in. */
 	spinlock_t erase_completion_lock;	/* Protect free_list and erasing_list
 						   against erase completion handler */
 	wait_queue_head_t erase_wait;		/* For waiting for erases to complete */
 	wait_queue_head_t inocache_wq;
 	struct jffs2_inode_cache **inocache_list;
 	spinlock_t inocache_lock;
 	/* Sem to allow jffs2_garbage_collect_deletion_dirent to
 	   drop the erase_completion_lock while it's holding a pointer
 	   to an obsoleted node. I don't like this. Alternatives welcomed. */
 	struct mutex erase_free_sem;
 	uint32_t wbuf_pagesize; /* 0 for NOR and other flashes with no wbuf */
 #ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
 	unsigned char *wbuf_verify; /* read-back buffer for verification */
 #endif
 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
 	unsigned char *wbuf; /* Write-behind buffer for NAND flash */
 	uint32_t wbuf_ofs;
 	uint32_t wbuf_len;
 	struct jffs2_inodirty *wbuf_inodes;
 	struct rw_semaphore wbuf_sem;	/* Protects the write buffer */
 	unsigned char *oobbuf;
 	int oobavail; /* How many bytes are available for JFFS2 in OOB */
 #endif
 	struct jffs2_summary *summary;		/* Summary information */
 #ifdef CONFIG_JFFS2_FS_XATTR
 #define XATTRINDEX_HASHSIZE	(57)
 	uint32_t highest_xid;
 	uint32_t highest_xseqno;
 	struct list_head xattrindex[XATTRINDEX_HASHSIZE];
 	struct list_head xattr_unchecked;
 	struct list_head xattr_dead_list;
 	struct jffs2_xattr_ref *xref_dead_list;
 	struct jffs2_xattr_ref *xref_temp;
 	struct rw_semaphore xattr_sem;
 	uint32_t xdatum_mem_usage;
 	uint32_t xdatum_mem_threshold;
 #endif
 	/* OS-private pointer for getting back to master superblock info */
 	void *os_priv;
 };
 #endif /* _JFFS2_FB_SB */