fs/jffs2/readinode.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@redhat.com>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: readinode.c,v 1.113 2003/11/03 13:20:33 dwmw2 Exp $
  11  *
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/slab.h>
  16 #include <linux/fs.h>
  17 #include <linux/crc32.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/mtd/mtd.h>
  20 #include <linux/compiler.h>
  21 #include "nodelist.h"
  22
  23 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *list, struct jffs2_node_frag *newfrag);
  24
  25 #if CONFIG_JFFS2_FS_DEBUG >= 1
  26 static void jffs2_print_fragtree(struct rb_root *list, int permitbug)
  27 {
  28         struct jffs2_node_frag *this = frag_first(list);
  29         uint32_t lastofs = 0;
  30         int buggy = 0;
  31
  32         while(this) {
  33                 if (this->node)
  34                         printk(KERN_DEBUG "frag %04x-%04x: 0x%08x(%d) on flash (*%p). left (%p), right (%p), parent (%p)\n",
  35                                this->ofs, this->ofs+this->size, ref_offset(this->node->raw), ref_flags(this->node->raw),
  36                                this, frag_left(this), frag_right(this), frag_parent(this));
  37                 else
  38                         printk(KERN_DEBUG "frag %04x-%04x: hole (*%p). left (%p} right (%p), parent (%p)\n", this->ofs,
  39                                this->ofs+this->size, this, frag_left(this), frag_right(this), frag_parent(this));
  40                 if (this->ofs != lastofs)
  41                         buggy = 1;
  42                 lastofs = this->ofs+this->size;
  43                 this = frag_next(this);
  44         }
  45         if (buggy && !permitbug) {
  46                 printk(KERN_CRIT "Frag tree got a hole in it\n");
  47                 BUG();
  48         }
  49 }
  50
  51 void jffs2_print_frag_list(struct jffs2_inode_info *f)
  52 {
  53         jffs2_print_fragtree(&f->fragtree, 0);
  54
  55         if (f->metadata) {
  56                 printk(KERN_DEBUG "metadata at 0x%08x\n", ref_offset(f->metadata->raw));
  57         }
  58 }
  59
  60 static int jffs2_sanitycheck_fragtree(struct jffs2_inode_info *f)
  61 {
  62         struct jffs2_node_frag *frag;
  63         int bitched = 0;
  64
  65         for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
  66
  67                 struct jffs2_full_dnode *fn = frag->node;
  68                 if (!fn || !fn->raw)
  69                         continue;
  70
  71                 if (ref_flags(fn->raw) == REF_PRISTINE) {
  72
  73                         if (fn->frags > 1) {
  74                                 printk(KERN_WARNING "REF_PRISTINE node at 0x%08x had %d frags. Tell dwmw2\n", ref_offset(fn->raw), fn->frags);
  75                                 bitched = 1;
  76                         }
  77                         /* A hole node which isn't multi-page should be garbage-collected
  78                            and merged anyway, so we just check for the frag size here,
  79                            rather than mucking around with actually reading the node
  80                            and checking the compression type, which is the real way
  81                            to tell a hole node. */
  82                         if (frag->ofs & (PAGE_CACHE_SIZE-1) && frag_prev(frag) && frag_prev(frag)->size < PAGE_CACHE_SIZE && frag_prev(frag)->node) {
  83                                 printk(KERN_WARNING "REF_PRISTINE node at 0x%08x had a previous non-hole frag in the same page. Tell dwmw2\n",
  84                                        ref_offset(fn->raw));
  85                                 bitched = 1;
  86                         }
  87
  88                         if ((frag->ofs+frag->size) & (PAGE_CACHE_SIZE-1) && frag_next(frag) && frag_next(frag)->size < PAGE_CACHE_SIZE && frag_next(frag)->node) {
  89                                 printk(KERN_WARNING "REF_PRISTINE node at 0x%08x (%08x-%08x) had a following non-hole frag in the same page. Tell dwmw2\n",
  90                                        ref_offset(fn->raw), frag->ofs, frag->ofs+frag->size);
  91                                 bitched = 1;
  92                         }
  93                 }
  94         }
  95
  96         if (bitched) {
  97                 struct jffs2_node_frag *thisfrag;
  98
  99                 printk(KERN_WARNING "Inode is #%u\n", f->inocache->ino);
 100                 thisfrag = frag_first(&f->fragtree);
 101                 while (thisfrag) {
 102                         if (!thisfrag->node) {
 103                                 printk("Frag @0x%x-0x%x; node-less hole\n",
 104                                        thisfrag->ofs, thisfrag->size + thisfrag->ofs);
 105                         } else if (!thisfrag->node->raw) {
 106                                 printk("Frag @0x%x-0x%x; raw-less hole\n",
 107                                        thisfrag->ofs, thisfrag->size + thisfrag->ofs);
 108                         } else {
 109                                 printk("Frag @0x%x-0x%x; raw at 0x%08x(%d) (0x%x-0x%x)\n",
 110                                        thisfrag->ofs, thisfrag->size + thisfrag->ofs,
 111                                        ref_offset(thisfrag->node->raw), ref_flags(thisfrag->node->raw),
 112                                        thisfrag->node->ofs, thisfrag->node->ofs+thisfrag->node->size);
 113                         }
 114                         thisfrag = frag_next(thisfrag);
 115                 }
 116         }
 117         return bitched;
 118 }
 119 #endif /* D1 */
 120
 121 static void jffs2_obsolete_node_frag(struct jffs2_sb_info *c, struct jffs2_node_frag *this)
 122 {
 123         if (this->node) {
 124                 this->node->frags--;
 125                 if (!this->node->frags) {
 126                         /* The node has no valid frags left. It's totally obsoleted */
 127                         D2(printk(KERN_DEBUG "Marking old node @0x%08x (0x%04x-0x%04x) obsolete\n",
 128                                   ref_offset(this->node->raw), this->node->ofs, this->node->ofs+this->node->size));
 129                         jffs2_mark_node_obsolete(c, this->node->raw);
 130                         jffs2_free_full_dnode(this->node);
 131                 } else {
 132                         D2(printk(KERN_DEBUG "Marking old node @0x%08x (0x%04x-0x%04x) REF_NORMAL. frags is %d\n",
 133                                   ref_offset(this->node->raw), this->node->ofs, this->node->ofs+this->node->size,
 134                                   this->node->frags));
 135                         mark_ref_normal(this->node->raw);
 136                 }
 137
 138         }
 139         jffs2_free_node_frag(this);
 140 }
 141
 142 /* Given an inode, probably with existing list of fragments, add the new node
 143  * to the fragment list.
 144  */
 145 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
 146 {
 147         int ret;
 148         struct jffs2_node_frag *newfrag;
 149
 150         D1(printk(KERN_DEBUG "jffs2_add_full_dnode_to_inode(ino #%u, f %p, fn %p)\n", f->inocache->ino, f, fn));
 151
 152         newfrag = jffs2_alloc_node_frag();
 153         if (unlikely(!newfrag))
 154                 return -ENOMEM;
 155
 156         D2(printk(KERN_DEBUG "adding node %04x-%04x @0x%08x on flash, newfrag *%p\n",
 157                   fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag));
 158
 159         if (unlikely(!fn->size)) {
 160                 jffs2_free_node_frag(newfrag);
 161                 return 0;
 162         }
 163
 164         newfrag->ofs = fn->ofs;
 165         newfrag->size = fn->size;
 166         newfrag->node = fn;
 167         newfrag->node->frags = 1;
 168
 169         ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag);
 170         if (ret)
 171                 return ret;
 172
 173         /* If we now share a page with other nodes, mark either previous
 174            or next node REF_NORMAL, as appropriate.  */
 175         if (newfrag->ofs & (PAGE_CACHE_SIZE-1)) {
 176                 struct jffs2_node_frag *prev = frag_prev(newfrag);
 177
 178                 mark_ref_normal(fn->raw);
 179                 /* If we don't start at zero there's _always_ a previous */
 180                 if (prev->node)
 181                         mark_ref_normal(prev->node->raw);
 182         }
 183
 184         if ((newfrag->ofs+newfrag->size) & (PAGE_CACHE_SIZE-1)) {
 185                 struct jffs2_node_frag *next = frag_next(newfrag);
 186
 187                 if (next) {
 188                         mark_ref_normal(fn->raw);
 189                         if (next->node)
 190                                 mark_ref_normal(next->node->raw);
 191                 }
 192         }
 193         D2(if (jffs2_sanitycheck_fragtree(f)) {
 194                    printk(KERN_WARNING "Just added node %04x-%04x @0x%08x on flash, newfrag *%p\n",
 195                           fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag);
 196                    return 0;
 197            })
 198         D2(jffs2_print_frag_list(f));
 199         return 0;
 200 }
 201
 202 /* Doesn't set inode->i_size */
 203 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *list, struct jffs2_node_frag *newfrag)
 204 {
 205         struct jffs2_node_frag *this;
 206         uint32_t lastend;
 207
 208         /* Skip all the nodes which are completed before this one starts */
 209         this = jffs2_lookup_node_frag(list, newfrag->node->ofs);
 210
 211         if (this) {
 212                 D2(printk(KERN_DEBUG "j_a_f_d_t_f: Lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
 213                           this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this));
 214                 lastend = this->ofs + this->size;
 215         } else {
 216                 D2(printk(KERN_DEBUG "j_a_f_d_t_f: Lookup gave no frag\n"));
 217                 lastend = 0;
 218         }
 219
 220         /* See if we ran off the end of the list */
 221         if (lastend <= newfrag->ofs) {
 222                 /* We did */
 223
 224                 /* Check if 'this' node was on the same page as the new node.
 225                    If so, both 'this' and the new node get marked REF_NORMAL so
 226                    the GC can take a look.
 227                 */
 228                 if ((lastend-1) >> PAGE_CACHE_SHIFT == newfrag->ofs >> PAGE_CACHE_SHIFT) {
 229                         if (this->node)
 230                                 mark_ref_normal(this->node->raw);
 231                         mark_ref_normal(newfrag->node->raw);
 232                 }
 233
 234                 if (lastend < newfrag->node->ofs) {
 235                         /* ... and we need to put a hole in before the new node */
 236                         struct jffs2_node_frag *holefrag = jffs2_alloc_node_frag();
 237                         if (!holefrag) {
 238                                 jffs2_free_node_frag(newfrag);
 239                                 return -ENOMEM;
 240                         }
 241                         holefrag->ofs = lastend;
 242                         holefrag->size = newfrag->node->ofs - lastend;
 243                         holefrag->node = NULL;
 244                         if (this) {
 245                                 /* By definition, the 'this' node has no right-hand child,
 246                                    because there are no frags with offset greater than it.
 247                                    So that's where we want to put the hole */
 248                                 D2(printk(KERN_DEBUG "Adding hole frag (%p) on right of node at (%p)\n", holefrag, this));
 249                                 rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right);
 250                         } else {
 251                                 D2(printk(KERN_DEBUG "Adding hole frag (%p) at root of tree\n", holefrag));
 252                                 rb_link_node(&holefrag->rb, NULL, &list->rb_node);
 253                         }
 254                         rb_insert_color(&holefrag->rb, list);
 255                         this = holefrag;
 256                 }
 257                 if (this) {
 258                         /* By definition, the 'this' node has no right-hand child,
 259                            because there are no frags with offset greater than it.
 260                            So that's where we want to put the hole */
 261                         D2(printk(KERN_DEBUG "Adding new frag (%p) on right of node at (%p)\n", newfrag, this));
 262                         rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
 263                 } else {
 264                         D2(printk(KERN_DEBUG "Adding new frag (%p) at root of tree\n", newfrag));
 265                         rb_link_node(&newfrag->rb, NULL, &list->rb_node);
 266                 }
 267                 rb_insert_color(&newfrag->rb, list);
 268                 return 0;
 269         }
 270
 271         D2(printk(KERN_DEBUG "j_a_f_d_t_f: dealing with frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
 272                   this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this));
 273
 274         /* OK. 'this' is pointing at the first frag that newfrag->ofs at least partially obsoletes,
 275          * - i.e. newfrag->ofs < this->ofs+this->size && newfrag->ofs >= this->ofs
 276          */
 277         if (newfrag->ofs > this->ofs) {
 278                 /* This node isn't completely obsoleted. The start of it remains valid */
 279
 280                 /* Mark the new node and the partially covered node REF_NORMAL -- let
 281                    the GC take a look at them */
 282                 mark_ref_normal(newfrag->node->raw);
 283                 if (this->node)
 284                         mark_ref_normal(this->node->raw);
 285
 286                 if (this->ofs + this->size > newfrag->ofs + newfrag->size) {
 287                         /* The new node splits 'this' frag into two */
 288                         struct jffs2_node_frag *newfrag2 = jffs2_alloc_node_frag();
 289                         if (!newfrag2) {
 290                                 jffs2_free_node_frag(newfrag);
 291                                 return -ENOMEM;
 292                         }
 293                         D2(printk(KERN_DEBUG "split old frag 0x%04x-0x%04x -->", this->ofs, this->ofs+this->size);
 294                         if (this->node)
 295                                 printk("phys 0x%08x\n", ref_offset(this->node->raw));
 296                         else
 297                                 printk("hole\n");
 298                            )
 299
 300                         /* New second frag pointing to this's node */
 301                         newfrag2->ofs = newfrag->ofs + newfrag->size;
 302                         newfrag2->size = (this->ofs+this->size) - newfrag2->ofs;
 303                         newfrag2->node = this->node;
 304                         if (this->node)
 305                                 this->node->frags++;
 306
 307                         /* Adjust size of original 'this' */
 308                         this->size = newfrag->ofs - this->ofs;
 309
 310                         /* Now, we know there's no node with offset
 311                            greater than this->ofs but smaller than
 312                            newfrag2->ofs or newfrag->ofs, for obvious
 313                            reasons. So we can do a tree insert from
 314                            'this' to insert newfrag, and a tree insert
 315                            from newfrag to insert newfrag2. */
 316                         jffs2_fragtree_insert(newfrag, this);
 317                         rb_insert_color(&newfrag->rb, list);
 318
 319                         jffs2_fragtree_insert(newfrag2, newfrag);
 320                         rb_insert_color(&newfrag2->rb, list);
 321
 322                         return 0;
 323                 }
 324                 /* New node just reduces 'this' frag in size, doesn't split it */
 325                 this->size = newfrag->ofs - this->ofs;
 326
 327                 /* Again, we know it lives down here in the tree */
 328                 jffs2_fragtree_insert(newfrag, this);
 329                 rb_insert_color(&newfrag->rb, list);
 330         } else {
 331                 /* New frag starts at the same point as 'this' used to. Replace
 332                    it in the tree without doing a delete and insertion */
 333                 D2(printk(KERN_DEBUG "Inserting newfrag (*%p),%d-%d in before 'this' (*%p),%d-%d\n",
 334                           newfrag, newfrag->ofs, newfrag->ofs+newfrag->size,
 335                           this, this->ofs, this->ofs+this->size));
 336
 337                 rb_replace_node(&this->rb, &newfrag->rb, list);
 338
 339                 if (newfrag->ofs + newfrag->size >= this->ofs+this->size) {
 340                         D2(printk(KERN_DEBUG "Obsoleting node frag %p (%x-%x)\n", this, this->ofs, this->ofs+this->size));
 341                         jffs2_obsolete_node_frag(c, this);
 342                 } else {
 343                         this->ofs += newfrag->size;
 344                         this->size -= newfrag->size;
 345
 346                         jffs2_fragtree_insert(this, newfrag);
 347                         rb_insert_color(&this->rb, list);
 348                         return 0;
 349                 }
 350         }
 351         /* OK, now we have newfrag added in the correct place in the tree, but
 352            frag_next(newfrag) may be a fragment which is overlapped by it
 353         */
 354         while ((this = frag_next(newfrag)) && newfrag->ofs + newfrag->size >= this->ofs + this->size) {
 355                 /* 'this' frag is obsoleted completely. */
 356                 D2(printk(KERN_DEBUG "Obsoleting node frag %p (%x-%x) and removing from tree\n", this, this->ofs, this->ofs+this->size));
 357                 rb_erase(&this->rb, list);
 358                 jffs2_obsolete_node_frag(c, this);
 359         }
 360         /* Now we're pointing at the first frag which isn't totally obsoleted by
 361            the new frag */
 362
 363         if (!this || newfrag->ofs + newfrag->size == this->ofs) {
 364                 return 0;
 365         }
 366         /* Still some overlap but we don't need to move it in the tree */
 367         this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);
 368         this->ofs = newfrag->ofs + newfrag->size;
 369
 370         /* And mark them REF_NORMAL so the GC takes a look at them */
 371         if (this->node)
 372                 mark_ref_normal(this->node->raw);
 373         mark_ref_normal(newfrag->node->raw);
 374
 375         return 0;
 376 }
 377
 378 void jffs2_truncate_fraglist (struct jffs2_sb_info *c, struct rb_root *list, uint32_t size)
 379 {
 380         struct jffs2_node_frag *frag = jffs2_lookup_node_frag(list, size);
 381
 382         D1(printk(KERN_DEBUG "Truncating fraglist to 0x%08x bytes\n", size));
 383
 384         /* We know frag->ofs <= size. That's what lookup does for us */
 385         if (frag && frag->ofs != size) {
 386                 if (frag->ofs+frag->size >= size) {
 387                         D1(printk(KERN_DEBUG "Truncating frag 0x%08x-0x%08x\n", frag->ofs, frag->ofs+frag->size));
 388                         frag->size = size - frag->ofs;
 389                 }
 390                 frag = frag_next(frag);
 391         }
 392         while (frag && frag->ofs >= size) {
 393                 struct jffs2_node_frag *next = frag_next(frag);
 394
 395                 D1(printk(KERN_DEBUG "Removing frag 0x%08x-0x%08x\n", frag->ofs, frag->ofs+frag->size));
 396                 frag_erase(frag, list);
 397                 jffs2_obsolete_node_frag(c, frag);
 398                 frag = next;
 399         }
 400 }
 401
 402 /* Scan the list of all nodes present for this ino, build map of versions, etc. */
 403
 404 static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
 405                                         struct jffs2_inode_info *f,
 406                                         struct jffs2_raw_inode *latest_node);
 407
 408 int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 409                         uint32_t ino, struct jffs2_raw_inode *latest_node)
 410 {
 411         D2(printk(KERN_DEBUG "jffs2_do_read_inode(): getting inocache\n"));
 412
 413  retry_inocache:
 414         spin_lock(&c->inocache_lock);
 415         f->inocache = jffs2_get_ino_cache(c, ino);
 416
 417         D2(printk(KERN_DEBUG "jffs2_do_read_inode(): Got inocache at %p\n", f->inocache));
 418
 419         if (f->inocache) {
 420                 /* Check its state. We may need to wait before we can use it */
 421                 switch(f->inocache->state) {
 422                 case INO_STATE_UNCHECKED:
 423                 case INO_STATE_CHECKEDABSENT:
 424                         f->inocache->state = INO_STATE_READING;
 425                         break;
 426
 427                 case INO_STATE_CHECKING:
 428                 case INO_STATE_GC:
 429                         /* If it's in either of these states, we need
 430                            to wait for whoever's got it to finish and
 431                            put it back. */
 432                         D1(printk(KERN_DEBUG "jffs2_get_ino_cache_read waiting for ino #%u in state %d\n",
 433                                   ino, f->inocache->state));
 434                         sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 435                         goto retry_inocache;
 436
 437                 case INO_STATE_READING:
 438                 case INO_STATE_PRESENT:
 439                         /* Eep. This should never happen. It can
 440                         happen if Linux calls read_inode() again
 441                         before clear_inode() has finished though. */
 442                         printk(KERN_WARNING "Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state);
 443                         /* Fail. That's probably better than allowing it to succeed */
 444                         f->inocache = NULL;
 445                         break;
 446
 447                 default:
 448                         BUG();
 449                 }
 450         }
 451         spin_unlock(&c->inocache_lock);
 452
 453         if (!f->inocache && ino == 1) {
 454                 /* Special case - no root inode on medium */
 455                 f->inocache = jffs2_alloc_inode_cache();
 456                 if (!f->inocache) {
 457                         printk(KERN_CRIT "jffs2_do_read_inode(): Cannot allocate inocache for root inode\n");
 458                         return -ENOMEM;
 459                 }
 460                 D1(printk(KERN_DEBUG "jffs2_do_read_inode(): Creating inocache for root inode\n"));
 461                 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
 462                 f->inocache->ino = f->inocache->nlink = 1;
 463                 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
 464                 f->inocache->state = INO_STATE_READING;
 465                 jffs2_add_ino_cache(c, f->inocache);
 466         }
 467         if (!f->inocache) {
 468                 printk(KERN_WARNING "jffs2_do_read_inode() on nonexistent ino %u\n", ino);
 469                 return -ENOENT;
 470         }
 471
 472         return jffs2_do_read_inode_internal(c, f, latest_node);
 473 }
 474
 475 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
 476 {
 477         struct jffs2_raw_inode n;
 478         struct jffs2_inode_info *f = kmalloc(sizeof(*f), GFP_KERNEL);
 479         int ret;
 480
 481         if (!f)
 482                 return -ENOMEM;
 483
 484         memset(f, 0, sizeof(*f));
 485         init_MUTEX_LOCKED(&f->sem);
 486         f->inocache = ic;
 487
 488         ret = jffs2_do_read_inode_internal(c, f, &n);
 489         if (!ret) {
 490                 up(&f->sem);
 491                 jffs2_do_clear_inode(c, f);
 492         }
 493         kfree (f);
 494         return ret;
 495 }
 496
 497 static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
 498                                         struct jffs2_inode_info *f,
 499                                         struct jffs2_raw_inode *latest_node)
 500 {
 501         struct jffs2_tmp_dnode_info *tn_list, *tn;
 502         struct jffs2_full_dirent *fd_list;
 503         struct jffs2_full_dnode *fn = NULL;
 504         uint32_t crc;
 505         uint32_t latest_mctime, mctime_ver;
 506         uint32_t mdata_ver = 0;
 507         size_t retlen;
 508         int ret;
 509
 510         D1(printk(KERN_DEBUG "jffs2_do_read_inode_internal(): ino #%u nlink is %d\n", f->inocache->ino, f->inocache->nlink));
 511
 512         /* Grab all nodes relevant to this ino */
 513         ret = jffs2_get_inode_nodes(c, f->inocache->ino, f, &tn_list, &fd_list, &f->highest_version, &latest_mctime, &mctime_ver);
 514
 515         if (ret) {
 516                 printk(KERN_CRIT "jffs2_get_inode_nodes() for ino %u returned %d\n", f->inocache->ino, ret);
 517                 if (f->inocache->state == INO_STATE_READING)
 518                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
 519                 return ret;
 520         }
 521         f->dents = fd_list;
 522
 523         while (tn_list) {
 524                 tn = tn_list;
 525
 526                 fn = tn->fn;
 527
 528                 if (f->metadata) {
 529                         if (likely(tn->version >= mdata_ver)) {
 530                                 D1(printk(KERN_DEBUG "Obsoleting old metadata at 0x%08x\n", ref_offset(f->metadata->raw)));
 531                                 jffs2_mark_node_obsolete(c, f->metadata->raw);
 532                                 jffs2_free_full_dnode(f->metadata);
 533                                 f->metadata = NULL;
 534
 535                                 mdata_ver = 0;
 536                         } else {
 537                                 /* This should never happen. */
 538                                 printk(KERN_WARNING "Er. New metadata at 0x%08x with ver %d is actually older than previous ver %d at 0x%08x\n",
 539                                           ref_offset(fn->raw), tn->version, mdata_ver, ref_offset(f->metadata->raw));
 540                                 jffs2_mark_node_obsolete(c, fn->raw);
 541                                 jffs2_free_full_dnode(fn);
 542                                 /* Fill in latest_node from the metadata, not this one we're about to free... */
 543                                 fn = f->metadata;
 544                                 goto next_tn;
 545                         }
 546                 }
 547
 548                 if (fn->size) {
 549                         jffs2_add_full_dnode_to_inode(c, f, fn);
 550                 } else {
 551                         /* Zero-sized node at end of version list. Just a metadata update */
 552                         D1(printk(KERN_DEBUG "metadata @%08x: ver %d\n", ref_offset(fn->raw), tn->version));
 553                         f->metadata = fn;
 554                         mdata_ver = tn->version;
 555                 }
 556         next_tn:
 557                 tn_list = tn->next;
 558                 jffs2_free_tmp_dnode_info(tn);
 559         }
 560         D1(jffs2_sanitycheck_fragtree(f));
 561
 562         if (!fn) {
 563                 /* No data nodes for this inode. */
 564                 if (f->inocache->ino != 1) {
 565                         printk(KERN_WARNING "jffs2_do_read_inode(): No data nodes found for ino #%u\n", f->inocache->ino);
 566                         if (!fd_list) {
 567                                 if (f->inocache->state == INO_STATE_READING)
 568                                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
 569                                 return -EIO;
 570                         }
 571                         printk(KERN_WARNING "jffs2_do_read_inode(): But it has children so we fake some modes for it\n");
 572                 }
 573                 latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO);
 574                 latest_node->version = cpu_to_je32(0);
 575                 latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0);
 576                 latest_node->isize = cpu_to_je32(0);
 577                 latest_node->gid = cpu_to_je16(0);
 578                 latest_node->uid = cpu_to_je16(0);
 579                 if (f->inocache->state == INO_STATE_READING)
 580                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
 581                 return 0;
 582         }
 583
 584         ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(*latest_node), &retlen, (void *)latest_node);
 585         if (ret || retlen != sizeof(*latest_node)) {
 586                 printk(KERN_NOTICE "MTD read in jffs2_do_read_inode() failed: Returned %d, %zd of %zd bytes read\n",
 587                        ret, retlen, sizeof(*latest_node));
 588                 /* FIXME: If this fails, there seems to be a memory leak. Find it. */
 589                 up(&f->sem);
 590                 jffs2_do_clear_inode(c, f);
 591                 return ret?ret:-EIO;
 592         }
 593
 594         crc = crc32(0, latest_node, sizeof(*latest_node)-8);
 595         if (crc != je32_to_cpu(latest_node->node_crc)) {
 596                 printk(KERN_NOTICE "CRC failed for read_inode of inode %u at physical location 0x%x\n", f->inocache->ino, ref_offset(fn->raw));
 597                 up(&f->sem);
 598                 jffs2_do_clear_inode(c, f);
 599                 return -EIO;
 600         }
 601
 602         switch(jemode_to_cpu(latest_node->mode) & S_IFMT) {
 603         case S_IFDIR:
 604                 if (mctime_ver > je32_to_cpu(latest_node->version)) {
 605                         /* The times in the latest_node are actually older than
 606                            mctime in the latest dirent. Cheat. */
 607                         latest_node->ctime = latest_node->mtime = cpu_to_je32(latest_mctime);
 608                 }
 609                 break;
 610
 611
 612         case S_IFREG:
 613                 /* If it was a regular file, truncate it to the latest node's isize */
 614                 jffs2_truncate_fraglist(c, &f->fragtree, je32_to_cpu(latest_node->isize));
 615                 break;
 616
 617         case S_IFLNK:
 618                 /* Hack to work around broken isize in old symlink code.
 619                    Remove this when dwmw2 comes to his senses and stops
 620                    symlinks from being an entirely gratuitous special
 621                    case. */
 622                 if (!je32_to_cpu(latest_node->isize))
 623                         latest_node->isize = latest_node->dsize;
 624                 /* fall through... */
 625
 626         case S_IFBLK:
 627         case S_IFCHR:
 628                 /* Certain inode types should have only one data node, and it's
 629                    kept as the metadata node */
 630                 if (f->metadata) {
 631                         printk(KERN_WARNING "Argh. Special inode #%u with mode 0%o had metadata node\n",
 632                                f->inocache->ino, jemode_to_cpu(latest_node->mode));
 633                         up(&f->sem);
 634                         jffs2_do_clear_inode(c, f);
 635                         return -EIO;
 636                 }
 637                 if (!frag_first(&f->fragtree)) {
 638                         printk(KERN_WARNING "Argh. Special inode #%u with mode 0%o has no fragments\n",
 639                                f->inocache->ino, jemode_to_cpu(latest_node->mode));
 640                         up(&f->sem);
 641                         jffs2_do_clear_inode(c, f);
 642                         return -EIO;
 643                 }
 644                 /* ASSERT: f->fraglist != NULL */
 645                 if (frag_next(frag_first(&f->fragtree))) {
 646                         printk(KERN_WARNING "Argh. Special inode #%u with mode 0x%x had more than one node\n",
 647                                f->inocache->ino, jemode_to_cpu(latest_node->mode));
 648                         /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
 649                         up(&f->sem);
 650                         jffs2_do_clear_inode(c, f);
 651                         return -EIO;
 652                 }
 653                 /* OK. We're happy */
 654                 f->metadata = frag_first(&f->fragtree)->node;
 655                 jffs2_free_node_frag(frag_first(&f->fragtree));
 656                 f->fragtree = RB_ROOT;
 657                 break;
 658         }
 659         if (f->inocache->state == INO_STATE_READING)
 660                 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
 661
 662         return 0;
 663 }
 664
 665 void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
 666 {
 667         struct jffs2_full_dirent *fd, *fds;
 668         int deleted;
 669
 670         down(&f->sem);
 671         deleted = f->inocache && !f->inocache->nlink;
 672
 673         if (f->metadata) {
 674                 if (deleted)
 675                         jffs2_mark_node_obsolete(c, f->metadata->raw);
 676                 jffs2_free_full_dnode(f->metadata);
 677         }
 678
 679         jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
 680
 681         fds = f->dents;
 682
 683         while(fds) {
 684                 fd = fds;
 685                 fds = fd->next;
 686                 jffs2_free_full_dirent(fd);
 687         }
 688
 689         if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
 690                 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
 691
 692         up(&f->sem);
 693 }