blob: bfebbf13698c0e0d255e20f5ebf26de7fd6b5845 [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
Geert Uytterhoeven4740f492014-11-27 12:05:46 +0100227 /* If a node has zero dsize, we only have to keep it if it might be the
David Woodhousedf8e96f2007-04-25 03:23:42 +0100228 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]);
Wei Fangeb042ec2015-09-29 11:23:55 +0800663 if (unlikely(read != rd->nsize - already) && likely(!err)) {
664 jffs2_free_full_dirent(fd);
665 JFFS2_ERROR("short read: wanted %d bytes, got %zd\n",
666 rd->nsize - already, read);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100667 return -EIO;
Wei Fangeb042ec2015-09-29 11:23:55 +0800668 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000669
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100670 if (unlikely(err)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +0100671 JFFS2_ERROR("read remainder of name: error %d\n", err);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100672 jffs2_free_full_dirent(fd);
673 return -EIO;
674 }
675 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000676
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100677 fd->nhash = full_name_hash(fd->name, rd->nsize);
678 fd->next = NULL;
679 fd->name[rd->nsize] = '\0';
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000680
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100681 /*
682 * Wheee. We now have a complete jffs2_full_dirent structure, with
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000683 * the name in it and everything. Link it into the list
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100684 */
David Woodhousedf8e96f2007-04-25 03:23:42 +0100685 jffs2_add_fd_to_list(c, fd, &rii->fds);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100686
687 return 0;
688}
689
690/*
691 * Helper function for jffs2_get_inode_nodes().
692 * It is called every time an inode node is found.
693 *
David Woodhouse14c63812007-07-03 16:51:19 -0400694 * Returns: 0 on success (possibly after marking a bad node obsolete);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100695 * negative error code on failure.
696 */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100697static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
David Woodhousedf8e96f2007-04-25 03:23:42 +0100698 struct jffs2_raw_inode *rd, int rdlen,
699 struct jffs2_readinode_info *rii)
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100700{
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100701 struct jffs2_tmp_dnode_info *tn;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100702 uint32_t len, csize;
David Woodhouse14c63812007-07-03 16:51:19 -0400703 int ret = 0;
David Woodhouse1046d882006-06-18 22:44:21 +0100704 uint32_t crc;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000705
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100706 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
707 BUG_ON(ref_obsolete(ref));
708
David Woodhouse1046d882006-06-18 22:44:21 +0100709 crc = crc32(0, rd, sizeof(*rd) - 8);
710 if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
711 JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n",
712 ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100713 jffs2_mark_node_obsolete(c, ref);
714 return 0;
David Woodhouse1046d882006-06-18 22:44:21 +0100715 }
716
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100717 tn = jffs2_alloc_tmp_dnode_info();
718 if (!tn) {
Randy Dunlapfb6a82c2006-04-11 20:12:10 -0400719 JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn));
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100720 return -ENOMEM;
721 }
722
723 tn->partial_crc = 0;
724 csize = je32_to_cpu(rd->csize);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000725
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100726 /* If we've never checked the CRCs on this node, check them now */
727 if (ref_flags(ref) == REF_UNCHECKED) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000728
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100729 /* Sanity checks */
730 if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) ||
731 unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) {
David Woodhouse14c63812007-07-03 16:51:19 -0400732 JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref));
733 jffs2_dbg_dump_node(c, ref_offset(ref));
734 jffs2_mark_node_obsolete(c, ref);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100735 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100736 }
737
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100738 if (jffs2_is_writebuffered(c) && csize != 0) {
739 /* At this point we are supposed to check the data CRC
740 * of our unchecked node. But thus far, we do not
741 * know whether the node is valid or obsolete. To
742 * figure this out, we need to walk all the nodes of
743 * the inode and build the inode fragtree. We don't
744 * want to spend time checking data of nodes which may
745 * later be found to be obsolete. So we put off the full
746 * data CRC checking until we have read all the inode
747 * nodes and have started building the fragtree.
748 *
749 * The fragtree is being built starting with nodes
750 * having the highest version number, so we'll be able
751 * to detect whether a node is valid (i.e., it is not
752 * overlapped by a node with higher version) or not.
753 * And we'll be able to check only those nodes, which
754 * are not obsolete.
755 *
756 * Of course, this optimization only makes sense in case
Robert P. J. Daye1b85132008-02-03 15:14:02 +0200757 * of NAND flashes (or other flashes with
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100758 * !jffs2_can_mark_obsolete()), since on NOR flashes
759 * nodes are marked obsolete physically.
760 *
761 * Since NAND flashes (or other flashes with
762 * jffs2_is_writebuffered(c)) are anyway read by
763 * fractions of c->wbuf_pagesize, and we have just read
764 * the node header, it is likely that the starting part
765 * of the node data is also read when we read the
766 * header. So we don't mind to check the CRC of the
767 * starting part of the data of the node now, and check
768 * the second part later (in jffs2_check_node_data()).
769 * Of course, we will not need to re-read and re-check
770 * the NAND page which we have just read. This is why we
771 * read the whole NAND page at jffs2_get_inode_nodes(),
772 * while we needed only the node header.
773 */
774 unsigned char *buf;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100775
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100776 /* 'buf' will point to the start of data */
777 buf = (unsigned char *)rd + sizeof(*rd);
778 /* len will be the read data length */
779 len = min_t(uint32_t, rdlen - sizeof(*rd), csize);
Artem B. Bityutskiy280562b2005-08-17 15:57:43 +0100780 tn->partial_crc = crc32(0, buf, len);
781
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100782 dbg_readinode("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100783
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100784 /* If we actually calculated the whole data CRC
785 * and it is wrong, drop the node. */
Artem B. Bityutskiy3c091332005-08-04 12:40:02 +0100786 if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) {
Artem B. Bityutskiy39243502005-08-03 10:26:50 +0100787 JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
788 ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc));
David Woodhouse14c63812007-07-03 16:51:19 -0400789 jffs2_mark_node_obsolete(c, ref);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100790 goto free_out;
Artem B. Bityutskiy39243502005-08-03 10:26:50 +0100791 }
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100792
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100793 } else if (csize == 0) {
794 /*
795 * We checked the header CRC. If the node has no data, adjust
796 * the space accounting now. For other nodes this will be done
797 * later either when the node is marked obsolete or when its
798 * data is checked.
799 */
800 struct jffs2_eraseblock *jeb;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100801
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100802 dbg_readinode("the node has no data.\n");
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100803 jeb = &c->blocks[ref->flash_offset / c->sector_size];
804 len = ref_totlen(c, jeb, ref);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100805
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100806 spin_lock(&c->erase_completion_lock);
807 jeb->used_size += len;
808 jeb->unchecked_size -= len;
809 c->used_size += len;
810 c->unchecked_size -= len;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100811 ref->flash_offset = ref_offset(ref) | REF_NORMAL;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100812 spin_unlock(&c->erase_completion_lock);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100813 }
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100814 }
815
816 tn->fn = jffs2_alloc_full_dnode();
817 if (!tn->fn) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +0100818 JFFS2_ERROR("alloc fn failed\n");
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100819 ret = -ENOMEM;
820 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100821 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000822
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100823 tn->version = je32_to_cpu(rd->version);
824 tn->fn->ofs = je32_to_cpu(rd->offset);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100825 tn->data_crc = je32_to_cpu(rd->data_crc);
826 tn->csize = csize;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100827 tn->fn->raw = ref;
David Woodhousedf8e96f2007-04-25 03:23:42 +0100828 tn->overlapped = 0;
829
830 if (tn->version > rii->highest_version)
831 rii->highest_version = tn->version;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000832
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100833 /* There was a bug where we wrote hole nodes out with
834 csize/dsize swapped. Deal with it */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100835 if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize)
836 tn->fn->size = csize;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100837 else // normal case...
838 tn->fn->size = je32_to_cpu(rd->dsize);
839
David Woodhouse2c61cb22008-04-23 16:43:15 +0100840 dbg_readinode2("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n",
841 ref_offset(ref), je32_to_cpu(rd->version),
842 je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000843
David Woodhousedf8e96f2007-04-25 03:23:42 +0100844 ret = jffs2_add_tn_to_tree(c, rii, tn);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100845
David Woodhousedf8e96f2007-04-25 03:23:42 +0100846 if (ret) {
847 jffs2_free_full_dnode(tn->fn);
848 free_out:
849 jffs2_free_tmp_dnode_info(tn);
850 return ret;
851 }
David Woodhouse2c61cb22008-04-23 16:43:15 +0100852#ifdef JFFS2_DBG_READINODE2_MESSAGES
853 dbg_readinode2("After adding ver %d:\n", je32_to_cpu(rd->version));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100854 tn = tn_first(&rii->tn_root);
855 while (tn) {
David Woodhouse2c61cb22008-04-23 16:43:15 +0100856 dbg_readinode2("%p: v %d r 0x%x-0x%x ov %d\n",
857 tn, tn->version, tn->fn->ofs,
858 tn->fn->ofs+tn->fn->size, tn->overlapped);
David Woodhousedf8e96f2007-04-25 03:23:42 +0100859 tn = tn_next(tn);
860 }
861#endif
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100862 return 0;
863}
864
865/*
866 * Helper function for jffs2_get_inode_nodes().
867 * It is called every time an unknown node is found.
868 *
David Woodhouse3877f0b2006-06-18 00:05:26 +0100869 * Returns: 0 on success;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100870 * negative error code on failure.
871 */
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100872static 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 +0100873{
874 /* We don't mark unknown nodes as REF_UNCHECKED */
David Woodhousec7258a42007-03-09 11:44:00 +0000875 if (ref_flags(ref) == REF_UNCHECKED) {
876 JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n",
877 ref_offset(ref));
878 JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n",
David Woodhouseef53cb02007-07-10 10:01:22 +0100879 je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
880 je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100881 jffs2_mark_node_obsolete(c, ref);
882 return 0;
David Woodhousec7258a42007-03-09 11:44:00 +0000883 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000884
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100885 un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype));
886
David Woodhouse3877f0b2006-06-18 00:05:26 +0100887 switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) {
888
889 case JFFS2_FEATURE_INCOMPAT:
890 JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n",
891 je16_to_cpu(un->nodetype), ref_offset(ref));
892 /* EEP */
893 BUG();
894 break;
895
896 case JFFS2_FEATURE_ROCOMPAT:
897 JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n",
898 je16_to_cpu(un->nodetype), ref_offset(ref));
899 BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO));
900 break;
901
902 case JFFS2_FEATURE_RWCOMPAT_COPY:
903 JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n",
904 je16_to_cpu(un->nodetype), ref_offset(ref));
905 break;
906
907 case JFFS2_FEATURE_RWCOMPAT_DELETE:
908 JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n",
909 je16_to_cpu(un->nodetype), ref_offset(ref));
David Woodhousedf8e96f2007-04-25 03:23:42 +0100910 jffs2_mark_node_obsolete(c, ref);
911 return 0;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100912 }
913
914 return 0;
915}
916
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100917/*
918 * Helper function for jffs2_get_inode_nodes().
919 * The function detects whether more data should be read and reads it if yes.
920 *
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200921 * Returns: 0 on success;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100922 * negative error code on failure.
923 */
924static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300925 int needed_len, int *rdlen, unsigned char *buf)
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100926{
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300927 int err, to_read = needed_len - *rdlen;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100928 size_t retlen;
929 uint32_t offs;
930
931 if (jffs2_is_writebuffered(c)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300932 int rem = to_read % c->wbuf_pagesize;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100933
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300934 if (rem)
935 to_read += c->wbuf_pagesize - rem;
936 }
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100937
938 /* We need to read more data */
939 offs = ref_offset(ref) + *rdlen;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000940
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300941 dbg_readinode("read more %d bytes\n", to_read);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100942
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300943 err = jffs2_flash_read(c, offs, to_read, &retlen, buf + *rdlen);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100944 if (err) {
945 JFFS2_ERROR("can not read %d bytes from 0x%08x, "
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300946 "error code: %d.\n", to_read, offs, err);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100947 return err;
948 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000949
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300950 if (retlen < to_read) {
Randy Dunlapfb6a82c2006-04-11 20:12:10 -0400951 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n",
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300952 offs, retlen, to_read);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100953 return -EIO;
954 }
955
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300956 *rdlen += to_read;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100957 return 0;
958}
959
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100960/* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
David Woodhousedf8e96f2007-04-25 03:23:42 +0100961 with this ino. Perform a preliminary ordering on data nodes, throwing away
962 those which are completely obsoleted by newer ones. The naïve approach we
963 use to take of just returning them _all_ in version order will cause us to
964 run out of memory in certain degenerate cases. */
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100965static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
David Woodhousedf8e96f2007-04-25 03:23:42 +0100966 struct jffs2_readinode_info *rii)
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100967{
968 struct jffs2_raw_node_ref *ref, *valid_ref;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100969 unsigned char *buf = NULL;
970 union jffs2_node_union *node;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100971 size_t retlen;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100972 int len, err;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100973
David Woodhousedf8e96f2007-04-25 03:23:42 +0100974 rii->mctime_ver = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000975
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +0100976 dbg_readinode("ino #%u\n", f->inocache->ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100977
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100978 /* FIXME: in case of NOR and available ->point() this
979 * needs to be fixed. */
Artem Bityutskiy10731f82007-04-04 13:59:11 +0300980 len = sizeof(union jffs2_node_union) + c->wbuf_pagesize;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100981 buf = kmalloc(len, GFP_KERNEL);
982 if (!buf)
983 return -ENOMEM;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000984
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100985 spin_lock(&c->erase_completion_lock);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100986 valid_ref = jffs2_first_valid_node(f->inocache->nodes);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +0100987 if (!valid_ref && f->inocache->ino != 1)
988 JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +0100989 while (valid_ref) {
990 /* We can hold a pointer to a non-obsolete node without the spinlock,
991 but _obsolete_ nodes may disappear at any time, if the block
992 they're in gets erased. So if we mark 'ref' obsolete while we're
993 not holding the lock, it can go away immediately. For that reason,
994 we find the next valid node first, before processing 'ref'.
995 */
996 ref = valid_ref;
997 valid_ref = jffs2_first_valid_node(ref->next_in_ino);
998 spin_unlock(&c->erase_completion_lock);
999
1000 cond_resched();
1001
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001002 /*
1003 * At this point we don't know the type of the node we're going
1004 * to read, so we do not know the size of its header. In order
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001005 * to minimize the amount of flash IO we assume the header is
1006 * of size = JFFS2_MIN_NODE_HEADER.
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001007 */
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001008 len = JFFS2_MIN_NODE_HEADER;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001009 if (jffs2_is_writebuffered(c)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001010 int end, rem;
1011
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001012 /*
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001013 * We are about to read JFFS2_MIN_NODE_HEADER bytes,
1014 * but this flash has some minimal I/O unit. It is
1015 * possible that we'll need to read more soon, so read
1016 * up to the next min. I/O unit, in order not to
1017 * re-read the same min. I/O unit twice.
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001018 */
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001019 end = ref_offset(ref) + len;
1020 rem = end % c->wbuf_pagesize;
1021 if (rem)
1022 end += c->wbuf_pagesize - rem;
1023 len = end - ref_offset(ref);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001024 }
1025
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001026 dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001027
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001028 /* FIXME: point() */
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001029 err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001030 if (err) {
Jean Delvaredf2e3012011-07-16 18:10:35 +02001031 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 +01001032 goto free_out;
1033 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001034
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001035 if (retlen < len) {
Randy Dunlapfb6a82c2006-04-11 20:12:10 -04001036 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001037 err = -EIO;
1038 goto free_out;
1039 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001040
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001041 node = (union jffs2_node_union *)buf;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001042
David Woodhouse3877f0b2006-06-18 00:05:26 +01001043 /* No need to mask in the valid bit; it shouldn't be invalid */
1044 if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) {
1045 JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n",
1046 ref_offset(ref), je16_to_cpu(node->u.magic),
1047 je16_to_cpu(node->u.nodetype),
1048 je32_to_cpu(node->u.totlen),
1049 je32_to_cpu(node->u.hdr_crc));
1050 jffs2_dbg_dump_node(c, ref_offset(ref));
1051 jffs2_mark_node_obsolete(c, ref);
1052 goto cont;
1053 }
Joakim Tjernlund0dec4c82007-03-10 17:08:44 +01001054 if (je16_to_cpu(node->u.magic) != JFFS2_MAGIC_BITMASK) {
1055 /* Not a JFFS2 node, whinge and move on */
1056 JFFS2_NOTICE("Wrong magic bitmask 0x%04x in node header at %#08x.\n",
1057 je16_to_cpu(node->u.magic), ref_offset(ref));
David Woodhousec7258a42007-03-09 11:44:00 +00001058 jffs2_mark_node_obsolete(c, ref);
1059 goto cont;
1060 }
David Woodhouse3877f0b2006-06-18 00:05:26 +01001061
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001062 switch (je16_to_cpu(node->u.nodetype)) {
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001063
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001064 case JFFS2_NODETYPE_DIRENT:
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001065
Artem Bityutskiyea55d302007-05-30 12:08:14 +03001066 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent) &&
1067 len < sizeof(struct jffs2_raw_dirent)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001068 err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001069 if (unlikely(err))
1070 goto free_out;
1071 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001072
David Woodhousedf8e96f2007-04-25 03:23:42 +01001073 err = read_direntry(c, ref, &node->d, retlen, rii);
1074 if (unlikely(err))
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001075 goto free_out;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001076
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001077 break;
1078
1079 case JFFS2_NODETYPE_INODE:
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001080
Artem Bityutskiyea55d302007-05-30 12:08:14 +03001081 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode) &&
1082 len < sizeof(struct jffs2_raw_inode)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001083 err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001084 if (unlikely(err))
1085 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001086 }
1087
David Woodhousedf8e96f2007-04-25 03:23:42 +01001088 err = read_dnode(c, ref, &node->i, len, rii);
1089 if (unlikely(err))
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001090 goto free_out;
1091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 break;
1093
1094 default:
Artem Bityutskiyea55d302007-05-30 12:08:14 +03001095 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node) &&
1096 len < sizeof(struct jffs2_unknown_node)) {
Artem Bityutskiy10731f82007-04-04 13:59:11 +03001097 err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001098 if (unlikely(err))
1099 goto free_out;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001100 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001101
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001102 err = read_unknown(c, ref, &node->u);
David Woodhouse14c63812007-07-03 16:51:19 -04001103 if (unlikely(err))
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001104 goto free_out;
1105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 }
David Woodhouse3877f0b2006-06-18 00:05:26 +01001107 cont:
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001108 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 }
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001110
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001111 spin_unlock(&c->erase_completion_lock);
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001112 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
David Woodhousedf8e96f2007-04-25 03:23:42 +01001114 f->highest_version = rii->highest_version;
1115
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001116 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 +01001117 f->inocache->ino, rii->highest_version, rii->latest_mctime,
1118 rii->mctime_ver);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001119 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001121 free_out:
David Woodhousedf8e96f2007-04-25 03:23:42 +01001122 jffs2_free_tmp_dnode_info_list(&rii->tn_root);
1123 jffs2_free_full_dirent_list(rii->fds);
1124 rii->fds = NULL;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001125 kfree(buf);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001126 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127}
1128
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001129static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 struct jffs2_inode_info *f,
1131 struct jffs2_raw_inode *latest_node)
1132{
David Woodhousedf8e96f2007-04-25 03:23:42 +01001133 struct jffs2_readinode_info rii;
David Woodhouse61c4b232007-04-25 17:04:23 +01001134 uint32_t crc, new_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 size_t retlen;
1136 int ret;
1137
David Woodhouse27c72b02008-05-01 18:47:17 +01001138 dbg_readinode("ino #%u pino/nlink is %d\n", f->inocache->ino,
1139 f->inocache->pino_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
David Woodhousedf8e96f2007-04-25 03:23:42 +01001141 memset(&rii, 0, sizeof(rii));
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 /* Grab all nodes relevant to this ino */
David Woodhousedf8e96f2007-04-25 03:23:42 +01001144 ret = jffs2_get_inode_nodes(c, f, &rii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
1146 if (ret) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001147 JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 if (f->inocache->state == INO_STATE_READING)
1149 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1150 return ret;
1151 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
David Woodhousedf8e96f2007-04-25 03:23:42 +01001153 ret = jffs2_build_inode_fragtree(c, f, &rii);
1154 if (ret) {
1155 JFFS2_ERROR("Failed to build final fragtree for inode #%u: error %d\n",
1156 f->inocache->ino, ret);
1157 if (f->inocache->state == INO_STATE_READING)
1158 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1159 jffs2_free_tmp_dnode_info_list(&rii.tn_root);
1160 /* FIXME: We could at least crc-check them all */
1161 if (rii.mdata_tn) {
1162 jffs2_free_full_dnode(rii.mdata_tn->fn);
1163 jffs2_free_tmp_dnode_info(rii.mdata_tn);
1164 rii.mdata_tn = NULL;
Artem B. Bityutskiy1e0da3c2005-08-01 13:05:22 +01001165 }
David Woodhousedf8e96f2007-04-25 03:23:42 +01001166 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 }
David Woodhousedf8e96f2007-04-25 03:23:42 +01001168
1169 if (rii.mdata_tn) {
1170 if (rii.mdata_tn->fn->raw == rii.latest_ref) {
1171 f->metadata = rii.mdata_tn->fn;
1172 jffs2_free_tmp_dnode_info(rii.mdata_tn);
1173 } else {
1174 jffs2_kill_tn(c, rii.mdata_tn);
1175 }
1176 rii.mdata_tn = NULL;
1177 }
1178
1179 f->dents = rii.fds;
1180
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +01001181 jffs2_dbg_fragtree_paranoia_check_nolock(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
David Woodhousedf8e96f2007-04-25 03:23:42 +01001183 if (unlikely(!rii.latest_ref)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 /* No data nodes for this inode. */
1185 if (f->inocache->ino != 1) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001186 JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino);
David Woodhousedf8e96f2007-04-25 03:23:42 +01001187 if (!rii.fds) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 if (f->inocache->state == INO_STATE_READING)
1189 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
1190 return -EIO;
1191 }
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001192 JFFS2_NOTICE("but it has children so we fake some modes for it\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 }
1194 latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO);
1195 latest_node->version = cpu_to_je32(0);
1196 latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0);
1197 latest_node->isize = cpu_to_je32(0);
1198 latest_node->gid = cpu_to_je16(0);
1199 latest_node->uid = cpu_to_je16(0);
1200 if (f->inocache->state == INO_STATE_READING)
1201 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
1202 return 0;
1203 }
1204
David Woodhousedf8e96f2007-04-25 03:23:42 +01001205 ret = jffs2_flash_read(c, ref_offset(rii.latest_ref), sizeof(*latest_node), &retlen, (void *)latest_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 if (ret || retlen != sizeof(*latest_node)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001207 JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n",
1208 ret, retlen, sizeof(*latest_node));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 /* FIXME: If this fails, there seems to be a memory leak. Find it. */
Brian Norris7aaea762014-02-25 18:27:40 -08001210 return ret ? ret : -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 }
1212
1213 crc = crc32(0, latest_node, sizeof(*latest_node)-8);
1214 if (crc != je32_to_cpu(latest_node->node_crc)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001215 JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n",
David Woodhousedf8e96f2007-04-25 03:23:42 +01001216 f->inocache->ino, ref_offset(rii.latest_ref));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 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);
Brian Norris7aaea762014-02-25 18:27:40 -08001253 if (csize > JFFS2_MAX_NAME_LEN)
Xi Wang7c80c352012-04-25 14:45:22 -04001254 return -ENAMETOOLONG;
Xi Wangb6778fd2012-04-25 14:45:23 -04001255 f->target = kmalloc(csize + 1, GFP_KERNEL);
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001256 if (!f->target) {
Xi Wangb6778fd2012-04-25 14:45:23 -04001257 JFFS2_ERROR("can't allocate %u bytes of memory for the symlink target path cache\n", csize);
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001258 return -ENOMEM;
1259 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001260
David Woodhousedf8e96f2007-04-25 03:23:42 +01001261 ret = jffs2_flash_read(c, ref_offset(rii.latest_ref) + sizeof(*latest_node),
Xi Wangb6778fd2012-04-25 14:45:23 -04001262 csize, &retlen, (char *)f->target);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001263
Xi Wangb6778fd2012-04-25 14:45:23 -04001264 if (ret || retlen != csize) {
1265 if (retlen != csize)
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001266 ret = -EIO;
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001267 kfree(f->target);
1268 f->target = NULL;
Roel Kluine670e412009-11-12 18:09:48 +01001269 return ret;
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001270 }
1271
Xi Wangb6778fd2012-04-25 14:45:23 -04001272 f->target[csize] = '\0';
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001273 dbg_readinode("symlink's target '%s' cached\n", f->target);
Artem B. Bityuckiy32f1a952005-03-01 10:50:52 +00001274 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001275
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 /* fall through... */
1277
1278 case S_IFBLK:
1279 case S_IFCHR:
1280 /* Certain inode types should have only one data node, and it's
1281 kept as the metadata node */
1282 if (f->metadata) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001283 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 f->inocache->ino, jemode_to_cpu(latest_node->mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 return -EIO;
1286 }
1287 if (!frag_first(&f->fragtree)) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001288 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 f->inocache->ino, jemode_to_cpu(latest_node->mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 return -EIO;
1291 }
1292 /* ASSERT: f->fraglist != NULL */
1293 if (frag_next(frag_first(&f->fragtree))) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001294 JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 f->inocache->ino, jemode_to_cpu(latest_node->mode));
1296 /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 return -EIO;
1298 }
1299 /* OK. We're happy */
1300 f->metadata = frag_first(&f->fragtree)->node;
1301 jffs2_free_node_frag(frag_first(&f->fragtree));
1302 f->fragtree = RB_ROOT;
1303 break;
1304 }
1305 if (f->inocache->state == INO_STATE_READING)
1306 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
1307
1308 return 0;
1309}
1310
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001311/* Scan the list of all nodes present for this ino, build map of versions, etc. */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001312int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001313 uint32_t ino, struct jffs2_raw_inode *latest_node)
1314{
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001315 dbg_readinode("read inode #%u\n", ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001316
1317 retry_inocache:
1318 spin_lock(&c->inocache_lock);
1319 f->inocache = jffs2_get_ino_cache(c, ino);
1320
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001321 if (f->inocache) {
1322 /* Check its state. We may need to wait before we can use it */
1323 switch(f->inocache->state) {
1324 case INO_STATE_UNCHECKED:
1325 case INO_STATE_CHECKEDABSENT:
1326 f->inocache->state = INO_STATE_READING;
1327 break;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001328
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001329 case INO_STATE_CHECKING:
1330 case INO_STATE_GC:
1331 /* If it's in either of these states, we need
1332 to wait for whoever's got it to finish and
1333 put it back. */
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001334 dbg_readinode("waiting for ino #%u in state %d\n", ino, f->inocache->state);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001335 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
1336 goto retry_inocache;
1337
1338 case INO_STATE_READING:
1339 case INO_STATE_PRESENT:
1340 /* Eep. This should never happen. It can
1341 happen if Linux calls read_inode() again
1342 before clear_inode() has finished though. */
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001343 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 +01001344 /* Fail. That's probably better than allowing it to succeed */
1345 f->inocache = NULL;
1346 break;
1347
1348 default:
1349 BUG();
1350 }
1351 }
1352 spin_unlock(&c->inocache_lock);
1353
1354 if (!f->inocache && ino == 1) {
1355 /* Special case - no root inode on medium */
1356 f->inocache = jffs2_alloc_inode_cache();
1357 if (!f->inocache) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001358 JFFS2_ERROR("cannot allocate inocache for root inode\n");
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001359 return -ENOMEM;
1360 }
Artem B. Bityutskiy733802d2005-09-22 12:25:00 +01001361 dbg_readinode("creating inocache for root inode\n");
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001362 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
David Woodhouse27c72b02008-05-01 18:47:17 +01001363 f->inocache->ino = f->inocache->pino_nlink = 1;
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001364 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
1365 f->inocache->state = INO_STATE_READING;
1366 jffs2_add_ino_cache(c, f->inocache);
1367 }
1368 if (!f->inocache) {
Artem B. Bityutskiye0d60132005-07-28 15:46:43 +01001369 JFFS2_ERROR("requestied to read an nonexistent ino %u\n", ino);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001370 return -ENOENT;
1371 }
1372
1373 return jffs2_do_read_inode_internal(c, f, latest_node);
1374}
1375
1376int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
1377{
1378 struct jffs2_raw_inode n;
Yan Burman3d375d92006-12-04 15:03:01 -08001379 struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001380 int ret;
1381
1382 if (!f)
1383 return -ENOMEM;
1384
David Woodhouseced22072008-04-22 15:13:40 +01001385 mutex_init(&f->sem);
1386 mutex_lock(&f->sem);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001387 f->inocache = ic;
1388
1389 ret = jffs2_do_read_inode_internal(c, f, &n);
Brian Norris7aaea762014-02-25 18:27:40 -08001390 mutex_unlock(&f->sem);
1391 jffs2_do_clear_inode(c, f);
Jean-Christophe DUBOIS8c5a0362012-05-10 17:14:03 +02001392 jffs2_xattr_do_crccheck_inode(c, ic);
Artem B. Bityutskiyf97117d2005-07-27 15:46:14 +01001393 kfree (f);
1394 return ret;
1395}
1396
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
1398{
1399 struct jffs2_full_dirent *fd, *fds;
1400 int deleted;
1401
KaiGai Kohei355ed4e2006-06-24 09:15:36 +09001402 jffs2_xattr_delete_inode(c, f->inocache);
David Woodhouseced22072008-04-22 15:13:40 +01001403 mutex_lock(&f->sem);
David Woodhouse27c72b02008-05-01 18:47:17 +01001404 deleted = f->inocache && !f->inocache->pino_nlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405
David Woodhouse67e345d2005-02-27 23:01:36 +00001406 if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
1407 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
1408
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 if (f->metadata) {
1410 if (deleted)
1411 jffs2_mark_node_obsolete(c, f->metadata->raw);
1412 jffs2_free_full_dnode(f->metadata);
1413 }
1414
1415 jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
1416
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001417 if (f->target) {
1418 kfree(f->target);
1419 f->target = NULL;
1420 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001421
Artem B. Bityutskiy2b79adc2005-07-17 12:13:51 +01001422 fds = f->dents;
1423 while(fds) {
1424 fd = fds;
1425 fds = fd->next;
1426 jffs2_free_full_dirent(fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 }
1428
David Woodhouse67e345d2005-02-27 23:01:36 +00001429 if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
David Woodhouse67e345d2005-02-27 23:01:36 +00001431 if (f->inocache->nodes == (void *)f->inocache)
1432 jffs2_del_ino_cache(c, f->inocache);
1433 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
David Woodhouseced22072008-04-22 15:13:40 +01001435 mutex_unlock(&f->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436}