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

Archive Download this file



interactive