11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001-2003 Red Hat, Inc. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 91da177e4SLinus Torvalds * 10182ec4eeSThomas Gleixner * $Id: readinode.c,v 1.143 2005/11/07 11:14:41 gleixner Exp $ 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds #include <linux/kernel.h> 15737b7661SAndrew Lunn #include <linux/sched.h> 161da177e4SLinus Torvalds #include <linux/slab.h> 171da177e4SLinus Torvalds #include <linux/fs.h> 181da177e4SLinus Torvalds #include <linux/crc32.h> 191da177e4SLinus Torvalds #include <linux/pagemap.h> 201da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 211da177e4SLinus Torvalds #include <linux/compiler.h> 221da177e4SLinus Torvalds #include "nodelist.h" 231da177e4SLinus Torvalds 24f97117d1SArtem B. Bityutskiy /* 25f97117d1SArtem B. Bityutskiy * Put a new tmp_dnode_info into the temporaty RB-tree, keeping the list in 26f97117d1SArtem B. Bityutskiy * order of increasing version. 27f97117d1SArtem B. Bityutskiy */ 28f97117d1SArtem B. Bityutskiy static void jffs2_add_tn_to_tree(struct jffs2_tmp_dnode_info *tn, struct rb_root *list) 291da177e4SLinus Torvalds { 30f97117d1SArtem B. Bityutskiy struct rb_node **p = &list->rb_node; 31f97117d1SArtem B. Bityutskiy struct rb_node * parent = NULL; 32f97117d1SArtem B. Bityutskiy struct jffs2_tmp_dnode_info *this; 331da177e4SLinus Torvalds 34f97117d1SArtem B. Bityutskiy while (*p) { 35f97117d1SArtem B. Bityutskiy parent = *p; 36f97117d1SArtem B. Bityutskiy this = rb_entry(parent, struct jffs2_tmp_dnode_info, rb); 371da177e4SLinus Torvalds 38f97117d1SArtem B. Bityutskiy /* There may actually be a collision here, but it doesn't 39f97117d1SArtem B. Bityutskiy actually matter. As long as the two nodes with the same 40f97117d1SArtem B. Bityutskiy version are together, it's all fine. */ 411e0da3cbSArtem B. Bityutskiy if (tn->version > this->version) 42f97117d1SArtem B. Bityutskiy p = &(*p)->rb_left; 43f97117d1SArtem B. Bityutskiy else 44f97117d1SArtem B. Bityutskiy p = &(*p)->rb_right; 45f97117d1SArtem B. Bityutskiy } 461da177e4SLinus Torvalds 47f97117d1SArtem B. Bityutskiy rb_link_node(&tn->rb, parent, p); 48f97117d1SArtem B. Bityutskiy rb_insert_color(&tn->rb, list); 49f97117d1SArtem B. Bityutskiy } 50f97117d1SArtem B. Bityutskiy 51f97117d1SArtem B. Bityutskiy static void jffs2_free_tmp_dnode_info_list(struct rb_root *list) 52f97117d1SArtem B. Bityutskiy { 53f97117d1SArtem B. Bityutskiy struct rb_node *this; 54f97117d1SArtem B. Bityutskiy struct jffs2_tmp_dnode_info *tn; 55f97117d1SArtem B. Bityutskiy 56f97117d1SArtem B. Bityutskiy this = list->rb_node; 57f97117d1SArtem B. Bityutskiy 58f97117d1SArtem B. Bityutskiy /* Now at bottom of tree */ 59f97117d1SArtem B. Bityutskiy while (this) { 60f97117d1SArtem B. Bityutskiy if (this->rb_left) 61f97117d1SArtem B. Bityutskiy this = this->rb_left; 62f97117d1SArtem B. Bityutskiy else if (this->rb_right) 63f97117d1SArtem B. Bityutskiy this = this->rb_right; 64f97117d1SArtem B. Bityutskiy else { 65f97117d1SArtem B. Bityutskiy tn = rb_entry(this, struct jffs2_tmp_dnode_info, rb); 66f97117d1SArtem B. Bityutskiy jffs2_free_full_dnode(tn->fn); 67f97117d1SArtem B. Bityutskiy jffs2_free_tmp_dnode_info(tn); 68f97117d1SArtem B. Bityutskiy 6921f1d5fcSDavid Woodhouse this = rb_parent(this); 70f97117d1SArtem B. Bityutskiy if (!this) 711da177e4SLinus Torvalds break; 721da177e4SLinus Torvalds 73f97117d1SArtem B. Bityutskiy if (this->rb_left == &tn->rb) 74f97117d1SArtem B. Bityutskiy this->rb_left = NULL; 75f97117d1SArtem B. Bityutskiy else if (this->rb_right == &tn->rb) 76f97117d1SArtem B. Bityutskiy this->rb_right = NULL; 77f97117d1SArtem B. Bityutskiy else BUG(); 78f97117d1SArtem B. Bityutskiy } 79f97117d1SArtem B. Bityutskiy } 80f97117d1SArtem B. Bityutskiy list->rb_node = NULL; 81f97117d1SArtem B. Bityutskiy } 821da177e4SLinus Torvalds 83f97117d1SArtem B. Bityutskiy static void jffs2_free_full_dirent_list(struct jffs2_full_dirent *fd) 84f97117d1SArtem B. Bityutskiy { 85f97117d1SArtem B. Bityutskiy struct jffs2_full_dirent *next; 86f97117d1SArtem B. Bityutskiy 87f97117d1SArtem B. Bityutskiy while (fd) { 88f97117d1SArtem B. Bityutskiy next = fd->next; 89f97117d1SArtem B. Bityutskiy jffs2_free_full_dirent(fd); 90f97117d1SArtem B. Bityutskiy fd = next; 91f97117d1SArtem B. Bityutskiy } 92f97117d1SArtem B. Bityutskiy } 93f97117d1SArtem B. Bityutskiy 94f97117d1SArtem B. Bityutskiy /* Returns first valid node after 'ref'. May return 'ref' */ 95f97117d1SArtem B. Bityutskiy static struct jffs2_raw_node_ref *jffs2_first_valid_node(struct jffs2_raw_node_ref *ref) 96f97117d1SArtem B. Bityutskiy { 97f97117d1SArtem B. Bityutskiy while (ref && ref->next_in_ino) { 98f97117d1SArtem B. Bityutskiy if (!ref_obsolete(ref)) 99f97117d1SArtem B. Bityutskiy return ref; 100733802d9SArtem B. Bityutskiy dbg_noderef("node at 0x%08x is obsoleted. Ignoring.\n", ref_offset(ref)); 101f97117d1SArtem B. Bityutskiy ref = ref->next_in_ino; 102f97117d1SArtem B. Bityutskiy } 103f97117d1SArtem B. Bityutskiy return NULL; 104f97117d1SArtem B. Bityutskiy } 105f97117d1SArtem B. Bityutskiy 106f97117d1SArtem B. Bityutskiy /* 107f97117d1SArtem B. Bityutskiy * Helper function for jffs2_get_inode_nodes(). 108f97117d1SArtem B. Bityutskiy * It is called every time an directory entry node is found. 109f97117d1SArtem B. Bityutskiy * 110f97117d1SArtem B. Bityutskiy * Returns: 0 on succes; 111f97117d1SArtem B. Bityutskiy * 1 if the node should be marked obsolete; 112f97117d1SArtem B. Bityutskiy * negative error code on failure. 113f97117d1SArtem B. Bityutskiy */ 1141e0da3cbSArtem B. Bityutskiy static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, 1150ef675d4SAtsushi Nemoto struct jffs2_raw_dirent *rd, size_t read, struct jffs2_full_dirent **fdp, 1161e0da3cbSArtem B. Bityutskiy uint32_t *latest_mctime, uint32_t *mctime_ver) 117f97117d1SArtem B. Bityutskiy { 118f97117d1SArtem B. Bityutskiy struct jffs2_full_dirent *fd; 1191046d880SDavid Woodhouse uint32_t crc; 120f97117d1SArtem B. Bityutskiy 121f97117d1SArtem B. Bityutskiy /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */ 122f97117d1SArtem B. Bityutskiy BUG_ON(ref_obsolete(ref)); 123f97117d1SArtem B. Bityutskiy 1241046d880SDavid Woodhouse crc = crc32(0, rd, sizeof(*rd) - 8); 1251046d880SDavid Woodhouse if (unlikely(crc != je32_to_cpu(rd->node_crc))) { 1261046d880SDavid Woodhouse JFFS2_NOTICE("header CRC failed on dirent node at %#08x: read %#08x, calculated %#08x\n", 1271046d880SDavid Woodhouse ref_offset(ref), je32_to_cpu(rd->node_crc), crc); 1281046d880SDavid Woodhouse return 1; 1291046d880SDavid Woodhouse } 1301046d880SDavid Woodhouse 1311046d880SDavid Woodhouse /* If we've never checked the CRCs on this node, check them now */ 1321046d880SDavid Woodhouse if (ref_flags(ref) == REF_UNCHECKED) { 1331046d880SDavid Woodhouse struct jffs2_eraseblock *jeb; 1341046d880SDavid Woodhouse int len; 1351046d880SDavid Woodhouse 136f97117d1SArtem B. Bityutskiy /* Sanity check */ 137f97117d1SArtem B. Bityutskiy if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) { 138e0d60137SArtem B. Bityutskiy JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n", 139f97117d1SArtem B. Bityutskiy ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen)); 140f97117d1SArtem B. Bityutskiy return 1; 141f97117d1SArtem B. Bityutskiy } 142f97117d1SArtem B. Bityutskiy 1431046d880SDavid Woodhouse jeb = &c->blocks[ref->flash_offset / c->sector_size]; 1441046d880SDavid Woodhouse len = ref_totlen(c, jeb, ref); 1451046d880SDavid Woodhouse 1461046d880SDavid Woodhouse spin_lock(&c->erase_completion_lock); 1471046d880SDavid Woodhouse jeb->used_size += len; 1481046d880SDavid Woodhouse jeb->unchecked_size -= len; 1491046d880SDavid Woodhouse c->used_size += len; 1501046d880SDavid Woodhouse c->unchecked_size -= len; 1511046d880SDavid Woodhouse ref->flash_offset = ref_offset(ref) | REF_PRISTINE; 1521046d880SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1531046d880SDavid Woodhouse } 1541046d880SDavid Woodhouse 155f97117d1SArtem B. Bityutskiy fd = jffs2_alloc_full_dirent(rd->nsize + 1); 156f97117d1SArtem B. Bityutskiy if (unlikely(!fd)) 157f97117d1SArtem B. Bityutskiy return -ENOMEM; 158f97117d1SArtem B. Bityutskiy 159f97117d1SArtem B. Bityutskiy fd->raw = ref; 160f97117d1SArtem B. Bityutskiy fd->version = je32_to_cpu(rd->version); 161f97117d1SArtem B. Bityutskiy fd->ino = je32_to_cpu(rd->ino); 162f97117d1SArtem B. Bityutskiy fd->type = rd->type; 163f97117d1SArtem B. Bityutskiy 164f97117d1SArtem B. Bityutskiy /* Pick out the mctime of the latest dirent */ 1653a69e0cdSArtem B. Bityutskiy if(fd->version > *mctime_ver && je32_to_cpu(rd->mctime)) { 166f97117d1SArtem B. Bityutskiy *mctime_ver = fd->version; 167f97117d1SArtem B. Bityutskiy *latest_mctime = je32_to_cpu(rd->mctime); 168f97117d1SArtem B. Bityutskiy } 169f97117d1SArtem B. Bityutskiy 170f97117d1SArtem B. Bityutskiy /* 171f97117d1SArtem B. Bityutskiy * Copy as much of the name as possible from the raw 172f97117d1SArtem B. Bityutskiy * dirent we've already read from the flash. 173f97117d1SArtem B. Bityutskiy */ 174f97117d1SArtem B. Bityutskiy if (read > sizeof(*rd)) 175f97117d1SArtem B. Bityutskiy memcpy(&fd->name[0], &rd->name[0], 176f97117d1SArtem B. Bityutskiy min_t(uint32_t, rd->nsize, (read - sizeof(*rd)) )); 177f97117d1SArtem B. Bityutskiy 178f97117d1SArtem B. Bityutskiy /* Do we need to copy any more of the name directly from the flash? */ 179f97117d1SArtem B. Bityutskiy if (rd->nsize + sizeof(*rd) > read) { 180f97117d1SArtem B. Bityutskiy /* FIXME: point() */ 181f97117d1SArtem B. Bityutskiy int err; 182f97117d1SArtem B. Bityutskiy int already = read - sizeof(*rd); 183f97117d1SArtem B. Bityutskiy 184f97117d1SArtem B. Bityutskiy err = jffs2_flash_read(c, (ref_offset(ref)) + read, 185f97117d1SArtem B. Bityutskiy rd->nsize - already, &read, &fd->name[already]); 186f97117d1SArtem B. Bityutskiy if (unlikely(read != rd->nsize - already) && likely(!err)) 187f97117d1SArtem B. Bityutskiy return -EIO; 188f97117d1SArtem B. Bityutskiy 189f97117d1SArtem B. Bityutskiy if (unlikely(err)) { 190e0d60137SArtem B. Bityutskiy JFFS2_ERROR("read remainder of name: error %d\n", err); 191f97117d1SArtem B. Bityutskiy jffs2_free_full_dirent(fd); 192f97117d1SArtem B. Bityutskiy return -EIO; 193f97117d1SArtem B. Bityutskiy } 194f97117d1SArtem B. Bityutskiy } 195f97117d1SArtem B. Bityutskiy 196f97117d1SArtem B. Bityutskiy fd->nhash = full_name_hash(fd->name, rd->nsize); 197f97117d1SArtem B. Bityutskiy fd->next = NULL; 198f97117d1SArtem B. Bityutskiy fd->name[rd->nsize] = '\0'; 199f97117d1SArtem B. Bityutskiy 200f97117d1SArtem B. Bityutskiy /* 201f97117d1SArtem B. Bityutskiy * Wheee. We now have a complete jffs2_full_dirent structure, with 202f97117d1SArtem B. Bityutskiy * the name in it and everything. Link it into the list 203f97117d1SArtem B. Bityutskiy */ 204f97117d1SArtem B. Bityutskiy jffs2_add_fd_to_list(c, fd, fdp); 205f97117d1SArtem B. Bityutskiy 206f97117d1SArtem B. Bityutskiy return 0; 207f97117d1SArtem B. Bityutskiy } 208f97117d1SArtem B. Bityutskiy 209f97117d1SArtem B. Bityutskiy /* 210f97117d1SArtem B. Bityutskiy * Helper function for jffs2_get_inode_nodes(). 211f97117d1SArtem B. Bityutskiy * It is called every time an inode node is found. 212f97117d1SArtem B. Bityutskiy * 213f97117d1SArtem B. Bityutskiy * Returns: 0 on succes; 214f97117d1SArtem B. Bityutskiy * 1 if the node should be marked obsolete; 215f97117d1SArtem B. Bityutskiy * negative error code on failure. 216f97117d1SArtem B. Bityutskiy */ 2171e0da3cbSArtem B. Bityutskiy static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, 2181e0da3cbSArtem B. Bityutskiy struct jffs2_raw_inode *rd, struct rb_root *tnp, int rdlen, 2191e0da3cbSArtem B. Bityutskiy uint32_t *latest_mctime, uint32_t *mctime_ver) 220f97117d1SArtem B. Bityutskiy { 221f97117d1SArtem B. Bityutskiy struct jffs2_tmp_dnode_info *tn; 2221e0da3cbSArtem B. Bityutskiy uint32_t len, csize; 2231e0da3cbSArtem B. Bityutskiy int ret = 1; 2241046d880SDavid Woodhouse uint32_t crc; 225f97117d1SArtem B. Bityutskiy 226f97117d1SArtem B. Bityutskiy /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */ 227f97117d1SArtem B. Bityutskiy BUG_ON(ref_obsolete(ref)); 228f97117d1SArtem B. Bityutskiy 2291046d880SDavid Woodhouse crc = crc32(0, rd, sizeof(*rd) - 8); 2301046d880SDavid Woodhouse if (unlikely(crc != je32_to_cpu(rd->node_crc))) { 2311046d880SDavid Woodhouse JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n", 2321046d880SDavid Woodhouse ref_offset(ref), je32_to_cpu(rd->node_crc), crc); 2331046d880SDavid Woodhouse return 1; 2341046d880SDavid Woodhouse } 2351046d880SDavid Woodhouse 2361e0da3cbSArtem B. Bityutskiy tn = jffs2_alloc_tmp_dnode_info(); 2371e0da3cbSArtem B. Bityutskiy if (!tn) { 238fb6a82c9SRandy Dunlap JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn)); 2391e0da3cbSArtem B. Bityutskiy return -ENOMEM; 2401e0da3cbSArtem B. Bityutskiy } 2411e0da3cbSArtem B. Bityutskiy 2421e0da3cbSArtem B. Bityutskiy tn->partial_crc = 0; 2431e0da3cbSArtem B. Bityutskiy csize = je32_to_cpu(rd->csize); 2441e0da3cbSArtem B. Bityutskiy 245f97117d1SArtem B. Bityutskiy /* If we've never checked the CRCs on this node, check them now */ 246f97117d1SArtem B. Bityutskiy if (ref_flags(ref) == REF_UNCHECKED) { 247f97117d1SArtem B. Bityutskiy 248f97117d1SArtem B. Bityutskiy /* Sanity checks */ 249f97117d1SArtem B. Bityutskiy if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) || 250f97117d1SArtem B. Bityutskiy unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) { 251e0d60137SArtem B. Bityutskiy JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref)); 252737b7661SAndrew Lunn jffs2_dbg_dump_node(c, ref_offset(ref)); 2531e0da3cbSArtem B. Bityutskiy goto free_out; 254f97117d1SArtem B. Bityutskiy } 255f97117d1SArtem B. Bityutskiy 2561e0da3cbSArtem B. Bityutskiy if (jffs2_is_writebuffered(c) && csize != 0) { 2571e0da3cbSArtem B. Bityutskiy /* At this point we are supposed to check the data CRC 2581e0da3cbSArtem B. Bityutskiy * of our unchecked node. But thus far, we do not 2591e0da3cbSArtem B. Bityutskiy * know whether the node is valid or obsolete. To 2601e0da3cbSArtem B. Bityutskiy * figure this out, we need to walk all the nodes of 2611e0da3cbSArtem B. Bityutskiy * the inode and build the inode fragtree. We don't 2621e0da3cbSArtem B. Bityutskiy * want to spend time checking data of nodes which may 2631e0da3cbSArtem B. Bityutskiy * later be found to be obsolete. So we put off the full 2641e0da3cbSArtem B. Bityutskiy * data CRC checking until we have read all the inode 2651e0da3cbSArtem B. Bityutskiy * nodes and have started building the fragtree. 2661e0da3cbSArtem B. Bityutskiy * 2671e0da3cbSArtem B. Bityutskiy * The fragtree is being built starting with nodes 2681e0da3cbSArtem B. Bityutskiy * having the highest version number, so we'll be able 2691e0da3cbSArtem B. Bityutskiy * to detect whether a node is valid (i.e., it is not 2701e0da3cbSArtem B. Bityutskiy * overlapped by a node with higher version) or not. 2711e0da3cbSArtem B. Bityutskiy * And we'll be able to check only those nodes, which 2721e0da3cbSArtem B. Bityutskiy * are not obsolete. 2731e0da3cbSArtem B. Bityutskiy * 2741e0da3cbSArtem B. Bityutskiy * Of course, this optimization only makes sense in case 2751e0da3cbSArtem B. Bityutskiy * of NAND flashes (or other flashes whith 2761e0da3cbSArtem B. Bityutskiy * !jffs2_can_mark_obsolete()), since on NOR flashes 2771e0da3cbSArtem B. Bityutskiy * nodes are marked obsolete physically. 2781e0da3cbSArtem B. Bityutskiy * 2791e0da3cbSArtem B. Bityutskiy * Since NAND flashes (or other flashes with 2801e0da3cbSArtem B. Bityutskiy * jffs2_is_writebuffered(c)) are anyway read by 2811e0da3cbSArtem B. Bityutskiy * fractions of c->wbuf_pagesize, and we have just read 2821e0da3cbSArtem B. Bityutskiy * the node header, it is likely that the starting part 2831e0da3cbSArtem B. Bityutskiy * of the node data is also read when we read the 2841e0da3cbSArtem B. Bityutskiy * header. So we don't mind to check the CRC of the 2851e0da3cbSArtem B. Bityutskiy * starting part of the data of the node now, and check 2861e0da3cbSArtem B. Bityutskiy * the second part later (in jffs2_check_node_data()). 2871e0da3cbSArtem B. Bityutskiy * Of course, we will not need to re-read and re-check 2881e0da3cbSArtem B. Bityutskiy * the NAND page which we have just read. This is why we 2891e0da3cbSArtem B. Bityutskiy * read the whole NAND page at jffs2_get_inode_nodes(), 2901e0da3cbSArtem B. Bityutskiy * while we needed only the node header. 2911e0da3cbSArtem B. Bityutskiy */ 2921e0da3cbSArtem B. Bityutskiy unsigned char *buf; 293f97117d1SArtem B. Bityutskiy 2941e0da3cbSArtem B. Bityutskiy /* 'buf' will point to the start of data */ 2951e0da3cbSArtem B. Bityutskiy buf = (unsigned char *)rd + sizeof(*rd); 2961e0da3cbSArtem B. Bityutskiy /* len will be the read data length */ 2971e0da3cbSArtem B. Bityutskiy len = min_t(uint32_t, rdlen - sizeof(*rd), csize); 298280562b2SArtem B. Bityutskiy tn->partial_crc = crc32(0, buf, len); 299f97117d1SArtem B. Bityutskiy 300733802d9SArtem B. Bityutskiy dbg_readinode("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize); 301f97117d1SArtem B. Bityutskiy 3021e0da3cbSArtem B. Bityutskiy /* If we actually calculated the whole data CRC 3031e0da3cbSArtem B. Bityutskiy * and it is wrong, drop the node. */ 3043c091337SArtem B. Bityutskiy if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) { 30539243508SArtem B. Bityutskiy JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n", 30639243508SArtem B. Bityutskiy ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc)); 3071e0da3cbSArtem B. Bityutskiy goto free_out; 30839243508SArtem B. Bityutskiy } 309f97117d1SArtem B. Bityutskiy 3101e0da3cbSArtem B. Bityutskiy } else if (csize == 0) { 3111e0da3cbSArtem B. Bityutskiy /* 3121e0da3cbSArtem B. Bityutskiy * We checked the header CRC. If the node has no data, adjust 3131e0da3cbSArtem B. Bityutskiy * the space accounting now. For other nodes this will be done 3141e0da3cbSArtem B. Bityutskiy * later either when the node is marked obsolete or when its 3151e0da3cbSArtem B. Bityutskiy * data is checked. 3161e0da3cbSArtem B. Bityutskiy */ 3171e0da3cbSArtem B. Bityutskiy struct jffs2_eraseblock *jeb; 3181e0da3cbSArtem B. Bityutskiy 319733802d9SArtem B. Bityutskiy dbg_readinode("the node has no data.\n"); 320f97117d1SArtem B. Bityutskiy jeb = &c->blocks[ref->flash_offset / c->sector_size]; 321f97117d1SArtem B. Bityutskiy len = ref_totlen(c, jeb, ref); 322f97117d1SArtem B. Bityutskiy 323f97117d1SArtem B. Bityutskiy spin_lock(&c->erase_completion_lock); 324f97117d1SArtem B. Bityutskiy jeb->used_size += len; 325f97117d1SArtem B. Bityutskiy jeb->unchecked_size -= len; 326f97117d1SArtem B. Bityutskiy c->used_size += len; 327f97117d1SArtem B. Bityutskiy c->unchecked_size -= len; 328f97117d1SArtem B. Bityutskiy ref->flash_offset = ref_offset(ref) | REF_NORMAL; 329f97117d1SArtem B. Bityutskiy spin_unlock(&c->erase_completion_lock); 330f97117d1SArtem B. Bityutskiy } 331f97117d1SArtem B. Bityutskiy } 332f97117d1SArtem B. Bityutskiy 333f97117d1SArtem B. Bityutskiy tn->fn = jffs2_alloc_full_dnode(); 334f97117d1SArtem B. Bityutskiy if (!tn->fn) { 335e0d60137SArtem B. Bityutskiy JFFS2_ERROR("alloc fn failed\n"); 3361e0da3cbSArtem B. Bityutskiy ret = -ENOMEM; 3371e0da3cbSArtem B. Bityutskiy goto free_out; 338f97117d1SArtem B. Bityutskiy } 339f97117d1SArtem B. Bityutskiy 340f97117d1SArtem B. Bityutskiy tn->version = je32_to_cpu(rd->version); 341f97117d1SArtem B. Bityutskiy tn->fn->ofs = je32_to_cpu(rd->offset); 3421e0da3cbSArtem B. Bityutskiy tn->data_crc = je32_to_cpu(rd->data_crc); 3431e0da3cbSArtem B. Bityutskiy tn->csize = csize; 344f97117d1SArtem B. Bityutskiy tn->fn->raw = ref; 345f97117d1SArtem B. Bityutskiy 346f97117d1SArtem B. Bityutskiy /* There was a bug where we wrote hole nodes out with 347f97117d1SArtem B. Bityutskiy csize/dsize swapped. Deal with it */ 3481e0da3cbSArtem B. Bityutskiy if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize) 3491e0da3cbSArtem B. Bityutskiy tn->fn->size = csize; 350f97117d1SArtem B. Bityutskiy else // normal case... 351f97117d1SArtem B. Bityutskiy tn->fn->size = je32_to_cpu(rd->dsize); 352f97117d1SArtem B. Bityutskiy 353733802d9SArtem B. Bityutskiy dbg_readinode("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n", 354280562b2SArtem B. Bityutskiy ref_offset(ref), je32_to_cpu(rd->version), je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize); 355f97117d1SArtem B. Bityutskiy 356f97117d1SArtem B. Bityutskiy jffs2_add_tn_to_tree(tn, tnp); 357f97117d1SArtem B. Bityutskiy 358f97117d1SArtem B. Bityutskiy return 0; 3591e0da3cbSArtem B. Bityutskiy 3601e0da3cbSArtem B. Bityutskiy free_out: 3611e0da3cbSArtem B. Bityutskiy jffs2_free_tmp_dnode_info(tn); 3621e0da3cbSArtem B. Bityutskiy return ret; 363f97117d1SArtem B. Bityutskiy } 364f97117d1SArtem B. Bityutskiy 365f97117d1SArtem B. Bityutskiy /* 366f97117d1SArtem B. Bityutskiy * Helper function for jffs2_get_inode_nodes(). 367f97117d1SArtem B. Bityutskiy * It is called every time an unknown node is found. 368f97117d1SArtem B. Bityutskiy * 3693877f0b6SDavid Woodhouse * Returns: 0 on success; 370f97117d1SArtem B. Bityutskiy * 1 if the node should be marked obsolete; 371f97117d1SArtem B. Bityutskiy * negative error code on failure. 372f97117d1SArtem B. Bityutskiy */ 3731e0da3cbSArtem B. Bityutskiy static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, struct jffs2_unknown_node *un) 374f97117d1SArtem B. Bityutskiy { 375f97117d1SArtem B. Bityutskiy /* We don't mark unknown nodes as REF_UNCHECKED */ 376c7258a44SDavid Woodhouse if (ref_flags(ref) == REF_UNCHECKED) { 377c7258a44SDavid Woodhouse JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n", 378c7258a44SDavid Woodhouse ref_offset(ref)); 379c7258a44SDavid Woodhouse JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n", 380c7258a44SDavid Woodhouse je16_to_cpu(un->magic), je16_to_cpu(un->nodetype), 381c7258a44SDavid Woodhouse je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc)); 382c7258a44SDavid Woodhouse return 1; 383c7258a44SDavid Woodhouse } 384f97117d1SArtem B. Bityutskiy 385f97117d1SArtem B. Bityutskiy un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype)); 386f97117d1SArtem B. Bityutskiy 387f97117d1SArtem B. Bityutskiy switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) { 388f97117d1SArtem B. Bityutskiy 389f97117d1SArtem B. Bityutskiy case JFFS2_FEATURE_INCOMPAT: 390e0d60137SArtem B. Bityutskiy JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n", 391f97117d1SArtem B. Bityutskiy je16_to_cpu(un->nodetype), ref_offset(ref)); 392f97117d1SArtem B. Bityutskiy /* EEP */ 393f97117d1SArtem B. Bityutskiy BUG(); 394f97117d1SArtem B. Bityutskiy break; 395f97117d1SArtem B. Bityutskiy 396f97117d1SArtem B. Bityutskiy case JFFS2_FEATURE_ROCOMPAT: 397e0d60137SArtem B. Bityutskiy JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n", 398f97117d1SArtem B. Bityutskiy je16_to_cpu(un->nodetype), ref_offset(ref)); 399f97117d1SArtem B. Bityutskiy BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO)); 400f97117d1SArtem B. Bityutskiy break; 401f97117d1SArtem B. Bityutskiy 402f97117d1SArtem B. Bityutskiy case JFFS2_FEATURE_RWCOMPAT_COPY: 403e0d60137SArtem B. Bityutskiy JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n", 404f97117d1SArtem B. Bityutskiy je16_to_cpu(un->nodetype), ref_offset(ref)); 405f97117d1SArtem B. Bityutskiy break; 406f97117d1SArtem B. Bityutskiy 407f97117d1SArtem B. Bityutskiy case JFFS2_FEATURE_RWCOMPAT_DELETE: 408e0d60137SArtem B. Bityutskiy JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n", 409f97117d1SArtem B. Bityutskiy je16_to_cpu(un->nodetype), ref_offset(ref)); 410f97117d1SArtem B. Bityutskiy return 1; 411f97117d1SArtem B. Bityutskiy } 412f97117d1SArtem B. Bityutskiy 413f97117d1SArtem B. Bityutskiy return 0; 414f97117d1SArtem B. Bityutskiy } 415f97117d1SArtem B. Bityutskiy 4161e0da3cbSArtem B. Bityutskiy /* 4171e0da3cbSArtem B. Bityutskiy * Helper function for jffs2_get_inode_nodes(). 4181e0da3cbSArtem B. Bityutskiy * The function detects whether more data should be read and reads it if yes. 4191e0da3cbSArtem B. Bityutskiy * 4201e0da3cbSArtem B. Bityutskiy * Returns: 0 on succes; 4211e0da3cbSArtem B. Bityutskiy * negative error code on failure. 4221e0da3cbSArtem B. Bityutskiy */ 4231e0da3cbSArtem B. Bityutskiy static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, 4241e0da3cbSArtem B. Bityutskiy int right_size, int *rdlen, unsigned char *buf, unsigned char *bufstart) 4251e0da3cbSArtem B. Bityutskiy { 4261e0da3cbSArtem B. Bityutskiy int right_len, err, len; 4271e0da3cbSArtem B. Bityutskiy size_t retlen; 4281e0da3cbSArtem B. Bityutskiy uint32_t offs; 4291e0da3cbSArtem B. Bityutskiy 4301e0da3cbSArtem B. Bityutskiy if (jffs2_is_writebuffered(c)) { 4311e0da3cbSArtem B. Bityutskiy right_len = c->wbuf_pagesize - (bufstart - buf); 4321e0da3cbSArtem B. Bityutskiy if (right_size + (int)(bufstart - buf) > c->wbuf_pagesize) 4331e0da3cbSArtem B. Bityutskiy right_len += c->wbuf_pagesize; 4341e0da3cbSArtem B. Bityutskiy } else 4351e0da3cbSArtem B. Bityutskiy right_len = right_size; 4361e0da3cbSArtem B. Bityutskiy 4371e0da3cbSArtem B. Bityutskiy if (*rdlen == right_len) 4381e0da3cbSArtem B. Bityutskiy return 0; 4391e0da3cbSArtem B. Bityutskiy 4401e0da3cbSArtem B. Bityutskiy /* We need to read more data */ 4411e0da3cbSArtem B. Bityutskiy offs = ref_offset(ref) + *rdlen; 4421e0da3cbSArtem B. Bityutskiy if (jffs2_is_writebuffered(c)) { 4431e0da3cbSArtem B. Bityutskiy bufstart = buf + c->wbuf_pagesize; 4441e0da3cbSArtem B. Bityutskiy len = c->wbuf_pagesize; 4451e0da3cbSArtem B. Bityutskiy } else { 4461e0da3cbSArtem B. Bityutskiy bufstart = buf + *rdlen; 4471e0da3cbSArtem B. Bityutskiy len = right_size - *rdlen; 4481e0da3cbSArtem B. Bityutskiy } 4491e0da3cbSArtem B. Bityutskiy 450733802d9SArtem B. Bityutskiy dbg_readinode("read more %d bytes\n", len); 4511e0da3cbSArtem B. Bityutskiy 4521e0da3cbSArtem B. Bityutskiy err = jffs2_flash_read(c, offs, len, &retlen, bufstart); 4531e0da3cbSArtem B. Bityutskiy if (err) { 4541e0da3cbSArtem B. Bityutskiy JFFS2_ERROR("can not read %d bytes from 0x%08x, " 4551e0da3cbSArtem B. Bityutskiy "error code: %d.\n", len, offs, err); 4561e0da3cbSArtem B. Bityutskiy return err; 4571e0da3cbSArtem B. Bityutskiy } 4581e0da3cbSArtem B. Bityutskiy 4591e0da3cbSArtem B. Bityutskiy if (retlen < len) { 460fb6a82c9SRandy Dunlap JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", 4611e0da3cbSArtem B. Bityutskiy offs, retlen, len); 4621e0da3cbSArtem B. Bityutskiy return -EIO; 4631e0da3cbSArtem B. Bityutskiy } 4641e0da3cbSArtem B. Bityutskiy 4651e0da3cbSArtem B. Bityutskiy *rdlen = right_len; 4661e0da3cbSArtem B. Bityutskiy 4671e0da3cbSArtem B. Bityutskiy return 0; 4681e0da3cbSArtem B. Bityutskiy } 4691e0da3cbSArtem B. Bityutskiy 470f97117d1SArtem B. Bityutskiy /* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated 471f97117d1SArtem B. Bityutskiy with this ino, returning the former in order of version */ 472f97117d1SArtem B. Bityutskiy static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 473f97117d1SArtem B. Bityutskiy struct rb_root *tnp, struct jffs2_full_dirent **fdp, 474f97117d1SArtem B. Bityutskiy uint32_t *highest_version, uint32_t *latest_mctime, 475f97117d1SArtem B. Bityutskiy uint32_t *mctime_ver) 476f97117d1SArtem B. Bityutskiy { 477f97117d1SArtem B. Bityutskiy struct jffs2_raw_node_ref *ref, *valid_ref; 478f97117d1SArtem B. Bityutskiy struct rb_root ret_tn = RB_ROOT; 479f97117d1SArtem B. Bityutskiy struct jffs2_full_dirent *ret_fd = NULL; 4801e0da3cbSArtem B. Bityutskiy unsigned char *buf = NULL; 4811e0da3cbSArtem B. Bityutskiy union jffs2_node_union *node; 482f97117d1SArtem B. Bityutskiy size_t retlen; 4831e0da3cbSArtem B. Bityutskiy int len, err; 484f97117d1SArtem B. Bityutskiy 485f97117d1SArtem B. Bityutskiy *mctime_ver = 0; 486f97117d1SArtem B. Bityutskiy 487733802d9SArtem B. Bityutskiy dbg_readinode("ino #%u\n", f->inocache->ino); 488f97117d1SArtem B. Bityutskiy 4891e0da3cbSArtem B. Bityutskiy if (jffs2_is_writebuffered(c)) { 4901e0da3cbSArtem B. Bityutskiy /* 4911e0da3cbSArtem B. Bityutskiy * If we have the write buffer, we assume the minimal I/O unit 4921e0da3cbSArtem B. Bityutskiy * is c->wbuf_pagesize. We implement some optimizations which in 4931e0da3cbSArtem B. Bityutskiy * this case and we need a temporary buffer of size = 4941e0da3cbSArtem B. Bityutskiy * 2*c->wbuf_pagesize bytes (see comments in read_dnode()). 4951e0da3cbSArtem B. Bityutskiy * Basically, we want to read not only the node header, but the 4961e0da3cbSArtem B. Bityutskiy * whole wbuf (NAND page in case of NAND) or 2, if the node 4971e0da3cbSArtem B. Bityutskiy * header overlaps the border between the 2 wbufs. 4981e0da3cbSArtem B. Bityutskiy */ 4991e0da3cbSArtem B. Bityutskiy len = 2*c->wbuf_pagesize; 5001e0da3cbSArtem B. Bityutskiy } else { 5011e0da3cbSArtem B. Bityutskiy /* 5021e0da3cbSArtem B. Bityutskiy * When there is no write buffer, the size of the temporary 5031e0da3cbSArtem B. Bityutskiy * buffer is the size of the larges node header. 5041e0da3cbSArtem B. Bityutskiy */ 5051e0da3cbSArtem B. Bityutskiy len = sizeof(union jffs2_node_union); 5061e0da3cbSArtem B. Bityutskiy } 5071e0da3cbSArtem B. Bityutskiy 5081e0da3cbSArtem B. Bityutskiy /* FIXME: in case of NOR and available ->point() this 5091e0da3cbSArtem B. Bityutskiy * needs to be fixed. */ 5101e0da3cbSArtem B. Bityutskiy buf = kmalloc(len, GFP_KERNEL); 5111e0da3cbSArtem B. Bityutskiy if (!buf) 5121e0da3cbSArtem B. Bityutskiy return -ENOMEM; 5131e0da3cbSArtem B. Bityutskiy 514f97117d1SArtem B. Bityutskiy spin_lock(&c->erase_completion_lock); 515f97117d1SArtem B. Bityutskiy valid_ref = jffs2_first_valid_node(f->inocache->nodes); 5161e0da3cbSArtem B. Bityutskiy if (!valid_ref && f->inocache->ino != 1) 5171e0da3cbSArtem B. Bityutskiy JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino); 518f97117d1SArtem B. Bityutskiy while (valid_ref) { 5191e0da3cbSArtem B. Bityutskiy unsigned char *bufstart; 5201e0da3cbSArtem B. Bityutskiy 521f97117d1SArtem B. Bityutskiy /* We can hold a pointer to a non-obsolete node without the spinlock, 522f97117d1SArtem B. Bityutskiy but _obsolete_ nodes may disappear at any time, if the block 523f97117d1SArtem B. Bityutskiy they're in gets erased. So if we mark 'ref' obsolete while we're 524f97117d1SArtem B. Bityutskiy not holding the lock, it can go away immediately. For that reason, 525f97117d1SArtem B. Bityutskiy we find the next valid node first, before processing 'ref'. 526f97117d1SArtem B. Bityutskiy */ 527f97117d1SArtem B. Bityutskiy ref = valid_ref; 528f97117d1SArtem B. Bityutskiy valid_ref = jffs2_first_valid_node(ref->next_in_ino); 529f97117d1SArtem B. Bityutskiy spin_unlock(&c->erase_completion_lock); 530f97117d1SArtem B. Bityutskiy 531f97117d1SArtem B. Bityutskiy cond_resched(); 532f97117d1SArtem B. Bityutskiy 5331e0da3cbSArtem B. Bityutskiy /* 5341e0da3cbSArtem B. Bityutskiy * At this point we don't know the type of the node we're going 5351e0da3cbSArtem B. Bityutskiy * to read, so we do not know the size of its header. In order 5361e0da3cbSArtem B. Bityutskiy * to minimize the amount of flash IO we assume the node has 5371e0da3cbSArtem B. Bityutskiy * size = JFFS2_MIN_NODE_HEADER. 5381e0da3cbSArtem B. Bityutskiy */ 5391e0da3cbSArtem B. Bityutskiy if (jffs2_is_writebuffered(c)) { 5401e0da3cbSArtem B. Bityutskiy /* 5411e0da3cbSArtem B. Bityutskiy * We treat 'buf' as 2 adjacent wbufs. We want to 5421e0da3cbSArtem B. Bityutskiy * adjust bufstart such as it points to the 5431e0da3cbSArtem B. Bityutskiy * beginning of the node within this wbuf. 5441e0da3cbSArtem B. Bityutskiy */ 5451e0da3cbSArtem B. Bityutskiy bufstart = buf + (ref_offset(ref) % c->wbuf_pagesize); 5461e0da3cbSArtem B. Bityutskiy /* We will read either one wbuf or 2 wbufs. */ 5471e0da3cbSArtem B. Bityutskiy len = c->wbuf_pagesize - (bufstart - buf); 54839243508SArtem B. Bityutskiy if (JFFS2_MIN_NODE_HEADER + (int)(bufstart - buf) > c->wbuf_pagesize) { 54939243508SArtem B. Bityutskiy /* The header spans the border of the first wbuf */ 5501e0da3cbSArtem B. Bityutskiy len += c->wbuf_pagesize; 5511e0da3cbSArtem B. Bityutskiy } 5521e0da3cbSArtem B. Bityutskiy } else { 5531e0da3cbSArtem B. Bityutskiy bufstart = buf; 5541e0da3cbSArtem B. Bityutskiy len = JFFS2_MIN_NODE_HEADER; 5551e0da3cbSArtem B. Bityutskiy } 5561e0da3cbSArtem B. Bityutskiy 557733802d9SArtem B. Bityutskiy dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref)); 5581e0da3cbSArtem B. Bityutskiy 559f97117d1SArtem B. Bityutskiy /* FIXME: point() */ 5601e0da3cbSArtem B. Bityutskiy err = jffs2_flash_read(c, ref_offset(ref), len, 5611e0da3cbSArtem B. Bityutskiy &retlen, bufstart); 562f97117d1SArtem B. Bityutskiy if (err) { 5631e0da3cbSArtem B. Bityutskiy JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err); 564f97117d1SArtem B. Bityutskiy goto free_out; 565f97117d1SArtem B. Bityutskiy } 566f97117d1SArtem B. Bityutskiy 5671e0da3cbSArtem B. Bityutskiy if (retlen < len) { 568fb6a82c9SRandy Dunlap JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len); 569f97117d1SArtem B. Bityutskiy err = -EIO; 570f97117d1SArtem B. Bityutskiy goto free_out; 571f97117d1SArtem B. Bityutskiy } 572f97117d1SArtem B. Bityutskiy 5731e0da3cbSArtem B. Bityutskiy node = (union jffs2_node_union *)bufstart; 5741e0da3cbSArtem B. Bityutskiy 5753877f0b6SDavid Woodhouse /* No need to mask in the valid bit; it shouldn't be invalid */ 5763877f0b6SDavid Woodhouse if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) { 5773877f0b6SDavid Woodhouse JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n", 5783877f0b6SDavid Woodhouse ref_offset(ref), je16_to_cpu(node->u.magic), 5793877f0b6SDavid Woodhouse je16_to_cpu(node->u.nodetype), 5803877f0b6SDavid Woodhouse je32_to_cpu(node->u.totlen), 5813877f0b6SDavid Woodhouse je32_to_cpu(node->u.hdr_crc)); 5823877f0b6SDavid Woodhouse jffs2_dbg_dump_node(c, ref_offset(ref)); 5833877f0b6SDavid Woodhouse jffs2_mark_node_obsolete(c, ref); 5843877f0b6SDavid Woodhouse goto cont; 5853877f0b6SDavid Woodhouse } 586c7258a44SDavid Woodhouse /* Due to poor choice of crc32 seed, an all-zero node will have a correct CRC */ 587c7258a44SDavid Woodhouse if (!je32_to_cpu(node->u.hdr_crc) && !je16_to_cpu(node->u.nodetype) && 588c7258a44SDavid Woodhouse !je16_to_cpu(node->u.magic) && !je32_to_cpu(node->u.totlen)) { 589c7258a44SDavid Woodhouse JFFS2_NOTICE("All zero node header at %#08x.\n", ref_offset(ref)); 590c7258a44SDavid Woodhouse jffs2_mark_node_obsolete(c, ref); 591c7258a44SDavid Woodhouse goto cont; 592c7258a44SDavid Woodhouse } 5933877f0b6SDavid Woodhouse 5941e0da3cbSArtem B. Bityutskiy switch (je16_to_cpu(node->u.nodetype)) { 5951e0da3cbSArtem B. Bityutskiy 5961e0da3cbSArtem B. Bityutskiy case JFFS2_NODETYPE_DIRENT: 5971e0da3cbSArtem B. Bityutskiy 5981e0da3cbSArtem B. Bityutskiy if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent)) { 5991e0da3cbSArtem B. Bityutskiy err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf, bufstart); 6001e0da3cbSArtem B. Bityutskiy if (unlikely(err)) 6011e0da3cbSArtem B. Bityutskiy goto free_out; 6021e0da3cbSArtem B. Bityutskiy } 6031e0da3cbSArtem B. Bityutskiy 6041e0da3cbSArtem B. Bityutskiy err = read_direntry(c, ref, &node->d, retlen, &ret_fd, latest_mctime, mctime_ver); 605f97117d1SArtem B. Bityutskiy if (err == 1) { 606f97117d1SArtem B. Bityutskiy jffs2_mark_node_obsolete(c, ref); 607f97117d1SArtem B. Bityutskiy break; 608f97117d1SArtem B. Bityutskiy } else if (unlikely(err)) 609f97117d1SArtem B. Bityutskiy goto free_out; 610f97117d1SArtem B. Bityutskiy 6111e0da3cbSArtem B. Bityutskiy if (je32_to_cpu(node->d.version) > *highest_version) 6121e0da3cbSArtem B. Bityutskiy *highest_version = je32_to_cpu(node->d.version); 613f97117d1SArtem B. Bityutskiy 614f97117d1SArtem B. Bityutskiy break; 615f97117d1SArtem B. Bityutskiy 616f97117d1SArtem B. Bityutskiy case JFFS2_NODETYPE_INODE: 617f97117d1SArtem B. Bityutskiy 6181e0da3cbSArtem B. Bityutskiy if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode)) { 6191e0da3cbSArtem B. Bityutskiy err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf, bufstart); 6201e0da3cbSArtem B. Bityutskiy if (unlikely(err)) 621f97117d1SArtem B. Bityutskiy goto free_out; 622f97117d1SArtem B. Bityutskiy } 623f97117d1SArtem B. Bityutskiy 6241e0da3cbSArtem B. Bityutskiy err = read_dnode(c, ref, &node->i, &ret_tn, len, latest_mctime, mctime_ver); 625f97117d1SArtem B. Bityutskiy if (err == 1) { 626f97117d1SArtem B. Bityutskiy jffs2_mark_node_obsolete(c, ref); 627f97117d1SArtem B. Bityutskiy break; 628f97117d1SArtem B. Bityutskiy } else if (unlikely(err)) 629f97117d1SArtem B. Bityutskiy goto free_out; 630f97117d1SArtem B. Bityutskiy 6311e0da3cbSArtem B. Bityutskiy if (je32_to_cpu(node->i.version) > *highest_version) 6321e0da3cbSArtem B. Bityutskiy *highest_version = je32_to_cpu(node->i.version); 633f97117d1SArtem B. Bityutskiy 6341da177e4SLinus Torvalds break; 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds default: 6371e0da3cbSArtem B. Bityutskiy if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node)) { 6381e0da3cbSArtem B. Bityutskiy err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf, bufstart); 6391e0da3cbSArtem B. Bityutskiy if (unlikely(err)) 6401e0da3cbSArtem B. Bityutskiy goto free_out; 6411da177e4SLinus Torvalds } 6421da177e4SLinus Torvalds 6431e0da3cbSArtem B. Bityutskiy err = read_unknown(c, ref, &node->u); 644f97117d1SArtem B. Bityutskiy if (err == 1) { 645f97117d1SArtem B. Bityutskiy jffs2_mark_node_obsolete(c, ref); 646f97117d1SArtem B. Bityutskiy break; 647f97117d1SArtem B. Bityutskiy } else if (unlikely(err)) 648f97117d1SArtem B. Bityutskiy goto free_out; 649f97117d1SArtem B. Bityutskiy 6501da177e4SLinus Torvalds } 6513877f0b6SDavid Woodhouse cont: 652f97117d1SArtem B. Bityutskiy spin_lock(&c->erase_completion_lock); 6531da177e4SLinus Torvalds } 6541e0da3cbSArtem B. Bityutskiy 655f97117d1SArtem B. Bityutskiy spin_unlock(&c->erase_completion_lock); 656f97117d1SArtem B. Bityutskiy *tnp = ret_tn; 657f97117d1SArtem B. Bityutskiy *fdp = ret_fd; 6581e0da3cbSArtem B. Bityutskiy kfree(buf); 659f97117d1SArtem B. Bityutskiy 660733802d9SArtem B. Bityutskiy dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n", 6611e0da3cbSArtem B. Bityutskiy f->inocache->ino, *highest_version, *latest_mctime, *mctime_ver); 662f97117d1SArtem B. Bityutskiy return 0; 663f97117d1SArtem B. Bityutskiy 664f97117d1SArtem B. Bityutskiy free_out: 665f97117d1SArtem B. Bityutskiy jffs2_free_tmp_dnode_info_list(&ret_tn); 666f97117d1SArtem B. Bityutskiy jffs2_free_full_dirent_list(ret_fd); 6671e0da3cbSArtem B. Bityutskiy kfree(buf); 668f97117d1SArtem B. Bityutskiy return err; 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c, 6721da177e4SLinus Torvalds struct jffs2_inode_info *f, 6731da177e4SLinus Torvalds struct jffs2_raw_inode *latest_node) 6741da177e4SLinus Torvalds { 6751e0da3cbSArtem B. Bityutskiy struct jffs2_tmp_dnode_info *tn; 6769dee7503SDavid Woodhouse struct rb_root tn_list; 6779dee7503SDavid Woodhouse struct rb_node *rb, *repl_rb; 6781da177e4SLinus Torvalds struct jffs2_full_dirent *fd_list; 6791e0da3cbSArtem B. Bityutskiy struct jffs2_full_dnode *fn, *first_fn = NULL; 6801da177e4SLinus Torvalds uint32_t crc; 6811da177e4SLinus Torvalds uint32_t latest_mctime, mctime_ver; 6821da177e4SLinus Torvalds size_t retlen; 6831da177e4SLinus Torvalds int ret; 6841da177e4SLinus Torvalds 685733802d9SArtem B. Bityutskiy dbg_readinode("ino #%u nlink is %d\n", f->inocache->ino, f->inocache->nlink); 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds /* Grab all nodes relevant to this ino */ 6881da177e4SLinus Torvalds ret = jffs2_get_inode_nodes(c, f, &tn_list, &fd_list, &f->highest_version, &latest_mctime, &mctime_ver); 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds if (ret) { 691e0d60137SArtem B. Bityutskiy JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret); 6921da177e4SLinus Torvalds if (f->inocache->state == INO_STATE_READING) 6931da177e4SLinus Torvalds jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 6941da177e4SLinus Torvalds return ret; 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds f->dents = fd_list; 6971da177e4SLinus Torvalds 6989dee7503SDavid Woodhouse rb = rb_first(&tn_list); 6991da177e4SLinus Torvalds 7009dee7503SDavid Woodhouse while (rb) { 7011e0da3cbSArtem B. Bityutskiy cond_resched(); 7029dee7503SDavid Woodhouse tn = rb_entry(rb, struct jffs2_tmp_dnode_info, rb); 7031da177e4SLinus Torvalds fn = tn->fn; 7041e0da3cbSArtem B. Bityutskiy ret = 1; 705733802d9SArtem B. Bityutskiy dbg_readinode("consider node ver %u, phys offset " 7061e0da3cbSArtem B. Bityutskiy "%#08x(%d), range %u-%u.\n", tn->version, 7071e0da3cbSArtem B. Bityutskiy ref_offset(fn->raw), ref_flags(fn->raw), 7081e0da3cbSArtem B. Bityutskiy fn->ofs, fn->ofs + fn->size); 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds if (fn->size) { 7111e0da3cbSArtem B. Bityutskiy ret = jffs2_add_older_frag_to_fragtree(c, f, tn); 7121e0da3cbSArtem B. Bityutskiy /* TODO: the error code isn't checked, check it */ 7131e0da3cbSArtem B. Bityutskiy jffs2_dbg_fragtree_paranoia_check_nolock(f); 7141e0da3cbSArtem B. Bityutskiy BUG_ON(ret < 0); 7151e0da3cbSArtem B. Bityutskiy if (!first_fn && ret == 0) 7161e0da3cbSArtem B. Bityutskiy first_fn = fn; 7171e0da3cbSArtem B. Bityutskiy } else if (!first_fn) { 7181e0da3cbSArtem B. Bityutskiy first_fn = fn; 7191da177e4SLinus Torvalds f->metadata = fn; 7201e0da3cbSArtem B. Bityutskiy ret = 0; /* Prevent freeing the metadata update node */ 7211e0da3cbSArtem B. Bityutskiy } else 7221e0da3cbSArtem B. Bityutskiy jffs2_mark_node_obsolete(c, fn->raw); 7231e0da3cbSArtem B. Bityutskiy 7249dee7503SDavid Woodhouse BUG_ON(rb->rb_left); 72521f1d5fcSDavid Woodhouse if (rb_parent(rb) && rb_parent(rb)->rb_left == rb) { 7269dee7503SDavid Woodhouse /* We were then left-hand child of our parent. We need 7271e0da3cbSArtem B. Bityutskiy * to move our own right-hand child into our place. */ 7289dee7503SDavid Woodhouse repl_rb = rb->rb_right; 7299dee7503SDavid Woodhouse if (repl_rb) 73021f1d5fcSDavid Woodhouse rb_set_parent(repl_rb, rb_parent(rb)); 7319dee7503SDavid Woodhouse } else 7329dee7503SDavid Woodhouse repl_rb = NULL; 7339dee7503SDavid Woodhouse 7349dee7503SDavid Woodhouse rb = rb_next(rb); 7359dee7503SDavid Woodhouse 7369dee7503SDavid Woodhouse /* Remove the spent tn from the tree; don't bother rebalancing 7371e0da3cbSArtem B. Bityutskiy * but put our right-hand child in our own place. */ 73821f1d5fcSDavid Woodhouse if (rb_parent(&tn->rb)) { 73921f1d5fcSDavid Woodhouse if (rb_parent(&tn->rb)->rb_left == &tn->rb) 74021f1d5fcSDavid Woodhouse rb_parent(&tn->rb)->rb_left = repl_rb; 74121f1d5fcSDavid Woodhouse else if (rb_parent(&tn->rb)->rb_right == &tn->rb) 74221f1d5fcSDavid Woodhouse rb_parent(&tn->rb)->rb_right = repl_rb; 7439dee7503SDavid Woodhouse else BUG(); 7449dee7503SDavid Woodhouse } else if (tn->rb.rb_right) 74521f1d5fcSDavid Woodhouse rb_set_parent(tn->rb.rb_right, NULL); 7469dee7503SDavid Woodhouse 7471da177e4SLinus Torvalds jffs2_free_tmp_dnode_info(tn); 7481e0da3cbSArtem B. Bityutskiy if (ret) { 749733802d9SArtem B. Bityutskiy dbg_readinode("delete dnode %u-%u.\n", 7501e0da3cbSArtem B. Bityutskiy fn->ofs, fn->ofs + fn->size); 7511e0da3cbSArtem B. Bityutskiy jffs2_free_full_dnode(fn); 7521e0da3cbSArtem B. Bityutskiy } 7531da177e4SLinus Torvalds } 754e0c8e42fSArtem B. Bityutskiy jffs2_dbg_fragtree_paranoia_check_nolock(f); 7551da177e4SLinus Torvalds 7561e0da3cbSArtem B. Bityutskiy BUG_ON(first_fn && ref_obsolete(first_fn->raw)); 7571e0da3cbSArtem B. Bityutskiy 7581e0da3cbSArtem B. Bityutskiy fn = first_fn; 7591e0da3cbSArtem B. Bityutskiy if (unlikely(!first_fn)) { 7601da177e4SLinus Torvalds /* No data nodes for this inode. */ 7611da177e4SLinus Torvalds if (f->inocache->ino != 1) { 762e0d60137SArtem B. Bityutskiy JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino); 7631da177e4SLinus Torvalds if (!fd_list) { 7641da177e4SLinus Torvalds if (f->inocache->state == INO_STATE_READING) 7651da177e4SLinus Torvalds jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 7661da177e4SLinus Torvalds return -EIO; 7671da177e4SLinus Torvalds } 768e0d60137SArtem B. Bityutskiy JFFS2_NOTICE("but it has children so we fake some modes for it\n"); 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO); 7711da177e4SLinus Torvalds latest_node->version = cpu_to_je32(0); 7721da177e4SLinus Torvalds latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0); 7731da177e4SLinus Torvalds latest_node->isize = cpu_to_je32(0); 7741da177e4SLinus Torvalds latest_node->gid = cpu_to_je16(0); 7751da177e4SLinus Torvalds latest_node->uid = cpu_to_je16(0); 7761da177e4SLinus Torvalds if (f->inocache->state == INO_STATE_READING) 7771da177e4SLinus Torvalds jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT); 7781da177e4SLinus Torvalds return 0; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(*latest_node), &retlen, (void *)latest_node); 7821da177e4SLinus Torvalds if (ret || retlen != sizeof(*latest_node)) { 783e0d60137SArtem B. Bityutskiy JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n", 7841da177e4SLinus Torvalds ret, retlen, sizeof(*latest_node)); 7851da177e4SLinus Torvalds /* FIXME: If this fails, there seems to be a memory leak. Find it. */ 7861da177e4SLinus Torvalds up(&f->sem); 7871da177e4SLinus Torvalds jffs2_do_clear_inode(c, f); 7881da177e4SLinus Torvalds return ret?ret:-EIO; 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds crc = crc32(0, latest_node, sizeof(*latest_node)-8); 7921da177e4SLinus Torvalds if (crc != je32_to_cpu(latest_node->node_crc)) { 793e0d60137SArtem B. Bityutskiy JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n", 794e0d60137SArtem B. Bityutskiy f->inocache->ino, ref_offset(fn->raw)); 7951da177e4SLinus Torvalds up(&f->sem); 7961da177e4SLinus Torvalds jffs2_do_clear_inode(c, f); 7971da177e4SLinus Torvalds return -EIO; 7981da177e4SLinus Torvalds } 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds switch(jemode_to_cpu(latest_node->mode) & S_IFMT) { 8011da177e4SLinus Torvalds case S_IFDIR: 8021da177e4SLinus Torvalds if (mctime_ver > je32_to_cpu(latest_node->version)) { 8031da177e4SLinus Torvalds /* The times in the latest_node are actually older than 8041da177e4SLinus Torvalds mctime in the latest dirent. Cheat. */ 8051da177e4SLinus Torvalds latest_node->ctime = latest_node->mtime = cpu_to_je32(latest_mctime); 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds break; 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds case S_IFREG: 8111da177e4SLinus Torvalds /* If it was a regular file, truncate it to the latest node's isize */ 812f302cd02SArtem B. Bityutskiy jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize)); 8131da177e4SLinus Torvalds break; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds case S_IFLNK: 8161da177e4SLinus Torvalds /* Hack to work around broken isize in old symlink code. 8171da177e4SLinus Torvalds Remove this when dwmw2 comes to his senses and stops 8181da177e4SLinus Torvalds symlinks from being an entirely gratuitous special 8191da177e4SLinus Torvalds case. */ 8201da177e4SLinus Torvalds if (!je32_to_cpu(latest_node->isize)) 8211da177e4SLinus Torvalds latest_node->isize = latest_node->dsize; 82232f1a95dSArtem B. Bityuckiy 82332f1a95dSArtem B. Bityuckiy if (f->inocache->state != INO_STATE_CHECKING) { 82432f1a95dSArtem B. Bityuckiy /* Symlink's inode data is the target path. Read it and 8252b79adccSArtem B. Bityutskiy * keep in RAM to facilitate quick follow symlink 8262b79adccSArtem B. Bityutskiy * operation. */ 8272b79adccSArtem B. Bityutskiy f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL); 8282b79adccSArtem B. Bityutskiy if (!f->target) { 829e0d60137SArtem B. Bityutskiy JFFS2_ERROR("can't allocate %d bytes of memory for the symlink target path cache\n", je32_to_cpu(latest_node->csize)); 83032f1a95dSArtem B. Bityuckiy up(&f->sem); 83132f1a95dSArtem B. Bityuckiy jffs2_do_clear_inode(c, f); 83232f1a95dSArtem B. Bityuckiy return -ENOMEM; 83332f1a95dSArtem B. Bityuckiy } 83432f1a95dSArtem B. Bityuckiy 83532f1a95dSArtem B. Bityuckiy ret = jffs2_flash_read(c, ref_offset(fn->raw) + sizeof(*latest_node), 8362b79adccSArtem B. Bityutskiy je32_to_cpu(latest_node->csize), &retlen, (char *)f->target); 83732f1a95dSArtem B. Bityuckiy 83832f1a95dSArtem B. Bityuckiy if (ret || retlen != je32_to_cpu(latest_node->csize)) { 83932f1a95dSArtem B. Bityuckiy if (retlen != je32_to_cpu(latest_node->csize)) 84032f1a95dSArtem B. Bityuckiy ret = -EIO; 8412b79adccSArtem B. Bityutskiy kfree(f->target); 8422b79adccSArtem B. Bityutskiy f->target = NULL; 84332f1a95dSArtem B. Bityuckiy up(&f->sem); 84432f1a95dSArtem B. Bityuckiy jffs2_do_clear_inode(c, f); 84532f1a95dSArtem B. Bityuckiy return -ret; 84632f1a95dSArtem B. Bityuckiy } 84732f1a95dSArtem B. Bityuckiy 8482b79adccSArtem B. Bityutskiy f->target[je32_to_cpu(latest_node->csize)] = '\0'; 849733802d9SArtem B. Bityutskiy dbg_readinode("symlink's target '%s' cached\n", f->target); 85032f1a95dSArtem B. Bityuckiy } 85132f1a95dSArtem B. Bityuckiy 8521da177e4SLinus Torvalds /* fall through... */ 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds case S_IFBLK: 8551da177e4SLinus Torvalds case S_IFCHR: 8561da177e4SLinus Torvalds /* Certain inode types should have only one data node, and it's 8571da177e4SLinus Torvalds kept as the metadata node */ 8581da177e4SLinus Torvalds if (f->metadata) { 859e0d60137SArtem B. Bityutskiy JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n", 8601da177e4SLinus Torvalds f->inocache->ino, jemode_to_cpu(latest_node->mode)); 8611da177e4SLinus Torvalds up(&f->sem); 8621da177e4SLinus Torvalds jffs2_do_clear_inode(c, f); 8631da177e4SLinus Torvalds return -EIO; 8641da177e4SLinus Torvalds } 8651da177e4SLinus Torvalds if (!frag_first(&f->fragtree)) { 866e0d60137SArtem B. Bityutskiy JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n", 8671da177e4SLinus Torvalds f->inocache->ino, jemode_to_cpu(latest_node->mode)); 8681da177e4SLinus Torvalds up(&f->sem); 8691da177e4SLinus Torvalds jffs2_do_clear_inode(c, f); 8701da177e4SLinus Torvalds return -EIO; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds /* ASSERT: f->fraglist != NULL */ 8731da177e4SLinus Torvalds if (frag_next(frag_first(&f->fragtree))) { 874e0d60137SArtem B. Bityutskiy JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n", 8751da177e4SLinus Torvalds f->inocache->ino, jemode_to_cpu(latest_node->mode)); 8761da177e4SLinus Torvalds /* FIXME: Deal with it - check crc32, check for duplicate node, check times and discard the older one */ 8771da177e4SLinus Torvalds up(&f->sem); 8781da177e4SLinus Torvalds jffs2_do_clear_inode(c, f); 8791da177e4SLinus Torvalds return -EIO; 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds /* OK. We're happy */ 8821da177e4SLinus Torvalds f->metadata = frag_first(&f->fragtree)->node; 8831da177e4SLinus Torvalds jffs2_free_node_frag(frag_first(&f->fragtree)); 8841da177e4SLinus Torvalds f->fragtree = RB_ROOT; 8851da177e4SLinus Torvalds break; 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds if (f->inocache->state == INO_STATE_READING) 8881da177e4SLinus Torvalds jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT); 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds return 0; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 893f97117d1SArtem B. Bityutskiy /* Scan the list of all nodes present for this ino, build map of versions, etc. */ 894f97117d1SArtem B. Bityutskiy int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 895f97117d1SArtem B. Bityutskiy uint32_t ino, struct jffs2_raw_inode *latest_node) 896f97117d1SArtem B. Bityutskiy { 897733802d9SArtem B. Bityutskiy dbg_readinode("read inode #%u\n", ino); 898f97117d1SArtem B. Bityutskiy 899f97117d1SArtem B. Bityutskiy retry_inocache: 900f97117d1SArtem B. Bityutskiy spin_lock(&c->inocache_lock); 901f97117d1SArtem B. Bityutskiy f->inocache = jffs2_get_ino_cache(c, ino); 902f97117d1SArtem B. Bityutskiy 903f97117d1SArtem B. Bityutskiy if (f->inocache) { 904f97117d1SArtem B. Bityutskiy /* Check its state. We may need to wait before we can use it */ 905f97117d1SArtem B. Bityutskiy switch(f->inocache->state) { 906f97117d1SArtem B. Bityutskiy case INO_STATE_UNCHECKED: 907f97117d1SArtem B. Bityutskiy case INO_STATE_CHECKEDABSENT: 908f97117d1SArtem B. Bityutskiy f->inocache->state = INO_STATE_READING; 909f97117d1SArtem B. Bityutskiy break; 910f97117d1SArtem B. Bityutskiy 911f97117d1SArtem B. Bityutskiy case INO_STATE_CHECKING: 912f97117d1SArtem B. Bityutskiy case INO_STATE_GC: 913f97117d1SArtem B. Bityutskiy /* If it's in either of these states, we need 914f97117d1SArtem B. Bityutskiy to wait for whoever's got it to finish and 915f97117d1SArtem B. Bityutskiy put it back. */ 916733802d9SArtem B. Bityutskiy dbg_readinode("waiting for ino #%u in state %d\n", ino, f->inocache->state); 917f97117d1SArtem B. Bityutskiy sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 918f97117d1SArtem B. Bityutskiy goto retry_inocache; 919f97117d1SArtem B. Bityutskiy 920f97117d1SArtem B. Bityutskiy case INO_STATE_READING: 921f97117d1SArtem B. Bityutskiy case INO_STATE_PRESENT: 922f97117d1SArtem B. Bityutskiy /* Eep. This should never happen. It can 923f97117d1SArtem B. Bityutskiy happen if Linux calls read_inode() again 924f97117d1SArtem B. Bityutskiy before clear_inode() has finished though. */ 925e0d60137SArtem B. Bityutskiy JFFS2_ERROR("Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state); 926f97117d1SArtem B. Bityutskiy /* Fail. That's probably better than allowing it to succeed */ 927f97117d1SArtem B. Bityutskiy f->inocache = NULL; 928f97117d1SArtem B. Bityutskiy break; 929f97117d1SArtem B. Bityutskiy 930f97117d1SArtem B. Bityutskiy default: 931f97117d1SArtem B. Bityutskiy BUG(); 932f97117d1SArtem B. Bityutskiy } 933f97117d1SArtem B. Bityutskiy } 934f97117d1SArtem B. Bityutskiy spin_unlock(&c->inocache_lock); 935f97117d1SArtem B. Bityutskiy 936f97117d1SArtem B. Bityutskiy if (!f->inocache && ino == 1) { 937f97117d1SArtem B. Bityutskiy /* Special case - no root inode on medium */ 938f97117d1SArtem B. Bityutskiy f->inocache = jffs2_alloc_inode_cache(); 939f97117d1SArtem B. Bityutskiy if (!f->inocache) { 940e0d60137SArtem B. Bityutskiy JFFS2_ERROR("cannot allocate inocache for root inode\n"); 941f97117d1SArtem B. Bityutskiy return -ENOMEM; 942f97117d1SArtem B. Bityutskiy } 943733802d9SArtem B. Bityutskiy dbg_readinode("creating inocache for root inode\n"); 944f97117d1SArtem B. Bityutskiy memset(f->inocache, 0, sizeof(struct jffs2_inode_cache)); 945f97117d1SArtem B. Bityutskiy f->inocache->ino = f->inocache->nlink = 1; 946f97117d1SArtem B. Bityutskiy f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 947f97117d1SArtem B. Bityutskiy f->inocache->state = INO_STATE_READING; 948f97117d1SArtem B. Bityutskiy jffs2_add_ino_cache(c, f->inocache); 949f97117d1SArtem B. Bityutskiy } 950f97117d1SArtem B. Bityutskiy if (!f->inocache) { 951e0d60137SArtem B. Bityutskiy JFFS2_ERROR("requestied to read an nonexistent ino %u\n", ino); 952f97117d1SArtem B. Bityutskiy return -ENOENT; 953f97117d1SArtem B. Bityutskiy } 954f97117d1SArtem B. Bityutskiy 955f97117d1SArtem B. Bityutskiy return jffs2_do_read_inode_internal(c, f, latest_node); 956f97117d1SArtem B. Bityutskiy } 957f97117d1SArtem B. Bityutskiy 958f97117d1SArtem B. Bityutskiy int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic) 959f97117d1SArtem B. Bityutskiy { 960f97117d1SArtem B. Bityutskiy struct jffs2_raw_inode n; 9613d375d9eSYan Burman struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL); 962f97117d1SArtem B. Bityutskiy int ret; 963f97117d1SArtem B. Bityutskiy 964f97117d1SArtem B. Bityutskiy if (!f) 965f97117d1SArtem B. Bityutskiy return -ENOMEM; 966f97117d1SArtem B. Bityutskiy 967f97117d1SArtem B. Bityutskiy init_MUTEX_LOCKED(&f->sem); 968f97117d1SArtem B. Bityutskiy f->inocache = ic; 969f97117d1SArtem B. Bityutskiy 970f97117d1SArtem B. Bityutskiy ret = jffs2_do_read_inode_internal(c, f, &n); 971f97117d1SArtem B. Bityutskiy if (!ret) { 972f97117d1SArtem B. Bityutskiy up(&f->sem); 973f97117d1SArtem B. Bityutskiy jffs2_do_clear_inode(c, f); 974f97117d1SArtem B. Bityutskiy } 975f97117d1SArtem B. Bityutskiy kfree (f); 976f97117d1SArtem B. Bityutskiy return ret; 977f97117d1SArtem B. Bityutskiy } 978f97117d1SArtem B. Bityutskiy 9791da177e4SLinus Torvalds void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f) 9801da177e4SLinus Torvalds { 9811da177e4SLinus Torvalds struct jffs2_full_dirent *fd, *fds; 9821da177e4SLinus Torvalds int deleted; 9831da177e4SLinus Torvalds 984c7afb0f9SKaiGai Kohei jffs2_clear_acl(f); 985355ed4e1SKaiGai Kohei jffs2_xattr_delete_inode(c, f->inocache); 9861da177e4SLinus Torvalds down(&f->sem); 9871da177e4SLinus Torvalds deleted = f->inocache && !f->inocache->nlink; 9881da177e4SLinus Torvalds 98967e345d1SDavid Woodhouse if (f->inocache && f->inocache->state != INO_STATE_CHECKING) 99067e345d1SDavid Woodhouse jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING); 99167e345d1SDavid Woodhouse 9921da177e4SLinus Torvalds if (f->metadata) { 9931da177e4SLinus Torvalds if (deleted) 9941da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 9951da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); 9991da177e4SLinus Torvalds 10002b79adccSArtem B. Bityutskiy if (f->target) { 10012b79adccSArtem B. Bityutskiy kfree(f->target); 10022b79adccSArtem B. Bityutskiy f->target = NULL; 100332f1a95dSArtem B. Bityuckiy } 10041da177e4SLinus Torvalds 10052b79adccSArtem B. Bityutskiy fds = f->dents; 10061da177e4SLinus Torvalds while(fds) { 10071da177e4SLinus Torvalds fd = fds; 10081da177e4SLinus Torvalds fds = fd->next; 10091da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds 101267e345d1SDavid Woodhouse if (f->inocache && f->inocache->state != INO_STATE_CHECKING) { 10131da177e4SLinus Torvalds jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 101467e345d1SDavid Woodhouse if (f->inocache->nodes == (void *)f->inocache) 101567e345d1SDavid Woodhouse jffs2_del_ino_cache(c, f->inocache); 101667e345d1SDavid Woodhouse } 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds up(&f->sem); 10191da177e4SLinus Torvalds } 1020