[net-next-2.6.git] / fs / jffs2 / build.c

/*
 * JFFS2 -- Journalling Flash File System, Version 2.
 *
 * Copyright © 2001-2007 Red Hat, Inc.
 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
 *
 * 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 < c->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 (fd->type == DT_DIR) {
			if (child_ic->pino_nlink) {
				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? */
			} else {
				child_ic->pino_nlink = ic->ino;
			}
		} else
			child_ic->pino_nlink++;

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

			if (fd->type == DT_DIR)
				child_ic->pino_nlink = 0;
			else
				child_ic->pino_nlink--;

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