[JFFS2] Build fragtree in reverse order

 *

 * For licensing information, see the file 'LICENCE' in this directory.

 *

 * $Id: nodelist.c,v 1.103 2005/07/31 08:20:44 dedekind Exp $

 * $Id: nodelist.c,v 1.104 2005/08/01 12:05:19 dedekind Exp $

 *

 */

	/* We know frag->ofs <= size. That's what lookup does for us */

	if (frag && frag->ofs != size) {

		if (frag->ofs+frag->size >= size) {

		if (frag->ofs+frag->size > size) {

			JFFS2_DBG_FRAGTREE2("truncating frag 0x%08x-0x%08x\n", frag->ofs, frag->ofs+frag->size);

			frag->size = size - frag->ofs;

		}

		jffs2_obsolete_node_frag(c, frag);

		frag = next;

	}

	if (size == 0)

		return;

	/* 

	 * If the last fragment starts at the RAM page boundary, it is

	 * REF_PRISTINE irrespective of its size.

	 */

	frag = frag_last(list);

	if ((frag->ofs & (PAGE_CACHE_SIZE - 1)) == 0) {

		JFFS2_DBG_FRAGTREE2("marking the last fragment 0x%08x-0x%08x REF_PRISTINE.\n",

			frag->ofs, frag->ofs + frag->size); 

		frag->node->raw->flash_offset = ref_offset(frag->node->raw) | REF_PRISTINE;

	}

}

void jffs2_obsolete_node_frag(struct jffs2_sb_info *c, struct jffs2_node_frag *this)

	rb_link_node(&newfrag->rb, &base->rb, link);

}

/* Doesn't set inode->i_size */

static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *list, struct jffs2_node_frag *newfrag)

/*

 * Allocate and initializes a new fragment.

 */

static inline struct jffs2_node_frag * new_fragment(struct jffs2_full_dnode *fn, uint32_t ofs, uint32_t size)

{

	struct jffs2_node_frag *this;

	uint32_t lastend;

	/* Skip all the nodes which are completed before this one starts */

	this = jffs2_lookup_node_frag(list, newfrag->node->ofs);

	struct jffs2_node_frag *newfrag;

	if (this) {

		JFFS2_DBG_FRAGTREE2("lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",

			  this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this);

		lastend = this->ofs + this->size;

	newfrag = jffs2_alloc_node_frag();

	if (likely(newfrag)) {

		newfrag->ofs = ofs;

		newfrag->size = size;

		newfrag->node = fn;

	} else {

		JFFS2_DBG_FRAGTREE2("lookup gave no frag\n");

		lastend = 0;

		JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");

	}

	/* See if we ran off the end of the list */

	if (lastend <= newfrag->ofs) {

		/* We did */

		/* Check if 'this' node was on the same page as the new node.

		   If so, both 'this' and the new node get marked REF_NORMAL so

		   the GC can take a look.

		*/

		if (lastend && (lastend-1) >> PAGE_CACHE_SHIFT == newfrag->ofs >> PAGE_CACHE_SHIFT) {

			if (this->node)

				mark_ref_normal(this->node->raw);

			mark_ref_normal(newfrag->node->raw);

	return newfrag;

}

/*

 * Called when there is no overlapping fragment exist. Inserts a hole before the new

 * fragment and inserts the new fragment to the fragtree.

 */

static int no_overlapping_node(struct jffs2_sb_info *c, struct rb_root *root,

		 	       struct jffs2_node_frag *newfrag,

			       struct jffs2_node_frag *this, uint32_t lastend)

{

	if (lastend < newfrag->node->ofs) {

			/* ... and we need to put a hole in before the new node */

			struct jffs2_node_frag *holefrag = jffs2_alloc_node_frag();

			if (!holefrag) {

		/* put a hole in before the new fragment */

		struct jffs2_node_frag *holefrag;

		holefrag= new_fragment(NULL, lastend, newfrag->node->ofs - lastend);

		if (unlikely(!holefrag)) {

			jffs2_free_node_frag(newfrag);

			return -ENOMEM;

		}

			holefrag->ofs = lastend;

			holefrag->size = newfrag->node->ofs - lastend;

			holefrag->node = NULL;

		if (this) {

			/* By definition, the 'this' node has no right-hand child, 

			   because there are no frags with offset greater than it.

			   So that's where we want to put the hole */

				JFFS2_DBG_FRAGTREE2("adding hole frag (%p) on right of node at (%p)\n", holefrag, this);

			JFFS2_DBG_FRAGTREE2("add hole frag %u-%u on the right of the new frag.\n",

				holefrag->ofs, holefrag->ofs + holefrag->size);

			rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right);

		} else {

				JFFS2_DBG_FRAGTREE2("adding hole frag (%p) at root of tree\n", holefrag);

				rb_link_node(&holefrag->rb, NULL, &list->rb_node);

			JFFS2_DBG_FRAGTREE2("Add hole frag %u-%u to the root of the tree.\n",

				holefrag->ofs, holefrag->ofs + holefrag->size);

			rb_link_node(&holefrag->rb, NULL, &root->rb_node);

		}

			rb_insert_color(&holefrag->rb, list);

		rb_insert_color(&holefrag->rb, root);

		this = holefrag;

	}

	if (this) {

		/* By definition, the 'this' node has no right-hand child, 

		   because there are no frags with offset greater than it.

		   So that's where we want to put new fragment */

			JFFS2_DBG_FRAGTREE2("adding new frag (%p) on right of node at (%p)\n", newfrag, this);

		JFFS2_DBG_FRAGTREE2("add the new node at the right\n");

		rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);			

	} else {

			JFFS2_DBG_FRAGTREE2("adding new frag (%p) at root of tree\n", newfrag);

			rb_link_node(&newfrag->rb, NULL, &list->rb_node);

		JFFS2_DBG_FRAGTREE2("insert the new node at the root of the tree\n");

		rb_link_node(&newfrag->rb, NULL, &root->rb_node);

	}

		rb_insert_color(&newfrag->rb, list);

	rb_insert_color(&newfrag->rb, root);

	return 0;

}

	JFFS2_DBG_FRAGTREE2("dealing with frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n", 

/* Doesn't set inode->i_size */

static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *root, struct jffs2_node_frag *newfrag)

{

	struct jffs2_node_frag *this;

	uint32_t lastend;

	/* Skip all the nodes which are completed before this one starts */

	this = jffs2_lookup_node_frag(root, newfrag->node->ofs);

	if (this) {

		JFFS2_DBG_FRAGTREE2("lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",

			  this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this);

		lastend = this->ofs + this->size;

	} else {

		JFFS2_DBG_FRAGTREE2("lookup gave no frag\n");

		lastend = 0;

	}

	/* See if we ran off the end of the fragtree */

	if (lastend <= newfrag->ofs) {

		/* We did */

		/* Check if 'this' node was on the same page as the new node.

		   If so, both 'this' and the new node get marked REF_NORMAL so

		   the GC can take a look.

		*/

		if (lastend && (lastend-1) >> PAGE_CACHE_SHIFT == newfrag->ofs >> PAGE_CACHE_SHIFT) {

			if (this->node)

				mark_ref_normal(this->node->raw);

			mark_ref_normal(newfrag->node->raw);

		}

		return no_overlapping_node(c, root, newfrag, this, lastend);

	}

	if (this->node)

		JFFS2_DBG_FRAGTREE2("dealing with frag %u-%u, phys %#08x(%d).\n",

		this->ofs, this->ofs + this->size,

		ref_offset(this->node->raw), ref_flags(this->node->raw));

	else

		JFFS2_DBG_FRAGTREE2("dealing with hole frag %u-%u.\n",

		this->ofs, this->ofs + this->size);

	/* OK. 'this' is pointing at the first frag that newfrag->ofs at least partially obsoletes,

	 * - i.e. newfrag->ofs < this->ofs+this->size && newfrag->ofs >= this->ofs  

		if (this->ofs + this->size > newfrag->ofs + newfrag->size) {

			/* The new node splits 'this' frag into two */

			struct jffs2_node_frag *newfrag2 = jffs2_alloc_node_frag();

			if (!newfrag2) {

				jffs2_free_node_frag(newfrag);

				return -ENOMEM;

			}

			struct jffs2_node_frag *newfrag2;

			if (this->node)

				JFFS2_DBG_FRAGTREE2("split old frag 0x%04x-0x%04x, phys 0x%08x\n",

					this->ofs, this->ofs+this->size, ref_offset(this->node->raw));

					this->ofs, this->ofs+this->size, ref_offset(this->node->raw));

			/* New second frag pointing to this's node */

			newfrag2->ofs = newfrag->ofs + newfrag->size;

			newfrag2->size = (this->ofs+this->size) - newfrag2->ofs;

			newfrag2->node = this->node;

			newfrag2 = new_fragment(this->node, newfrag->ofs + newfrag->size,

						this->ofs + this->size - newfrag->ofs - newfrag->size);

			if (unlikely(!newfrag2))

				return -ENOMEM;

			if (this->node)

				this->node->frags++;

			   'this' to insert newfrag, and a tree insert

			   from newfrag to insert newfrag2. */

			jffs2_fragtree_insert(newfrag, this);

			rb_insert_color(&newfrag->rb, list);

			rb_insert_color(&newfrag->rb, root);

			jffs2_fragtree_insert(newfrag2, newfrag);

			rb_insert_color(&newfrag2->rb, list);

			rb_insert_color(&newfrag2->rb, root);

			return 0;

		}

		/* Again, we know it lives down here in the tree */

		jffs2_fragtree_insert(newfrag, this);

		rb_insert_color(&newfrag->rb, list);

		rb_insert_color(&newfrag->rb, root);

	} else {

		/* New frag starts at the same point as 'this' used to. Replace 

		   it in the tree without doing a delete and insertion */

		JFFS2_DBG_FRAGTREE2("inserting newfrag (*%p),%d-%d in before 'this' (*%p),%d-%d\n",

			  newfrag, newfrag->ofs, newfrag->ofs+newfrag->size, this, this->ofs, this->ofs+this->size);

		rb_replace_node(&this->rb, &newfrag->rb, list);

		rb_replace_node(&this->rb, &newfrag->rb, root);

		if (newfrag->ofs + newfrag->size >= this->ofs+this->size) {

			JFFS2_DBG_FRAGTREE2("obsoleting node frag %p (%x-%x)\n", this, this->ofs, this->ofs+this->size);

			this->size -= newfrag->size;

			jffs2_fragtree_insert(this, newfrag);

			rb_insert_color(&this->rb, list);

			rb_insert_color(&this->rb, root);

			return 0;

		}

	}

		/* 'this' frag is obsoleted completely. */

		JFFS2_DBG_FRAGTREE2("obsoleting node frag %p (%x-%x) and removing from tree\n",

			this, this->ofs, this->ofs+this->size);

		rb_erase(&this->rb, list);

		rb_erase(&this->rb, root);

		jffs2_obsolete_node_frag(c, this);

	}

	/* Now we're pointing at the first frag which isn't totally obsoleted by 

	   the new frag */

	if (!this || newfrag->ofs + newfrag->size == this->ofs) {

	if (!this || newfrag->ofs + newfrag->size == this->ofs)

		return 0;

	}

	/* Still some overlap but we don't need to move it in the tree */

	this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);

	this->ofs = newfrag->ofs + newfrag->size;

	return 0;

}

/* Given an inode, probably with existing list of fragments, add the new node

 * to the fragment list.

/* 

 * Given an inode, probably with existing tree of fragments, add the new node

 * to the fragment tree.

 */

int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)

{

	if (unlikely(!fn->size))

		return 0;

	newfrag = jffs2_alloc_node_frag();

	newfrag = new_fragment(fn, fn->ofs, fn->size);

	if (unlikely(!newfrag))

		return -ENOMEM;

	newfrag->node->frags = 1;

	JFFS2_DBG_FRAGTREE("adding node %#04x-%#04x @0x%08x on flash, newfrag *%p\n",

		  fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag);

	newfrag->ofs = fn->ofs;

	newfrag->size = fn->size;

	newfrag->node = fn;

	newfrag->node->frags = 1;

	ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag);

	if (unlikely(ret))

		return ret;

		}

	}

	jffs2_dbg_fragtree_paranoia_check_nolock(f);

	jffs2_dbg_dump_fragtree_nolock(f);

	return 0;

}

/*

 * Check the data CRC of the node.

 *

 * Returns: 0 if the data CRC is correct;

 * 	    1 - if incorrect;

 *	    error code if an error occured.

 */

static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)

{

	struct jffs2_raw_node_ref *ref = tn->fn->raw;

	int err = 0, pointed = 0;

	struct jffs2_eraseblock *jeb;

	unsigned char *buffer;

	uint32_t crc, ofs, retlen, len;

	BUG_ON(tn->csize == 0);

	/* Calculate how many bytes were already checked */

	ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);

	len = ofs - (ofs & (PAGE_CACHE_SIZE - 1));

	len = c->wbuf_pagesize - len;

	if (len >= tn->csize) {

		JFFS2_DBG_READINODE("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n",

			ref_offset(ref), tn->csize, ofs);

		goto adj_acc;

	}

	ofs += len;

	len = tn->csize - len;

	JFFS2_DBG_READINODE("check node at %#08x, data length %u, partial CRC %#08x, correct CRC %#08x, data starts at %#08x, start checking from %#08x - %u bytes.\n",

		ref_offset(ref), tn->csize, tn->partial_crc, tn->data_crc, ofs - len, ofs, len);

#ifndef __ECOS

	/* TODO: instead, incapsulate point() stuff to jffs2_flash_read(),

	 * adding and jffs2_flash_read_end() interface. */

	if (c->mtd->point) {

		err = c->mtd->point(c->mtd, ofs, len, &retlen, &buffer);

		if (!err && retlen < tn->csize) {

			JFFS2_WARNING("MTD point returned len too short: %u instead of %u.\n", retlen, tn->csize);

			c->mtd->unpoint(c->mtd, buffer, ofs, len);

		} else if (err)

			JFFS2_WARNING("MTD point failed: error code %d.\n", err);

		else

			pointed = 1; /* succefully pointed to device */

	}

#endif

	if (!pointed) {

		buffer = kmalloc(len, GFP_KERNEL);

		if (unlikely(!buffer))

			return -ENOMEM;

		/* TODO: this is very frequent pattern, make it a separate

		 * routine */

		err = jffs2_flash_read(c, ofs, len, &retlen, buffer);

		if (err) {

			JFFS2_ERROR("can not read %d bytes from 0x%08x, error code: %d.\n", len, ofs, err);

			goto free_out;

		}

		if (retlen != len) {

			JFFS2_ERROR("short read at %#08x: %d instead of %d.\n", ofs, retlen, len);

			err = -EIO;

			goto free_out;

		}

	}

	/* Continue calculating CRC */

	crc = crc32(tn->partial_crc, buffer, len);

	if(!pointed)

		kfree(buffer);

#ifndef __ECOS

	else

		c->mtd->unpoint(c->mtd, buffer, ofs, len);

#endif

	if (crc != tn->data_crc) {

		JFFS2_NOTICE("drong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",

			ofs, tn->data_crc, crc);

		return 1;

	}

adj_acc:

	jeb = &c->blocks[ref->flash_offset / c->sector_size];

	len = ref_totlen(c, jeb, ref);

	/* 

	 * Mark the node as having been checked and fix the

	 * accounting accordingly.

	 */

	spin_lock(&c->erase_completion_lock);

	jeb->used_size += len;

	jeb->unchecked_size -= len;

	c->used_size += len;

	c->unchecked_size -= len;

	spin_unlock(&c->erase_completion_lock);

	return 0;

free_out:

	if(!pointed)

		kfree(buffer);

#ifndef __ECOS

	else

		c->mtd->unpoint(c->mtd, buffer, ofs, len);

#endif

	return err;

}

/*

 * Helper function for jffs2_add_older_frag_to_fragtree().

 *

 * Checks the node if we are in the checking stage.

 */

static inline int check_node(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_tmp_dnode_info *tn)

{

	int ret;

	BUG_ON(ref_obsolete(tn->fn->raw));

	/* We only check the data CRC of unchecked nodes */

	if (ref_flags(tn->fn->raw) != REF_UNCHECKED)

		return 0;

	JFFS2_DBG_FRAGTREE2("check node %u-%u, phys offs %#08x.\n",

		tn->fn->ofs, tn->fn->ofs + tn->fn->size,

		ref_offset(tn->fn->raw));

	ret = check_node_data(c, tn);

	if (unlikely(ret < 0)) {

		JFFS2_ERROR("check_node_data() returned error: %d.\n",

			ret);

	} else if (unlikely(ret > 0)) {

		JFFS2_DBG_FRAGTREE2("CRC error, mark it obsolete.\n");

		jffs2_mark_node_obsolete(c, tn->fn->raw);

	}

	return ret;

}

/* 

 * Helper function for jffs2_add_older_frag_to_fragtree().

 *

 * Called when the new fragment that is being inserted

 * splits a hole fragment.

 */

static int split_hole(struct jffs2_sb_info *c, struct rb_root *root,

		      struct jffs2_node_frag *newfrag, struct jffs2_node_frag *hole)

{

	JFFS2_DBG_FRAGTREE2("fragment %#04x-%#04x splits the hole %#04x-%#04x\n",

		newfrag->ofs, newfrag->ofs + newfrag->size, hole->ofs, hole->ofs + hole->size);

	if (hole->ofs == newfrag->ofs) {

		/* 

		 * Well, the new fragment actually starts at the same offset as

		 * the hole.

		 */

		if (hole->ofs + hole->size > newfrag->ofs + newfrag->size) {

			/* 

			 * We replace the overlapped left part of the hole by

			 * the new node.

			 */

			JFFS2_DBG_FRAGTREE2("insert fragment %#04x-%#04x and cut the left part of the hole\n",

				newfrag->ofs, newfrag->ofs + newfrag->size);

			rb_replace_node(&hole->rb, &newfrag->rb, root);

			hole->ofs += newfrag->size;

			hole->size -= newfrag->size;

			/* 

			 * We know that 'hole' should be the right hand

			 * fragment.

			 */

			jffs2_fragtree_insert(hole, newfrag);

			rb_insert_color(&hole->rb, root);

		} else {

			/* 

			 * Ah, the new fragment is of the same size as the hole.

			 * Relace the hole by it.

			 */

			JFFS2_DBG_FRAGTREE2("insert fragment %#04x-%#04x and overwrite hole\n",

				newfrag->ofs, newfrag->ofs + newfrag->size);

			rb_replace_node(&hole->rb, &newfrag->rb, root);

			jffs2_free_node_frag(hole);

		}

	} else {

		/* The new fragment lefts some hole space at the left */

		struct jffs2_node_frag * newfrag2 = NULL;

		if (hole->ofs + hole->size > newfrag->ofs + newfrag->size) {

			/* The new frag also lefts some space at the right */

			newfrag2 = new_fragment(NULL, newfrag->ofs +

				newfrag->size, hole->ofs + hole->size

				- newfrag->ofs - newfrag->size);

			if (unlikely(!newfrag2)) {

				jffs2_free_node_frag(newfrag);

				return -ENOMEM;

			}

		}

		hole->size = newfrag->ofs - hole->ofs;

		JFFS2_DBG_FRAGTREE2("left the hole %#04x-%#04x at the left and inserd fragment %#04x-%#04x\n",

			hole->ofs, hole->ofs + hole->size, newfrag->ofs, newfrag->ofs + newfrag->size);

		jffs2_fragtree_insert(newfrag, hole);

		rb_insert_color(&newfrag->rb, root);

		if (newfrag2) {

			JFFS2_DBG_FRAGTREE2("left the hole %#04x-%#04x at the right\n",

				newfrag2->ofs, newfrag2->ofs + newfrag2->size);

			jffs2_fragtree_insert(newfrag2, newfrag);

			rb_insert_color(&newfrag2->rb, root);

		}

	}

	return 0;

}

/*

 * This function is used when we build inode. It expects the nodes are passed

 * in the decreasing version order. The whole point of this is to improve the

 * inodes checking on NAND: we check the nodes' data CRC only when they are not

 * obsoleted. Previously, add_frag_to_fragtree() function was used and

 * nodes were passed to it in the increasing version ordes and CRCs of all

 * nodes were checked.

 *

 * Note: tn->fn->size shouldn't be zero.

 *

 * Returns 0 if the node was inserted

 *         1 if it wasn't inserted (since it is obsolete)

 *         < 0 an if error occured

 */

int jffs2_add_older_frag_to_fragtree(struct jffs2_sb_info *c, struct jffs2_inode_info *f,

				     struct jffs2_tmp_dnode_info *tn)

{

	struct jffs2_node_frag *this, *newfrag;

	uint32_t lastend;

	struct jffs2_full_dnode *fn = tn->fn;

	struct rb_root *root = &f->fragtree;

	uint32_t fn_size = fn->size, fn_ofs = fn->ofs;

	int err, checked = 0;

	int ref_flag;

	JFFS2_DBG_FRAGTREE("insert fragment %#04x-%#04x\n", fn_ofs, fn_ofs + fn_size);

	/* Skip all the nodes which are completed before this one starts */

	this = jffs2_lookup_node_frag(root, fn_ofs);

	if (this)

		JFFS2_DBG_FRAGTREE2("'this' found %#04x-%#04x (%s)\n", this->ofs, this->ofs + this->size, this->node ? "data" : "hole");

	if (this)

		lastend = this->ofs + this->size;

	else

		lastend = 0;

	/* Detect the preliminary type of node */

	if (fn->size >= PAGE_CACHE_SIZE)

		ref_flag = REF_PRISTINE;

	else

		ref_flag = REF_NORMAL;

	/* See if we ran off the end of the root */

	if (lastend <= fn_ofs) {

		/* We did */

		/* 

		 * We are going to insert the new node into the

		 * fragment tree, so check it.

		 */

		err = check_node(c, f, tn);

		if (err != 0)

			return err;

		fn->frags = 1;

		newfrag = new_fragment(fn, fn_ofs, fn_size);

		if (unlikely(!newfrag))

			return -ENOMEM;

		err = no_overlapping_node(c, root, newfrag, this, lastend);

		if (unlikely(err != 0)) {

			jffs2_free_node_frag(newfrag);

			return err;

		}

		goto out_ok;

	}

	fn->frags = 0;

	while (1) {

		/* 

		 * Here we have:

		 * fn_ofs < this->ofs + this->size && fn_ofs >= this->ofs.

		 * 

		 * Remember, 'this' has higher version, any non-hole node

		 * which is already in the fragtree is newer then the newly

		 * inserted.

		 */

		if (!this->node) {

			/* 

			 * 'this' is the hole fragment, so at least the

			 * beginning of the new fragment is valid.

			 */

			/* 

			 * We are going to insert the new node into the

			 * fragment tree, so check it.

			 */

			if (!checked) {

				err = check_node(c, f, tn);

				if (unlikely(err != 0))