mm: move common segment checks to separate helper function
[linux-2.6] / fs / jffs2 / readinode.c
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright © 2001-2007 Red Hat, Inc.
5  *
6  * Created by David Woodhouse <dwmw2@infradead.org>
7  *
8  * For licensing information, see the file 'LICENCE' in this directory.
9  *
10  */
11
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/fs.h>
16 #include <linux/crc32.h>
17 #include <linux/pagemap.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/compiler.h>
20 #include "nodelist.h"
21
22 /*
23  * Check the data CRC of the node.
24  *
25  * Returns: 0 if the data CRC is correct;
26  *          1 - if incorrect;
27  *          error code if an error occured.
28  */
29 static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)
30 {
31         struct jffs2_raw_node_ref *ref = tn->fn->raw;
32         int err = 0, pointed = 0;
33         struct jffs2_eraseblock *jeb;
34         unsigned char *buffer;
35         uint32_t crc, ofs, len;
36         size_t retlen;
37
38         BUG_ON(tn->csize == 0);
39
40         if (!jffs2_is_writebuffered(c))
41                 goto adj_acc;
42
43         /* Calculate how many bytes were already checked */
44         ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);
45         len = ofs % c->wbuf_pagesize;
46         if (likely(len))
47                 len = c->wbuf_pagesize - len;
48
49         if (len >= tn->csize) {
50                 dbg_readinode("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n",
51                         ref_offset(ref), tn->csize, ofs);
52                 goto adj_acc;
53         }
54
55         ofs += len;
56         len = tn->csize - len;
57
58         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",
59                 ref_offset(ref), tn->csize, tn->partial_crc, tn->data_crc, ofs - len, ofs, len);
60
61 #ifndef __ECOS
62         /* TODO: instead, incapsulate point() stuff to jffs2_flash_read(),
63          * adding and jffs2_flash_read_end() interface. */
64         if (c->mtd->point) {
65                 err = c->mtd->point(c->mtd, ofs, len, &retlen, &buffer);
66                 if (!err && retlen < tn->csize) {
67                         JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
68                         c->mtd->unpoint(c->mtd, buffer, ofs, len);
69                 } else if (err)
70                         JFFS2_WARNING("MTD point failed: error code %d.\n", err);
71                 else
72                         pointed = 1; /* succefully pointed to device */
73         }
74 #endif
75
76         if (!pointed) {
77                 buffer = kmalloc(len, GFP_KERNEL);
78                 if (unlikely(!buffer))
79                         return -ENOMEM;
80
81                 /* TODO: this is very frequent pattern, make it a separate
82                  * routine */
83                 err = jffs2_flash_read(c, ofs, len, &retlen, buffer);
84                 if (err) {
85                         JFFS2_ERROR("can not read %d bytes from 0x%08x, error code: %d.\n", len, ofs, err);
86                         goto free_out;
87                 }
88
89                 if (retlen != len) {
90                         JFFS2_ERROR("short read at %#08x: %zd instead of %d.\n", ofs, retlen, len);
91                         err = -EIO;
92                         goto free_out;
93                 }
94         }
95
96         /* Continue calculating CRC */
97         crc = crc32(tn->partial_crc, buffer, len);
98         if(!pointed)
99                 kfree(buffer);
100 #ifndef __ECOS
101         else
102                 c->mtd->unpoint(c->mtd, buffer, ofs, len);
103 #endif
104
105         if (crc != tn->data_crc) {
106                 JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
107                         ofs, tn->data_crc, crc);
108                 return 1;
109         }
110
111 adj_acc:
112         jeb = &c->blocks[ref->flash_offset / c->sector_size];
113         len = ref_totlen(c, jeb, ref);
114         /* If it should be REF_NORMAL, it'll get marked as such when
115            we build the fragtree, shortly. No need to worry about GC
116            moving it while it's marked REF_PRISTINE -- GC won't happen
117            till we've finished checking every inode anyway. */
118         ref->flash_offset |= REF_PRISTINE;
119         /*
120          * Mark the node as having been checked and fix the
121          * accounting accordingly.
122          */
123         spin_lock(&c->erase_completion_lock);
124         jeb->used_size += len;
125         jeb->unchecked_size -= len;
126         c->used_size += len;
127         c->unchecked_size -= len;
128         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
129         spin_unlock(&c->erase_completion_lock);
130
131         return 0;
132
133 free_out:
134         if(!pointed)
135                 kfree(buffer);
136 #ifndef __ECOS
137         else
138                 c->mtd->unpoint(c->mtd, buffer, ofs, len);
139 #endif
140         return err;
141 }
142
143 /*
144  * Helper function for jffs2_add_older_frag_to_fragtree().
145  *
146  * Checks the node if we are in the checking stage.
147  */
148 static int check_tn_node(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)
149 {
150         int ret;
151
152         BUG_ON(ref_obsolete(tn->fn->raw));
153
154         /* We only check the data CRC of unchecked nodes */
155         if (ref_flags(tn->fn->raw) != REF_UNCHECKED)
156                 return 0;
157
158         dbg_readinode("check node %#04x-%#04x, phys offs %#08x\n",
159                       tn->fn->ofs, tn->fn->ofs + tn->fn->size, ref_offset(tn->fn->raw));
160
161         ret = check_node_data(c, tn);
162         if (unlikely(ret < 0)) {
163                 JFFS2_ERROR("check_node_data() returned error: %d.\n",
164                         ret);
165         } else if (unlikely(ret > 0)) {
166                 dbg_readinode("CRC error, mark it obsolete.\n");
167                 jffs2_mark_node_obsolete(c, tn->fn->raw);
168         }
169
170         return ret;
171 }
172
173 static struct jffs2_tmp_dnode_info *jffs2_lookup_tn(struct rb_root *tn_root, uint32_t offset)
174 {
175         struct rb_node *next;
176         struct jffs2_tmp_dnode_info *tn = NULL;
177
178         dbg_readinode("root %p, offset %d\n", tn_root, offset);
179
180         next = tn_root->rb_node;
181
182         while (next) {
183                 tn = rb_entry(next, struct jffs2_tmp_dnode_info, rb);
184
185                 if (tn->fn->ofs < offset)
186                         next = tn->rb.rb_right;
187                 else if (tn->fn->ofs >= offset)
188                         next = tn->rb.rb_left;
189                 else
190                         break;
191         }
192
193         return tn;
194 }
195
196
197 static void jffs2_kill_tn(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)
198 {
199         jffs2_mark_node_obsolete(c, tn->fn->raw);
200         jffs2_free_full_dnode(tn->fn);
201         jffs2_free_tmp_dnode_info(tn);
202 }
203 /*
204  * This function is used when we read an inode. Data nodes arrive in
205  * arbitrary order -- they may be older or newer than the nodes which
206  * are already in the tree. Where overlaps occur, the older node can
207  * be discarded as long as the newer passes the CRC check. We don't
208  * bother to keep track of holes in this rbtree, and neither do we deal
209  * with frags -- we can have multiple entries starting at the same
210  * offset, and the one with the smallest length will come first in the
211  * ordering.
212  *
213  * Returns 0 if the node was inserted
214  *         1 if the node is obsolete (because we can't mark it so yet)
215  *         < 0 an if error occurred
216  */
217 static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
218                                 struct jffs2_readinode_info *rii,
219                                 struct jffs2_tmp_dnode_info *tn)
220 {
221         uint32_t fn_end = tn->fn->ofs + tn->fn->size;
222         struct jffs2_tmp_dnode_info *insert_point = NULL, *this;
223
224         dbg_readinode("insert fragment %#04x-%#04x, ver %u\n", tn->fn->ofs, fn_end, tn->version);
225
226         /* If a node has zero dsize, we only have to keep if it if it might be the
227            node with highest version -- i.e. the one which will end up as f->metadata.
228            Note that such nodes won't be REF_UNCHECKED since there are no data to
229            check anyway. */
230         if (!tn->fn->size) {
231                 if (rii->mdata_tn) {
232                         /* We had a candidate mdata node already */
233                         dbg_readinode("kill old mdata with ver %d\n", rii->mdata_tn->version);
234                         jffs2_kill_tn(c, rii->mdata_tn);
235                 }
236                 rii->mdata_tn = tn;
237                 dbg_readinode("keep new mdata with ver %d\n", tn->version);
238                 return 0;
239         }
240
241         /* Find the earliest node which _may_ be relevant to this one */
242         this = jffs2_lookup_tn(&rii->tn_root, tn->fn->ofs);
243         if (!this) {
244                 /* First addition to empty tree. $DEITY how I love the easy cases */
245                 rb_link_node(&tn->rb, NULL, &rii->tn_root.rb_node);
246                 rb_insert_color(&tn->rb, &rii->tn_root);
247                 dbg_readinode("keep new frag\n");
248                 return 0;
249         }
250
251         /* If we add a new node it'll be somewhere under here. */
252         insert_point = this;
253
254         /* If the node is coincident with another at a lower address,
255            back up until the other node is found. It may be relevant */
256         while (tn->overlapped)
257                 tn = tn_prev(tn);
258
259         dbg_readinode("'this' found %#04x-%#04x (%s)\n", this->fn->ofs, this->fn->ofs + this->fn->size, this->fn ? "data" : "hole");
260
261         while (this) {
262                 if (this->fn->ofs > fn_end)
263                         break;
264                 dbg_readinode("Ponder this ver %d, 0x%x-0x%x\n",
265                               this->version, this->fn->ofs, this->fn->size);
266
267                 if (this->version == tn->version) {
268                         /* Version number collision means REF_PRISTINE GC. Accept either of them
269                            as long as the CRC is correct. Check the one we have already...  */
270                         if (!check_tn_node(c, this)) {
271                                 /* The one we already had was OK. Keep it and throw away the new one */
272                                 dbg_readinode("Like old node. Throw away new\n");
273                                 jffs2_kill_tn(c, tn);
274                                 return 0;
275                         } else {
276                                 /* Who cares if the new one is good; keep it for now anyway. */
277                                 rb_replace_node(&this->rb, &tn->rb, &rii->tn_root);
278                                 /* Same overlapping from in front and behind */
279                                 tn->overlapped = this->overlapped;
280                                 jffs2_kill_tn(c, this);
281                                 dbg_readinode("Like new node. Throw away old\n");
282                                 return 0;
283                         }
284                 }
285                 if (this->version < tn->version &&
286                     this->fn->ofs >= tn->fn->ofs &&
287                     this->fn->ofs + this->fn->size <= fn_end) {
288                         /* New node entirely overlaps 'this' */
289                         if (check_tn_node(c, tn)) {
290                                 dbg_readinode("new node bad CRC\n");
291                                 jffs2_kill_tn(c, tn);
292                                 return 0;
293                         }
294                         /* ... and is good. Kill 'this'... */
295                         rb_replace_node(&this->rb, &tn->rb, &rii->tn_root);
296                         tn->overlapped = this->overlapped;
297                         jffs2_kill_tn(c, this);
298                         /* ... and any subsequent nodes which are also overlapped */
299                         this = tn_next(tn);
300                         while (this && this->fn->ofs + this->fn->size < fn_end) {
301                                 struct jffs2_tmp_dnode_info *next = tn_next(this);
302                                 if (this->version < tn->version) {
303                                         tn_erase(this, &rii->tn_root);
304                                         dbg_readinode("Kill overlapped ver %d, 0x%x-0x%x\n",
305                                                       this->version, this->fn->ofs,
306                                                       this->fn->ofs+this->fn->size);
307                                         jffs2_kill_tn(c, this);
308                                 }
309                                 this = next;
310                         }
311                         dbg_readinode("Done inserting new\n");
312                         return 0;
313                 }
314                 if (this->version > tn->version &&
315                     this->fn->ofs <= tn->fn->ofs &&
316                     this->fn->ofs+this->fn->size >= fn_end) {
317                         /* New node entirely overlapped by 'this' */
318                         if (!check_tn_node(c, this)) {
319                                 dbg_readinode("Good CRC on old node. Kill new\n");
320                                 jffs2_kill_tn(c, tn);
321                                 return 0;
322                         }
323                         /* ... but 'this' was bad. Replace it... */
324                         rb_replace_node(&this->rb, &tn->rb, &rii->tn_root);
325                         dbg_readinode("Bad CRC on old overlapping node. Kill it\n");
326                         jffs2_kill_tn(c, this);
327                         return 0;
328                 }
329                 /* We want to be inserted under the last node which is
330                    either at a lower offset _or_ has a smaller range */
331                 if (this->fn->ofs < tn->fn->ofs ||
332                     (this->fn->ofs == tn->fn->ofs &&
333                      this->fn->size <= tn->fn->size))
334                         insert_point = this;
335
336                 this = tn_next(this);
337         }
338         dbg_readinode("insert_point %p, ver %d, 0x%x-0x%x, ov %d\n",
339                       insert_point, insert_point->version, insert_point->fn->ofs,
340                       insert_point->fn->ofs+insert_point->fn->size,
341                       insert_point->overlapped);
342         /* We neither completely obsoleted nor were completely
343            obsoleted by an earlier node. Insert under insert_point */
344         {
345                 struct rb_node *parent = &insert_point->rb;
346                 struct rb_node **link = &parent;
347
348                 while (*link) {
349                         parent = *link;
350                         insert_point = rb_entry(parent, struct jffs2_tmp_dnode_info, rb);
351                         if (tn->fn->ofs > insert_point->fn->ofs)
352                                 link = &insert_point->rb.rb_right;
353                         else if (tn->fn->ofs < insert_point->fn->ofs ||
354                                  tn->fn->size < insert_point->fn->size)
355                                 link = &insert_point->rb.rb_left;
356                         else
357                                 link = &insert_point->rb.rb_right;
358                 }
359                 rb_link_node(&tn->rb, &insert_point->rb, link);
360                 rb_insert_color(&tn->rb, &rii->tn_root);
361         }
362         /* If there's anything behind that overlaps us, note it */
363         this = tn_prev(tn);
364         if (this) {
365                 while (1) {
366                         if (this->fn->ofs + this->fn->size > tn->fn->ofs) {
367                                 dbg_readinode("Node is overlapped by %p (v %d, 0x%x-0x%x)\n",
368                                               this, this->version, this->fn->ofs,
369                                               this->fn->ofs+this->fn->size);
370                                 tn->overlapped = 1;
371                                 break;
372                         }
373                         if (!this->overlapped)
374                                 break;
375                         this = tn_prev(this);
376                 }
377         }
378
379         /* If the new node overlaps anything ahead, note it */
380         this = tn_next(tn);
381         while (this && this->fn->ofs < fn_end) {
382                 this->overlapped = 1;
383                 dbg_readinode("Node ver %d, 0x%x-0x%x is overlapped\n",
384                               this->version, this->fn->ofs,
385                               this->fn->ofs+this->fn->size);
386                 this = tn_next(this);
387         }
388         return 0;
389 }
390
391 /* Trivial function to remove the last node in the tree. Which by definition
392    has no right-hand -- so can be removed just by making its only child (if
393    any) take its place under its parent. */
394 static void eat_last(struct rb_root *root, struct rb_node *node)
395 {
396         struct rb_node *parent = rb_parent(node);
397         struct rb_node **link;
398
399         /* LAST! */
400         BUG_ON(node->rb_right);
401
402         if (!parent)
403                 link = &root->rb_node;
404         else if (node == parent->rb_left)
405                 link = &parent->rb_left;
406         else
407                 link = &parent->rb_right;
408
409         *link = node->rb_left;
410         /* Colour doesn't matter now. Only the parent pointer. */
411         if (node->rb_left)
412                 node->rb_left->rb_parent_color = node->rb_parent_color;
413 }
414
415 /* We put this in reverse order, so we can just use eat_last */
416 static void ver_insert(struct rb_root *ver_root, struct jffs2_tmp_dnode_info *tn)
417 {
418         struct rb_node **link = &ver_root->rb_node;
419         struct rb_node *parent = NULL;
420         struct jffs2_tmp_dnode_info *this_tn;
421
422         while (*link) {
423                 parent = *link;
424                 this_tn = rb_entry(parent, struct jffs2_tmp_dnode_info, rb);
425
426                 if (tn->version > this_tn->version)
427                         link = &parent->rb_left;
428                 else
429                         link = &parent->rb_right;
430         }
431         dbg_readinode("Link new node at %p (root is %p)\n", link, ver_root);
432         rb_link_node(&tn->rb, parent, link);
433         rb_insert_color(&tn->rb, ver_root);
434 }
435
436 /* Build final, normal fragtree from tn tree. It doesn't matter which order
437    we add nodes to the real fragtree, as long as they don't overlap. And
438    having thrown away the majority of overlapped nodes as we went, there
439    really shouldn't be many sets of nodes which do overlap. If we start at
440    the end, we can use the overlap markers -- we can just eat nodes which
441    aren't overlapped, and when we encounter nodes which _do_ overlap we
442    sort them all into a temporary tree in version order before replaying them. */
443 static int jffs2_build_inode_fragtree(struct jffs2_sb_info *c,
444                                       struct jffs2_inode_info *f,
445                                       struct jffs2_readinode_info *rii)
446 {
447         struct jffs2_tmp_dnode_info *pen, *last, *this;
448         struct rb_root ver_root = RB_ROOT;
449         uint32_t high_ver = 0;
450
451         if (rii->mdata_tn) {
452                 dbg_readinode("potential mdata is ver %d at %p\n", rii->mdata_tn->version, rii->mdata_tn);
453                 high_ver = rii->mdata_tn->version;
454                 rii->latest_ref = rii->mdata_tn->fn->raw;
455         }
456 #ifdef JFFS2_DBG_READINODE_MESSAGES
457         this = tn_last(&rii->tn_root);
458         while (this) {
459                 dbg_readinode("tn %p ver %d range 0x%x-0x%x ov %d\n", this, this->version, this->fn->ofs,
460                              this->fn->ofs+this->fn->size, this->overlapped);
461                 this = tn_prev(this);
462         }
463 #endif
464         pen = tn_last(&rii->tn_root);
465         while ((last = pen)) {
466                 pen = tn_prev(last);
467
468                 eat_last(&rii->tn_root, &last->rb);
469                 ver_insert(&ver_root, last);
470
471                 if (unlikely(last->overlapped))
472                         continue;
473
474                 /* Now we have a bunch of nodes in reverse version
475                    order, in the tree at ver_root. Most of the time,
476                    there'll actually be only one node in the 'tree',
477                    in fact. */
478                 this = tn_last(&ver_root);
479
480                 while (this) {
481                         struct jffs2_tmp_dnode_info *vers_next;
482                         int ret;
483                         vers_next = tn_prev(this);
484                         eat_last(&ver_root, &this->rb);
485                         if (check_tn_node(c, this)) {
486                                 dbg_readinode("node ver %x, 0x%x-0x%x failed CRC\n",
487                                              this->version, this->fn->ofs,
488                                              this->fn->ofs+this->fn->size);
489                                 jffs2_kill_tn(c, this);
490                         } else {
491                                 if (this->version > high_ver) {
492                                         /* Note that this is different from the other
493                                            highest_version, because this one is only
494                                            counting _valid_ nodes which could give the
495                                            latest inode metadata */
496                                         high_ver = this->version;
497                                         rii->latest_ref = this->fn->raw;
498                                 }
499                                 dbg_readinode("Add %p (v %x, 0x%x-0x%x, ov %d) to fragtree\n",
500                                              this, this->version, this->fn->ofs,
501                                              this->fn->ofs+this->fn->size, this->overlapped);
502
503                                 ret = jffs2_add_full_dnode_to_inode(c, f, this->fn);
504                                 if (ret) {
505                                         /* Free the nodes in vers_root; let the caller
506                                            deal with the rest */
507                                         JFFS2_ERROR("Add node to tree failed %d\n", ret);
508                                         while (1) {
509                                                 vers_next = tn_prev(this);
510                                                 if (check_tn_node(c, this))
511                                                         jffs2_mark_node_obsolete(c, this->fn->raw);
512                                                 jffs2_free_full_dnode(this->fn);
513                                                 jffs2_free_tmp_dnode_info(this);
514                                                 this = vers_next;
515                                                 if (!this)
516                                                         break;
517                                                 eat_last(&ver_root, &vers_next->rb);
518                                         }
519                                         return ret;
520                                 }
521                                 jffs2_free_tmp_dnode_info(this);
522                         }
523                         this = vers_next;
524                 }
525         }
526         return 0;
527 }
528
529 static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
530 {
531         struct rb_node *this;
532         struct jffs2_tmp_dnode_info *tn;
533
534         this = list->rb_node;
535
536         /* Now at bottom of tree */
537         while (this) {
538                 if (this->rb_left)
539                         this = this->rb_left;
540                 else if (this->rb_right)
541                         this = this->rb_right;
542                 else {
543                         tn = rb_entry(this, struct jffs2_tmp_dnode_info, rb);
544                         jffs2_free_full_dnode(tn->fn);
545                         jffs2_free_tmp_dnode_info(tn);
546
547                         this = rb_parent(this);
548                         if (!this)
549                                 break;
550
551                         if (this->rb_left == &tn->rb)
552                                 this->rb_left = NULL;
553                         else if (this->rb_right == &tn->rb)
554                                 this->rb_right = NULL;
555                         else BUG();
556                 }
557         }
558         list->rb_node = NULL;
559 }
560
561 static void jffs2_free_full_dirent_list(struct jffs2_full_dirent *fd)
562 {
563         struct jffs2_full_dirent *next;
564
565         while (fd) {
566                 next = fd->next;
567                 jffs2_free_full_dirent(fd);
568                 fd = next;
569         }
570 }
571
572 /* Returns first valid node after 'ref'. May return 'ref' */
573 static struct jffs2_raw_node_ref *jffs2_first_valid_node(struct jffs2_raw_node_ref *ref)
574 {
575         while (ref && ref->next_in_ino) {
576                 if (!ref_obsolete(ref))
577                         return ref;
578                 dbg_noderef("node at 0x%08x is obsoleted. Ignoring.\n", ref_offset(ref));
579                 ref = ref->next_in_ino;
580         }
581         return NULL;
582 }
583
584 /*
585  * Helper function for jffs2_get_inode_nodes().
586  * It is called every time an directory entry node is found.
587  *
588  * Returns: 0 on succes;
589  *          1 if the node should be marked obsolete;
590  *          negative error code on failure.
591  */
592 static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
593                                 struct jffs2_raw_dirent *rd, size_t read,
594                                 struct jffs2_readinode_info *rii)
595 {
596         struct jffs2_full_dirent *fd;
597         uint32_t crc;
598
599         /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
600         BUG_ON(ref_obsolete(ref));
601
602         crc = crc32(0, rd, sizeof(*rd) - 8);
603         if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
604                 JFFS2_NOTICE("header CRC failed on dirent node at %#08x: read %#08x, calculated %#08x\n",
605                              ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
606                 jffs2_mark_node_obsolete(c, ref);
607                 return 0;
608         }
609
610         /* If we've never checked the CRCs on this node, check them now */
611         if (ref_flags(ref) == REF_UNCHECKED) {
612                 struct jffs2_eraseblock *jeb;
613                 int len;
614
615                 /* Sanity check */
616                 if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) {
617                         JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n",
618                                     ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen));
619                         jffs2_mark_node_obsolete(c, ref);
620                         return 0;
621                 }
622
623                 jeb = &c->blocks[ref->flash_offset / c->sector_size];
624                 len = ref_totlen(c, jeb, ref);
625
626                 spin_lock(&c->erase_completion_lock);
627                 jeb->used_size += len;
628                 jeb->unchecked_size -= len;
629                 c->used_size += len;
630                 c->unchecked_size -= len;
631                 ref->flash_offset = ref_offset(ref) | REF_PRISTINE;
632                 spin_unlock(&c->erase_completion_lock);
633         }
634
635         fd = jffs2_alloc_full_dirent(rd->nsize + 1);
636         if (unlikely(!fd))
637                 return -ENOMEM;
638
639         fd->raw = ref;
640         fd->version = je32_to_cpu(rd->version);
641         fd->ino = je32_to_cpu(rd->ino);
642         fd->type = rd->type;
643
644         if (fd->version > rii->highest_version)
645                 rii->highest_version = fd->version;
646
647         /* Pick out the mctime of the latest dirent */
648         if(fd->version > rii->mctime_ver && je32_to_cpu(rd->mctime)) {
649                 rii->mctime_ver = fd->version;
650                 rii->latest_mctime = je32_to_cpu(rd->mctime);
651         }
652
653         /*
654          * Copy as much of the name as possible from the raw
655          * dirent we've already read from the flash.
656          */
657         if (read > sizeof(*rd))
658                 memcpy(&fd->name[0], &rd->name[0],
659                        min_t(uint32_t, rd->nsize, (read - sizeof(*rd)) ));
660
661         /* Do we need to copy any more of the name directly from the flash? */
662         if (rd->nsize + sizeof(*rd) > read) {
663                 /* FIXME: point() */
664                 int err;
665                 int already = read - sizeof(*rd);
666
667                 err = jffs2_flash_read(c, (ref_offset(ref)) + read,
668                                 rd->nsize - already, &read, &fd->name[already]);
669                 if (unlikely(read != rd->nsize - already) && likely(!err))
670                         return -EIO;
671
672                 if (unlikely(err)) {
673                         JFFS2_ERROR("read remainder of name: error %d\n", err);
674                         jffs2_free_full_dirent(fd);
675                         return -EIO;
676                 }
677         }
678
679         fd->nhash = full_name_hash(fd->name, rd->nsize);
680         fd->next = NULL;
681         fd->name[rd->nsize] = '\0';
682
683         /*
684          * Wheee. We now have a complete jffs2_full_dirent structure, with
685          * the name in it and everything. Link it into the list
686          */
687         jffs2_add_fd_to_list(c, fd, &rii->fds);
688
689         return 0;
690 }
691
692 /*
693  * Helper function for jffs2_get_inode_nodes().
694  * It is called every time an inode node is found.
695  *
696  * Returns: 0 on success;
697  *          1 if the node should be marked obsolete;
698  *          negative error code on failure.
699  */
700 static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
701                              struct jffs2_raw_inode *rd, int rdlen,
702                              struct jffs2_readinode_info *rii)
703 {
704         struct jffs2_tmp_dnode_info *tn;
705         uint32_t len, csize;
706         int ret = 1;
707         uint32_t crc;
708
709         /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
710         BUG_ON(ref_obsolete(ref));
711
712         crc = crc32(0, rd, sizeof(*rd) - 8);
713         if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
714                 JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n",
715                              ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
716                 jffs2_mark_node_obsolete(c, ref);
717                 return 0;
718         }
719
720         tn = jffs2_alloc_tmp_dnode_info();
721         if (!tn) {
722                 JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn));
723                 return -ENOMEM;
724         }
725
726         tn->partial_crc = 0;
727         csize = je32_to_cpu(rd->csize);
728
729         /* If we've never checked the CRCs on this node, check them now */
730         if (ref_flags(ref) == REF_UNCHECKED) {
731
732                 /* Sanity checks */
733                 if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) ||
734                     unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) {
735                                 JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref));
736                                 jffs2_dbg_dump_node(c, ref_offset(ref));
737                         goto free_out;
738                 }
739
740                 if (jffs2_is_writebuffered(c) && csize != 0) {
741                         /* At this point we are supposed to check the data CRC
742                          * of our unchecked node. But thus far, we do not
743                          * know whether the node is valid or obsolete. To
744                          * figure this out, we need to walk all the nodes of
745                          * the inode and build the inode fragtree. We don't
746                          * want to spend time checking data of nodes which may
747                          * later be found to be obsolete. So we put off the full
748                          * data CRC checking until we have read all the inode
749                          * nodes and have started building the fragtree.
750                          *
751                          * The fragtree is being built starting with nodes
752                          * having the highest version number, so we'll be able
753                          * to detect whether a node is valid (i.e., it is not
754                          * overlapped by a node with higher version) or not.
755                          * And we'll be able to check only those nodes, which
756                          * are not obsolete.
757                          *
758                          * Of course, this optimization only makes sense in case
759                          * of NAND flashes (or other flashes whith
760                          * !jffs2_can_mark_obsolete()), since on NOR flashes
761                          * nodes are marked obsolete physically.
762                          *
763                          * Since NAND flashes (or other flashes with
764                          * jffs2_is_writebuffered(c)) are anyway read by
765                          * fractions of c->wbuf_pagesize, and we have just read
766                          * the node header, it is likely that the starting part
767                          * of the node data is also read when we read the
768                          * header. So we don't mind to check the CRC of the
769                          * starting part of the data of the node now, and check
770                          * the second part later (in jffs2_check_node_data()).
771                          * Of course, we will not need to re-read and re-check
772                          * the NAND page which we have just read. This is why we
773                          * read the whole NAND page at jffs2_get_inode_nodes(),
774                          * while we needed only the node header.
775                          */
776                         unsigned char *buf;
777
778                         /* 'buf' will point to the start of data */
779                         buf = (unsigned char *)rd + sizeof(*rd);
780                         /* len will be the read data length */
781                         len = min_t(uint32_t, rdlen - sizeof(*rd), csize);
782                         tn->partial_crc = crc32(0, buf, len);
783
784                         dbg_readinode("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize);
785
786                         /* If we actually calculated the whole data CRC
787                          * and it is wrong, drop the node. */
788                         if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) {
789                                 JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
790                                         ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc));
791                                 goto free_out;
792                         }
793
794                 } else if (csize == 0) {
795                         /*
796                          * We checked the header CRC. If the node has no data, adjust
797                          * the space accounting now. For other nodes this will be done
798                          * later either when the node is marked obsolete or when its
799                          * data is checked.
800                          */
801                         struct jffs2_eraseblock *jeb;
802
803                         dbg_readinode("the node has no data.\n");
804                         jeb = &c->blocks[ref->flash_offset / c->sector_size];
805                         len = ref_totlen(c, jeb, ref);
806
807                         spin_lock(&c->erase_completion_lock);
808                         jeb->used_size += len;
809                         jeb->unchecked_size -= len;
810                         c->used_size += len;
811                         c->unchecked_size -= len;
812                         ref->flash_offset = ref_offset(ref) | REF_NORMAL;
813                         spin_unlock(&c->erase_completion_lock);
814                 }
815         }
816
817         tn->fn = jffs2_alloc_full_dnode();
818         if (!tn->fn) {
819                 JFFS2_ERROR("alloc fn failed\n");
820                 ret = -ENOMEM;
821                 goto free_out;
822         }
823
824         tn->version = je32_to_cpu(rd->version);
825         tn->fn->ofs = je32_to_cpu(rd->offset);
826         tn->data_crc = je32_to_cpu(rd->data_crc);
827         tn->csize = csize;
828         tn->fn->raw = ref;
829         tn->overlapped = 0;
830
831         if (tn->version > rii->highest_version)
832                 rii->highest_version = tn->version;
833
834         /* There was a bug where we wrote hole nodes out with
835            csize/dsize swapped. Deal with it */
836         if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize)
837                 tn->fn->size = csize;
838         else // normal case...
839                 tn->fn->size = je32_to_cpu(rd->dsize);
840
841         dbg_readinode("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n",
842                   ref_offset(ref), je32_to_cpu(rd->version), je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize);
843
844         ret = jffs2_add_tn_to_tree(c, rii, tn);
845
846         if (ret) {
847                 jffs2_free_full_dnode(tn->fn);
848         free_out:
849                 jffs2_free_tmp_dnode_info(tn);
850                 return ret;
851         }
852 #ifdef JFFS2_DBG_READINODE_MESSAGES
853         dbg_readinode("After adding ver %d:\n", tn->version);
854         tn = tn_first(&rii->tn_root);
855         while (tn) {
856                 dbg_readinode("%p: v %d r 0x%x-0x%x ov %d\n",
857                              tn, tn->version, tn->fn->ofs,
858                              tn->fn->ofs+tn->fn->size, tn->overlapped);
859                 tn = tn_next(tn);
860         }
861 #endif
862         return 0;
863 }
864
865 /*
866  * Helper function for jffs2_get_inode_nodes().
867  * It is called every time an unknown node is found.
868  *
869  * Returns: 0 on success;
870  *          1 if the node should be marked obsolete;
871  *          negative error code on failure.
872  */
873 static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, struct jffs2_unknown_node *un)
874 {
875         /* We don't mark unknown nodes as REF_UNCHECKED */
876         if (ref_flags(ref) == REF_UNCHECKED) {
877                 JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n",
878                             ref_offset(ref));
879                 JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n",
880                             je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
881                             je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
882                 jffs2_mark_node_obsolete(c, ref);
883                 return 0;
884         }
885
886         un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype));
887
888         switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) {
889
890         case JFFS2_FEATURE_INCOMPAT:
891                 JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n",
892                             je16_to_cpu(un->nodetype), ref_offset(ref));
893                 /* EEP */
894                 BUG();
895                 break;
896
897         case JFFS2_FEATURE_ROCOMPAT:
898                 JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n",
899                             je16_to_cpu(un->nodetype), ref_offset(ref));
900                 BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO));
901                 break;
902
903         case JFFS2_FEATURE_RWCOMPAT_COPY:
904                 JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n",
905                              je16_to_cpu(un->nodetype), ref_offset(ref));
906                 break;
907
908         case JFFS2_FEATURE_RWCOMPAT_DELETE:
909                 JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n",
910                              je16_to_cpu(un->nodetype), ref_offset(ref));
911                 jffs2_mark_node_obsolete(c, ref);
912                 return 0;
913         }
914
915         return 0;
916 }
917
918 /*
919  * Helper function for jffs2_get_inode_nodes().
920  * The function detects whether more data should be read and reads it if yes.
921  *
922  * Returns: 0 on succes;
923  *          negative error code on failure.
924  */
925 static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
926                      int needed_len, int *rdlen, unsigned char *buf)
927 {
928         int err, to_read = needed_len - *rdlen;
929         size_t retlen;
930         uint32_t offs;
931
932         if (jffs2_is_writebuffered(c)) {
933                 int rem = to_read % c->wbuf_pagesize;
934
935                 if (rem)
936                         to_read += c->wbuf_pagesize - rem;
937         }
938
939         /* We need to read more data */
940         offs = ref_offset(ref) + *rdlen;
941
942         dbg_readinode("read more %d bytes\n", to_read);
943
944         err = jffs2_flash_read(c, offs, to_read, &retlen, buf + *rdlen);
945         if (err) {
946                 JFFS2_ERROR("can not read %d bytes from 0x%08x, "
947                         "error code: %d.\n", to_read, offs, err);
948                 return err;
949         }
950
951         if (retlen < to_read) {
952                 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n",
953                                 offs, retlen, to_read);
954                 return -EIO;
955         }
956
957         *rdlen += to_read;
958         return 0;
959 }
960
961 /* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
962    with this ino. Perform a preliminary ordering on data nodes, throwing away
963    those which are completely obsoleted by newer ones. The naïve approach we
964    use to take of just returning them _all_ in version order will cause us to
965    run out of memory in certain degenerate cases. */
966 static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
967                                  struct jffs2_readinode_info *rii)
968 {
969         struct jffs2_raw_node_ref *ref, *valid_ref;
970         unsigned char *buf = NULL;
971         union jffs2_node_union *node;
972         size_t retlen;
973         int len, err;
974
975         rii->mctime_ver = 0;
976
977         dbg_readinode("ino #%u\n", f->inocache->ino);
978
979         /* FIXME: in case of NOR and available ->point() this
980          * needs to be fixed. */
981         len = sizeof(union jffs2_node_union) + c->wbuf_pagesize;
982         buf = kmalloc(len, GFP_KERNEL);
983         if (!buf)
984                 return -ENOMEM;
985
986         spin_lock(&c->erase_completion_lock);
987         valid_ref = jffs2_first_valid_node(f->inocache->nodes);
988         if (!valid_ref && f->inocache->ino != 1)
989                 JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
990         while (valid_ref) {
991                 /* We can hold a pointer to a non-obsolete node without the spinlock,
992                    but _obsolete_ nodes may disappear at any time, if the block
993                    they're in gets erased. So if we mark 'ref' obsolete while we're
994                    not holding the lock, it can go away immediately. For that reason,
995                    we find the next valid node first, before processing 'ref'.
996                 */
997                 ref = valid_ref;
998                 valid_ref = jffs2_first_valid_node(ref->next_in_ino);
999                 spin_unlock(&c->erase_completion_lock);
1000
1001                 cond_resched();
1002
1003                 /*
1004                  * At this point we don't know the type of the node we're going
1005                  * to read, so we do not know the size of its header. In order
1006                  * to minimize the amount of flash IO we assume the header is
1007                  * of size = JFFS2_MIN_NODE_HEADER.
1008                  */
1009                 len = JFFS2_MIN_NODE_HEADER;
1010                 if (jffs2_is_writebuffered(c)) {
1011                         int end, rem;
1012
1013                         /*
1014                          * We are about to read JFFS2_MIN_NODE_HEADER bytes,
1015                          * but this flash has some minimal I/O unit. It is
1016                          * possible that we'll need to read more soon, so read
1017                          * up to the next min. I/O unit, in order not to
1018                          * re-read the same min. I/O unit twice.
1019                          */
1020                         end = ref_offset(ref) + len;
1021                         rem = end % c->wbuf_pagesize;
1022                         if (rem)
1023                                 end += c->wbuf_pagesize - rem;
1024                         len = end - ref_offset(ref);
1025                 }
1026
1027                 dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
1028
1029                 /* FIXME: point() */
1030                 err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf);
1031                 if (err) {
1032                         JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err);
1033                         goto free_out;
1034                 }
1035
1036                 if (retlen < len) {
1037                         JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len);
1038                         err = -EIO;
1039                         goto free_out;
1040                 }
1041
1042                 node = (union jffs2_node_union *)buf;
1043
1044                 /* No need to mask in the valid bit; it shouldn't be invalid */
1045                 if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) {
1046                         JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n",
1047                                      ref_offset(ref), je16_to_cpu(node->u.magic),
1048                                      je16_to_cpu(node->u.nodetype),
1049                                      je32_to_cpu(node->u.totlen),
1050                                      je32_to_cpu(node->u.hdr_crc));
1051                         jffs2_dbg_dump_node(c, ref_offset(ref));
1052                         jffs2_mark_node_obsolete(c, ref);
1053                         goto cont;
1054                 }
1055                 if (je16_to_cpu(node->u.magic) != JFFS2_MAGIC_BITMASK) {
1056                         /* Not a JFFS2 node, whinge and move on */
1057                         JFFS2_NOTICE("Wrong magic bitmask 0x%04x in node header at %#08x.\n",
1058                                      je16_to_cpu(node->u.magic), ref_offset(ref));
1059                         jffs2_mark_node_obsolete(c, ref);
1060                         goto cont;
1061                 }
1062
1063                 switch (je16_to_cpu(node->u.nodetype)) {
1064
1065                 case JFFS2_NODETYPE_DIRENT:
1066
1067                         if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent)) {
1068                                 err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf);
1069                                 if (unlikely(err))
1070                                         goto free_out;
1071                         }
1072
1073                         err = read_direntry(c, ref, &node->d, retlen, rii);
1074                         if (unlikely(err))
1075                                 goto free_out;
1076
1077                         break;
1078
1079                 case JFFS2_NODETYPE_INODE:
1080
1081                         if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode)) {
1082                                 err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf);
1083                                 if (unlikely(err))
1084                                         goto free_out;
1085                         }
1086
1087                         err = read_dnode(c, ref, &node->i, len, rii);
1088                         if (unlikely(err))
1089                                 goto free_out;
1090
1091                         break;
1092
1093                 default:
1094                         if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node)) {
1095                                 err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf);
1096                                 if (unlikely(err))
1097                                         goto free_out;
1098                         }
1099
1100                         err = read_unknown(c, ref, &node->u);
1101                         if (err == 1) {
1102                                 jffs2_mark_node_obsolete(c, ref);
1103                                 break;
1104                         } else if (unlikely(err))
1105                                 goto free_out;
1106
1107                 }
1108         cont:
1109                 spin_lock(&c->erase_completion_lock);
1110         }
1111
1112         spin_unlock(&c->erase_completion_lock);
1113         kfree(buf);
1114
1115         f->highest_version = rii->highest_version;
1116
1117         dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n",
1118                       f->inocache->ino, rii->highest_version, rii->latest_mctime,
1119                       rii->mctime_ver);
1120         return 0;
1121
1122  free_out:
1123         jffs2_free_tmp_dnode_info_list(&rii->tn_root);
1124         jffs2_free_full_dirent_list(rii->fds);
1125         rii->fds = NULL;
1126         kfree(buf);
1127         return err;
1128 }
1129
1130 static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
1131                                         struct jffs2_inode_info *f,
1132                                         struct jffs2_raw_inode *latest_node)
1133 {
1134         struct jffs2_readinode_info rii;
1135         uint32_t crc, new_size;
1136         size_t retlen;
1137         int ret;
1138
1139         dbg_readinode("ino #%u nlink is %d\n", f->inocache->ino, f->inocache->nlink);
1140
1141         memset(&rii, 0, sizeof(rii));
1142
1143         /* Grab all nodes relevant to this ino */
1144         ret = jffs2_get_inode_nodes(c, f, &rii);
1145
1146         if (ret) {
1147                 JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret);
1148                 if (f->inocache->state == INO_STATE_READING)
1149                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1150                 return ret;
1151         }
1152
1153         ret = jffs2_build_inode_fragtree(c, f, &rii);
1154         if (ret) {
1155                 JFFS2_ERROR("Failed to build final fragtree for inode #%u: error %d\n",
1156                             f->inocache->ino, ret);
1157                 if (f->inocache->state == INO_STATE_READING)
1158                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1159                 jffs2_free_tmp_dnode_info_list(&rii.tn_root);
1160                 /* FIXME: We could at least crc-check them all */
1161                 if (rii.mdata_tn) {
1162                         jffs2_free_full_dnode(rii.mdata_tn->fn);
1163                         jffs2_free_tmp_dnode_info(rii.mdata_tn);
1164                         rii.mdata_tn = NULL;
1165                 }
1166                 return ret;
1167         }
1168
1169         if (rii.mdata_tn) {
1170                 if (rii.mdata_tn->fn->raw == rii.latest_ref) {
1171                         f->metadata = rii.mdata_tn->fn;
1172                         jffs2_free_tmp_dnode_info(rii.mdata_tn);
1173                 } else {
1174                         jffs2_kill_tn(c, rii.mdata_tn);
1175                 }
1176                 rii.mdata_tn = NULL;
1177         }
1178
1179         f->dents = rii.fds;
1180
1181         jffs2_dbg_fragtree_paranoia_check_nolock(f);
1182
1183         if (unlikely(!rii.latest_ref)) {
1184                 /* No data nodes for this inode. */
1185                 if (f->inocache->ino != 1) {
1186                         JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino);
1187                         if (!rii.fds) {
1188                                 if (f->inocache->state == INO_STATE_READING)
1189                                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1190                                 return -EIO;
1191                         }
1192                         JFFS2_NOTICE("but it has children so we fake some modes for it\n");
1193                 }
1194                 latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO);
1195                 latest_node->version = cpu_to_je32(0);
1196                 latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0);
1197                 latest_node->isize = cpu_to_je32(0);
1198                 latest_node->gid = cpu_to_je16(0);
1199                 latest_node->uid = cpu_to_je16(0);
1200                 if (f->inocache->state == INO_STATE_READING)
1201                         jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
1202                 return 0;
1203         }
1204
1205         ret = jffs2_flash_read(c, ref_offset(rii.latest_ref), sizeof(*latest_node), &retlen, (void *)latest_node);
1206         if (ret || retlen != sizeof(*latest_node)) {
1207                 JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n",
1208                         ret, retlen, sizeof(*latest_node));
1209                 /* FIXME: If this fails, there seems to be a memory leak. Find it. */
1210                 up(&f->sem);
1211                 jffs2_do_clear_inode(c, f);
1212                 return ret?ret:-EIO;
1213         }
1214
1215         crc = crc32(0, latest_node, sizeof(*latest_node)-8);
1216         if (crc != je32_to_cpu(latest_node->node_crc)) {
1217                 JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n",
1218                         f->inocache->ino, ref_offset(rii.latest_ref));
1219                 up(&f->sem);
1220                 jffs2_do_clear_inode(c, f);
1221                 return -EIO;
1222         }
1223
1224         switch(jemode_to_cpu(latest_node->mode) & S_IFMT) {
1225         case S_IFDIR:
1226                 if (rii.mctime_ver > je32_to_cpu(latest_node->version)) {
1227                         /* The times in the latest_node are actually older than
1228                            mctime in the latest dirent. Cheat. */
1229                         latest_node->ctime = latest_node->mtime = cpu_to_je32(rii.latest_mctime);
1230                 }
1231                 break;
1232
1233
1234         case S_IFREG:
1235                 /* If it was a regular file, truncate it to the latest node's isize */
1236                 new_size = jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize));
1237                 if (new_size != je32_to_cpu(latest_node->isize)) {
1238                         JFFS2_WARNING("Truncating ino #%u to %d bytes failed because it only had %d bytes to start with!\n",
1239                                       f->inocache->ino, je32_to_cpu(latest_node->isize), new_size);
1240                         latest_node->isize = cpu_to_je32(new_size);
1241                 }
1242                 break;
1243
1244         case S_IFLNK:
1245                 /* Hack to work around broken isize in old symlink code.
1246                    Remove this when dwmw2 comes to his senses and stops
1247                    symlinks from being an entirely gratuitous special
1248                    case. */
1249                 if (!je32_to_cpu(latest_node->isize))
1250                         latest_node->isize = latest_node->dsize;
1251
1252                 if (f->inocache->state != INO_STATE_CHECKING) {
1253                         /* Symlink's inode data is the target path. Read it and
1254                          * keep in RAM to facilitate quick follow symlink
1255                          * operation. */
1256                         f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL);
1257                         if (!f->target) {
1258                                 JFFS2_ERROR("can't allocate %d bytes of memory for the symlink target path cache\n", je32_to_cpu(latest_node->csize));
1259                                 up(&f->sem);
1260                                 jffs2_do_clear_inode(c, f);
1261                                 return -ENOMEM;
1262                         }
1263
1264                         ret = jffs2_flash_read(c, ref_offset(rii.latest_ref) + sizeof(*latest_node),
1265                                                 je32_to_cpu(latest_node->csize), &retlen, (char *)f->target);
1266
1267                         if (ret  || retlen != je32_to_cpu(latest_node->csize)) {
1268                                 if (retlen != je32_to_cpu(latest_node->csize))
1269                                         ret = -EIO;
1270                                 kfree(f->target);
1271                                 f->target = NULL;
1272                                 up(&f->sem);
1273                                 jffs2_do_clear_inode(c, f);
1274                                 return -ret;
1275                         }
1276
1277                         f->target[je32_to_cpu(latest_node->csize)] = '\0';
1278                         dbg_readinode("symlink's target '%s' cached\n", f->target);
1279                 }
1280
1281                 /* fall through... */
1282
1283         case S_IFBLK:
1284         case S_IFCHR:
1285                 /* Certain inode types should have only one data node, and it's
1286                    kept as the metadata node */
1287                 if (f->metadata) {
1288                         JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n",
1289                                f->inocache->ino, jemode_to_cpu(latest_node->mode));
1290                         up(&f->sem);
1291                         jffs2_do_clear_inode(c, f);
1292                         return -EIO;
1293                 }
1294                 if (!frag_first(&f->fragtree)) {
1295                         JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n",
1296                                f->inocache->ino, jemode_to_cpu(latest_node->mode));
1297                         up(&f->sem);
1298                         jffs2_do_clear_inode(c, f);
1299                         return -EIO;
1300                 }
1301                 /* ASSERT: f->fraglist != NULL */
1302                 if (frag_next(frag_first(&f->fragtree))) {
1303                         JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n",
1304                                f->inocache->ino, jemode_to_cpu(latest_node->mode));
1305                         /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
1306                         up(&f->sem);
1307                         jffs2_do_clear_inode(c, f);
1308                         return -EIO;
1309                 }
1310                 /* OK. We're happy */
1311                 f->metadata = frag_first(&f->fragtree)->node;
1312                 jffs2_free_node_frag(frag_first(&f->fragtree));
1313                 f->fragtree = RB_ROOT;
1314                 break;
1315         }
1316         if (f->inocache->state == INO_STATE_READING)
1317                 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
1318
1319         return 0;
1320 }
1321
1322 /* Scan the list of all nodes present for this ino, build map of versions, etc. */
1323 int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
1324                         uint32_t ino, struct jffs2_raw_inode *latest_node)
1325 {
1326         dbg_readinode("read inode #%u\n", ino);
1327
1328  retry_inocache:
1329         spin_lock(&c->inocache_lock);
1330         f->inocache = jffs2_get_ino_cache(c, ino);
1331
1332         if (f->inocache) {
1333                 /* Check its state. We may need to wait before we can use it */
1334                 switch(f->inocache->state) {
1335                 case INO_STATE_UNCHECKED:
1336                 case INO_STATE_CHECKEDABSENT:
1337                         f->inocache->state = INO_STATE_READING;
1338                         break;
1339
1340                 case INO_STATE_CHECKING:
1341                 case INO_STATE_GC:
1342                         /* If it's in either of these states, we need
1343                            to wait for whoever's got it to finish and
1344                            put it back. */
1345                         dbg_readinode("waiting for ino #%u in state %d\n", ino, f->inocache->state);
1346                         sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
1347                         goto retry_inocache;
1348
1349                 case INO_STATE_READING:
1350                 case INO_STATE_PRESENT:
1351                         /* Eep. This should never happen. It can
1352                         happen if Linux calls read_inode() again
1353                         before clear_inode() has finished though. */
1354                         JFFS2_ERROR("Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state);
1355                         /* Fail. That's probably better than allowing it to succeed */
1356                         f->inocache = NULL;
1357                         break;
1358
1359                 default:
1360                         BUG();
1361                 }
1362         }
1363         spin_unlock(&c->inocache_lock);
1364
1365         if (!f->inocache && ino == 1) {
1366                 /* Special case - no root inode on medium */
1367                 f->inocache = jffs2_alloc_inode_cache();
1368                 if (!f->inocache) {
1369                         JFFS2_ERROR("cannot allocate inocache for root inode\n");
1370                         return -ENOMEM;
1371                 }
1372                 dbg_readinode("creating inocache for root inode\n");
1373                 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
1374                 f->inocache->ino = f->inocache->nlink = 1;
1375                 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
1376                 f->inocache->state = INO_STATE_READING;
1377                 jffs2_add_ino_cache(c, f->inocache);
1378         }
1379         if (!f->inocache) {
1380                 JFFS2_ERROR("requestied to read an nonexistent ino %u\n", ino);
1381                 return -ENOENT;
1382         }
1383
1384         return jffs2_do_read_inode_internal(c, f, latest_node);
1385 }
1386
1387 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
1388 {
1389         struct jffs2_raw_inode n;
1390         struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
1391         int ret;
1392
1393         if (!f)
1394                 return -ENOMEM;
1395
1396         init_MUTEX_LOCKED(&f->sem);
1397         f->inocache = ic;
1398
1399         ret = jffs2_do_read_inode_internal(c, f, &n);
1400         if (!ret) {
1401                 up(&f->sem);
1402                 jffs2_do_clear_inode(c, f);
1403         }
1404         kfree (f);
1405         return ret;
1406 }
1407
1408 void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
1409 {
1410         struct jffs2_full_dirent *fd, *fds;
1411         int deleted;
1412
1413         jffs2_clear_acl(f);
1414         jffs2_xattr_delete_inode(c, f->inocache);
1415         down(&f->sem);
1416         deleted = f->inocache && !f->inocache->nlink;
1417
1418         if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
1419                 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
1420
1421         if (f->metadata) {
1422                 if (deleted)
1423                         jffs2_mark_node_obsolete(c, f->metadata->raw);
1424                 jffs2_free_full_dnode(f->metadata);
1425         }
1426
1427         jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
1428
1429         if (f->target) {
1430                 kfree(f->target);
1431                 f->target = NULL;
1432         }
1433
1434         fds = f->dents;
1435         while(fds) {
1436                 fd = fds;
1437                 fds = fd->next;
1438                 jffs2_free_full_dirent(fd);
1439         }
1440
1441         if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {
1442                 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1443                 if (f->inocache->nodes == (void *)f->inocache)
1444                         jffs2_del_ino_cache(c, f->inocache);
1445         }
1446
1447         up(&f->sem);
1448 }