MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / fs / jffs2.org / readinode.c
blob54a5d1ac3aa16e4324dc9a3604c09584f6f6083d
1 /*
2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@redhat.com>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: readinode.c,v 1.113 2003/11/03 13:20:33 dwmw2 Exp $
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/fs.h>
17 #include <linux/crc32.h>
18 #include <linux/pagemap.h>
19 #include <linux/mtd/mtd.h>
20 #include <linux/compiler.h>
21 #include "nodelist.h"
23 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *list, struct jffs2_node_frag *newfrag);
25 #if CONFIG_JFFS2_FS_DEBUG >= 1
26 static void jffs2_print_fragtree(struct rb_root *list, int permitbug)
28 struct jffs2_node_frag *this = frag_first(list);
29 uint32_t lastofs = 0;
30 int buggy = 0;
32 while(this) {
33 if (this->node)
34 printk(KERN_DEBUG "frag %04x-%04x: 0x%08x(%d) on flash (*%p). left (%p), right (%p), parent (%p)\n",
35 this->ofs, this->ofs+this->size, ref_offset(this->node->raw), ref_flags(this->node->raw),
36 this, frag_left(this), frag_right(this), frag_parent(this));
37 else
38 printk(KERN_DEBUG "frag %04x-%04x: hole (*%p). left (%p} right (%p), parent (%p)\n", this->ofs,
39 this->ofs+this->size, this, frag_left(this), frag_right(this), frag_parent(this));
40 if (this->ofs != lastofs)
41 buggy = 1;
42 lastofs = this->ofs+this->size;
43 this = frag_next(this);
45 if (buggy && !permitbug) {
46 printk(KERN_CRIT "Frag tree got a hole in it\n");
47 BUG();
51 void jffs2_print_frag_list(struct jffs2_inode_info *f)
53 jffs2_print_fragtree(&f->fragtree, 0);
55 if (f->metadata) {
56 printk(KERN_DEBUG "metadata at 0x%08x\n", ref_offset(f->metadata->raw));
60 static int jffs2_sanitycheck_fragtree(struct jffs2_inode_info *f)
62 struct jffs2_node_frag *frag;
63 int bitched = 0;
65 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
67 struct jffs2_full_dnode *fn = frag->node;
68 if (!fn || !fn->raw)
69 continue;
71 if (ref_flags(fn->raw) == REF_PRISTINE) {
73 if (fn->frags > 1) {
74 printk(KERN_WARNING "REF_PRISTINE node at 0x%08x had %d frags. Tell dwmw2\n", ref_offset(fn->raw), fn->frags);
75 bitched = 1;
77 /* A hole node which isn't multi-page should be garbage-collected
78 and merged anyway, so we just check for the frag size here,
79 rather than mucking around with actually reading the node
80 and checking the compression type, which is the real way
81 to tell a hole node. */
82 if (frag->ofs & (PAGE_CACHE_SIZE-1) && frag_prev(frag) && frag_prev(frag)->size < PAGE_CACHE_SIZE && frag_prev(frag)->node) {
83 printk(KERN_WARNING "REF_PRISTINE node at 0x%08x had a previous non-hole frag in the same page. Tell dwmw2\n",
84 ref_offset(fn->raw));
85 bitched = 1;
88 if ((frag->ofs+frag->size) & (PAGE_CACHE_SIZE-1) && frag_next(frag) && frag_next(frag)->size < PAGE_CACHE_SIZE && frag_next(frag)->node) {
89 printk(KERN_WARNING "REF_PRISTINE node at 0x%08x (%08x-%08x) had a following non-hole frag in the same page. Tell dwmw2\n",
90 ref_offset(fn->raw), frag->ofs, frag->ofs+frag->size);
91 bitched = 1;
96 if (bitched) {
97 struct jffs2_node_frag *thisfrag;
99 printk(KERN_WARNING "Inode is #%u\n", f->inocache->ino);
100 thisfrag = frag_first(&f->fragtree);
101 while (thisfrag) {
102 if (!thisfrag->node) {
103 printk("Frag @0x%x-0x%x; node-less hole\n",
104 thisfrag->ofs, thisfrag->size + thisfrag->ofs);
105 } else if (!thisfrag->node->raw) {
106 printk("Frag @0x%x-0x%x; raw-less hole\n",
107 thisfrag->ofs, thisfrag->size + thisfrag->ofs);
108 } else {
109 printk("Frag @0x%x-0x%x; raw at 0x%08x(%d) (0x%x-0x%x)\n",
110 thisfrag->ofs, thisfrag->size + thisfrag->ofs,
111 ref_offset(thisfrag->node->raw), ref_flags(thisfrag->node->raw),
112 thisfrag->node->ofs, thisfrag->node->ofs+thisfrag->node->size);
114 thisfrag = frag_next(thisfrag);
117 return bitched;
119 #endif /* D1 */
121 static void jffs2_obsolete_node_frag(struct jffs2_sb_info *c, struct jffs2_node_frag *this)
123 if (this->node) {
124 this->node->frags--;
125 if (!this->node->frags) {
126 /* The node has no valid frags left. It's totally obsoleted */
127 D2(printk(KERN_DEBUG "Marking old node @0x%08x (0x%04x-0x%04x) obsolete\n",
128 ref_offset(this->node->raw), this->node->ofs, this->node->ofs+this->node->size));
129 jffs2_mark_node_obsolete(c, this->node->raw);
130 jffs2_free_full_dnode(this->node);
131 } else {
132 D2(printk(KERN_DEBUG "Marking old node @0x%08x (0x%04x-0x%04x) REF_NORMAL. frags is %d\n",
133 ref_offset(this->node->raw), this->node->ofs, this->node->ofs+this->node->size,
134 this->node->frags));
135 mark_ref_normal(this->node->raw);
139 jffs2_free_node_frag(this);
142 /* Given an inode, probably with existing list of fragments, add the new node
143 * to the fragment list.
145 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
147 int ret;
148 struct jffs2_node_frag *newfrag;
150 D1(printk(KERN_DEBUG "jffs2_add_full_dnode_to_inode(ino #%u, f %p, fn %p)\n", f->inocache->ino, f, fn));
152 newfrag = jffs2_alloc_node_frag();
153 if (unlikely(!newfrag))
154 return -ENOMEM;
156 D2(printk(KERN_DEBUG "adding node %04x-%04x @0x%08x on flash, newfrag *%p\n",
157 fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag));
159 if (unlikely(!fn->size)) {
160 jffs2_free_node_frag(newfrag);
161 return 0;
164 newfrag->ofs = fn->ofs;
165 newfrag->size = fn->size;
166 newfrag->node = fn;
167 newfrag->node->frags = 1;
169 ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag);
170 if (ret)
171 return ret;
173 /* If we now share a page with other nodes, mark either previous
174 or next node REF_NORMAL, as appropriate. */
175 if (newfrag->ofs & (PAGE_CACHE_SIZE-1)) {
176 struct jffs2_node_frag *prev = frag_prev(newfrag);
178 mark_ref_normal(fn->raw);
179 /* If we don't start at zero there's _always_ a previous */
180 if (prev->node)
181 mark_ref_normal(prev->node->raw);
184 if ((newfrag->ofs+newfrag->size) & (PAGE_CACHE_SIZE-1)) {
185 struct jffs2_node_frag *next = frag_next(newfrag);
187 if (next) {
188 mark_ref_normal(fn->raw);
189 if (next->node)
190 mark_ref_normal(next->node->raw);
193 D2(if (jffs2_sanitycheck_fragtree(f)) {
194 printk(KERN_WARNING "Just added node %04x-%04x @0x%08x on flash, newfrag *%p\n",
195 fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag);
196 return 0;
198 D2(jffs2_print_frag_list(f));
199 return 0;
202 /* Doesn't set inode->i_size */
203 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *list, struct jffs2_node_frag *newfrag)
205 struct jffs2_node_frag *this;
206 uint32_t lastend;
208 /* Skip all the nodes which are completed before this one starts */
209 this = jffs2_lookup_node_frag(list, newfrag->node->ofs);
211 if (this) {
212 D2(printk(KERN_DEBUG "j_a_f_d_t_f: Lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
213 this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this));
214 lastend = this->ofs + this->size;
215 } else {
216 D2(printk(KERN_DEBUG "j_a_f_d_t_f: Lookup gave no frag\n"));
217 lastend = 0;
220 /* See if we ran off the end of the list */
221 if (lastend <= newfrag->ofs) {
222 /* We did */
224 /* Check if 'this' node was on the same page as the new node.
225 If so, both 'this' and the new node get marked REF_NORMAL so
226 the GC can take a look.
228 if ((lastend-1) >> PAGE_CACHE_SHIFT == newfrag->ofs >> PAGE_CACHE_SHIFT) {
229 if (this->node)
230 mark_ref_normal(this->node->raw);
231 mark_ref_normal(newfrag->node->raw);
234 if (lastend < newfrag->node->ofs) {
235 /* ... and we need to put a hole in before the new node */
236 struct jffs2_node_frag *holefrag = jffs2_alloc_node_frag();
237 if (!holefrag) {
238 jffs2_free_node_frag(newfrag);
239 return -ENOMEM;
241 holefrag->ofs = lastend;
242 holefrag->size = newfrag->node->ofs - lastend;
243 holefrag->node = NULL;
244 if (this) {
245 /* By definition, the 'this' node has no right-hand child,
246 because there are no frags with offset greater than it.
247 So that's where we want to put the hole */
248 D2(printk(KERN_DEBUG "Adding hole frag (%p) on right of node at (%p)\n", holefrag, this));
249 rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right);
250 } else {
251 D2(printk(KERN_DEBUG "Adding hole frag (%p) at root of tree\n", holefrag));
252 rb_link_node(&holefrag->rb, NULL, &list->rb_node);
254 rb_insert_color(&holefrag->rb, list);
255 this = holefrag;
257 if (this) {
258 /* By definition, the 'this' node has no right-hand child,
259 because there are no frags with offset greater than it.
260 So that's where we want to put the hole */
261 D2(printk(KERN_DEBUG "Adding new frag (%p) on right of node at (%p)\n", newfrag, this));
262 rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
263 } else {
264 D2(printk(KERN_DEBUG "Adding new frag (%p) at root of tree\n", newfrag));
265 rb_link_node(&newfrag->rb, NULL, &list->rb_node);
267 rb_insert_color(&newfrag->rb, list);
268 return 0;
271 D2(printk(KERN_DEBUG "j_a_f_d_t_f: dealing with frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
272 this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this));
274 /* OK. 'this' is pointing at the first frag that newfrag->ofs at least partially obsoletes,
275 * - i.e. newfrag->ofs < this->ofs+this->size && newfrag->ofs >= this->ofs
277 if (newfrag->ofs > this->ofs) {
278 /* This node isn't completely obsoleted. The start of it remains valid */
280 /* Mark the new node and the partially covered node REF_NORMAL -- let
281 the GC take a look at them */
282 mark_ref_normal(newfrag->node->raw);
283 if (this->node)
284 mark_ref_normal(this->node->raw);
286 if (this->ofs + this->size > newfrag->ofs + newfrag->size) {
287 /* The new node splits 'this' frag into two */
288 struct jffs2_node_frag *newfrag2 = jffs2_alloc_node_frag();
289 if (!newfrag2) {
290 jffs2_free_node_frag(newfrag);
291 return -ENOMEM;
293 D2(printk(KERN_DEBUG "split old frag 0x%04x-0x%04x -->", this->ofs, this->ofs+this->size);
294 if (this->node)
295 printk("phys 0x%08x\n", ref_offset(this->node->raw));
296 else
297 printk("hole\n");
300 /* New second frag pointing to this's node */
301 newfrag2->ofs = newfrag->ofs + newfrag->size;
302 newfrag2->size = (this->ofs+this->size) - newfrag2->ofs;
303 newfrag2->node = this->node;
304 if (this->node)
305 this->node->frags++;
307 /* Adjust size of original 'this' */
308 this->size = newfrag->ofs - this->ofs;
310 /* Now, we know there's no node with offset
311 greater than this->ofs but smaller than
312 newfrag2->ofs or newfrag->ofs, for obvious
313 reasons. So we can do a tree insert from
314 'this' to insert newfrag, and a tree insert
315 from newfrag to insert newfrag2. */
316 jffs2_fragtree_insert(newfrag, this);
317 rb_insert_color(&newfrag->rb, list);
319 jffs2_fragtree_insert(newfrag2, newfrag);
320 rb_insert_color(&newfrag2->rb, list);
322 return 0;
324 /* New node just reduces 'this' frag in size, doesn't split it */
325 this->size = newfrag->ofs - this->ofs;
327 /* Again, we know it lives down here in the tree */
328 jffs2_fragtree_insert(newfrag, this);
329 rb_insert_color(&newfrag->rb, list);
330 } else {
331 /* New frag starts at the same point as 'this' used to. Replace
332 it in the tree without doing a delete and insertion */
333 D2(printk(KERN_DEBUG "Inserting newfrag (*%p),%d-%d in before 'this' (*%p),%d-%d\n",
334 newfrag, newfrag->ofs, newfrag->ofs+newfrag->size,
335 this, this->ofs, this->ofs+this->size));
337 rb_replace_node(&this->rb, &newfrag->rb, list);
339 if (newfrag->ofs + newfrag->size >= this->ofs+this->size) {
340 D2(printk(KERN_DEBUG "Obsoleting node frag %p (%x-%x)\n", this, this->ofs, this->ofs+this->size));
341 jffs2_obsolete_node_frag(c, this);
342 } else {
343 this->ofs += newfrag->size;
344 this->size -= newfrag->size;
346 jffs2_fragtree_insert(this, newfrag);
347 rb_insert_color(&this->rb, list);
348 return 0;
351 /* OK, now we have newfrag added in the correct place in the tree, but
352 frag_next(newfrag) may be a fragment which is overlapped by it
354 while ((this = frag_next(newfrag)) && newfrag->ofs + newfrag->size >= this->ofs + this->size) {
355 /* 'this' frag is obsoleted completely. */
356 D2(printk(KERN_DEBUG "Obsoleting node frag %p (%x-%x) and removing from tree\n", this, this->ofs, this->ofs+this->size));
357 rb_erase(&this->rb, list);
358 jffs2_obsolete_node_frag(c, this);
360 /* Now we're pointing at the first frag which isn't totally obsoleted by
361 the new frag */
363 if (!this || newfrag->ofs + newfrag->size == this->ofs) {
364 return 0;
366 /* Still some overlap but we don't need to move it in the tree */
367 this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);
368 this->ofs = newfrag->ofs + newfrag->size;
370 /* And mark them REF_NORMAL so the GC takes a look at them */
371 if (this->node)
372 mark_ref_normal(this->node->raw);
373 mark_ref_normal(newfrag->node->raw);
375 return 0;
378 void jffs2_truncate_fraglist (struct jffs2_sb_info *c, struct rb_root *list, uint32_t size)
380 struct jffs2_node_frag *frag = jffs2_lookup_node_frag(list, size);
382 D1(printk(KERN_DEBUG "Truncating fraglist to 0x%08x bytes\n", size));
384 /* We know frag->ofs <= size. That's what lookup does for us */
385 if (frag && frag->ofs != size) {
386 if (frag->ofs+frag->size >= size) {
387 D1(printk(KERN_DEBUG "Truncating frag 0x%08x-0x%08x\n", frag->ofs, frag->ofs+frag->size));
388 frag->size = size - frag->ofs;
390 frag = frag_next(frag);
392 while (frag && frag->ofs >= size) {
393 struct jffs2_node_frag *next = frag_next(frag);
395 D1(printk(KERN_DEBUG "Removing frag 0x%08x-0x%08x\n", frag->ofs, frag->ofs+frag->size));
396 frag_erase(frag, list);
397 jffs2_obsolete_node_frag(c, frag);
398 frag = next;
402 /* Scan the list of all nodes present for this ino, build map of versions, etc. */
404 static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
405 struct jffs2_inode_info *f,
406 struct jffs2_raw_inode *latest_node);
408 int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
409 uint32_t ino, struct jffs2_raw_inode *latest_node)
411 D2(printk(KERN_DEBUG "jffs2_do_read_inode(): getting inocache\n"));
413 retry_inocache:
414 spin_lock(&c->inocache_lock);
415 f->inocache = jffs2_get_ino_cache(c, ino);
417 D2(printk(KERN_DEBUG "jffs2_do_read_inode(): Got inocache at %p\n", f->inocache));
419 if (f->inocache) {
420 /* Check its state. We may need to wait before we can use it */
421 switch(f->inocache->state) {
422 case INO_STATE_UNCHECKED:
423 case INO_STATE_CHECKEDABSENT:
424 f->inocache->state = INO_STATE_READING;
425 break;
427 case INO_STATE_CHECKING:
428 case INO_STATE_GC:
429 /* If it's in either of these states, we need
430 to wait for whoever's got it to finish and
431 put it back. */
432 D1(printk(KERN_DEBUG "jffs2_get_ino_cache_read waiting for ino #%u in state %d\n",
433 ino, f->inocache->state));
434 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
435 goto retry_inocache;
437 case INO_STATE_READING:
438 case INO_STATE_PRESENT:
439 /* Eep. This should never happen. It can
440 happen if Linux calls read_inode() again
441 before clear_inode() has finished though. */
442 printk(KERN_WARNING "Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state);
443 /* Fail. That's probably better than allowing it to succeed */
444 f->inocache = NULL;
445 break;
447 default:
448 BUG();
451 spin_unlock(&c->inocache_lock);
453 if (!f->inocache && ino == 1) {
454 /* Special case - no root inode on medium */
455 f->inocache = jffs2_alloc_inode_cache();
456 if (!f->inocache) {
457 printk(KERN_CRIT "jffs2_do_read_inode(): Cannot allocate inocache for root inode\n");
458 return -ENOMEM;
460 D1(printk(KERN_DEBUG "jffs2_do_read_inode(): Creating inocache for root inode\n"));
461 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
462 f->inocache->ino = f->inocache->nlink = 1;
463 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
464 f->inocache->state = INO_STATE_READING;
465 jffs2_add_ino_cache(c, f->inocache);
467 if (!f->inocache) {
468 printk(KERN_WARNING "jffs2_do_read_inode() on nonexistent ino %u\n", ino);
469 return -ENOENT;
472 return jffs2_do_read_inode_internal(c, f, latest_node);
475 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
477 struct jffs2_raw_inode n;
478 struct jffs2_inode_info *f = kmalloc(sizeof(*f), GFP_KERNEL);
479 int ret;
481 if (!f)
482 return -ENOMEM;
484 memset(f, 0, sizeof(*f));
485 init_MUTEX_LOCKED(&f->sem);
486 f->inocache = ic;
488 ret = jffs2_do_read_inode_internal(c, f, &n);
489 if (!ret) {
490 up(&f->sem);
491 jffs2_do_clear_inode(c, f);
493 kfree (f);
494 return ret;
497 static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
498 struct jffs2_inode_info *f,
499 struct jffs2_raw_inode *latest_node)
501 struct jffs2_tmp_dnode_info *tn_list, *tn;
502 struct jffs2_full_dirent *fd_list;
503 struct jffs2_full_dnode *fn = NULL;
504 uint32_t crc;
505 uint32_t latest_mctime, mctime_ver;
506 uint32_t mdata_ver = 0;
507 size_t retlen;
508 int ret;
510 D1(printk(KERN_DEBUG "jffs2_do_read_inode_internal(): ino #%u nlink is %d\n", f->inocache->ino, f->inocache->nlink));
512 /* Grab all nodes relevant to this ino */
513 ret = jffs2_get_inode_nodes(c, f->inocache->ino, f, &tn_list, &fd_list, &f->highest_version, &latest_mctime, &mctime_ver);
515 if (ret) {
516 printk(KERN_CRIT "jffs2_get_inode_nodes() for ino %u returned %d\n", f->inocache->ino, ret);
517 if (f->inocache->state == INO_STATE_READING)
518 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
519 return ret;
521 f->dents = fd_list;
523 while (tn_list) {
524 tn = tn_list;
526 fn = tn->fn;
528 if (f->metadata) {
529 if (likely(tn->version >= mdata_ver)) {
530 D1(printk(KERN_DEBUG "Obsoleting old metadata at 0x%08x\n", ref_offset(f->metadata->raw)));
531 jffs2_mark_node_obsolete(c, f->metadata->raw);
532 jffs2_free_full_dnode(f->metadata);
533 f->metadata = NULL;
535 mdata_ver = 0;
536 } else {
537 /* This should never happen. */
538 printk(KERN_WARNING "Er. New metadata at 0x%08x with ver %d is actually older than previous ver %d at 0x%08x\n",
539 ref_offset(fn->raw), tn->version, mdata_ver, ref_offset(f->metadata->raw));
540 jffs2_mark_node_obsolete(c, fn->raw);
541 jffs2_free_full_dnode(fn);
542 /* Fill in latest_node from the metadata, not this one we're about to free... */
543 fn = f->metadata;
544 goto next_tn;
548 if (fn->size) {
549 jffs2_add_full_dnode_to_inode(c, f, fn);
550 } else {
551 /* Zero-sized node at end of version list. Just a metadata update */
552 D1(printk(KERN_DEBUG "metadata @%08x: ver %d\n", ref_offset(fn->raw), tn->version));
553 f->metadata = fn;
554 mdata_ver = tn->version;
556 next_tn:
557 tn_list = tn->next;
558 jffs2_free_tmp_dnode_info(tn);
560 D1(jffs2_sanitycheck_fragtree(f));
562 if (!fn) {
563 /* No data nodes for this inode. */
564 if (f->inocache->ino != 1) {
565 printk(KERN_WARNING "jffs2_do_read_inode(): No data nodes found for ino #%u\n", f->inocache->ino);
566 if (!fd_list) {
567 if (f->inocache->state == INO_STATE_READING)
568 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
569 return -EIO;
571 printk(KERN_WARNING "jffs2_do_read_inode(): But it has children so we fake some modes for it\n");
573 latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO);
574 latest_node->version = cpu_to_je32(0);
575 latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0);
576 latest_node->isize = cpu_to_je32(0);
577 latest_node->gid = cpu_to_je16(0);
578 latest_node->uid = cpu_to_je16(0);
579 if (f->inocache->state == INO_STATE_READING)
580 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
581 return 0;
584 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(*latest_node), &retlen, (void *)latest_node);
585 if (ret || retlen != sizeof(*latest_node)) {
586 printk(KERN_NOTICE "MTD read in jffs2_do_read_inode() failed: Returned %d, %zd of %zd bytes read\n",
587 ret, retlen, sizeof(*latest_node));
588 /* FIXME: If this fails, there seems to be a memory leak. Find it. */
589 up(&f->sem);
590 jffs2_do_clear_inode(c, f);
591 return ret?ret:-EIO;
594 crc = crc32(0, latest_node, sizeof(*latest_node)-8);
595 if (crc != je32_to_cpu(latest_node->node_crc)) {
596 printk(KERN_NOTICE "CRC failed for read_inode of inode %u at physical location 0x%x\n", f->inocache->ino, ref_offset(fn->raw));
597 up(&f->sem);
598 jffs2_do_clear_inode(c, f);
599 return -EIO;
602 switch(jemode_to_cpu(latest_node->mode) & S_IFMT) {
603 case S_IFDIR:
604 if (mctime_ver > je32_to_cpu(latest_node->version)) {
605 /* The times in the latest_node are actually older than
606 mctime in the latest dirent. Cheat. */
607 latest_node->ctime = latest_node->mtime = cpu_to_je32(latest_mctime);
609 break;
612 case S_IFREG:
613 /* If it was a regular file, truncate it to the latest node's isize */
614 jffs2_truncate_fraglist(c, &f->fragtree, je32_to_cpu(latest_node->isize));
615 break;
617 case S_IFLNK:
618 /* Hack to work around broken isize in old symlink code.
619 Remove this when dwmw2 comes to his senses and stops
620 symlinks from being an entirely gratuitous special
621 case. */
622 if (!je32_to_cpu(latest_node->isize))
623 latest_node->isize = latest_node->dsize;
624 /* fall through... */
626 case S_IFBLK:
627 case S_IFCHR:
628 /* Certain inode types should have only one data node, and it's
629 kept as the metadata node */
630 if (f->metadata) {
631 printk(KERN_WARNING "Argh. Special inode #%u with mode 0%o had metadata node\n",
632 f->inocache->ino, jemode_to_cpu(latest_node->mode));
633 up(&f->sem);
634 jffs2_do_clear_inode(c, f);
635 return -EIO;
637 if (!frag_first(&f->fragtree)) {
638 printk(KERN_WARNING "Argh. Special inode #%u with mode 0%o has no fragments\n",
639 f->inocache->ino, jemode_to_cpu(latest_node->mode));
640 up(&f->sem);
641 jffs2_do_clear_inode(c, f);
642 return -EIO;
644 /* ASSERT: f->fraglist != NULL */
645 if (frag_next(frag_first(&f->fragtree))) {
646 printk(KERN_WARNING "Argh. Special inode #%u with mode 0x%x had more than one node\n",
647 f->inocache->ino, jemode_to_cpu(latest_node->mode));
648 /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
649 up(&f->sem);
650 jffs2_do_clear_inode(c, f);
651 return -EIO;
653 /* OK. We're happy */
654 f->metadata = frag_first(&f->fragtree)->node;
655 jffs2_free_node_frag(frag_first(&f->fragtree));
656 f->fragtree = RB_ROOT;
657 break;
659 if (f->inocache->state == INO_STATE_READING)
660 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
662 return 0;
665 void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
667 struct jffs2_full_dirent *fd, *fds;
668 int deleted;
670 down(&f->sem);
671 deleted = f->inocache && !f->inocache->nlink;
673 if (f->metadata) {
674 if (deleted)
675 jffs2_mark_node_obsolete(c, f->metadata->raw);
676 jffs2_free_full_dnode(f->metadata);
679 jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
681 fds = f->dents;
683 while(fds) {
684 fd = fds;
685 fds = fd->next;
686 jffs2_free_full_dirent(fd);
689 if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
690 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
692 up(&f->sem);