arm: tegra: cardhu: remove NVSD debug message
[linux-2.6.git] / fs / jffs2 / readinode.c
index 5ea4faa..ee57bac 100644 (file)
@@ -1,14 +1,12 @@
 /*
  * JFFS2 -- Journalling Flash File System, Version 2.
  *
- * Copyright (C) 2001-2003 Red Hat, Inc.
+ * Copyright © 2001-2007 Red Hat, Inc.
  *
  * Created by David Woodhouse <dwmw2@infradead.org>
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: readinode.c,v 1.143 2005/11/07 11:14:41 gleixner Exp $
- *
  */
 
 #include <linux/kernel.h>
 #include "nodelist.h"
 
 /*
- * Put a new tmp_dnode_info into the temporaty RB-tree, keeping the list in
- * order of increasing version.
+ * Check the data CRC of the node.
+ *
+ * Returns: 0 if the data CRC is correct;
+ *         1 - if incorrect;
+ *         error code if an error occurred.
  */
-static void jffs2_add_tn_to_tree(struct jffs2_tmp_dnode_info *tn, struct rb_root *list)
+static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)
 {
-       struct rb_node **p = &list->rb_node;
-       struct rb_node * parent = NULL;
-       struct jffs2_tmp_dnode_info *this;
-
-       while (*p) {
-               parent = *p;
-               this = rb_entry(parent, struct jffs2_tmp_dnode_info, rb);
-
-               /* There may actually be a collision here, but it doesn't
-                  actually matter. As long as the two nodes with the same
-                  version are together, it's all fine. */
-               if (tn->version > this->version)
-                       p = &(*p)->rb_left;
+       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);
+
+       /* Calculate how many bytes were already checked */
+       ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);
+       len = tn->csize;
+
+       if (jffs2_is_writebuffered(c)) {
+               int adj = ofs % c->wbuf_pagesize;
+               if (likely(adj))
+                       adj = c->wbuf_pagesize - adj;
+
+               if (adj >= 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 += adj;
+               len -= adj;
+       }
+
+       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,
+                                   (void **)&buffer, NULL);
+               if (!err && retlen < len) {
+                       JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
+                       c->mtd->unpoint(c->mtd, ofs, retlen);
+               } else if (err)
+                       JFFS2_WARNING("MTD point failed: error code %d.\n", err);
                else
-                       p = &(*p)->rb_right;
+                       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, ofs, len);
+#endif
+
+       if (crc != tn->data_crc) {
+               JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
+                            ref_offset(ref), tn->data_crc, crc);
+               return 1;
+       }
+
+adj_acc:
+       jeb = &c->blocks[ref->flash_offset / c->sector_size];
+       len = ref_totlen(c, jeb, ref);
+       /* If it should be REF_NORMAL, it'll get marked as such when
+          we build the fragtree, shortly. No need to worry about GC
+          moving it while it's marked REF_PRISTINE -- GC won't happen
+          till we've finished checking every inode anyway. */
+       ref->flash_offset |= REF_PRISTINE;
+       /*
+        * 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;
+       jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
+       spin_unlock(&c->erase_completion_lock);
+
+       return 0;
+
+free_out:
+       if(!pointed)
+               kfree(buffer);
+#ifndef __ECOS
+       else
+               c->mtd->unpoint(c->mtd, 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_tn_node(struct jffs2_sb_info *c, 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_readinode("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_readinode("CRC error, mark it obsolete.\n");
+               jffs2_mark_node_obsolete(c, tn->fn->raw);
        }
 
-       rb_link_node(&tn->rb, parent, p);
-       rb_insert_color(&tn->rb, list);
+       return ret;
+}
+
+static struct jffs2_tmp_dnode_info *jffs2_lookup_tn(struct rb_root *tn_root, uint32_t offset)
+{
+       struct rb_node *next;
+       struct jffs2_tmp_dnode_info *tn = NULL;
+
+       dbg_readinode("root %p, offset %d\n", tn_root, offset);
+
+       next = tn_root->rb_node;
+
+       while (next) {
+               tn = rb_entry(next, struct jffs2_tmp_dnode_info, rb);
+
+               if (tn->fn->ofs < offset)
+                       next = tn->rb.rb_right;
+               else if (tn->fn->ofs >= offset)
+                       next = tn->rb.rb_left;
+               else
+                       break;
+       }
+
+       return tn;
+}
+
+
+static void jffs2_kill_tn(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)
+{
+       jffs2_mark_node_obsolete(c, tn->fn->raw);
+       jffs2_free_full_dnode(tn->fn);
+       jffs2_free_tmp_dnode_info(tn);
+}
+/*
+ * This function is used when we read an inode. Data nodes arrive in
+ * arbitrary order -- they may be older or newer than the nodes which
+ * are already in the tree. Where overlaps occur, the older node can
+ * be discarded as long as the newer passes the CRC check. We don't
+ * bother to keep track of holes in this rbtree, and neither do we deal
+ * with frags -- we can have multiple entries starting at the same
+ * offset, and the one with the smallest length will come first in the
+ * ordering.
+ *
+ * Returns 0 if the node was handled (including marking it obsolete)
+ *      < 0 an if error occurred
+ */
+static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
+                               struct jffs2_readinode_info *rii,
+                               struct jffs2_tmp_dnode_info *tn)
+{
+       uint32_t fn_end = tn->fn->ofs + tn->fn->size;
+       struct jffs2_tmp_dnode_info *this, *ptn;
+
+       dbg_readinode("insert fragment %#04x-%#04x, ver %u at %08x\n", tn->fn->ofs, fn_end, tn->version, ref_offset(tn->fn->raw));
+
+       /* If a node has zero dsize, we only have to keep if it if it might be the
+          node with highest version -- i.e. the one which will end up as f->metadata.
+          Note that such nodes won't be REF_UNCHECKED since there are no data to
+          check anyway. */
+       if (!tn->fn->size) {
+               if (rii->mdata_tn) {
+                       if (rii->mdata_tn->version < tn->version) {
+                               /* We had a candidate mdata node already */
+                               dbg_readinode("kill old mdata with ver %d\n", rii->mdata_tn->version);
+                               jffs2_kill_tn(c, rii->mdata_tn);
+                       } else {
+                               dbg_readinode("kill new mdata with ver %d (older than existing %d\n",
+                                             tn->version, rii->mdata_tn->version);
+                               jffs2_kill_tn(c, tn);
+                               return 0;
+                       }
+               }
+               rii->mdata_tn = tn;
+               dbg_readinode("keep new mdata with ver %d\n", tn->version);
+               return 0;
+       }
+
+       /* Find the earliest node which _may_ be relevant to this one */
+       this = jffs2_lookup_tn(&rii->tn_root, tn->fn->ofs);
+       if (this) {
+               /* If the node is coincident with another at a lower address,
+                  back up until the other node is found. It may be relevant */
+               while (this->overlapped) {
+                       ptn = tn_prev(this);
+                       if (!ptn) {
+                               /*
+                                * We killed a node which set the overlapped
+                                * flags during the scan. Fix it up.
+                                */
+                               this->overlapped = 0;
+                               break;
+                       }
+                       this = ptn;
+               }
+               dbg_readinode("'this' found %#04x-%#04x (%s)\n", this->fn->ofs, this->fn->ofs + this->fn->size, this->fn ? "data" : "hole");
+       }
+
+       while (this) {
+               if (this->fn->ofs > fn_end)
+                       break;
+               dbg_readinode("Ponder this ver %d, 0x%x-0x%x\n",
+                             this->version, this->fn->ofs, this->fn->size);
+
+               if (this->version == tn->version) {
+                       /* Version number collision means REF_PRISTINE GC. Accept either of them
+                          as long as the CRC is correct. Check the one we have already...  */
+                       if (!check_tn_node(c, this)) {
+                               /* The one we already had was OK. Keep it and throw away the new one */
+                               dbg_readinode("Like old node. Throw away new\n");
+                               jffs2_kill_tn(c, tn);
+                               return 0;
+                       } else {
+                               /* Who cares if the new one is good; keep it for now anyway. */
+                               dbg_readinode("Like new node. Throw away old\n");
+                               rb_replace_node(&this->rb, &tn->rb, &rii->tn_root);
+                               jffs2_kill_tn(c, this);
+                               /* Same overlapping from in front and behind */
+                               return 0;
+                       }
+               }
+               if (this->version < tn->version &&
+                   this->fn->ofs >= tn->fn->ofs &&
+                   this->fn->ofs + this->fn->size <= fn_end) {
+                       /* New node entirely overlaps 'this' */
+                       if (check_tn_node(c, tn)) {
+                               dbg_readinode("new node bad CRC\n");
+                               jffs2_kill_tn(c, tn);
+                               return 0;
+                       }
+                       /* ... and is good. Kill 'this' and any subsequent nodes which are also overlapped */
+                       while (this && this->fn->ofs + this->fn->size <= fn_end) {
+                               struct jffs2_tmp_dnode_info *next = tn_next(this);
+                               if (this->version < tn->version) {
+                                       tn_erase(this, &rii->tn_root);
+                                       dbg_readinode("Kill overlapped ver %d, 0x%x-0x%x\n",
+                                                     this->version, this->fn->ofs,
+                                                     this->fn->ofs+this->fn->size);
+                                       jffs2_kill_tn(c, this);
+                               }
+                               this = next;
+                       }
+                       dbg_readinode("Done killing overlapped nodes\n");
+                       continue;
+               }
+               if (this->version > tn->version &&
+                   this->fn->ofs <= tn->fn->ofs &&
+                   this->fn->ofs+this->fn->size >= fn_end) {
+                       /* New node entirely overlapped by 'this' */
+                       if (!check_tn_node(c, this)) {
+                               dbg_readinode("Good CRC on old node. Kill new\n");
+                               jffs2_kill_tn(c, tn);
+                               return 0;
+                       }
+                       /* ... but 'this' was bad. Replace it... */
+                       dbg_readinode("Bad CRC on old overlapping node. Kill it\n");
+                       tn_erase(this, &rii->tn_root);
+                       jffs2_kill_tn(c, this);
+                       break;
+               }
+
+               this = tn_next(this);
+       }
+
+       /* We neither completely obsoleted nor were completely
+          obsoleted by an earlier node. Insert into the tree */
+       {
+               struct rb_node *parent;
+               struct rb_node **link = &rii->tn_root.rb_node;
+               struct jffs2_tmp_dnode_info *insert_point = NULL;
+
+               while (*link) {
+                       parent = *link;
+                       insert_point = rb_entry(parent, struct jffs2_tmp_dnode_info, rb);
+                       if (tn->fn->ofs > insert_point->fn->ofs)
+                               link = &insert_point->rb.rb_right;
+                       else if (tn->fn->ofs < insert_point->fn->ofs ||
+                                tn->fn->size < insert_point->fn->size)
+                               link = &insert_point->rb.rb_left;
+                       else
+                               link = &insert_point->rb.rb_right;
+               }
+               rb_link_node(&tn->rb, &insert_point->rb, link);
+               rb_insert_color(&tn->rb, &rii->tn_root);
+       }
+
+       /* If there's anything behind that overlaps us, note it */
+       this = tn_prev(tn);
+       if (this) {
+               while (1) {
+                       if (this->fn->ofs + this->fn->size > tn->fn->ofs) {
+                               dbg_readinode("Node is overlapped by %p (v %d, 0x%x-0x%x)\n",
+                                             this, this->version, this->fn->ofs,
+                                             this->fn->ofs+this->fn->size);
+                               tn->overlapped = 1;
+                               break;
+                       }
+                       if (!this->overlapped)
+                               break;
+
+                       ptn = tn_prev(this);
+                       if (!ptn) {
+                               /*
+                                * We killed a node which set the overlapped
+                                * flags during the scan. Fix it up.
+                                */
+                               this->overlapped = 0;
+                               break;
+                       }
+                       this = ptn;
+               }
+       }
+
+       /* If the new node overlaps anything ahead, note it */
+       this = tn_next(tn);
+       while (this && this->fn->ofs < fn_end) {
+               this->overlapped = 1;
+               dbg_readinode("Node ver %d, 0x%x-0x%x is overlapped\n",
+                             this->version, this->fn->ofs,
+                             this->fn->ofs+this->fn->size);
+               this = tn_next(this);
+       }
+       return 0;
+}
+
+/* Trivial function to remove the last node in the tree. Which by definition
+   has no right-hand -- so can be removed just by making its only child (if
+   any) take its place under its parent. */
+static void eat_last(struct rb_root *root, struct rb_node *node)
+{
+       struct rb_node *parent = rb_parent(node);
+       struct rb_node **link;
+
+       /* LAST! */
+       BUG_ON(node->rb_right);
+
+       if (!parent)
+               link = &root->rb_node;
+       else if (node == parent->rb_left)
+               link = &parent->rb_left;
+       else
+               link = &parent->rb_right;
+
+       *link = node->rb_left;
+       /* Colour doesn't matter now. Only the parent pointer. */
+       if (node->rb_left)
+               node->rb_left->rb_parent_color = node->rb_parent_color;
+}
+
+/* We put this in reverse order, so we can just use eat_last */
+static void ver_insert(struct rb_root *ver_root, struct jffs2_tmp_dnode_info *tn)
+{
+       struct rb_node **link = &ver_root->rb_node;
+       struct rb_node *parent = NULL;
+       struct jffs2_tmp_dnode_info *this_tn;
+
+       while (*link) {
+               parent = *link;
+               this_tn = rb_entry(parent, struct jffs2_tmp_dnode_info, rb);
+
+               if (tn->version > this_tn->version)
+                       link = &parent->rb_left;
+               else
+                       link = &parent->rb_right;
+       }
+       dbg_readinode("Link new node at %p (root is %p)\n", link, ver_root);
+       rb_link_node(&tn->rb, parent, link);
+       rb_insert_color(&tn->rb, ver_root);
+}
+
+/* Build final, normal fragtree from tn tree. It doesn't matter which order
+   we add nodes to the real fragtree, as long as they don't overlap. And
+   having thrown away the majority of overlapped nodes as we went, there
+   really shouldn't be many sets of nodes which do overlap. If we start at
+   the end, we can use the overlap markers -- we can just eat nodes which
+   aren't overlapped, and when we encounter nodes which _do_ overlap we
+   sort them all into a temporary tree in version order before replaying them. */
+static int jffs2_build_inode_fragtree(struct jffs2_sb_info *c,
+                                     struct jffs2_inode_info *f,
+                                     struct jffs2_readinode_info *rii)
+{
+       struct jffs2_tmp_dnode_info *pen, *last, *this;
+       struct rb_root ver_root = RB_ROOT;
+       uint32_t high_ver = 0;
+
+       if (rii->mdata_tn) {
+               dbg_readinode("potential mdata is ver %d at %p\n", rii->mdata_tn->version, rii->mdata_tn);
+               high_ver = rii->mdata_tn->version;
+               rii->latest_ref = rii->mdata_tn->fn->raw;
+       }
+#ifdef JFFS2_DBG_READINODE_MESSAGES
+       this = tn_last(&rii->tn_root);
+       while (this) {
+               dbg_readinode("tn %p ver %d range 0x%x-0x%x ov %d\n", this, this->version, this->fn->ofs,
+                             this->fn->ofs+this->fn->size, this->overlapped);
+               this = tn_prev(this);
+       }
+#endif
+       pen = tn_last(&rii->tn_root);
+       while ((last = pen)) {
+               pen = tn_prev(last);
+
+               eat_last(&rii->tn_root, &last->rb);
+               ver_insert(&ver_root, last);
+
+               if (unlikely(last->overlapped)) {
+                       if (pen)
+                               continue;
+                       /*
+                        * We killed a node which set the overlapped
+                        * flags during the scan. Fix it up.
+                        */
+                       last->overlapped = 0;
+               }
+
+               /* Now we have a bunch of nodes in reverse version
+                  order, in the tree at ver_root. Most of the time,
+                  there'll actually be only one node in the 'tree',
+                  in fact. */
+               this = tn_last(&ver_root);
+
+               while (this) {
+                       struct jffs2_tmp_dnode_info *vers_next;
+                       int ret;
+                       vers_next = tn_prev(this);
+                       eat_last(&ver_root, &this->rb);
+                       if (check_tn_node(c, this)) {
+                               dbg_readinode("node ver %d, 0x%x-0x%x failed CRC\n",
+                                            this->version, this->fn->ofs,
+                                            this->fn->ofs+this->fn->size);
+                               jffs2_kill_tn(c, this);
+                       } else {
+                               if (this->version > high_ver) {
+                                       /* Note that this is different from the other
+                                          highest_version, because this one is only
+                                          counting _valid_ nodes which could give the
+                                          latest inode metadata */
+                                       high_ver = this->version;
+                                       rii->latest_ref = this->fn->raw;
+                               }
+                               dbg_readinode("Add %p (v %d, 0x%x-0x%x, ov %d) to fragtree\n",
+                                            this, this->version, this->fn->ofs,
+                                            this->fn->ofs+this->fn->size, this->overlapped);
+
+                               ret = jffs2_add_full_dnode_to_inode(c, f, this->fn);
+                               if (ret) {
+                                       /* Free the nodes in vers_root; let the caller
+                                          deal with the rest */
+                                       JFFS2_ERROR("Add node to tree failed %d\n", ret);
+                                       while (1) {
+                                               vers_next = tn_prev(this);
+                                               if (check_tn_node(c, this))
+                                                       jffs2_mark_node_obsolete(c, this->fn->raw);
+                                               jffs2_free_full_dnode(this->fn);
+                                               jffs2_free_tmp_dnode_info(this);
+                                               this = vers_next;
+                                               if (!this)
+                                                       break;
+                                               eat_last(&ver_root, &vers_next->rb);
+                                       }
+                                       return ret;
+                               }
+                               jffs2_free_tmp_dnode_info(this);
+                       }
+                       this = vers_next;
+               }
+       }
+       return 0;
 }
 
 static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
@@ -66,7 +556,7 @@ static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
                        jffs2_free_full_dnode(tn->fn);
                        jffs2_free_tmp_dnode_info(tn);
 
-                       this = this->rb_parent;
+                       this = rb_parent(this);
                        if (!this)
                                break;
 
@@ -77,7 +567,7 @@ static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
                        else BUG();
                }
        }
-       list->rb_node = NULL;
+       *list = RB_ROOT;
 }
 
 static void jffs2_free_full_dirent_list(struct jffs2_full_dirent *fd)
@@ -107,13 +597,12 @@ static struct jffs2_raw_node_ref *jffs2_first_valid_node(struct jffs2_raw_node_r
  * Helper function for jffs2_get_inode_nodes().
  * It is called every time an directory entry node is found.
  *
- * Returns: 0 on succes;
- *         1 if the node should be marked obsolete;
+ * Returns: 0 on success;
  *         negative error code on failure.
  */
 static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
-                               struct jffs2_raw_dirent *rd, size_t read, struct jffs2_full_dirent **fdp,
-                               uint32_t *latest_mctime, uint32_t *mctime_ver)
+                               struct jffs2_raw_dirent *rd, size_t read,
+                               struct jffs2_readinode_info *rii)
 {
        struct jffs2_full_dirent *fd;
        uint32_t crc;
@@ -125,7 +614,8 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
        if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
                JFFS2_NOTICE("header CRC failed on dirent node at %#08x: read %#08x, calculated %#08x\n",
                             ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
-               return 1;
+               jffs2_mark_node_obsolete(c, ref);
+               return 0;
        }
 
        /* If we've never checked the CRCs on this node, check them now */
@@ -137,7 +627,8 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
                if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) {
                        JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n",
                                    ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen));
-                       return 1;
+                       jffs2_mark_node_obsolete(c, ref);
+                       return 0;
                }
 
                jeb = &c->blocks[ref->flash_offset / c->sector_size];
@@ -148,7 +639,7 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
                jeb->unchecked_size -= len;
                c->used_size += len;
                c->unchecked_size -= len;
-               ref->flash_offset = ref_offset(ref) | REF_PRISTINE;
+               ref->flash_offset = ref_offset(ref) | dirent_node_state(rd);
                spin_unlock(&c->erase_completion_lock);
        }
 
@@ -161,10 +652,13 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
        fd->ino = je32_to_cpu(rd->ino);
        fd->type = rd->type;
 
+       if (fd->version > rii->highest_version)
+               rii->highest_version = fd->version;
+
        /* Pick out the mctime of the latest dirent */
-       if(fd->version > *mctime_ver && je32_to_cpu(rd->mctime)) {
-               *mctime_ver = fd->version;
-               *latest_mctime = je32_to_cpu(rd->mctime);
+       if(fd->version > rii->mctime_ver && je32_to_cpu(rd->mctime)) {
+               rii->mctime_ver = fd->version;
+               rii->latest_mctime = je32_to_cpu(rd->mctime);
        }
 
        /*
@@ -201,7 +695,7 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
         * Wheee. We now have a complete jffs2_full_dirent structure, with
         * the name in it and everything. Link it into the list
         */
-       jffs2_add_fd_to_list(c, fd, fdp);
+       jffs2_add_fd_to_list(c, fd, &rii->fds);
 
        return 0;
 }
@@ -210,17 +704,16 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
  * Helper function for jffs2_get_inode_nodes().
  * It is called every time an inode node is found.
  *
- * Returns: 0 on succes;
- *         1 if the node should be marked obsolete;
+ * Returns: 0 on success (possibly after marking a bad node obsolete);
  *         negative error code on failure.
  */
 static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
-                            struct jffs2_raw_inode *rd, struct rb_root *tnp, int rdlen,
-                            uint32_t *latest_mctime, uint32_t *mctime_ver)
+                            struct jffs2_raw_inode *rd, int rdlen,
+                            struct jffs2_readinode_info *rii)
 {
        struct jffs2_tmp_dnode_info *tn;
        uint32_t len, csize;
-       int ret = 1;
+       int ret = 0;
        uint32_t crc;
 
        /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
@@ -230,7 +723,8 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
        if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
                JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n",
                             ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
-               return 1;
+               jffs2_mark_node_obsolete(c, ref);
+               return 0;
        }
 
        tn = jffs2_alloc_tmp_dnode_info();
@@ -248,8 +742,9 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                /* Sanity checks */
                if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) ||
                    unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) {
-                               JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref));
-                               jffs2_dbg_dump_node(c, ref_offset(ref));
+                       JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref));
+                       jffs2_dbg_dump_node(c, ref_offset(ref));
+                       jffs2_mark_node_obsolete(c, ref);
                        goto free_out;
                }
 
@@ -272,7 +767,7 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                         * are not obsolete.
                         *
                         * Of course, this optimization only makes sense in case
-                        * of NAND flashes (or other flashes whith
+                        * of NAND flashes (or other flashes with
                         * !jffs2_can_mark_obsolete()), since on NOR flashes
                         * nodes are marked obsolete physically.
                         *
@@ -304,6 +799,7 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
                        if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) {
                                JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
                                        ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc));
+                               jffs2_mark_node_obsolete(c, ref);
                                goto free_out;
                        }
 
@@ -342,6 +838,10 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
        tn->data_crc = je32_to_cpu(rd->data_crc);
        tn->csize = csize;
        tn->fn->raw = ref;
+       tn->overlapped = 0;
+
+       if (tn->version > rii->highest_version)
+               rii->highest_version = tn->version;
 
        /* There was a bug where we wrote hole nodes out with
           csize/dsize swapped. Deal with it */
@@ -350,16 +850,29 @@ static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref
        else // normal case...
                tn->fn->size = je32_to_cpu(rd->dsize);
 
-       dbg_readinode("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n",
-                 ref_offset(ref), je32_to_cpu(rd->version), je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize);
+       dbg_readinode2("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n",
+                      ref_offset(ref), je32_to_cpu(rd->version),
+                      je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize);
 
-       jffs2_add_tn_to_tree(tn, tnp);
+       ret = jffs2_add_tn_to_tree(c, rii, tn);
 
+       if (ret) {
+               jffs2_free_full_dnode(tn->fn);
+       free_out:
+               jffs2_free_tmp_dnode_info(tn);
+               return ret;
+       }
+#ifdef JFFS2_DBG_READINODE2_MESSAGES
+       dbg_readinode2("After adding ver %d:\n", je32_to_cpu(rd->version));
+       tn = tn_first(&rii->tn_root);
+       while (tn) {
+               dbg_readinode2("%p: v %d r 0x%x-0x%x ov %d\n",
+                              tn, tn->version, tn->fn->ofs,
+                              tn->fn->ofs+tn->fn->size, tn->overlapped);
+               tn = tn_next(tn);
+       }
+#endif
        return 0;
-
-free_out:
-       jffs2_free_tmp_dnode_info(tn);
-       return ret;
 }
 
 /*
@@ -367,13 +880,20 @@ free_out:
  * It is called every time an unknown node is found.
  *
  * Returns: 0 on success;
- *         1 if the node should be marked obsolete;
  *         negative error code on failure.
  */
 static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, struct jffs2_unknown_node *un)
 {
        /* We don't mark unknown nodes as REF_UNCHECKED */
-       BUG_ON(ref_flags(ref) == REF_UNCHECKED);
+       if (ref_flags(ref) == REF_UNCHECKED) {
+               JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n",
+                           ref_offset(ref));
+               JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n",
+                           je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
+                           je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
+               jffs2_mark_node_obsolete(c, ref);
+               return 0;
+       }
 
        un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype));
 
@@ -400,7 +920,8 @@ static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_re
        case JFFS2_FEATURE_RWCOMPAT_DELETE:
                JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n",
                             je16_to_cpu(un->nodetype), ref_offset(ref));
-               return 1;
+               jffs2_mark_node_obsolete(c, ref);
+               return 0;
        }
 
        return 0;
@@ -410,96 +931,66 @@ static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_re
  * Helper function for jffs2_get_inode_nodes().
  * The function detects whether more data should be read and reads it if yes.
  *
- * Returns: 0 on succes;
+ * Returns: 0 on success;
  *         negative error code on failure.
  */
 static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
-                    int right_size, int *rdlen, unsigned char *buf, unsigned char *bufstart)
+                    int needed_len, int *rdlen, unsigned char *buf)
 {
-       int right_len, err, len;
+       int err, to_read = needed_len - *rdlen;
        size_t retlen;
        uint32_t offs;
 
        if (jffs2_is_writebuffered(c)) {
-               right_len = c->wbuf_pagesize - (bufstart - buf);
-               if (right_size + (int)(bufstart - buf) > c->wbuf_pagesize)
-                       right_len += c->wbuf_pagesize;
-       } else
-               right_len = right_size;
+               int rem = to_read % c->wbuf_pagesize;
 
-       if (*rdlen == right_len)
-               return 0;
+               if (rem)
+                       to_read += c->wbuf_pagesize - rem;
+       }
 
        /* We need to read more data */
        offs = ref_offset(ref) + *rdlen;
-       if (jffs2_is_writebuffered(c)) {
-               bufstart = buf + c->wbuf_pagesize;
-               len = c->wbuf_pagesize;
-       } else {
-               bufstart = buf + *rdlen;
-               len = right_size - *rdlen;
-       }
 
-       dbg_readinode("read more %d bytes\n", len);
+       dbg_readinode("read more %d bytes\n", to_read);
 
-       err = jffs2_flash_read(c, offs, len, &retlen, bufstart);
+       err = jffs2_flash_read(c, offs, to_read, &retlen, buf + *rdlen);
        if (err) {
                JFFS2_ERROR("can not read %d bytes from 0x%08x, "
-                       "error code: %d.\n", len, offs, err);
+                       "error code: %d.\n", to_read, offs, err);
                return err;
        }
 
-       if (retlen < len) {
+       if (retlen < to_read) {
                JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n",
-                               offs, retlen, len);
+                               offs, retlen, to_read);
                return -EIO;
        }
 
-       *rdlen = right_len;
-
+       *rdlen += to_read;
        return 0;
 }
 
 /* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
-   with this ino, returning the former in order of version */
+   with this ino. Perform a preliminary ordering on data nodes, throwing away
+   those which are completely obsoleted by newer ones. The naïve approach we
+   use to take of just returning them _all_ in version order will cause us to
+   run out of memory in certain degenerate cases. */
 static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
-                                struct rb_root *tnp, struct jffs2_full_dirent **fdp,
-                                uint32_t *highest_version, uint32_t *latest_mctime,
-                                uint32_t *mctime_ver)
+                                struct jffs2_readinode_info *rii)
 {
        struct jffs2_raw_node_ref *ref, *valid_ref;
-       struct rb_root ret_tn = RB_ROOT;
-       struct jffs2_full_dirent *ret_fd = NULL;
        unsigned char *buf = NULL;
        union jffs2_node_union *node;
        size_t retlen;
        int len, err;
 
-       *mctime_ver = 0;
+       rii->mctime_ver = 0;
 
        dbg_readinode("ino #%u\n", f->inocache->ino);
 
-       if (jffs2_is_writebuffered(c)) {
-               /*
-                * If we have the write buffer, we assume the minimal I/O unit
-                * is c->wbuf_pagesize. We implement some optimizations which in
-                * this case and we need a temporary buffer of size =
-                * 2*c->wbuf_pagesize bytes (see comments in read_dnode()).
-                * Basically, we want to read not only the node header, but the
-                * whole wbuf (NAND page in case of NAND) or 2, if the node
-                * header overlaps the border between the 2 wbufs.
-                */
-               len = 2*c->wbuf_pagesize;
-       } else {
-               /*
-                * When there is no write buffer, the size of the temporary
-                * buffer is the size of the larges node header.
-                */
-               len = sizeof(union jffs2_node_union);
-       }
-
        /* FIXME: in case of NOR and available ->point() this
         * needs to be fixed. */
+       len = sizeof(union jffs2_node_union) + c->wbuf_pagesize;
        buf = kmalloc(len, GFP_KERNEL);
        if (!buf)
                return -ENOMEM;
@@ -509,8 +1000,6 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
        if (!valid_ref && f->inocache->ino != 1)
                JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
        while (valid_ref) {
-               unsigned char *bufstart;
-
                /* We can hold a pointer to a non-obsolete node without the spinlock,
                   but _obsolete_ nodes may disappear at any time, if the block
                   they're in gets erased. So if we mark 'ref' obsolete while we're
@@ -526,34 +1015,33 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
                /*
                 * At this point we don't know the type of the node we're going
                 * to read, so we do not know the size of its header. In order
-                * to minimize the amount of flash IO we assume the node has
-                * size = JFFS2_MIN_NODE_HEADER.
+                * to minimize the amount of flash IO we assume the header is
+                * of size = JFFS2_MIN_NODE_HEADER.
                 */
+               len = JFFS2_MIN_NODE_HEADER;
                if (jffs2_is_writebuffered(c)) {
+                       int end, rem;
+
                        /*
-                        * We treat 'buf' as 2 adjacent wbufs. We want to
-                        * adjust bufstart such as it points to the
-                        * beginning of the node within this wbuf.
+                        * We are about to read JFFS2_MIN_NODE_HEADER bytes,
+                        * but this flash has some minimal I/O unit. It is
+                        * possible that we'll need to read more soon, so read
+                        * up to the next min. I/O unit, in order not to
+                        * re-read the same min. I/O unit twice.
                         */
-                       bufstart = buf + (ref_offset(ref) % c->wbuf_pagesize);
-                       /* We will read either one wbuf or 2 wbufs. */
-                       len = c->wbuf_pagesize - (bufstart - buf);
-                       if (JFFS2_MIN_NODE_HEADER + (int)(bufstart - buf) > c->wbuf_pagesize) {
-                               /* The header spans the border of the first wbuf */
-                               len += c->wbuf_pagesize;
-                       }
-               } else {
-                       bufstart = buf;
-                       len = JFFS2_MIN_NODE_HEADER;
+                       end = ref_offset(ref) + len;
+                       rem = end % c->wbuf_pagesize;
+                       if (rem)
+                               end += c->wbuf_pagesize - rem;
+                       len = end - ref_offset(ref);
                }
 
                dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
 
                /* FIXME: point() */
-               err = jffs2_flash_read(c, ref_offset(ref), len,
-                                      &retlen, bufstart);
+               err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf);
                if (err) {
-                       JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err);
+                       JFFS2_ERROR("can not read %d bytes from 0x%08x, error code: %d.\n", len, ref_offset(ref), err);
                        goto free_out;
                }
 
@@ -563,7 +1051,7 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
                        goto free_out;
                }
 
-               node = (union jffs2_node_union *)bufstart;
+               node = (union jffs2_node_union *)buf;
 
                /* No need to mask in the valid bit; it shouldn't be invalid */
                if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) {
@@ -576,61 +1064,56 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
                        jffs2_mark_node_obsolete(c, ref);
                        goto cont;
                }
+               if (je16_to_cpu(node->u.magic) != JFFS2_MAGIC_BITMASK) {
+                       /* Not a JFFS2 node, whinge and move on */
+                       JFFS2_NOTICE("Wrong magic bitmask 0x%04x in node header at %#08x.\n",
+                                    je16_to_cpu(node->u.magic), ref_offset(ref));
+                       jffs2_mark_node_obsolete(c, ref);
+                       goto cont;
+               }
 
                switch (je16_to_cpu(node->u.nodetype)) {
 
                case JFFS2_NODETYPE_DIRENT:
 
-                       if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent)) {
-                               err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf, bufstart);
+                       if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent) &&
+                           len < sizeof(struct jffs2_raw_dirent)) {
+                               err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf);
                                if (unlikely(err))
                                        goto free_out;
                        }
 
-                       err = read_direntry(c, ref, &node->d, retlen, &ret_fd, latest_mctime, mctime_ver);
-                       if (err == 1) {
-                               jffs2_mark_node_obsolete(c, ref);
-                               break;
-                       } else if (unlikely(err))
+                       err = read_direntry(c, ref, &node->d, retlen, rii);
+                       if (unlikely(err))
                                goto free_out;
 
-                       if (je32_to_cpu(node->d.version) > *highest_version)
-                               *highest_version = je32_to_cpu(node->d.version);
-
                        break;
 
                case JFFS2_NODETYPE_INODE:
 
-                       if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode)) {
-                               err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf, bufstart);
+                       if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode) &&
+                           len < sizeof(struct jffs2_raw_inode)) {
+                               err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf);
                                if (unlikely(err))
                                        goto free_out;
                        }
 
-                       err = read_dnode(c, ref, &node->i, &ret_tn, len, latest_mctime, mctime_ver);
-                       if (err == 1) {
-                               jffs2_mark_node_obsolete(c, ref);
-                               break;
-                       } else if (unlikely(err))
+                       err = read_dnode(c, ref, &node->i, len, rii);
+                       if (unlikely(err))
                                goto free_out;
 
-                       if (je32_to_cpu(node->i.version) > *highest_version)
-                               *highest_version = je32_to_cpu(node->i.version);
-
                        break;
 
                default:
-                       if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node)) {
-                               err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf, bufstart);
+                       if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node) &&
+                           len < sizeof(struct jffs2_unknown_node)) {
+                               err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf);
                                if (unlikely(err))
                                        goto free_out;
                        }
 
                        err = read_unknown(c, ref, &node->u);
-                       if (err == 1) {
-                               jffs2_mark_node_obsolete(c, ref);
-                               break;
-                       } else if (unlikely(err))
+                       if (unlikely(err))
                                goto free_out;
 
                }
@@ -639,17 +1122,19 @@ static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_inf
        }
 
        spin_unlock(&c->erase_completion_lock);
-       *tnp = ret_tn;
-       *fdp = ret_fd;
        kfree(buf);
 
+       f->highest_version = rii->highest_version;
+
        dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n",
-                       f->inocache->ino, *highest_version, *latest_mctime, *mctime_ver);
+                     f->inocache->ino, rii->highest_version, rii->latest_mctime,
+                     rii->mctime_ver);
        return 0;
 
  free_out:
-       jffs2_free_tmp_dnode_info_list(&ret_tn);
-       jffs2_free_full_dirent_list(ret_fd);
+       jffs2_free_tmp_dnode_info_list(&rii->tn_root);
+       jffs2_free_full_dirent_list(rii->fds);
+       rii->fds = NULL;
        kfree(buf);
        return err;
 }
@@ -658,20 +1143,18 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                                        struct jffs2_inode_info *f,
                                        struct jffs2_raw_inode *latest_node)
 {
-       struct jffs2_tmp_dnode_info *tn;
-       struct rb_root tn_list;
-       struct rb_node *rb, *repl_rb;
-       struct jffs2_full_dirent *fd_list;
-       struct jffs2_full_dnode *fn, *first_fn = NULL;
-       uint32_t crc;
-       uint32_t latest_mctime, mctime_ver;
+       struct jffs2_readinode_info rii;
+       uint32_t crc, new_size;
        size_t retlen;
        int ret;
 
-       dbg_readinode("ino #%u nlink is %d\n", f->inocache->ino, f->inocache->nlink);
+       dbg_readinode("ino #%u pino/nlink is %d\n", f->inocache->ino,
+                     f->inocache->pino_nlink);
+
+       memset(&rii, 0, sizeof(rii));
 
        /* Grab all nodes relevant to this ino */
-       ret = jffs2_get_inode_nodes(c, f, &tn_list, &fd_list, &f->highest_version, &latest_mctime, &mctime_ver);
+       ret = jffs2_get_inode_nodes(c, f, &rii);
 
        if (ret) {
                JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret);
@@ -679,74 +1162,42 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                        jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
                return ret;
        }
-       f->dents = fd_list;
 
-       rb = rb_first(&tn_list);
-
-       while (rb) {
-               cond_resched();
-               tn = rb_entry(rb, struct jffs2_tmp_dnode_info, rb);
-               fn = tn->fn;
-               ret = 1;
-               dbg_readinode("consider node ver %u, phys offset "
-                       "%#08x(%d), range %u-%u.\n", tn->version,
-                       ref_offset(fn->raw), ref_flags(fn->raw),
-                       fn->ofs, fn->ofs + fn->size);
-
-               if (fn->size) {
-                       ret = jffs2_add_older_frag_to_fragtree(c, f, tn);
-                       /* TODO: the error code isn't checked, check it */
-                       jffs2_dbg_fragtree_paranoia_check_nolock(f);
-                       BUG_ON(ret < 0);
-                       if (!first_fn && ret == 0)
-                               first_fn = fn;
-               } else if (!first_fn) {
-                       first_fn = fn;
-                       f->metadata = fn;
-                       ret = 0; /* Prevent freeing the metadata update node */
-               } else
-                       jffs2_mark_node_obsolete(c, fn->raw);
-
-               BUG_ON(rb->rb_left);
-               if (rb->rb_parent && rb->rb_parent->rb_left == rb) {
-                       /* We were then left-hand child of our parent. We need
-                        * to move our own right-hand child into our place. */
-                       repl_rb = rb->rb_right;
-                       if (repl_rb)
-                               repl_rb->rb_parent = rb->rb_parent;
-               } else
-                       repl_rb = NULL;
-
-               rb = rb_next(rb);
-
-               /* Remove the spent tn from the tree; don't bother rebalancing
-                * but put our right-hand child in our own place. */
-               if (tn->rb.rb_parent) {
-                       if (tn->rb.rb_parent->rb_left == &tn->rb)
-                               tn->rb.rb_parent->rb_left = repl_rb;
-                       else if (tn->rb.rb_parent->rb_right == &tn->rb)
-                               tn->rb.rb_parent->rb_right = repl_rb;
-                       else BUG();
-               } else if (tn->rb.rb_right)
-                       tn->rb.rb_right->rb_parent = NULL;
+       ret = jffs2_build_inode_fragtree(c, f, &rii);
+       if (ret) {
+               JFFS2_ERROR("Failed to build final fragtree for inode #%u: error %d\n",
+                           f->inocache->ino, ret);
+               if (f->inocache->state == INO_STATE_READING)
+                       jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
+               jffs2_free_tmp_dnode_info_list(&rii.tn_root);
+               /* FIXME: We could at least crc-check them all */
+               if (rii.mdata_tn) {
+                       jffs2_free_full_dnode(rii.mdata_tn->fn);
+                       jffs2_free_tmp_dnode_info(rii.mdata_tn);
+                       rii.mdata_tn = NULL;
+               }
+               return ret;
+       }
 
-               jffs2_free_tmp_dnode_info(tn);
-               if (ret) {
-                       dbg_readinode("delete dnode %u-%u.\n",
-                               fn->ofs, fn->ofs + fn->size);
-                       jffs2_free_full_dnode(fn);
+       if (rii.mdata_tn) {
+               if (rii.mdata_tn->fn->raw == rii.latest_ref) {
+                       f->metadata = rii.mdata_tn->fn;
+                       jffs2_free_tmp_dnode_info(rii.mdata_tn);
+               } else {
+                       jffs2_kill_tn(c, rii.mdata_tn);
                }
+               rii.mdata_tn = NULL;
        }
-       jffs2_dbg_fragtree_paranoia_check_nolock(f);
 
-       BUG_ON(first_fn && ref_obsolete(first_fn->raw));
+       f->dents = rii.fds;
 
-       fn = first_fn;
-       if (unlikely(!first_fn)) {
+       jffs2_dbg_fragtree_paranoia_check_nolock(f);
+
+       if (unlikely(!rii.latest_ref)) {
                /* No data nodes for this inode. */
                if (f->inocache->ino != 1) {
                        JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino);
-                       if (!fd_list) {
+                       if (!rii.fds) {
                                if (f->inocache->state == INO_STATE_READING)
                                        jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
                                return -EIO;
@@ -764,12 +1215,12 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                return 0;
        }
 
-       ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(*latest_node), &retlen, (void *)latest_node);
+       ret = jffs2_flash_read(c, ref_offset(rii.latest_ref), sizeof(*latest_node), &retlen, (void *)latest_node);
        if (ret || retlen != sizeof(*latest_node)) {
                JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n",
                        ret, retlen, sizeof(*latest_node));
                /* FIXME: If this fails, there seems to be a memory leak. Find it. */
-               up(&f->sem);
+               mutex_unlock(&f->sem);
                jffs2_do_clear_inode(c, f);
                return ret?ret:-EIO;
        }
@@ -777,25 +1228,30 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
        crc = crc32(0, latest_node, sizeof(*latest_node)-8);
        if (crc != je32_to_cpu(latest_node->node_crc)) {
                JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n",
-                       f->inocache->ino, ref_offset(fn->raw));
-               up(&f->sem);
+                       f->inocache->ino, ref_offset(rii.latest_ref));
+               mutex_unlock(&f->sem);
                jffs2_do_clear_inode(c, f);
                return -EIO;
        }
 
        switch(jemode_to_cpu(latest_node->mode) & S_IFMT) {
        case S_IFDIR:
-               if (mctime_ver > je32_to_cpu(latest_node->version)) {
+               if (rii.mctime_ver > je32_to_cpu(latest_node->version)) {
                        /* The times in the latest_node are actually older than
                           mctime in the latest dirent. Cheat. */
-                       latest_node->ctime = latest_node->mtime = cpu_to_je32(latest_mctime);
+                       latest_node->ctime = latest_node->mtime = cpu_to_je32(rii.latest_mctime);
                }
                break;
 
 
        case S_IFREG:
                /* If it was a regular file, truncate it to the latest node's isize */
-               jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize));
+               new_size = jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize));
+               if (new_size != je32_to_cpu(latest_node->isize)) {
+                       JFFS2_WARNING("Truncating ino #%u to %d bytes failed because it only had %d bytes to start with!\n",
+                                     f->inocache->ino, je32_to_cpu(latest_node->isize), new_size);
+                       latest_node->isize = cpu_to_je32(new_size);
+               }
                break;
 
        case S_IFLNK:
@@ -813,12 +1269,12 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                        f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL);
                        if (!f->target) {
                                JFFS2_ERROR("can't allocate %d bytes of memory for the symlink target path cache\n", je32_to_cpu(latest_node->csize));
-                               up(&f->sem);
+                               mutex_unlock(&f->sem);
                                jffs2_do_clear_inode(c, f);
                                return -ENOMEM;
                        }
 
-                       ret = jffs2_flash_read(c, ref_offset(fn->raw) + sizeof(*latest_node),
+                       ret = jffs2_flash_read(c, ref_offset(rii.latest_ref) + sizeof(*latest_node),
                                                je32_to_cpu(latest_node->csize), &retlen, (char *)f->target);
 
                        if (ret  || retlen != je32_to_cpu(latest_node->csize)) {
@@ -826,9 +1282,9 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                                        ret = -EIO;
                                kfree(f->target);
                                f->target = NULL;
-                               up(&f->sem);
+                               mutex_unlock(&f->sem);
                                jffs2_do_clear_inode(c, f);
-                               return -ret;
+                               return ret;
                        }
 
                        f->target[je32_to_cpu(latest_node->csize)] = '\0';
@@ -844,14 +1300,14 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                if (f->metadata) {
                        JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n",
                               f->inocache->ino, jemode_to_cpu(latest_node->mode));
-                       up(&f->sem);
+                       mutex_unlock(&f->sem);
                        jffs2_do_clear_inode(c, f);
                        return -EIO;
                }
                if (!frag_first(&f->fragtree)) {
                        JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n",
                               f->inocache->ino, jemode_to_cpu(latest_node->mode));
-                       up(&f->sem);
+                       mutex_unlock(&f->sem);
                        jffs2_do_clear_inode(c, f);
                        return -EIO;
                }
@@ -860,7 +1316,7 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                        JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n",
                               f->inocache->ino, jemode_to_cpu(latest_node->mode));
                        /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
-                       up(&f->sem);
+                       mutex_unlock(&f->sem);
                        jffs2_do_clear_inode(c, f);
                        return -EIO;
                }
@@ -928,7 +1384,7 @@ int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                }
                dbg_readinode("creating inocache for root inode\n");
                memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
-               f->inocache->ino = f->inocache->nlink = 1;
+               f->inocache->ino = f->inocache->pino_nlink = 1;
                f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
                f->inocache->state = INO_STATE_READING;
                jffs2_add_ino_cache(c, f->inocache);
@@ -944,19 +1400,19 @@ int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
 {
        struct jffs2_raw_inode n;
-       struct jffs2_inode_info *f = kmalloc(sizeof(*f), GFP_KERNEL);
+       struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
        int ret;
 
        if (!f)
                return -ENOMEM;
 
-       memset(f, 0, sizeof(*f));
-       init_MUTEX_LOCKED(&f->sem);
+       mutex_init(&f->sem);
+       mutex_lock(&f->sem);
        f->inocache = ic;
 
        ret = jffs2_do_read_inode_internal(c, f, &n);
        if (!ret) {
-               up(&f->sem);
+               mutex_unlock(&f->sem);
                jffs2_do_clear_inode(c, f);
        }
        kfree (f);
@@ -968,8 +1424,9 @@ void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
        struct jffs2_full_dirent *fd, *fds;
        int deleted;
 
-       down(&f->sem);
-       deleted = f->inocache && !f->inocache->nlink;
+       jffs2_xattr_delete_inode(c, f->inocache);
+       mutex_lock(&f->sem);
+       deleted = f->inocache && !f->inocache->pino_nlink;
 
        if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
                jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
@@ -1000,5 +1457,5 @@ void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
                        jffs2_del_ino_cache(c, f->inocache);
        }
 
-       up(&f->sem);
+       mutex_unlock(&f->sem);
 }