source: rtems/cpukit/libfs/src/jffs2/src/readinode.c @ 410dd26

Last change on this file since 410dd26 was 410dd26, checked in by Wei Fang <fangwei1@…>, on Sep 29, 2015 at 3:23:55 AM

jffs2: fix a memleak in read_direntry()

Need to free the memory allocated for 'fd' if failed to read all
of the remainder name.

Signed-off-by: Wei Fang <fangwei1@…>
Signed-off-by: Brian Norris <computersforpeace@…>

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