source: rtems/cpukit/libfs/src/jffs2/src/readinode.c @ 3c96bee

4.11
Last change on this file since 3c96bee was 3c96bee, checked in by Sebastian Huber <sebastian.huber@…>, on Sep 12, 2013 at 1:32:07 PM

JFFS2: Add RTEMS support

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