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