[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / jffs2 / build.c

/*
 * 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: build.c,v 1.85 2005/11/07 11:14:38 gleixner Exp $
 *
 */

#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;

	/* 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);
}

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_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)
		return ret;

	if (jffs2_build_filesystem(c)) {
		dbg_fsbuild("build_fs failed\n");
		jffs2_free_ino_caches(c);
		jffs2_free_raw_node_refs(c);
#ifndef __ECOS
		if (jffs2_blocks_use_vmalloc(c))
			vfree(c->blocks);
		else
#endif
			kfree(c->blocks);

		return -EIO;
	}

	jffs2_calc_trigger_levels(c);

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* JFFS2 -- Journalling Flash File System, Version 2.
	3	*
	4	* Copyright (C) 2001-2003 Red Hat, Inc.
	5	*
	6	* Created by David Woodhouse <dwmw2@infradead.org>
	7	*
	8	* For licensing information, see the file 'LICENCE' in this directory.
	9	*
182ec4ee	10	* $Id: build.c,v 1.85 2005/11/07 11:14:38 gleixner Exp $
1da177e4 LT	11	*
	12	*/
	13
	14	#include <linux/kernel.h>
	15	#include <linux/sched.h>
	16	#include <linux/slab.h>
	17	#include <linux/vmalloc.h>
	18	#include <linux/mtd/mtd.h>
	19	#include "nodelist.h"
	20
733802d9 AB	21	static void jffs2_build_remove_unlinked_inode(struct jffs2_sb_info *,
733802d9 AB	22	struct jffs2_inode_cache , struct jffs2_full_dirent *);
1da177e4 LT	23
	24	static inline struct jffs2_inode_cache *
	25	first_inode_chain(int i, struct jffs2_sb_info c)
	26	{
	27	for (; i < INOCACHE_HASHSIZE; (i)++) {
	28	if (c->inocache_list[*i])
	29	return c->inocache_list[*i];
	30	}
	31	return NULL;
	32	}
	33
	34	static inline struct jffs2_inode_cache *
	35	next_inode(int i, struct jffs2_inode_cache ic, struct jffs2_sb_info *c)
	36	{
	37	/* More in this chain? */
	38	if (ic->next)
	39	return ic->next;
	40	(*i)++;
	41	return first_inode_chain(i, c);
	42	}
	43
	44	#define for_each_inode(i, c, ic) \
	45	for (i = 0, ic = first_inode_chain(&i, (c)); \
	46	ic; \
	47	ic = next_inode(&i, ic, (c)))
	48
	49
858119e1	50	static void jffs2_build_inode_pass1(struct jffs2_sb_info *c,
733802d9	51	struct jffs2_inode_cache *ic)
1da177e4 LT	52	{
	53	struct jffs2_full_dirent *fd;
	54
733802d9	55	dbg_fsbuild("building directory inode #%u\n", ic->ino);
1da177e4 LT	56
	57	/* For each child, increase nlink */
	58	for(fd = ic->scan_dents; fd; fd = fd->next) {
	59	struct jffs2_inode_cache *child_ic;
	60	if (!fd->ino)
	61	continue;
	62
733802d9	63	/* we can get high latency here with huge directories */
1da177e4 LT	64
	65	child_ic = jffs2_get_ino_cache(c, fd->ino);
	66	if (!child_ic) {
733802d9	67	dbg_fsbuild("child \"%s\" (ino #%u) of dir ino #%u doesn't exist!\n",
1da177e4 LT	68	fd->name, fd->ino, ic->ino);
	69	jffs2_mark_node_obsolete(c, fd->raw);
	70	continue;
	71	}
	72
	73	if (child_ic->nlink++ && fd->type == DT_DIR) {
733802d9 AB	74	JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u appears to be a hard link\n",
	75	fd->name, fd->ino, ic->ino);
	76	/* TODO: What do we do about it? */
1da177e4	77	}
733802d9 AB	78	dbg_fsbuild("increased nlink for child \"%s\" (ino #%u)\n", fd->name, fd->ino);
733802d9 AB	79	/* Can't free scan_dents so far. We might need them in pass 2 */
1da177e4 LT	80	}
	81	}
	82
	83	/* Scan plan:
	84	- Scan physical nodes. Build map of inodes/dirents. Allocate inocaches as we go
	85	- Scan directory tree from top down, setting nlink in inocaches
	86	- Scan inocaches for inodes with nlink==0
	87	*/
	88	static int jffs2_build_filesystem(struct jffs2_sb_info *c)
	89	{
	90	int ret;
	91	int i;
	92	struct jffs2_inode_cache *ic;
	93	struct jffs2_full_dirent *fd;
	94	struct jffs2_full_dirent *dead_fds = NULL;
	95
733802d9 AB	96	dbg_fsbuild("build FS data structures\n");
733802d9 AB	97
1da177e4 LT	98	/* First, scan the medium and build all the inode caches with
	99	lists of physical nodes */
	100
31fbdf7a	101	c->flags \|= JFFS2_SB_FLAG_SCANNING;
1da177e4	102	ret = jffs2_scan_medium(c);
31fbdf7a	103	c->flags &= ~JFFS2_SB_FLAG_SCANNING;
1da177e4 LT	104	if (ret)
	105	goto exit;
	106
733802d9	107	dbg_fsbuild("scanned flash completely\n");
e0c8e42f	108	jffs2_dbg_dump_block_lists_nolock(c);
1da177e4	109
733802d9	110	dbg_fsbuild("pass 1 starting\n");
31fbdf7a	111	c->flags \|= JFFS2_SB_FLAG_BUILDING;
1da177e4 LT	112	/* Now scan the directory tree, increasing nlink according to every dirent found. */
1da177e4 LT	113	for_each_inode(i, c, ic) {
1da177e4 LT	114	if (ic->scan_dents) {
	115	jffs2_build_inode_pass1(c, ic);
	116	cond_resched();
	117	}
	118	}
1da177e4	119
733802d9	120	dbg_fsbuild("pass 1 complete\n");
1da177e4 LT	121
	122	/* Next, scan for inodes with nlink == 0 and remove them. If
	123	they were directories, then decrement the nlink of their
	124	children too, and repeat the scan. As that's going to be
	125	a fairly uncommon occurrence, it's not so evil to do it this
	126	way. Recursion bad. */
733802d9	127	dbg_fsbuild("pass 2 starting\n");
1da177e4 LT	128
1da177e4 LT	129	for_each_inode(i, c, ic) {
1da177e4 LT	130	if (ic->nlink)
1da177e4 LT	131	continue;
182ec4ee	132
1da177e4 LT	133	jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
1da177e4 LT	134	cond_resched();
182ec4ee	135	}
1da177e4	136
733802d9	137	dbg_fsbuild("pass 2a starting\n");
1da177e4 LT	138
	139	while (dead_fds) {
	140	fd = dead_fds;
	141	dead_fds = fd->next;
	142
	143	ic = jffs2_get_ino_cache(c, fd->ino);
1da177e4 LT	144
	145	if (ic)
	146	jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
	147	jffs2_free_full_dirent(fd);
	148	}
	149
733802d9 AB	150	dbg_fsbuild("pass 2a complete\n");
733802d9 AB	151	dbg_fsbuild("freeing temporary data structures\n");
182ec4ee	152
1da177e4 LT	153	/* Finally, we can scan again and free the dirent structs */
1da177e4 LT	154	for_each_inode(i, c, ic) {
1da177e4 LT	155	while(ic->scan_dents) {
	156	fd = ic->scan_dents;
	157	ic->scan_dents = fd->next;
	158	jffs2_free_full_dirent(fd);
	159	}
	160	ic->scan_dents = NULL;
	161	cond_resched();
	162	}
aa98d7cf	163	jffs2_build_xattr_subsystem(c);
31fbdf7a	164	c->flags &= ~JFFS2_SB_FLAG_BUILDING;
182ec4ee	165
733802d9	166	dbg_fsbuild("FS build complete\n");
1da177e4 LT	167
	168	/* Rotate the lists by some number to ensure wear levelling */
	169	jffs2_rotate_lists(c);
	170
	171	ret = 0;
	172
	173	exit:
	174	if (ret) {
	175	for_each_inode(i, c, ic) {
	176	while(ic->scan_dents) {
	177	fd = ic->scan_dents;
	178	ic->scan_dents = fd->next;
	179	jffs2_free_full_dirent(fd);
	180	}
	181	}
aa98d7cf	182	jffs2_clear_xattr_subsystem(c);
1da177e4 LT	183	}
	184
	185	return ret;
	186	}
	187
733802d9 AB	188	static void jffs2_build_remove_unlinked_inode(struct jffs2_sb_info *c,
	189	struct jffs2_inode_cache *ic,
	190	struct jffs2_full_dirent **dead_fds)
1da177e4 LT	191	{
	192	struct jffs2_raw_node_ref *raw;
	193	struct jffs2_full_dirent *fd;
	194
733802d9	195	dbg_fsbuild("removing ino #%u with nlink == zero.\n", ic->ino);
182ec4ee	196
1da177e4 LT	197	raw = ic->nodes;
	198	while (raw != (void *)ic) {
	199	struct jffs2_raw_node_ref *next = raw->next_in_ino;
733802d9	200	dbg_fsbuild("obsoleting node at 0x%08x\n", ref_offset(raw));
1da177e4 LT	201	jffs2_mark_node_obsolete(c, raw);
	202	raw = next;
	203	}
	204
	205	if (ic->scan_dents) {
	206	int whinged = 0;
733802d9	207	dbg_fsbuild("inode #%u was a directory which may have children...\n", ic->ino);
1da177e4 LT	208
	209	while(ic->scan_dents) {
	210	struct jffs2_inode_cache *child_ic;
	211
	212	fd = ic->scan_dents;
	213	ic->scan_dents = fd->next;
	214
	215	if (!fd->ino) {
	216	/* It's a deletion dirent. Ignore it */
733802d9	217	dbg_fsbuild("child \"%s\" is a deletion dirent, skipping...\n", fd->name);
1da177e4 LT	218	jffs2_free_full_dirent(fd);
	219	continue;
	220	}
733802d9	221	if (!whinged)
1da177e4	222	whinged = 1;
1da177e4	223
733802d9	224	dbg_fsbuild("removing child \"%s\", ino #%u\n", fd->name, fd->ino);
182ec4ee	225
1da177e4 LT	226	child_ic = jffs2_get_ino_cache(c, fd->ino);
1da177e4 LT	227	if (!child_ic) {
733802d9 AB	228	dbg_fsbuild("cannot remove child \"%s\", ino #%u, because it doesn't exist\n",
733802d9 AB	229	fd->name, fd->ino);
1da177e4 LT	230	jffs2_free_full_dirent(fd);
	231	continue;
	232	}
	233
182ec4ee	234	/* Reduce nlink of the child. If it's now zero, stick it on the
1da177e4 LT	235	dead_fds list to be cleaned up later. Else just free the fd */
	236
	237	child_ic->nlink--;
182ec4ee	238
1da177e4	239	if (!child_ic->nlink) {
733802d9 AB	240	dbg_fsbuild("inode #%u (\"%s\") has now got zero nlink, adding to dead_fds list.\n",
733802d9 AB	241	fd->ino, fd->name);
1da177e4 LT	242	fd->next = *dead_fds;
	243	*dead_fds = fd;
	244	} else {
733802d9 AB	245	dbg_fsbuild("inode #%u (\"%s\") has now got nlink %d. Ignoring.\n",
733802d9 AB	246	fd->ino, fd->name, child_ic->nlink);
1da177e4 LT	247	jffs2_free_full_dirent(fd);
	248	}
	249	}
	250	}
	251
	252	/*
182ec4ee	253	We don't delete the inocache from the hash list and free it yet.
1da177e4 LT	254	The erase code will do that, when all the nodes are completely gone.
	255	*/
	256	}
	257
	258	static void jffs2_calc_trigger_levels(struct jffs2_sb_info *c)
	259	{
	260	uint32_t size;
	261
	262	/* Deletion should almost _always_ be allowed. We're fairly
	263	buggered once we stop allowing people to delete stuff
	264	because there's not enough free space... */
	265	c->resv_blocks_deletion = 2;
	266
182ec4ee	267	/* Be conservative about how much space we need before we allow writes.
1da177e4 LT	268	On top of that which is required for deletia, require an extra 2%
	269	of the medium to be available, for overhead caused by nodes being
	270	split across blocks, etc. */
	271
	272	size = c->flash_size / 50; /* 2% of flash size */
	273	size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */
	274	size += c->sector_size - 1; /* ... and round up */
	275
	276	c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
	277
	278	/* When do we let the GC thread run in the background */
	279
	280	c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
	281
182ec4ee	282	/* When do we allow garbage collection to merge nodes to make
1da177e4 LT	283	long-term progress at the expense of short-term space exhaustion? */
	284	c->resv_blocks_gcmerge = c->resv_blocks_deletion + 1;
	285
	286	/* When do we allow garbage collection to eat from bad blocks rather
	287	than actually making progress? */
	288	c->resv_blocks_gcbad = 0;//c->resv_blocks_deletion + 2;
	289
	290	/* If there's less than this amount of dirty space, don't bother
	291	trying to GC to make more space. It'll be a fruitless task */
	292	c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
	293
733802d9 AB	294	dbg_fsbuild("JFFS2 trigger levels (size %d KiB, block size %d KiB, %d blocks)\n",
	295	c->flash_size / 1024, c->sector_size / 1024, c->nr_blocks);
	296	dbg_fsbuild("Blocks required to allow deletion: %d (%d KiB)\n",
	297	c->resv_blocks_deletion, c->resv_blocks_deletion*c->sector_size/1024);
	298	dbg_fsbuild("Blocks required to allow writes: %d (%d KiB)\n",
	299	c->resv_blocks_write, c->resv_blocks_write*c->sector_size/1024);
	300	dbg_fsbuild("Blocks required to quiesce GC thread: %d (%d KiB)\n",
	301	c->resv_blocks_gctrigger, c->resv_blocks_gctrigger*c->sector_size/1024);
	302	dbg_fsbuild("Blocks required to allow GC merges: %d (%d KiB)\n",
	303	c->resv_blocks_gcmerge, c->resv_blocks_gcmerge*c->sector_size/1024);
	304	dbg_fsbuild("Blocks required to GC bad blocks: %d (%d KiB)\n",
	305	c->resv_blocks_gcbad, c->resv_blocks_gcbad*c->sector_size/1024);
	306	dbg_fsbuild("Amount of dirty space required to GC: %d bytes\n",
	307	c->nospc_dirty_size);
182ec4ee	308	}
1da177e4 LT	309
	310	int jffs2_do_mount_fs(struct jffs2_sb_info *c)
	311	{
c617e842	312	int ret;
1da177e4	313	int i;
d55849aa	314	int size;
1da177e4 LT	315
	316	c->free_size = c->flash_size;
	317	c->nr_blocks = c->flash_size / c->sector_size;
d55849aa	318	size = sizeof(struct jffs2_eraseblock) * c->nr_blocks;
737b7661	319	#ifndef __ECOS
4ce1f562	320	if (jffs2_blocks_use_vmalloc(c))
d55849aa	321	c->blocks = vmalloc(size);
1da177e4	322	else
737b7661	323	#endif
d55849aa	324	c->blocks = kmalloc(size, GFP_KERNEL);
1da177e4 LT	325	if (!c->blocks)
1da177e4 LT	326	return -ENOMEM;
d55849aa AB	327
d55849aa AB	328	memset(c->blocks, 0, size);
1da177e4 LT	329	for (i=0; i<c->nr_blocks; i++) {
	330	INIT_LIST_HEAD(&c->blocks[i].list);
	331	c->blocks[i].offset = i * c->sector_size;
	332	c->blocks[i].free_size = c->sector_size;
1da177e4 LT	333	}
1da177e4 LT	334
1da177e4 LT	335	INIT_LIST_HEAD(&c->clean_list);
	336	INIT_LIST_HEAD(&c->very_dirty_list);
	337	INIT_LIST_HEAD(&c->dirty_list);
	338	INIT_LIST_HEAD(&c->erasable_list);
	339	INIT_LIST_HEAD(&c->erasing_list);
	340	INIT_LIST_HEAD(&c->erase_pending_list);
	341	INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
	342	INIT_LIST_HEAD(&c->erase_complete_list);
	343	INIT_LIST_HEAD(&c->free_list);
	344	INIT_LIST_HEAD(&c->bad_list);
	345	INIT_LIST_HEAD(&c->bad_used_list);
	346	c->highest_ino = 1;
e631ddba FH	347	c->summary = NULL;
e631ddba FH	348
c617e842 FH	349	ret = jffs2_sum_init(c);
	350	if (ret)
	351	return ret;
1da177e4 LT	352
1da177e4 LT	353	if (jffs2_build_filesystem(c)) {
733802d9	354	dbg_fsbuild("build_fs failed\n");
1da177e4 LT	355	jffs2_free_ino_caches(c);
1da177e4 LT	356	jffs2_free_raw_node_refs(c);
737b7661	357	#ifndef __ECOS
4ce1f562	358	if (jffs2_blocks_use_vmalloc(c))
e631ddba	359	vfree(c->blocks);
182ec4ee	360	else
737b7661	361	#endif
e631ddba FH	362	kfree(c->blocks);
e631ddba FH	363
1da177e4 LT	364	return -EIO;
	365	}
	366
	367	jffs2_calc_trigger_levels(c);
	368
	369	return 0;
	370	}