blob: 386303dca382e636fa9aab5d547f343e2e5058a1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
David Woodhousec00c3102007-04-25 14:16:47 +01004 * Copyright © 2001-2007 Red Hat, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 */
11
Joe Perches5a528952012-02-15 15:56:45 -080012#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/kernel.h>
Andrew Lunn737b7662005-07-30 16:29:30 +010015#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#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
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +010024/*
David Woodhousedf8e96f2007-04-25 03:23:42 +010025 * Check the data CRC of the node.
26 *
27 * Returns: 0 if the data CRC is correct;
28 * 1 - if incorrect;
Lucas De Marchi25985ed2011-03-30 22:57:33 -030029 * error code if an error occurred.
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +010030 */
David Woodhousedf8e96f2007-04-25 03:23:42 +010031static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070032{
David Woodhousedf8e96f2007-04-25 03:23:42 +010033 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
David Woodhousedf8e96f2007-04-25 03:23:42 +010040 BUG_ON(tn->csize == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
David Woodhousedf8e96f2007-04-25 03:23:42 +010042 /* Calculate how many bytes were already checked */
43 ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode);
David Woodhouse92525722007-11-21 12:08:16 -050044 len = tn->csize;
David Woodhousedf8e96f2007-04-25 03:23:42 +010045
David Woodhouse92525722007-11-21 12:08:16 -050046 if (jffs2_is_writebuffered(c)) {
47 int adj = ofs % c->wbuf_pagesize;
48 if (likely(adj))
49 adj = c->wbuf_pagesize - adj;
50
51 if (adj >= tn->csize) {
52 dbg_readinode("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n",
53 ref_offset(ref), tn->csize, ofs);
54 goto adj_acc;
55 }
56
57 ofs += adj;
58 len -= adj;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +010059 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
David Woodhousedf8e96f2007-04-25 03:23:42 +010061 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. */
Artem Bityutskiy10934472011-12-28 15:55:42 +020067 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)
David Woodhousedf8e96f2007-04-25 03:23:42 +010073 JFFS2_WARNING("MTD point failed: error code %d.\n", err);
Artem Bityutskiy10934472011-12-28 15:55:42 +020074 } else
75 pointed = 1; /* succefully pointed to device */
David Woodhousedf8e96f2007-04-25 03:23:42 +010076#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
Artem Bityutskiy72197782011-12-23 17:05:52 +0200104 mtd_unpoint(c->mtd, ofs, len);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100105#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",
David Woodhouseb2e25232007-07-05 01:57:26 -0400109 ref_offset(ref), tn->data_crc, crc);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100110 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
Artem Bityutskiy72197782011-12-23 17:05:52 +0200140 mtd_unpoint(c->mtd, ofs, len);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100141#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 *
David Woodhouse14c63812007-07-03 16:51:19 -0400215 * Returns 0 if the node was handled (including marking it obsolete)
David Woodhouseef53cb02007-07-10 10:01:22 +0100216 * < 0 an if error occurred
David Woodhousedf8e96f2007-04-25 03:23:42 +0100217 */
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;
Thomas Gleixner4c41bd02009-02-16 21:29:31 +0100223 struct jffs2_tmp_dnode_info *this, *ptn;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100224
David Woodhousefcf3caf2007-05-07 13:16:13 +0100225 dbg_readinode("insert fragment %#04x-%#04x, ver %u at %08x\n", tn->fn->ofs, fn_end, tn->version, ref_offset(tn->fn->raw));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100226
227 /* If a node has zero dsize, we only have to keep if it if it might be the
228 node with highest version -- i.e. the one which will end up as f->metadata.
229 Note that such nodes won't be REF_UNCHECKED since there are no data to
230 check anyway. */
231 if (!tn->fn->size) {
232 if (rii->mdata_tn) {
David Woodhouse0477d242007-06-01 20:04:43 +0100233 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 }
David Woodhousedf8e96f2007-04-25 03:23:42 +0100243 }
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);
David Woodhouse1c979642007-05-08 00:19:54 +0100251 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 */
Thomas Gleixner4c41bd02009-02-16 21:29:31 +0100254 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 }
David Woodhouse1c979642007-05-08 00:19:54 +0100266 dbg_readinode("'this' found %#04x-%#04x (%s)\n", this->fn->ofs, this->fn->ofs + this->fn->size, this->fn ? "data" : "hole");
David Woodhousedf8e96f2007-04-25 03:23:42 +0100267 }
268
David Woodhousedf8e96f2007-04-25 03:23:42 +0100269 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. */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100285 dbg_readinode("Like new node. Throw away old\n");
David Woodhousefcf3caf2007-05-07 13:16:13 +0100286 rb_replace_node(&this->rb, &tn->rb, &rii->tn_root);
287 jffs2_kill_tn(c, this);
288 /* Same overlapping from in front and behind */
289 return 0;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100290 }
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 }
David Woodhousefcf3caf2007-05-07 13:16:13 +0100301 /* ... and is good. Kill 'this' and any subsequent nodes which are also overlapped */
David Woodhouse1c979642007-05-08 00:19:54 +0100302 while (this && this->fn->ofs + this->fn->size <= fn_end) {
David Woodhousedf8e96f2007-04-25 03:23:42 +0100303 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 }
David Woodhousefcf3caf2007-05-07 13:16:13 +0100313 dbg_readinode("Done killing overlapped nodes\n");
David Woodhouse1c979642007-05-08 00:19:54 +0100314 continue;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100315 }
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... */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100326 dbg_readinode("Bad CRC on old overlapping node. Kill it\n");
David Woodhousefcf3caf2007-05-07 13:16:13 +0100327 tn_erase(this, &rii->tn_root);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100328 jffs2_kill_tn(c, this);
David Woodhousefcf3caf2007-05-07 13:16:13 +0100329 break;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100330 }
David Woodhousedf8e96f2007-04-25 03:23:42 +0100331
332 this = tn_next(this);
333 }
David Woodhouse96dd8d22007-05-06 14:41:40 +0100334
David Woodhousedf8e96f2007-04-25 03:23:42 +0100335 /* We neither completely obsoleted nor were completely
David Woodhouse96dd8d22007-05-06 14:41:40 +0100336 obsoleted by an earlier node. Insert into the tree */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100337 {
David Woodhouse96dd8d22007-05-06 14:41:40 +0100338 struct rb_node *parent;
339 struct rb_node **link = &rii->tn_root.rb_node;
David Woodhouse1c979642007-05-08 00:19:54 +0100340 struct jffs2_tmp_dnode_info *insert_point = NULL;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100341
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 }
David Woodhouse1123e2a2007-05-05 16:29:34 +0100356
David Woodhousedf8e96f2007-04-25 03:23:42 +0100357 /* 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;
Thomas Gleixner4c41bd02009-02-16 21:29:31 +0100370
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;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100381 }
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
Michel Lespinassebf7ad8e2012-10-08 16:30:37 -0700397 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. */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100402static void eat_last(struct rb_root *root, struct rb_node *node)
403{
404 struct rb_node *parent = rb_parent(node);
405 struct rb_node **link;
406
407 /* LAST! */
408 BUG_ON(node->rb_right);
409
410 if (!parent)
411 link = &root->rb_node;
412 else if (node == parent->rb_left)
413 link = &parent->rb_left;
414 else
415 link = &parent->rb_right;
416
417 *link = node->rb_left;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100418 if (node->rb_left)
Michel Lespinassebf7ad8e2012-10-08 16:30:37 -0700419 node->rb_left->__rb_parent_color = node->__rb_parent_color;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100420}
421
Michel Lespinassebf7ad8e2012-10-08 16:30:37 -0700422/* 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). */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100424static 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;
436 else
437 link = &parent->rb_right;
438 }
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}
443
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,
David Woodhouse96dd8d22007-05-06 14:41:40 +0100468 this->fn->ofs+this->fn->size, this->overlapped);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100469 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
Thomas Gleixner4c41bd02009-02-16 21:29:31 +0100479 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 }
David Woodhousedf8e96f2007-04-25 03:23:42 +0100488
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)) {
David Woodhouse1123e2a2007-05-05 16:29:34 +0100501 dbg_readinode("node ver %d, 0x%x-0x%x failed CRC\n",
David Woodhousedf8e96f2007-04-25 03:23:42 +0100502 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 }
David Woodhouse1123e2a2007-05-05 16:29:34 +0100514 dbg_readinode("Add %p (v %d, 0x%x-0x%x, ov %d) to fragtree\n",
David Woodhousedf8e96f2007-04-25 03:23:42 +0100515 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;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100542}
543
544static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
545{
Cody P Schafere8bbeeb2014-01-23 15:56:11 -0800546 struct jffs2_tmp_dnode_info *tn, *next;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100547
Cody P Schafere8bbeeb2014-01-23 15:56:11 -0800548 rbtree_postorder_for_each_entry_safe(tn, next, list, rb) {
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100549 jffs2_free_full_dnode(tn->fn);
550 jffs2_free_tmp_dnode_info(tn);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100551 }
Cody P Schafere8bbeeb2014-01-23 15:56:11 -0800552
Venkatesh Pallipadibcc54e2a2010-03-15 00:34:59 -0400553 *list = RB_ROOT;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100554}
555
556static void jffs2_free_full_dirent_list(struct jffs2_full_dirent *fd)
557{
558 struct jffs2_full_dirent *next;
559
560 while (fd) {
561 next = fd->next;
562 jffs2_free_full_dirent(fd);
563 fd = next;
564 }
565}
566
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;
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100573 dbg_noderef("node at 0x%08x is obsoleted. Ignoring.\n", ref_offset(ref));
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100574 ref = ref->next_in_ino;
575 }
576 return NULL;
577}
578
579/*
580 * Helper function for jffs2_get_inode_nodes().
581 * It is called every time an directory entry node is found.
582 *
David Woodhouse14c63812007-07-03 16:51:19 -0400583 * Returns: 0 on success;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100584 * negative error code on failure.
585 */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100586static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
David Woodhousedf8e96f2007-04-25 03:23:42 +0100587 struct jffs2_raw_dirent *rd, size_t read,
588 struct jffs2_readinode_info *rii)
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100589{
590 struct jffs2_full_dirent *fd;
David Woodhouse1046d882006-06-18 22:44:21 +0100591 uint32_t crc;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000592
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100593 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
594 BUG_ON(ref_obsolete(ref));
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000595
David Woodhouse1046d882006-06-18 22:44:21 +0100596 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);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100600 jffs2_mark_node_obsolete(c, ref);
601 return 0;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100602 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000603
David Woodhouse1046d882006-06-18 22:44:21 +0100604 /* 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));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100613 jffs2_mark_node_obsolete(c, ref);
614 return 0;
David Woodhouse1046d882006-06-18 22:44:21 +0100615 }
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;
David Woodhouse43dfa072007-06-29 13:39:57 +0100625 ref->flash_offset = ref_offset(ref) | dirent_node_state(rd);
David Woodhouse1046d882006-06-18 22:44:21 +0100626 spin_unlock(&c->erase_completion_lock);
627 }
628
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100629 fd = jffs2_alloc_full_dirent(rd->nsize + 1);
630 if (unlikely(!fd))
631 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100633 fd->raw = ref;
634 fd->version = je32_to_cpu(rd->version);
635 fd->ino = je32_to_cpu(rd->ino);
636 fd->type = rd->type;
637
David Woodhousedf8e96f2007-04-25 03:23:42 +0100638 if (fd->version > rii->highest_version)
639 rii->highest_version = fd->version;
640
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100641 /* Pick out the mctime of the latest dirent */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100642 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);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100645 }
646
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000647 /*
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100648 * 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)) ));
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000654
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100655 /* 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);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000660
661 err = jffs2_flash_read(c, (ref_offset(ref)) + read,
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100662 rd->nsize - already, &read, &fd->name[already]);
663 if (unlikely(read != rd->nsize - already) && likely(!err))
664 return -EIO;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000665
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100666 if (unlikely(err)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +0100667 JFFS2_ERROR("read remainder of name: error %d\n", err);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100668 jffs2_free_full_dirent(fd);
669 return -EIO;
670 }
671 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000672
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100673 fd->nhash = full_name_hash(fd->name, rd->nsize);
674 fd->next = NULL;
675 fd->name[rd->nsize] = '\0';
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000676
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100677 /*
678 * Wheee. We now have a complete jffs2_full_dirent structure, with
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000679 * the name in it and everything. Link it into the list
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100680 */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100681 jffs2_add_fd_to_list(c, fd, &rii->fds);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100682
683 return 0;
684}
685
686/*
687 * Helper function for jffs2_get_inode_nodes().
688 * It is called every time an inode node is found.
689 *
David Woodhouse14c63812007-07-03 16:51:19 -0400690 * Returns: 0 on success (possibly after marking a bad node obsolete);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100691 * negative error code on failure.
692 */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100693static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
David Woodhousedf8e96f2007-04-25 03:23:42 +0100694 struct jffs2_raw_inode *rd, int rdlen,
695 struct jffs2_readinode_info *rii)
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100696{
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100697 struct jffs2_tmp_dnode_info *tn;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100698 uint32_t len, csize;
David Woodhouse14c63812007-07-03 16:51:19 -0400699 int ret = 0;
David Woodhouse1046d882006-06-18 22:44:21 +0100700 uint32_t crc;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000701
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100702 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
703 BUG_ON(ref_obsolete(ref));
704
David Woodhouse1046d882006-06-18 22:44:21 +0100705 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);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100709 jffs2_mark_node_obsolete(c, ref);
710 return 0;
David Woodhouse1046d882006-06-18 22:44:21 +0100711 }
712
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100713 tn = jffs2_alloc_tmp_dnode_info();
714 if (!tn) {
Randy Dunlapfb6a82c2006-04-11 20:12:10 -0400715 JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn));
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100716 return -ENOMEM;
717 }
718
719 tn->partial_crc = 0;
720 csize = je32_to_cpu(rd->csize);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000721
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100722 /* If we've never checked the CRCs on this node, check them now */
723 if (ref_flags(ref) == REF_UNCHECKED) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000724
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100725 /* 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)))) {
David Woodhouse14c63812007-07-03 16:51:19 -0400728 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);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100731 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100732 }
733
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100734 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
Robert P. J. Daye1b85132008-02-03 15:14:02 +0200753 * of NAND flashes (or other flashes with
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100754 * !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;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100771
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100772 /* '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);
Artem B. Bityutskiy280562b2005-08-17 15:57:43 +0100776 tn->partial_crc = crc32(0, buf, len);
777
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100778 dbg_readinode("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100779
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100780 /* If we actually calculated the whole data CRC
781 * and it is wrong, drop the node. */
Artem B. Bityutskiy3c091332005-08-04 12:40:02 +0100782 if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) {
Artem B. Bityutskiy39243502005-08-03 10:26:50 +0100783 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));
David Woodhouse14c63812007-07-03 16:51:19 -0400785 jffs2_mark_node_obsolete(c, ref);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100786 goto free_out;
Artem B. Bityutskiy39243502005-08-03 10:26:50 +0100787 }
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100788
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100789 } 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;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100797
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100798 dbg_readinode("the node has no data.\n");
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100799 jeb = &c->blocks[ref->flash_offset / c->sector_size];
800 len = ref_totlen(c, jeb, ref);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100801
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100802 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;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100807 ref->flash_offset = ref_offset(ref) | REF_NORMAL;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100808 spin_unlock(&c->erase_completion_lock);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100809 }
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100810 }
811
812 tn->fn = jffs2_alloc_full_dnode();
813 if (!tn->fn) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +0100814 JFFS2_ERROR("alloc fn failed\n");
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100815 ret = -ENOMEM;
816 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100817 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000818
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100819 tn->version = je32_to_cpu(rd->version);
820 tn->fn->ofs = je32_to_cpu(rd->offset);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100821 tn->data_crc = je32_to_cpu(rd->data_crc);
822 tn->csize = csize;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100823 tn->fn->raw = ref;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100824 tn->overlapped = 0;
825
826 if (tn->version > rii->highest_version)
827 rii->highest_version = tn->version;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000828
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100829 /* There was a bug where we wrote hole nodes out with
830 csize/dsize swapped. Deal with it */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100831 if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize)
832 tn->fn->size = csize;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100833 else // normal case...
834 tn->fn->size = je32_to_cpu(rd->dsize);
835
David Woodhouse2c61cb22008-04-23 16:43:15 +0100836 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);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000839
David Woodhousedf8e96f2007-04-25 03:23:42 +0100840 ret = jffs2_add_tn_to_tree(c, rii, tn);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100841
David Woodhousedf8e96f2007-04-25 03:23:42 +0100842 if (ret) {
843 jffs2_free_full_dnode(tn->fn);
844 free_out:
845 jffs2_free_tmp_dnode_info(tn);
846 return ret;
847 }
David Woodhouse2c61cb22008-04-23 16:43:15 +0100848#ifdef JFFS2_DBG_READINODE2_MESSAGES
849 dbg_readinode2("After adding ver %d:\n", je32_to_cpu(rd->version));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100850 tn = tn_first(&rii->tn_root);
851 while (tn) {
David Woodhouse2c61cb22008-04-23 16:43:15 +0100852 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);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100855 tn = tn_next(tn);
856 }
857#endif
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100858 return 0;
859}
860
861/*
862 * Helper function for jffs2_get_inode_nodes().
863 * It is called every time an unknown node is found.
864 *
David Woodhouse3877f0b2006-06-18 00:05:26 +0100865 * Returns: 0 on success;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100866 * negative error code on failure.
867 */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100868static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, struct jffs2_unknown_node *un)
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100869{
870 /* We don't mark unknown nodes as REF_UNCHECKED */
David Woodhousec7258a42007-03-09 11:44:00 +0000871 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",
David Woodhouseef53cb02007-07-10 10:01:22 +0100875 je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
876 je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100877 jffs2_mark_node_obsolete(c, ref);
878 return 0;
David Woodhousec7258a42007-03-09 11:44:00 +0000879 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000880
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100881 un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype));
882
David Woodhouse3877f0b2006-06-18 00:05:26 +0100883 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));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100906 jffs2_mark_node_obsolete(c, ref);
907 return 0;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100908 }
909
910 return 0;
911}
912
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100913/*
914 * Helper function for jffs2_get_inode_nodes().
915 * The function detects whether more data should be read and reads it if yes.
916 *
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200917 * Returns: 0 on success;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100918 * negative error code on failure.
919 */
920static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300921 int needed_len, int *rdlen, unsigned char *buf)
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100922{
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300923 int err, to_read = needed_len - *rdlen;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100924 size_t retlen;
925 uint32_t offs;
926
927 if (jffs2_is_writebuffered(c)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300928 int rem = to_read % c->wbuf_pagesize;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100929
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300930 if (rem)
931 to_read += c->wbuf_pagesize - rem;
932 }
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100933
934 /* We need to read more data */
935 offs = ref_offset(ref) + *rdlen;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000936
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300937 dbg_readinode("read more %d bytes\n", to_read);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100938
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300939 err = jffs2_flash_read(c, offs, to_read, &retlen, buf + *rdlen);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100940 if (err) {
941 JFFS2_ERROR("can not read %d bytes from 0x%08x, "
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300942 "error code: %d.\n", to_read, offs, err);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100943 return err;
944 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000945
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300946 if (retlen < to_read) {
Randy Dunlapfb6a82c2006-04-11 20:12:10 -0400947 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n",
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300948 offs, retlen, to_read);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100949 return -EIO;
950 }
951
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300952 *rdlen += to_read;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100953 return 0;
954}
955
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100956/* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
David Woodhousedf8e96f2007-04-25 03:23:42 +0100957 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. */
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100961static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
David Woodhousedf8e96f2007-04-25 03:23:42 +0100962 struct jffs2_readinode_info *rii)
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100963{
964 struct jffs2_raw_node_ref *ref, *valid_ref;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100965 unsigned char *buf = NULL;
966 union jffs2_node_union *node;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100967 size_t retlen;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100968 int len, err;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100969
David Woodhousedf8e96f2007-04-25 03:23:42 +0100970 rii->mctime_ver = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000971
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100972 dbg_readinode("ino #%u\n", f->inocache->ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100973
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100974 /* FIXME: in case of NOR and available ->point() this
975 * needs to be fixed. */
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300976 len = sizeof(union jffs2_node_union) + c->wbuf_pagesize;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100977 buf = kmalloc(len, GFP_KERNEL);
978 if (!buf)
979 return -ENOMEM;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000980
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100981 spin_lock(&c->erase_completion_lock);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100982 valid_ref = jffs2_first_valid_node(f->inocache->nodes);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100983 if (!valid_ref && f->inocache->ino != 1)
984 JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100985 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
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100998 /*
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
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001001 * to minimize the amount of flash IO we assume the header is
1002 * of size = JFFS2_MIN_NODE_HEADER.
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001003 */
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001004 len = JFFS2_MIN_NODE_HEADER;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001005 if (jffs2_is_writebuffered(c)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001006 int end, rem;
1007
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001008 /*
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001009 * 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.
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001014 */
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001015 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);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001020 }
1021
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001022 dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001023
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001024 /* FIXME: point() */
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001025 err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001026 if (err) {
Jean Delvaredf2e3012011-07-16 18:10:35 +02001027 JFFS2_ERROR("can not read %d bytes from 0x%08x, error code: %d.\n", len, ref_offset(ref), err);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001028 goto free_out;
1029 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001030
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001031 if (retlen < len) {
Randy Dunlapfb6a82c2006-04-11 20:12:10 -04001032 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001033 err = -EIO;
1034 goto free_out;
1035 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001036
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001037 node = (union jffs2_node_union *)buf;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001038
David Woodhouse3877f0b2006-06-18 00:05:26 +01001039 /* 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 }
Joakim Tjernlund0dec4c82007-03-10 17:08:44 +01001050 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));
David Woodhousec7258a42007-03-09 11:44:00 +00001054 jffs2_mark_node_obsolete(c, ref);
1055 goto cont;
1056 }
David Woodhouse3877f0b2006-06-18 00:05:26 +01001057
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001058 switch (je16_to_cpu(node->u.nodetype)) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001059
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001060 case JFFS2_NODETYPE_DIRENT:
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001061
Artem Bityutskiyea55d302007-05-30 12:08:14 +03001062 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent) &&
1063 len < sizeof(struct jffs2_raw_dirent)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001064 err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001065 if (unlikely(err))
1066 goto free_out;
1067 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001068
David Woodhousedf8e96f2007-04-25 03:23:42 +01001069 err = read_direntry(c, ref, &node->d, retlen, rii);
1070 if (unlikely(err))
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001071 goto free_out;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001072
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001073 break;
1074
1075 case JFFS2_NODETYPE_INODE:
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001076
Artem Bityutskiyea55d302007-05-30 12:08:14 +03001077 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode) &&
1078 len < sizeof(struct jffs2_raw_inode)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001079 err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001080 if (unlikely(err))
1081 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001082 }
1083
David Woodhousedf8e96f2007-04-25 03:23:42 +01001084 err = read_dnode(c, ref, &node->i, len, rii);
1085 if (unlikely(err))
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001086 goto free_out;
1087
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 break;
1089
1090 default:
Artem Bityutskiyea55d302007-05-30 12:08:14 +03001091 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node) &&
1092 len < sizeof(struct jffs2_unknown_node)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001093 err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001094 if (unlikely(err))
1095 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001096 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001097
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001098 err = read_unknown(c, ref, &node->u);
David Woodhouse14c63812007-07-03 16:51:19 -04001099 if (unlikely(err))
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001100 goto free_out;
1101
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 }
David Woodhouse3877f0b2006-06-18 00:05:26 +01001103 cont:
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001104 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 }
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001106
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001107 spin_unlock(&c->erase_completion_lock);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001108 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
David Woodhousedf8e96f2007-04-25 03:23:42 +01001110 f->highest_version = rii->highest_version;
1111
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001112 dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n",
David Woodhousedf8e96f2007-04-25 03:23:42 +01001113 f->inocache->ino, rii->highest_version, rii->latest_mctime,
1114 rii->mctime_ver);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001115 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001117 free_out:
David Woodhousedf8e96f2007-04-25 03:23:42 +01001118 jffs2_free_tmp_dnode_info_list(&rii->tn_root);
1119 jffs2_free_full_dirent_list(rii->fds);
1120 rii->fds = NULL;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001121 kfree(buf);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001122 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001125static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 struct jffs2_inode_info *f,
1127 struct jffs2_raw_inode *latest_node)
1128{
David Woodhousedf8e96f2007-04-25 03:23:42 +01001129 struct jffs2_readinode_info rii;
David Woodhouse61c4b232007-04-25 17:04:23 +01001130 uint32_t crc, new_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 size_t retlen;
1132 int ret;
1133
David Woodhouse27c72b02008-05-01 18:47:17 +01001134 dbg_readinode("ino #%u pino/nlink is %d\n", f->inocache->ino,
1135 f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
David Woodhousedf8e96f2007-04-25 03:23:42 +01001137 memset(&rii, 0, sizeof(rii));
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 /* Grab all nodes relevant to this ino */
David Woodhousedf8e96f2007-04-25 03:23:42 +01001140 ret = jffs2_get_inode_nodes(c, f, &rii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142 if (ret) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001143 JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 if (f->inocache->state == INO_STATE_READING)
1145 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1146 return ret;
1147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
David Woodhousedf8e96f2007-04-25 03:23:42 +01001149 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;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001161 }
David Woodhousedf8e96f2007-04-25 03:23:42 +01001162 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 }
David Woodhousedf8e96f2007-04-25 03:23:42 +01001164
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);
1171 }
1172 rii.mdata_tn = NULL;
1173 }
1174
1175 f->dents = rii.fds;
1176
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +01001177 jffs2_dbg_fragtree_paranoia_check_nolock(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
David Woodhousedf8e96f2007-04-25 03:23:42 +01001179 if (unlikely(!rii.latest_ref)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 /* No data nodes for this inode. */
1181 if (f->inocache->ino != 1) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001182 JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino);
David Woodhousedf8e96f2007-04-25 03:23:42 +01001183 if (!rii.fds) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 if (f->inocache->state == INO_STATE_READING)
1185 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1186 return -EIO;
1187 }
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001188 JFFS2_NOTICE("but it has children so we fake some modes for it\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 }
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
David Woodhousedf8e96f2007-04-25 03:23:42 +01001201 ret = jffs2_flash_read(c, ref_offset(rii.latest_ref), sizeof(*latest_node), &retlen, (void *)latest_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 if (ret || retlen != sizeof(*latest_node)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001203 JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n",
1204 ret, retlen, sizeof(*latest_node));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 /* FIXME: If this fails, there seems to be a memory leak. Find it. */
David Woodhouseced22072008-04-22 15:13:40 +01001206 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 jffs2_do_clear_inode(c, f);
1208 return ret?ret:-EIO;
1209 }
1210
1211 crc = crc32(0, latest_node, sizeof(*latest_node)-8);
1212 if (crc != je32_to_cpu(latest_node->node_crc)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001213 JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n",
David Woodhousedf8e96f2007-04-25 03:23:42 +01001214 f->inocache->ino, ref_offset(rii.latest_ref));
David Woodhouseced22072008-04-22 15:13:40 +01001215 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 jffs2_do_clear_inode(c, f);
1217 return -EIO;
1218 }
1219
1220 switch(jemode_to_cpu(latest_node->mode) & S_IFMT) {
1221 case S_IFDIR:
David Woodhousedf8e96f2007-04-25 03:23:42 +01001222 if (rii.mctime_ver > je32_to_cpu(latest_node->version)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 /* The times in the latest_node are actually older than
1224 mctime in the latest dirent. Cheat. */
David Woodhousedf8e96f2007-04-25 03:23:42 +01001225 latest_node->ctime = latest_node->mtime = cpu_to_je32(rii.latest_mctime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 }
1227 break;
1228
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001229
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 case S_IFREG:
1231 /* If it was a regular file, truncate it to the latest node's isize */
David Woodhouse61c4b232007-04-25 17:04:23 +01001232 new_size = jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize));
1233 if (new_size != je32_to_cpu(latest_node->isize)) {
1234 JFFS2_WARNING("Truncating ino #%u to %d bytes failed because it only had %d bytes to start with!\n",
1235 f->inocache->ino, je32_to_cpu(latest_node->isize), new_size);
1236 latest_node->isize = cpu_to_je32(new_size);
1237 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 break;
1239
1240 case S_IFLNK:
1241 /* Hack to work around broken isize in old symlink code.
1242 Remove this when dwmw2 comes to his senses and stops
1243 symlinks from being an entirely gratuitous special
1244 case. */
1245 if (!je32_to_cpu(latest_node->isize))
1246 latest_node->isize = latest_node->dsize;
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001247
1248 if (f->inocache->state != INO_STATE_CHECKING) {
1249 /* Symlink's inode data is the target path. Read it and
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001250 * keep in RAM to facilitate quick follow symlink
1251 * operation. */
Xi Wang7c80c352012-04-25 14:45:22 -04001252 uint32_t csize = je32_to_cpu(latest_node->csize);
1253 if (csize > JFFS2_MAX_NAME_LEN) {
1254 mutex_unlock(&f->sem);
1255 jffs2_do_clear_inode(c, f);
1256 return -ENAMETOOLONG;
1257 }
Xi Wangb6778fd2012-04-25 14:45:23 -04001258 f->target = kmalloc(csize + 1, GFP_KERNEL);
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001259 if (!f->target) {
Xi Wangb6778fd2012-04-25 14:45:23 -04001260 JFFS2_ERROR("can't allocate %u bytes of memory for the symlink target path cache\n", csize);
David Woodhouseced22072008-04-22 15:13:40 +01001261 mutex_unlock(&f->sem);
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001262 jffs2_do_clear_inode(c, f);
1263 return -ENOMEM;
1264 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001265
David Woodhousedf8e96f2007-04-25 03:23:42 +01001266 ret = jffs2_flash_read(c, ref_offset(rii.latest_ref) + sizeof(*latest_node),
Xi Wangb6778fd2012-04-25 14:45:23 -04001267 csize, &retlen, (char *)f->target);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001268
Xi Wangb6778fd2012-04-25 14:45:23 -04001269 if (ret || retlen != csize) {
1270 if (retlen != csize)
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001271 ret = -EIO;
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001272 kfree(f->target);
1273 f->target = NULL;
David Woodhouseced22072008-04-22 15:13:40 +01001274 mutex_unlock(&f->sem);
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001275 jffs2_do_clear_inode(c, f);
Roel Kluine670e412009-11-12 18:09:48 +01001276 return ret;
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001277 }
1278
Xi Wangb6778fd2012-04-25 14:45:23 -04001279 f->target[csize] = '\0';
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001280 dbg_readinode("symlink's target '%s' cached\n", f->target);
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001281 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001282
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 /* fall through... */
1284
1285 case S_IFBLK:
1286 case S_IFCHR:
1287 /* Certain inode types should have only one data node, and it's
1288 kept as the metadata node */
1289 if (f->metadata) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001290 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 f->inocache->ino, jemode_to_cpu(latest_node->mode));
David Woodhouseced22072008-04-22 15:13:40 +01001292 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 jffs2_do_clear_inode(c, f);
1294 return -EIO;
1295 }
1296 if (!frag_first(&f->fragtree)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001297 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 f->inocache->ino, jemode_to_cpu(latest_node->mode));
David Woodhouseced22072008-04-22 15:13:40 +01001299 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 jffs2_do_clear_inode(c, f);
1301 return -EIO;
1302 }
1303 /* ASSERT: f->fraglist != NULL */
1304 if (frag_next(frag_first(&f->fragtree))) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001305 JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 f->inocache->ino, jemode_to_cpu(latest_node->mode));
1307 /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
David Woodhouseced22072008-04-22 15:13:40 +01001308 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 jffs2_do_clear_inode(c, f);
1310 return -EIO;
1311 }
1312 /* OK. We're happy */
1313 f->metadata = frag_first(&f->fragtree)->node;
1314 jffs2_free_node_frag(frag_first(&f->fragtree));
1315 f->fragtree = RB_ROOT;
1316 break;
1317 }
1318 if (f->inocache->state == INO_STATE_READING)
1319 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
1320
1321 return 0;
1322}
1323
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001324/* Scan the list of all nodes present for this ino, build map of versions, etc. */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001325int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001326 uint32_t ino, struct jffs2_raw_inode *latest_node)
1327{
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001328 dbg_readinode("read inode #%u\n", ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001329
1330 retry_inocache:
1331 spin_lock(&c->inocache_lock);
1332 f->inocache = jffs2_get_ino_cache(c, ino);
1333
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001334 if (f->inocache) {
1335 /* Check its state. We may need to wait before we can use it */
1336 switch(f->inocache->state) {
1337 case INO_STATE_UNCHECKED:
1338 case INO_STATE_CHECKEDABSENT:
1339 f->inocache->state = INO_STATE_READING;
1340 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001341
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001342 case INO_STATE_CHECKING:
1343 case INO_STATE_GC:
1344 /* If it's in either of these states, we need
1345 to wait for whoever's got it to finish and
1346 put it back. */
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001347 dbg_readinode("waiting for ino #%u in state %d\n", ino, f->inocache->state);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001348 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
1349 goto retry_inocache;
1350
1351 case INO_STATE_READING:
1352 case INO_STATE_PRESENT:
1353 /* Eep. This should never happen. It can
1354 happen if Linux calls read_inode() again
1355 before clear_inode() has finished though. */
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001356 JFFS2_ERROR("Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001357 /* Fail. That's probably better than allowing it to succeed */
1358 f->inocache = NULL;
1359 break;
1360
1361 default:
1362 BUG();
1363 }
1364 }
1365 spin_unlock(&c->inocache_lock);
1366
1367 if (!f->inocache && ino == 1) {
1368 /* Special case - no root inode on medium */
1369 f->inocache = jffs2_alloc_inode_cache();
1370 if (!f->inocache) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001371 JFFS2_ERROR("cannot allocate inocache for root inode\n");
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001372 return -ENOMEM;
1373 }
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001374 dbg_readinode("creating inocache for root inode\n");
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001375 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
David Woodhouse27c72b02008-05-01 18:47:17 +01001376 f->inocache->ino = f->inocache->pino_nlink = 1;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001377 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
1378 f->inocache->state = INO_STATE_READING;
1379 jffs2_add_ino_cache(c, f->inocache);
1380 }
1381 if (!f->inocache) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001382 JFFS2_ERROR("requestied to read an nonexistent ino %u\n", ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001383 return -ENOENT;
1384 }
1385
1386 return jffs2_do_read_inode_internal(c, f, latest_node);
1387}
1388
1389int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
1390{
1391 struct jffs2_raw_inode n;
Yan Burman3d375d92006-12-04 15:03:01 -08001392 struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001393 int ret;
1394
1395 if (!f)
1396 return -ENOMEM;
1397
David Woodhouseced22072008-04-22 15:13:40 +01001398 mutex_init(&f->sem);
1399 mutex_lock(&f->sem);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001400 f->inocache = ic;
1401
1402 ret = jffs2_do_read_inode_internal(c, f, &n);
1403 if (!ret) {
David Woodhouseced22072008-04-22 15:13:40 +01001404 mutex_unlock(&f->sem);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001405 jffs2_do_clear_inode(c, f);
1406 }
Jean-Christophe DUBOIS8c5a0362012-05-10 17:14:03 +02001407 jffs2_xattr_do_crccheck_inode(c, ic);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001408 kfree (f);
1409 return ret;
1410}
1411
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
1413{
1414 struct jffs2_full_dirent *fd, *fds;
1415 int deleted;
1416
KaiGai Kohei355ed4e2006-06-24 09:15:36 +09001417 jffs2_xattr_delete_inode(c, f->inocache);
David Woodhouseced22072008-04-22 15:13:40 +01001418 mutex_lock(&f->sem);
David Woodhouse27c72b02008-05-01 18:47:17 +01001419 deleted = f->inocache && !f->inocache->pino_nlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
David Woodhouse67e345d2005-02-27 23:01:36 +00001421 if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
1422 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
1423
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 if (f->metadata) {
1425 if (deleted)
1426 jffs2_mark_node_obsolete(c, f->metadata->raw);
1427 jffs2_free_full_dnode(f->metadata);
1428 }
1429
1430 jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
1431
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001432 if (f->target) {
1433 kfree(f->target);
1434 f->target = NULL;
1435 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001436
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001437 fds = f->dents;
1438 while(fds) {
1439 fd = fds;
1440 fds = fd->next;
1441 jffs2_free_full_dirent(fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 }
1443
David Woodhouse67e345d2005-02-27 23:01:36 +00001444 if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
David Woodhouse67e345d2005-02-27 23:01:36 +00001446 if (f->inocache->nodes == (void *)f->inocache)
1447 jffs2_del_ino_cache(c, f->inocache);
1448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449
David Woodhouseced22072008-04-22 15:13:40 +01001450 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451}