1 files changed, 0 insertions, 460 deletions
diff --git a/fs/jffs2/nodelist.c b/fs/jffs2/nodelist.c
index 5a6b4d64206c..fecffbc63552 100644
--- a/fs/jffs2/nodelist.c
+++ b/fs/jffs2/nodelist.c
@@ -397,466 +397,6 @@ int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_in
        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, len;
-        size_t retlen;
-        BUG_ON(tn->csize == 0);
-        if (!jffs2_is_writebuffered(c))
-                goto adj_acc;
-        /* Calculate how many bytes were already checked */
-        ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);
-        len = ofs % c->wbuf_pagesize;
-        if (likely(len))
-                len = c->wbuf_pagesize - len;
-        if (len >= tn->csize) {
-                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;
-        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: %zu 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: %zd 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("wrong 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 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;
-        dbg_fragtree2("check node %#04x-%#04x, 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)) {
-                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)
-{
-        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.
-                         */
-                        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.
-                         */
-                        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;
-                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) {
-                        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;
-        dbg_fragtree("insert fragment %#04x-%#04x, ver %u\n", fn_ofs, fn_ofs + fn_size, tn->version);
-        /* Skip all the nodes which are completed before this one starts */
-        this = jffs2_lookup_node_frag(root, fn_ofs);
-        if (this)
-                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))
-                                        return err;
-                                checked = 1;
-                        }
-                        if (this->ofs + this->size >= fn_ofs + fn_size) {
-                                /* We split the hole on two parts */
-                                fn->frags += 1;
-                                newfrag = new_fragment(fn, fn_ofs, fn_size);
-                                if (unlikely(!newfrag))
-                                        return -ENOMEM;
-                                err = split_hole(c, root, newfrag, this);
-                                if (unlikely(err))
-                                        return err;
-                                goto out_ok;
-                        }
-                        /*
-                         * The beginning of the new fragment is valid since it
-                         * overlaps the hole node.
-                         */
-                        ref_flag = REF_NORMAL;
-                        fn->frags += 1;
-                        newfrag = new_fragment(fn, fn_ofs,
-                                        this->ofs + this->size - fn_ofs);
-                        if (unlikely(!newfrag))
-                                return -ENOMEM;
-                        if (fn_ofs == this->ofs) {
-                                /*
-                                 * The new node starts at the same offset as
-                                 * the hole and supersieds the hole.
-                                 */
-                                dbg_fragtree2("add the new fragment instead of hole %#04x-%#04x, refcnt %d\n",
-                                        fn_ofs, fn_ofs + this->ofs + this->size - fn_ofs, fn->frags);
-                                rb_replace_node(&this->rb, &newfrag->rb, root);
-                                jffs2_free_node_frag(this);
-                        } else {
-                                /*
-                                 * The hole becomes shorter as its right part
-                                 * is supersieded by the new fragment.
-                                 */
-                                dbg_fragtree2("reduce size of hole %#04x-%#04x to %#04x-%#04x\n",
-                                        this->ofs, this->ofs + this->size, this->ofs, this->ofs + this->size - newfrag->size);
-                                dbg_fragtree2("add new fragment %#04x-%#04x, refcnt %d\n", fn_ofs,
-                                        fn_ofs + this->ofs + this->size - fn_ofs, fn->frags);
-                                this->size -= newfrag->size;
-                                jffs2_fragtree_insert(newfrag, this);
-                                rb_insert_color(&newfrag->rb, root);
-                        }
-                        fn_ofs += newfrag->size;
-                        fn_size -= newfrag->size;
-                        this = rb_entry(rb_next(&newfrag->rb),
-                                        struct jffs2_node_frag, rb);
-                        dbg_fragtree2("switch to the next 'this' fragment: %#04x-%#04x %s\n",
-                                this->ofs, this->ofs + this->size, this->node ? "(data)" : "(hole)");
-                }
-                /*
-                 * 'This' node is not the hole so it obsoletes the new fragment
-                 * either fully or partially.
-                 */
-                if (this->ofs + this->size >= fn_ofs + fn_size) {
-                        /* The new node is obsolete, drop it */
-                        if (fn->frags == 0) {
-                                dbg_fragtree2("%#04x-%#04x is obsolete, mark it obsolete\n", fn_ofs, fn_ofs + fn_size);
-                                ref_flag = REF_OBSOLETE;
-                        }
-                        goto out_ok;
-                } else {
-                        struct jffs2_node_frag *new_this;
-                        /* 'This' node obsoletes the beginning of the new node */
-                        dbg_fragtree2("the beginning %#04x-%#04x is obsolete\n", fn_ofs, this->ofs + this->size);
-                        ref_flag = REF_NORMAL;
-                        fn_size -= this->ofs + this->size - fn_ofs;
-                        fn_ofs = this->ofs + this->size;
-                        dbg_fragtree2("now considering %#04x-%#04x\n", fn_ofs, fn_ofs + fn_size);
-                        new_this = rb_entry(rb_next(&this->rb), struct jffs2_node_frag, rb);
-                        if (!new_this) {
-                                /*
-                                 * There is no next fragment. Add the rest of
-                                 * the new node as the right-hand child.
-                                 */
-                                if (!checked) {
-                                        err = check_node(c, f, tn);
-                                        if (unlikely(err != 0))
-                                                return err;
-                                        checked = 1;
-                                }
-                                fn->frags += 1;
-                                newfrag = new_fragment(fn, fn_ofs, fn_size);
-                                if (unlikely(!newfrag))
-                                        return -ENOMEM;
-                                dbg_fragtree2("there are no more fragments, insert %#04x-%#04x\n",
-                                        newfrag->ofs, newfrag->ofs + newfrag->size);
-                                rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
-                                rb_insert_color(&newfrag->rb, root);
-                                goto out_ok;
-                        } else {
-                                this = new_this;
-                                dbg_fragtree2("switch to the next 'this' fragment: %#04x-%#04x %s\n",
-                                        this->ofs, this->ofs + this->size, this->node ? "(data)" : "(hole)");
-                        }
-                }
-        }
-out_ok:
-        BUG_ON(fn->size < PAGE_CACHE_SIZE && ref_flag == REF_PRISTINE);
-        if (ref_flag == REF_OBSOLETE) {
-                dbg_fragtree2("the node is obsolete now\n");
-                /* jffs2_mark_node_obsolete() will adjust space accounting */
-                jffs2_mark_node_obsolete(c, fn->raw);
-                return 1;
-        }
-        dbg_fragtree2("the node is \"%s\" now\n", ref_flag == REF_NORMAL ? "REF_NORMAL" : "REF_PRISTINE");
-        /* Space accounting was adjusted at check_node_data() */
-        spin_lock(&c->erase_completion_lock);
-        fn->raw->flash_offset = ref_offset(fn->raw) | ref_flag;
-        spin_unlock(&c->erase_completion_lock);
-        return 0;
-}
 void jffs2_set_inocache_state(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic, int state)
 {
        spin_lock(&c->inocache_lock);

diff --git a/fs/jffs2/nodelist.c b/fs/jffs2/nodelist.c index 5a6b4d64206c..fecffbc63552 100644 --- a/fs/jffs2/nodelist.c +++ b/fs/jffs2/nodelist.c
@@ -397,466 +397,6 @@ int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_in
397	return 0;	397	return 0;
398	}	398	}
399		399
400	/*
401	* Check the data CRC of the node.
402	*
403	* Returns: 0 if the data CRC is correct;
404	* 1 - if incorrect;
405	* error code if an error occured.
406	*/
407	static int check_node_data(struct jffs2_sb_info c, struct jffs2_tmp_dnode_info tn)
408	{
409	struct jffs2_raw_node_ref *ref = tn->fn->raw;
410	int err = 0, pointed = 0;
411	struct jffs2_eraseblock *jeb;
412	unsigned char *buffer;
413	uint32_t crc, ofs, len;
414	size_t retlen;
415
416	BUG_ON(tn->csize == 0);
417
418	if (!jffs2_is_writebuffered(c))
419	goto adj_acc;
420
421	/* Calculate how many bytes were already checked */
422	ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);
423	len = ofs % c->wbuf_pagesize;
424	if (likely(len))
425	len = c->wbuf_pagesize - len;
426
427	if (len >= tn->csize) {
428	dbg_readinode("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n",
429	ref_offset(ref), tn->csize, ofs);
430	goto adj_acc;
431	}
432
433	ofs += len;
434	len = tn->csize - len;
435
436	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",
437	ref_offset(ref), tn->csize, tn->partial_crc, tn->data_crc, ofs - len, ofs, len);
438
439	#ifndef __ECOS
440	/* TODO: instead, incapsulate point() stuff to jffs2_flash_read(),
441	* adding and jffs2_flash_read_end() interface. */
442	if (c->mtd->point) {
443	err = c->mtd->point(c->mtd, ofs, len, &retlen, &buffer);
444	if (!err && retlen < tn->csize) {
445	JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
446	c->mtd->unpoint(c->mtd, buffer, ofs, len);
447	} else if (err)
448	JFFS2_WARNING("MTD point failed: error code %d.\n", err);
449	else
450	pointed = 1; /* succefully pointed to device */
451	}
452	#endif
453
454	if (!pointed) {
455	buffer = kmalloc(len, GFP_KERNEL);
456	if (unlikely(!buffer))
457	return -ENOMEM;
458
459	/* TODO: this is very frequent pattern, make it a separate
460	* routine */
461	err = jffs2_flash_read(c, ofs, len, &retlen, buffer);
462	if (err) {
463	JFFS2_ERROR("can not read %d bytes from 0x%08x, error code: %d.\n", len, ofs, err);
464	goto free_out;
465	}
466
467	if (retlen != len) {
468	JFFS2_ERROR("short read at %#08x: %zd instead of %d.\n", ofs, retlen, len);
469	err = -EIO;
470	goto free_out;
471	}
472	}
473
474	/* Continue calculating CRC */
475	crc = crc32(tn->partial_crc, buffer, len);
476	if(!pointed)
477	kfree(buffer);
478	#ifndef __ECOS
479	else
480	c->mtd->unpoint(c->mtd, buffer, ofs, len);
481	#endif
482
483	if (crc != tn->data_crc) {
484	JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
485	ofs, tn->data_crc, crc);
486	return 1;
487	}
488
489	adj_acc:
490	jeb = &c->blocks[ref->flash_offset / c->sector_size];
491	len = ref_totlen(c, jeb, ref);
492
493	/*
494	* Mark the node as having been checked and fix the
495	* accounting accordingly.
496	*/
497	spin_lock(&c->erase_completion_lock);
498	jeb->used_size += len;
499	jeb->unchecked_size -= len;
500	c->used_size += len;
501	c->unchecked_size -= len;
502	spin_unlock(&c->erase_completion_lock);
503
504	return 0;
505
506	free_out:
507	if(!pointed)
508	kfree(buffer);
509	#ifndef __ECOS
510	else
511	c->mtd->unpoint(c->mtd, buffer, ofs, len);
512	#endif
513	return err;
514	}
515
516	/*
517	* Helper function for jffs2_add_older_frag_to_fragtree().
518	*
519	* Checks the node if we are in the checking stage.
520	*/
521	static int check_node(struct jffs2_sb_info c, struct jffs2_inode_info f, struct jffs2_tmp_dnode_info *tn)
522	{
523	int ret;
524
525	BUG_ON(ref_obsolete(tn->fn->raw));
526
527	/* We only check the data CRC of unchecked nodes */
528	if (ref_flags(tn->fn->raw) != REF_UNCHECKED)
529	return 0;
530
531	dbg_fragtree2("check node %#04x-%#04x, phys offs %#08x.\n",
532	tn->fn->ofs, tn->fn->ofs + tn->fn->size, ref_offset(tn->fn->raw));
533
534	ret = check_node_data(c, tn);
535	if (unlikely(ret < 0)) {
536	JFFS2_ERROR("check_node_data() returned error: %d.\n",
537	ret);
538	} else if (unlikely(ret > 0)) {
539	dbg_fragtree2("CRC error, mark it obsolete.\n");
540	jffs2_mark_node_obsolete(c, tn->fn->raw);
541	}
542
543	return ret;
544	}
545
546	/*
547	* Helper function for jffs2_add_older_frag_to_fragtree().
548	*
549	* Called when the new fragment that is being inserted
550	* splits a hole fragment.
551	*/
552	static int split_hole(struct jffs2_sb_info c, struct rb_root root,
553	struct jffs2_node_frag newfrag, struct jffs2_node_frag hole)
554	{
555	dbg_fragtree2("fragment %#04x-%#04x splits the hole %#04x-%#04x\n",
556	newfrag->ofs, newfrag->ofs + newfrag->size, hole->ofs, hole->ofs + hole->size);
557
558	if (hole->ofs == newfrag->ofs) {
559	/*
560	* Well, the new fragment actually starts at the same offset as
561	* the hole.
562	*/
563	if (hole->ofs + hole->size > newfrag->ofs + newfrag->size) {
564	/*
565	* We replace the overlapped left part of the hole by
566	* the new node.
567	*/
568
569	dbg_fragtree2("insert fragment %#04x-%#04x and cut the left part of the hole\n",
570	newfrag->ofs, newfrag->ofs + newfrag->size);
571	rb_replace_node(&hole->rb, &newfrag->rb, root);
572
573	hole->ofs += newfrag->size;
574	hole->size -= newfrag->size;
575
576	/*
577	* We know that 'hole' should be the right hand
578	* fragment.
579	*/
580	jffs2_fragtree_insert(hole, newfrag);
581	rb_insert_color(&hole->rb, root);
582	} else {
583	/*
584	* Ah, the new fragment is of the same size as the hole.
585	* Relace the hole by it.
586	*/
587	dbg_fragtree2("insert fragment %#04x-%#04x and overwrite hole\n",
588	newfrag->ofs, newfrag->ofs + newfrag->size);
589	rb_replace_node(&hole->rb, &newfrag->rb, root);
590	jffs2_free_node_frag(hole);
591	}
592	} else {
593	/* The new fragment lefts some hole space at the left */
594
595	struct jffs2_node_frag * newfrag2 = NULL;
596
597	if (hole->ofs + hole->size > newfrag->ofs + newfrag->size) {
598	/* The new frag also lefts some space at the right */
599	newfrag2 = new_fragment(NULL, newfrag->ofs +
600	newfrag->size, hole->ofs + hole->size
601	- newfrag->ofs - newfrag->size);
602	if (unlikely(!newfrag2)) {
603	jffs2_free_node_frag(newfrag);
604	return -ENOMEM;
605	}
606	}
607
608	hole->size = newfrag->ofs - hole->ofs;
609	dbg_fragtree2("left the hole %#04x-%#04x at the left and inserd fragment %#04x-%#04x\n",
610	hole->ofs, hole->ofs + hole->size, newfrag->ofs, newfrag->ofs + newfrag->size);
611
612	jffs2_fragtree_insert(newfrag, hole);
613	rb_insert_color(&newfrag->rb, root);
614
615	if (newfrag2) {
616	dbg_fragtree2("left the hole %#04x-%#04x at the right\n",
617	newfrag2->ofs, newfrag2->ofs + newfrag2->size);
618	jffs2_fragtree_insert(newfrag2, newfrag);
619	rb_insert_color(&newfrag2->rb, root);
620	}
621	}
622
623	return 0;
624	}
625
626	/*
627	* This function is used when we build inode. It expects the nodes are passed
628	* in the decreasing version order. The whole point of this is to improve the
629	* inodes checking on NAND: we check the nodes' data CRC only when they are not
630	* obsoleted. Previously, add_frag_to_fragtree() function was used and
631	* nodes were passed to it in the increasing version ordes and CRCs of all
632	* nodes were checked.
633	*
634	* Note: tn->fn->size shouldn't be zero.
635	*
636	* Returns 0 if the node was inserted
637	* 1 if it wasn't inserted (since it is obsolete)
638	* < 0 an if error occured
639	*/
640	int jffs2_add_older_frag_to_fragtree(struct jffs2_sb_info c, struct jffs2_inode_info f,
641	struct jffs2_tmp_dnode_info *tn)
642	{
643	struct jffs2_node_frag this, newfrag;
644	uint32_t lastend;
645	struct jffs2_full_dnode *fn = tn->fn;
646	struct rb_root *root = &f->fragtree;
647	uint32_t fn_size = fn->size, fn_ofs = fn->ofs;
648	int err, checked = 0;
649	int ref_flag;
650
651	dbg_fragtree("insert fragment %#04x-%#04x, ver %u\n", fn_ofs, fn_ofs + fn_size, tn->version);
652
653	/* Skip all the nodes which are completed before this one starts */
654	this = jffs2_lookup_node_frag(root, fn_ofs);
655	if (this)
656	dbg_fragtree2("'this' found %#04x-%#04x (%s)\n", this->ofs, this->ofs + this->size, this->node ? "data" : "hole");
657
658	if (this)
659	lastend = this->ofs + this->size;
660	else
661	lastend = 0;
662
663	/* Detect the preliminary type of node */
664	if (fn->size >= PAGE_CACHE_SIZE)
665	ref_flag = REF_PRISTINE;
666	else
667	ref_flag = REF_NORMAL;
668
669	/* See if we ran off the end of the root */
670	if (lastend <= fn_ofs) {
671	/* We did */
672
673	/*
674	* We are going to insert the new node into the
675	* fragment tree, so check it.
676	*/
677	err = check_node(c, f, tn);
678	if (err != 0)
679	return err;
680
681	fn->frags = 1;
682
683	newfrag = new_fragment(fn, fn_ofs, fn_size);
684	if (unlikely(!newfrag))
685	return -ENOMEM;
686
687	err = no_overlapping_node(c, root, newfrag, this, lastend);
688	if (unlikely(err != 0)) {
689	jffs2_free_node_frag(newfrag);
690	return err;
691	}
692
693	goto out_ok;
694	}
695
696	fn->frags = 0;
697
698	while (1) {
699	/*
700	* Here we have:
701	* fn_ofs < this->ofs + this->size && fn_ofs >= this->ofs.
702	*
703	* Remember, 'this' has higher version, any non-hole node
704	* which is already in the fragtree is newer then the newly
705	* inserted.
706	*/
707	if (!this->node) {
708	/*
709	* 'this' is the hole fragment, so at least the
710	* beginning of the new fragment is valid.
711	*/
712
713	/*
714	* We are going to insert the new node into the
715	* fragment tree, so check it.
716	*/
717	if (!checked) {
718	err = check_node(c, f, tn);
719	if (unlikely(err != 0))
720	return err;
721	checked = 1;
722	}
723
724	if (this->ofs + this->size >= fn_ofs + fn_size) {
725	/* We split the hole on two parts */
726
727	fn->frags += 1;
728	newfrag = new_fragment(fn, fn_ofs, fn_size);
729	if (unlikely(!newfrag))
730	return -ENOMEM;
731
732	err = split_hole(c, root, newfrag, this);
733	if (unlikely(err))
734	return err;
735	goto out_ok;
736	}
737
738	/*
739	* The beginning of the new fragment is valid since it
740	* overlaps the hole node.
741	*/
742
743	ref_flag = REF_NORMAL;
744
745	fn->frags += 1;
746	newfrag = new_fragment(fn, fn_ofs,
747	this->ofs + this->size - fn_ofs);
748	if (unlikely(!newfrag))
749	return -ENOMEM;
750
751	if (fn_ofs == this->ofs) {
752	/*
753	* The new node starts at the same offset as
754	* the hole and supersieds the hole.
755	*/
756	dbg_fragtree2("add the new fragment instead of hole %#04x-%#04x, refcnt %d\n",
757	fn_ofs, fn_ofs + this->ofs + this->size - fn_ofs, fn->frags);
758
759	rb_replace_node(&this->rb, &newfrag->rb, root);
760	jffs2_free_node_frag(this);
761	} else {
762	/*
763	* The hole becomes shorter as its right part
764	* is supersieded by the new fragment.
765	*/
766	dbg_fragtree2("reduce size of hole %#04x-%#04x to %#04x-%#04x\n",
767	this->ofs, this->ofs + this->size, this->ofs, this->ofs + this->size - newfrag->size);
768
769	dbg_fragtree2("add new fragment %#04x-%#04x, refcnt %d\n", fn_ofs,
770	fn_ofs + this->ofs + this->size - fn_ofs, fn->frags);
771
772	this->size -= newfrag->size;
773	jffs2_fragtree_insert(newfrag, this);
774	rb_insert_color(&newfrag->rb, root);
775	}
776
777	fn_ofs += newfrag->size;
778	fn_size -= newfrag->size;
779	this = rb_entry(rb_next(&newfrag->rb),
780	struct jffs2_node_frag, rb);
781
782	dbg_fragtree2("switch to the next 'this' fragment: %#04x-%#04x %s\n",
783	this->ofs, this->ofs + this->size, this->node ? "(data)" : "(hole)");
784	}
785
786	/*
787	* 'This' node is not the hole so it obsoletes the new fragment
788	* either fully or partially.
789	*/
790	if (this->ofs + this->size >= fn_ofs + fn_size) {
791	/* The new node is obsolete, drop it */
792	if (fn->frags == 0) {
793	dbg_fragtree2("%#04x-%#04x is obsolete, mark it obsolete\n", fn_ofs, fn_ofs + fn_size);
794	ref_flag = REF_OBSOLETE;
795	}
796	goto out_ok;
797	} else {
798	struct jffs2_node_frag *new_this;
799
800	/* 'This' node obsoletes the beginning of the new node */
801	dbg_fragtree2("the beginning %#04x-%#04x is obsolete\n", fn_ofs, this->ofs + this->size);
802
803	ref_flag = REF_NORMAL;
804
805	fn_size -= this->ofs + this->size - fn_ofs;
806	fn_ofs = this->ofs + this->size;
807	dbg_fragtree2("now considering %#04x-%#04x\n", fn_ofs, fn_ofs + fn_size);
808
809	new_this = rb_entry(rb_next(&this->rb), struct jffs2_node_frag, rb);
810	if (!new_this) {
811	/*
812	* There is no next fragment. Add the rest of
813	* the new node as the right-hand child.
814	*/
815	if (!checked) {
816	err = check_node(c, f, tn);
817	if (unlikely(err != 0))
818	return err;
819	checked = 1;
820	}
821
822	fn->frags += 1;
823	newfrag = new_fragment(fn, fn_ofs, fn_size);
824	if (unlikely(!newfrag))
825	return -ENOMEM;
826
827	dbg_fragtree2("there are no more fragments, insert %#04x-%#04x\n",
828	newfrag->ofs, newfrag->ofs + newfrag->size);
829	rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
830	rb_insert_color(&newfrag->rb, root);
831	goto out_ok;
832	} else {
833	this = new_this;
834	dbg_fragtree2("switch to the next 'this' fragment: %#04x-%#04x %s\n",
835	this->ofs, this->ofs + this->size, this->node ? "(data)" : "(hole)");
836	}
837	}
838	}
839
840	out_ok:
841	BUG_ON(fn->size < PAGE_CACHE_SIZE && ref_flag == REF_PRISTINE);
842
843	if (ref_flag == REF_OBSOLETE) {
844	dbg_fragtree2("the node is obsolete now\n");
845	/* jffs2_mark_node_obsolete() will adjust space accounting */
846	jffs2_mark_node_obsolete(c, fn->raw);
847	return 1;
848	}
849
850	dbg_fragtree2("the node is \"%s\" now\n", ref_flag == REF_NORMAL ? "REF_NORMAL" : "REF_PRISTINE");
851
852	/* Space accounting was adjusted at check_node_data() */
853	spin_lock(&c->erase_completion_lock);
854	fn->raw->flash_offset = ref_offset(fn->raw) \| ref_flag;
855	spin_unlock(&c->erase_completion_lock);
856
857	return 0;
858	}
859
860	void jffs2_set_inocache_state(struct jffs2_sb_info c, struct jffs2_inode_cache ic, int state)	400	void jffs2_set_inocache_state(struct jffs2_sb_info c, struct jffs2_inode_cache ic, int state)
861	{	401	{
862	spin_lock(&c->inocache_lock);	402	spin_lock(&c->inocache_lock);