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