2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: readinode.c,v 1.143 2005/11/07 11:14:41 gleixner Exp $
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
16 #include <linux/slab.h>
18 #include <linux/crc32.h>
19 #include <linux/pagemap.h>
20 #include <linux/mtd/mtd.h>
21 #include <linux/compiler.h>
25 * Put a new tmp_dnode_info into the temporaty RB-tree, keeping the list in
26 * order of increasing version.
28 static void jffs2_add_tn_to_tree(struct jffs2_tmp_dnode_info *tn, struct rb_root *list)
30 struct rb_node **p = &list->rb_node;
31 struct rb_node * parent = NULL;
32 struct jffs2_tmp_dnode_info *this;
36 this = rb_entry(parent, struct jffs2_tmp_dnode_info, rb);
38 /* There may actually be a collision here, but it doesn't
39 actually matter. As long as the two nodes with the same
40 version are together, it's all fine. */
41 if (tn->version > this->version)
47 rb_link_node(&tn->rb, parent, p);
48 rb_insert_color(&tn->rb, list);
51 static void jffs2_free_tmp_dnode_info_list(struct rb_root *list)
54 struct jffs2_tmp_dnode_info *tn;
58 /* Now at bottom of tree */
62 else if (this->rb_right)
63 this = this->rb_right;
65 tn = rb_entry(this, struct jffs2_tmp_dnode_info, rb);
66 jffs2_free_full_dnode(tn->fn);
67 jffs2_free_tmp_dnode_info(tn);
69 this = rb_parent(this);
73 if (this->rb_left == &tn->rb)
75 else if (this->rb_right == &tn->rb)
76 this->rb_right = NULL;
83 static void jffs2_free_full_dirent_list(struct jffs2_full_dirent *fd)
85 struct jffs2_full_dirent *next;
89 jffs2_free_full_dirent(fd);
94 /* Returns first valid node after 'ref'. May return 'ref' */
95 static struct jffs2_raw_node_ref *jffs2_first_valid_node(struct jffs2_raw_node_ref *ref)
97 while (ref && ref->next_in_ino) {
98 if (!ref_obsolete(ref))
100 dbg_noderef("node at 0x%08x is obsoleted. Ignoring.\n", ref_offset(ref));
101 ref = ref->next_in_ino;
107 * Helper function for jffs2_get_inode_nodes().
108 * It is called every time an directory entry node is found.
110 * Returns: 0 on succes;
111 * 1 if the node should be marked obsolete;
112 * negative error code on failure.
114 static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
115 struct jffs2_raw_dirent *rd, size_t read, struct jffs2_full_dirent **fdp,
116 uint32_t *latest_mctime, uint32_t *mctime_ver)
118 struct jffs2_full_dirent *fd;
121 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
122 BUG_ON(ref_obsolete(ref));
124 crc = crc32(0, rd, sizeof(*rd) - 8);
125 if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
126 JFFS2_NOTICE("header CRC failed on dirent node at %#08x: read %#08x, calculated %#08x\n",
127 ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
131 /* If we've never checked the CRCs on this node, check them now */
132 if (ref_flags(ref) == REF_UNCHECKED) {
133 struct jffs2_eraseblock *jeb;
137 if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) {
138 JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n",
139 ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen));
143 jeb = &c->blocks[ref->flash_offset / c->sector_size];
144 len = ref_totlen(c, jeb, ref);
146 spin_lock(&c->erase_completion_lock);
147 jeb->used_size += len;
148 jeb->unchecked_size -= len;
150 c->unchecked_size -= len;
151 ref->flash_offset = ref_offset(ref) | REF_PRISTINE;
152 spin_unlock(&c->erase_completion_lock);
155 fd = jffs2_alloc_full_dirent(rd->nsize + 1);
160 fd->version = je32_to_cpu(rd->version);
161 fd->ino = je32_to_cpu(rd->ino);
164 /* Pick out the mctime of the latest dirent */
165 if(fd->version > *mctime_ver && je32_to_cpu(rd->mctime)) {
166 *mctime_ver = fd->version;
167 *latest_mctime = je32_to_cpu(rd->mctime);
171 * Copy as much of the name as possible from the raw
172 * dirent we've already read from the flash.
174 if (read > sizeof(*rd))
175 memcpy(&fd->name[0], &rd->name[0],
176 min_t(uint32_t, rd->nsize, (read - sizeof(*rd)) ));
178 /* Do we need to copy any more of the name directly from the flash? */
179 if (rd->nsize + sizeof(*rd) > read) {
182 int already = read - sizeof(*rd);
184 err = jffs2_flash_read(c, (ref_offset(ref)) + read,
185 rd->nsize - already, &read, &fd->name[already]);
186 if (unlikely(read != rd->nsize - already) && likely(!err))
190 JFFS2_ERROR("read remainder of name: error %d\n", err);
191 jffs2_free_full_dirent(fd);
196 fd->nhash = full_name_hash(fd->name, rd->nsize);
198 fd->name[rd->nsize] = '\0';
201 * Wheee. We now have a complete jffs2_full_dirent structure, with
202 * the name in it and everything. Link it into the list
204 jffs2_add_fd_to_list(c, fd, fdp);
210 * Helper function for jffs2_get_inode_nodes().
211 * It is called every time an inode node is found.
213 * Returns: 0 on succes;
214 * 1 if the node should be marked obsolete;
215 * negative error code on failure.
217 static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
218 struct jffs2_raw_inode *rd, struct rb_root *tnp, int rdlen,
219 uint32_t *latest_mctime, uint32_t *mctime_ver)
221 struct jffs2_tmp_dnode_info *tn;
226 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */
227 BUG_ON(ref_obsolete(ref));
229 crc = crc32(0, rd, sizeof(*rd) - 8);
230 if (unlikely(crc != je32_to_cpu(rd->node_crc))) {
231 JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n",
232 ref_offset(ref), je32_to_cpu(rd->node_crc), crc);
236 tn = jffs2_alloc_tmp_dnode_info();
238 JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn));
243 csize = je32_to_cpu(rd->csize);
245 /* If we've never checked the CRCs on this node, check them now */
246 if (ref_flags(ref) == REF_UNCHECKED) {
249 if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) ||
250 unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) {
251 JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref));
252 jffs2_dbg_dump_node(c, ref_offset(ref));
256 if (jffs2_is_writebuffered(c) && csize != 0) {
257 /* At this point we are supposed to check the data CRC
258 * of our unchecked node. But thus far, we do not
259 * know whether the node is valid or obsolete. To
260 * figure this out, we need to walk all the nodes of
261 * the inode and build the inode fragtree. We don't
262 * want to spend time checking data of nodes which may
263 * later be found to be obsolete. So we put off the full
264 * data CRC checking until we have read all the inode
265 * nodes and have started building the fragtree.
267 * The fragtree is being built starting with nodes
268 * having the highest version number, so we'll be able
269 * to detect whether a node is valid (i.e., it is not
270 * overlapped by a node with higher version) or not.
271 * And we'll be able to check only those nodes, which
274 * Of course, this optimization only makes sense in case
275 * of NAND flashes (or other flashes whith
276 * !jffs2_can_mark_obsolete()), since on NOR flashes
277 * nodes are marked obsolete physically.
279 * Since NAND flashes (or other flashes with
280 * jffs2_is_writebuffered(c)) are anyway read by
281 * fractions of c->wbuf_pagesize, and we have just read
282 * the node header, it is likely that the starting part
283 * of the node data is also read when we read the
284 * header. So we don't mind to check the CRC of the
285 * starting part of the data of the node now, and check
286 * the second part later (in jffs2_check_node_data()).
287 * Of course, we will not need to re-read and re-check
288 * the NAND page which we have just read. This is why we
289 * read the whole NAND page at jffs2_get_inode_nodes(),
290 * while we needed only the node header.
294 /* 'buf' will point to the start of data */
295 buf = (unsigned char *)rd + sizeof(*rd);
296 /* len will be the read data length */
297 len = min_t(uint32_t, rdlen - sizeof(*rd), csize);
298 tn->partial_crc = crc32(0, buf, len);
300 dbg_readinode("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize);
302 /* If we actually calculated the whole data CRC
303 * and it is wrong, drop the node. */
304 if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) {
305 JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n",
306 ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc));
310 } else if (csize == 0) {
312 * We checked the header CRC. If the node has no data, adjust
313 * the space accounting now. For other nodes this will be done
314 * later either when the node is marked obsolete or when its
317 struct jffs2_eraseblock *jeb;
319 dbg_readinode("the node has no data.\n");
320 jeb = &c->blocks[ref->flash_offset / c->sector_size];
321 len = ref_totlen(c, jeb, ref);
323 spin_lock(&c->erase_completion_lock);
324 jeb->used_size += len;
325 jeb->unchecked_size -= len;
327 c->unchecked_size -= len;
328 ref->flash_offset = ref_offset(ref) | REF_NORMAL;
329 spin_unlock(&c->erase_completion_lock);
333 tn->fn = jffs2_alloc_full_dnode();
335 JFFS2_ERROR("alloc fn failed\n");
340 tn->version = je32_to_cpu(rd->version);
341 tn->fn->ofs = je32_to_cpu(rd->offset);
342 tn->data_crc = je32_to_cpu(rd->data_crc);
346 /* There was a bug where we wrote hole nodes out with
347 csize/dsize swapped. Deal with it */
348 if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize)
349 tn->fn->size = csize;
350 else // normal case...
351 tn->fn->size = je32_to_cpu(rd->dsize);
353 dbg_readinode("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n",
354 ref_offset(ref), je32_to_cpu(rd->version), je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize);
356 jffs2_add_tn_to_tree(tn, tnp);
361 jffs2_free_tmp_dnode_info(tn);
366 * Helper function for jffs2_get_inode_nodes().
367 * It is called every time an unknown node is found.
369 * Returns: 0 on success;
370 * 1 if the node should be marked obsolete;
371 * negative error code on failure.
373 static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, struct jffs2_unknown_node *un)
375 /* We don't mark unknown nodes as REF_UNCHECKED */
376 if (ref_flags(ref) == REF_UNCHECKED) {
377 JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n",
379 JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n",
380 je16_to_cpu(un->magic), je16_to_cpu(un->nodetype),
381 je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc));
385 un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype));
387 switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) {
389 case JFFS2_FEATURE_INCOMPAT:
390 JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n",
391 je16_to_cpu(un->nodetype), ref_offset(ref));
396 case JFFS2_FEATURE_ROCOMPAT:
397 JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n",
398 je16_to_cpu(un->nodetype), ref_offset(ref));
399 BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO));
402 case JFFS2_FEATURE_RWCOMPAT_COPY:
403 JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n",
404 je16_to_cpu(un->nodetype), ref_offset(ref));
407 case JFFS2_FEATURE_RWCOMPAT_DELETE:
408 JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n",
409 je16_to_cpu(un->nodetype), ref_offset(ref));
417 * Helper function for jffs2_get_inode_nodes().
418 * The function detects whether more data should be read and reads it if yes.
420 * Returns: 0 on succes;
421 * negative error code on failure.
423 static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
424 int needed_len, int *rdlen, unsigned char *buf)
426 int err, to_read = needed_len - *rdlen;
430 if (jffs2_is_writebuffered(c)) {
431 int rem = to_read % c->wbuf_pagesize;
434 to_read += c->wbuf_pagesize - rem;
437 /* We need to read more data */
438 offs = ref_offset(ref) + *rdlen;
440 dbg_readinode("read more %d bytes\n", to_read);
442 err = jffs2_flash_read(c, offs, to_read, &retlen, buf + *rdlen);
444 JFFS2_ERROR("can not read %d bytes from 0x%08x, "
445 "error code: %d.\n", to_read, offs, err);
449 if (retlen < to_read) {
450 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n",
451 offs, retlen, to_read);
459 /* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
460 with this ino, returning the former in order of version */
461 static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
462 struct rb_root *tnp, struct jffs2_full_dirent **fdp,
463 uint32_t *highest_version, uint32_t *latest_mctime,
464 uint32_t *mctime_ver)
466 struct jffs2_raw_node_ref *ref, *valid_ref;
467 struct rb_root ret_tn = RB_ROOT;
468 struct jffs2_full_dirent *ret_fd = NULL;
469 unsigned char *buf = NULL;
470 union jffs2_node_union *node;
476 dbg_readinode("ino #%u\n", f->inocache->ino);
478 /* FIXME: in case of NOR and available ->point() this
479 * needs to be fixed. */
480 len = sizeof(union jffs2_node_union) + c->wbuf_pagesize;
481 buf = kmalloc(len, GFP_KERNEL);
485 spin_lock(&c->erase_completion_lock);
486 valid_ref = jffs2_first_valid_node(f->inocache->nodes);
487 if (!valid_ref && f->inocache->ino != 1)
488 JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
490 /* We can hold a pointer to a non-obsolete node without the spinlock,
491 but _obsolete_ nodes may disappear at any time, if the block
492 they're in gets erased. So if we mark 'ref' obsolete while we're
493 not holding the lock, it can go away immediately. For that reason,
494 we find the next valid node first, before processing 'ref'.
497 valid_ref = jffs2_first_valid_node(ref->next_in_ino);
498 spin_unlock(&c->erase_completion_lock);
503 * At this point we don't know the type of the node we're going
504 * to read, so we do not know the size of its header. In order
505 * to minimize the amount of flash IO we assume the header is
506 * of size = JFFS2_MIN_NODE_HEADER.
508 len = JFFS2_MIN_NODE_HEADER;
509 if (jffs2_is_writebuffered(c)) {
513 * We are about to read JFFS2_MIN_NODE_HEADER bytes,
514 * but this flash has some minimal I/O unit. It is
515 * possible that we'll need to read more soon, so read
516 * up to the next min. I/O unit, in order not to
517 * re-read the same min. I/O unit twice.
519 end = ref_offset(ref) + len;
520 rem = end % c->wbuf_pagesize;
522 end += c->wbuf_pagesize - rem;
523 len = end - ref_offset(ref);
526 dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
529 err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf);
531 JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err);
536 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len);
541 node = (union jffs2_node_union *)buf;
543 /* No need to mask in the valid bit; it shouldn't be invalid */
544 if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) {
545 JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n",
546 ref_offset(ref), je16_to_cpu(node->u.magic),
547 je16_to_cpu(node->u.nodetype),
548 je32_to_cpu(node->u.totlen),
549 je32_to_cpu(node->u.hdr_crc));
550 jffs2_dbg_dump_node(c, ref_offset(ref));
551 jffs2_mark_node_obsolete(c, ref);
554 /* Due to poor choice of crc32 seed, an all-zero node will have a correct CRC */
555 if (!je32_to_cpu(node->u.hdr_crc) && !je16_to_cpu(node->u.nodetype) &&
556 !je16_to_cpu(node->u.magic) && !je32_to_cpu(node->u.totlen)) {
557 JFFS2_NOTICE("All zero node header at %#08x.\n", ref_offset(ref));
558 jffs2_mark_node_obsolete(c, ref);
562 switch (je16_to_cpu(node->u.nodetype)) {
564 case JFFS2_NODETYPE_DIRENT:
566 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent)) {
567 err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf);
572 err = read_direntry(c, ref, &node->d, retlen, &ret_fd, latest_mctime, mctime_ver);
574 jffs2_mark_node_obsolete(c, ref);
576 } else if (unlikely(err))
579 if (je32_to_cpu(node->d.version) > *highest_version)
580 *highest_version = je32_to_cpu(node->d.version);
584 case JFFS2_NODETYPE_INODE:
586 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode)) {
587 err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf);
592 err = read_dnode(c, ref, &node->i, &ret_tn, len, latest_mctime, mctime_ver);
594 jffs2_mark_node_obsolete(c, ref);
596 } else if (unlikely(err))
599 if (je32_to_cpu(node->i.version) > *highest_version)
600 *highest_version = je32_to_cpu(node->i.version);
605 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node)) {
606 err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf);
611 err = read_unknown(c, ref, &node->u);
613 jffs2_mark_node_obsolete(c, ref);
615 } else if (unlikely(err))
620 spin_lock(&c->erase_completion_lock);
623 spin_unlock(&c->erase_completion_lock);
628 dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n",
629 f->inocache->ino, *highest_version, *latest_mctime, *mctime_ver);
633 jffs2_free_tmp_dnode_info_list(&ret_tn);
634 jffs2_free_full_dirent_list(ret_fd);
639 static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
640 struct jffs2_inode_info *f,
641 struct jffs2_raw_inode *latest_node)
643 struct jffs2_tmp_dnode_info *tn;
644 struct rb_root tn_list;
645 struct rb_node *rb, *repl_rb;
646 struct jffs2_full_dirent *fd_list;
647 struct jffs2_full_dnode *fn, *first_fn = NULL;
649 uint32_t latest_mctime, mctime_ver;
653 dbg_readinode("ino #%u nlink is %d\n", f->inocache->ino, f->inocache->nlink);
655 /* Grab all nodes relevant to this ino */
656 ret = jffs2_get_inode_nodes(c, f, &tn_list, &fd_list, &f->highest_version, &latest_mctime, &mctime_ver);
659 JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret);
660 if (f->inocache->state == INO_STATE_READING)
661 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
666 rb = rb_first(&tn_list);
670 tn = rb_entry(rb, struct jffs2_tmp_dnode_info, rb);
673 dbg_readinode("consider node ver %u, phys offset "
674 "%#08x(%d), range %u-%u.\n", tn->version,
675 ref_offset(fn->raw), ref_flags(fn->raw),
676 fn->ofs, fn->ofs + fn->size);
679 ret = jffs2_add_older_frag_to_fragtree(c, f, tn);
680 /* TODO: the error code isn't checked, check it */
681 jffs2_dbg_fragtree_paranoia_check_nolock(f);
683 if (!first_fn && ret == 0)
685 } else if (!first_fn) {
688 ret = 0; /* Prevent freeing the metadata update node */
690 jffs2_mark_node_obsolete(c, fn->raw);
693 if (rb_parent(rb) && rb_parent(rb)->rb_left == rb) {
694 /* We were then left-hand child of our parent. We need
695 * to move our own right-hand child into our place. */
696 repl_rb = rb->rb_right;
698 rb_set_parent(repl_rb, rb_parent(rb));
704 /* Remove the spent tn from the tree; don't bother rebalancing
705 * but put our right-hand child in our own place. */
706 if (rb_parent(&tn->rb)) {
707 if (rb_parent(&tn->rb)->rb_left == &tn->rb)
708 rb_parent(&tn->rb)->rb_left = repl_rb;
709 else if (rb_parent(&tn->rb)->rb_right == &tn->rb)
710 rb_parent(&tn->rb)->rb_right = repl_rb;
712 } else if (tn->rb.rb_right)
713 rb_set_parent(tn->rb.rb_right, NULL);
715 jffs2_free_tmp_dnode_info(tn);
717 dbg_readinode("delete dnode %u-%u.\n",
718 fn->ofs, fn->ofs + fn->size);
719 jffs2_free_full_dnode(fn);
722 jffs2_dbg_fragtree_paranoia_check_nolock(f);
724 BUG_ON(first_fn && ref_obsolete(first_fn->raw));
727 if (unlikely(!first_fn)) {
728 /* No data nodes for this inode. */
729 if (f->inocache->ino != 1) {
730 JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino);
732 if (f->inocache->state == INO_STATE_READING)
733 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
736 JFFS2_NOTICE("but it has children so we fake some modes for it\n");
738 latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO);
739 latest_node->version = cpu_to_je32(0);
740 latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0);
741 latest_node->isize = cpu_to_je32(0);
742 latest_node->gid = cpu_to_je16(0);
743 latest_node->uid = cpu_to_je16(0);
744 if (f->inocache->state == INO_STATE_READING)
745 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
749 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(*latest_node), &retlen, (void *)latest_node);
750 if (ret || retlen != sizeof(*latest_node)) {
751 JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n",
752 ret, retlen, sizeof(*latest_node));
753 /* FIXME: If this fails, there seems to be a memory leak. Find it. */
755 jffs2_do_clear_inode(c, f);
759 crc = crc32(0, latest_node, sizeof(*latest_node)-8);
760 if (crc != je32_to_cpu(latest_node->node_crc)) {
761 JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n",
762 f->inocache->ino, ref_offset(fn->raw));
764 jffs2_do_clear_inode(c, f);
768 switch(jemode_to_cpu(latest_node->mode) & S_IFMT) {
770 if (mctime_ver > je32_to_cpu(latest_node->version)) {
771 /* The times in the latest_node are actually older than
772 mctime in the latest dirent. Cheat. */
773 latest_node->ctime = latest_node->mtime = cpu_to_je32(latest_mctime);
779 /* If it was a regular file, truncate it to the latest node's isize */
780 jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize));
784 /* Hack to work around broken isize in old symlink code.
785 Remove this when dwmw2 comes to his senses and stops
786 symlinks from being an entirely gratuitous special
788 if (!je32_to_cpu(latest_node->isize))
789 latest_node->isize = latest_node->dsize;
791 if (f->inocache->state != INO_STATE_CHECKING) {
792 /* Symlink's inode data is the target path. Read it and
793 * keep in RAM to facilitate quick follow symlink
795 f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL);
797 JFFS2_ERROR("can't allocate %d bytes of memory for the symlink target path cache\n", je32_to_cpu(latest_node->csize));
799 jffs2_do_clear_inode(c, f);
803 ret = jffs2_flash_read(c, ref_offset(fn->raw) + sizeof(*latest_node),
804 je32_to_cpu(latest_node->csize), &retlen, (char *)f->target);
806 if (ret || retlen != je32_to_cpu(latest_node->csize)) {
807 if (retlen != je32_to_cpu(latest_node->csize))
812 jffs2_do_clear_inode(c, f);
816 f->target[je32_to_cpu(latest_node->csize)] = '\0';
817 dbg_readinode("symlink's target '%s' cached\n", f->target);
820 /* fall through... */
824 /* Certain inode types should have only one data node, and it's
825 kept as the metadata node */
827 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n",
828 f->inocache->ino, jemode_to_cpu(latest_node->mode));
830 jffs2_do_clear_inode(c, f);
833 if (!frag_first(&f->fragtree)) {
834 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n",
835 f->inocache->ino, jemode_to_cpu(latest_node->mode));
837 jffs2_do_clear_inode(c, f);
840 /* ASSERT: f->fraglist != NULL */
841 if (frag_next(frag_first(&f->fragtree))) {
842 JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n",
843 f->inocache->ino, jemode_to_cpu(latest_node->mode));
844 /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */
846 jffs2_do_clear_inode(c, f);
849 /* OK. We're happy */
850 f->metadata = frag_first(&f->fragtree)->node;
851 jffs2_free_node_frag(frag_first(&f->fragtree));
852 f->fragtree = RB_ROOT;
855 if (f->inocache->state == INO_STATE_READING)
856 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT);
861 /* Scan the list of all nodes present for this ino, build map of versions, etc. */
862 int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
863 uint32_t ino, struct jffs2_raw_inode *latest_node)
865 dbg_readinode("read inode #%u\n", ino);
868 spin_lock(&c->inocache_lock);
869 f->inocache = jffs2_get_ino_cache(c, ino);
872 /* Check its state. We may need to wait before we can use it */
873 switch(f->inocache->state) {
874 case INO_STATE_UNCHECKED:
875 case INO_STATE_CHECKEDABSENT:
876 f->inocache->state = INO_STATE_READING;
879 case INO_STATE_CHECKING:
881 /* If it's in either of these states, we need
882 to wait for whoever's got it to finish and
884 dbg_readinode("waiting for ino #%u in state %d\n", ino, f->inocache->state);
885 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
888 case INO_STATE_READING:
889 case INO_STATE_PRESENT:
890 /* Eep. This should never happen. It can
891 happen if Linux calls read_inode() again
892 before clear_inode() has finished though. */
893 JFFS2_ERROR("Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state);
894 /* Fail. That's probably better than allowing it to succeed */
902 spin_unlock(&c->inocache_lock);
904 if (!f->inocache && ino == 1) {
905 /* Special case - no root inode on medium */
906 f->inocache = jffs2_alloc_inode_cache();
908 JFFS2_ERROR("cannot allocate inocache for root inode\n");
911 dbg_readinode("creating inocache for root inode\n");
912 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache));
913 f->inocache->ino = f->inocache->nlink = 1;
914 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
915 f->inocache->state = INO_STATE_READING;
916 jffs2_add_ino_cache(c, f->inocache);
919 JFFS2_ERROR("requestied to read an nonexistent ino %u\n", ino);
923 return jffs2_do_read_inode_internal(c, f, latest_node);
926 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
928 struct jffs2_raw_inode n;
929 struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
935 init_MUTEX_LOCKED(&f->sem);
938 ret = jffs2_do_read_inode_internal(c, f, &n);
941 jffs2_do_clear_inode(c, f);
947 void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
949 struct jffs2_full_dirent *fd, *fds;
953 jffs2_xattr_delete_inode(c, f->inocache);
955 deleted = f->inocache && !f->inocache->nlink;
957 if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
958 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
962 jffs2_mark_node_obsolete(c, f->metadata->raw);
963 jffs2_free_full_dnode(f->metadata);
966 jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
977 jffs2_free_full_dirent(fd);
980 if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {
981 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
982 if (f->inocache->nodes == (void *)f->inocache)
983 jffs2_del_ino_cache(c, f->inocache);