1/* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright �� 2001-2007 Red Hat, Inc. 5 * 6 * Created by David Woodhouse <dwmw2@infradead.org> 7 * 8 * For licensing information, see the file 'LICENCE' in this directory. 9 * 10 */ 11 12#include <linux/kernel.h> 13#include <linux/slab.h> 14#include <linux/crc32.h> 15#include <linux/pagemap.h> 16#include <linux/mtd/mtd.h> 17#include <linux/compiler.h> 18#include "nodelist.h" 19#include "compr.h" 20 21int jffs2_read_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 22 struct jffs2_full_dnode *fd, unsigned char *buf, 23 int ofs, int len) 24{ 25 struct jffs2_raw_inode *ri; 26 size_t readlen; 27 uint32_t crc; 28 unsigned char *decomprbuf = NULL; 29 unsigned char *readbuf = NULL; 30 int ret = 0; 31 32 ri = jffs2_alloc_raw_inode(); 33 if (!ri) 34 return -ENOMEM; 35 36 ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri); 37 if (ret) { 38 jffs2_free_raw_inode(ri); 39 printk(KERN_WARNING "Error reading node from 0x%08x: %d\n", ref_offset(fd->raw), ret); 40 return ret; 41 } 42 if (readlen != sizeof(*ri)) { 43 jffs2_free_raw_inode(ri); 44 printk(KERN_WARNING "Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n", 45 ref_offset(fd->raw), sizeof(*ri), readlen); 46 return -EIO; 47 } 48 crc = crc32(0, ri, sizeof(*ri)-8); 49 50 D1(printk(KERN_DEBUG "Node read from %08x: node_crc %08x, calculated CRC %08x. dsize %x, csize %x, offset %x, buf %p\n", 51 ref_offset(fd->raw), je32_to_cpu(ri->node_crc), 52 crc, je32_to_cpu(ri->dsize), je32_to_cpu(ri->csize), 53 je32_to_cpu(ri->offset), buf)); 54 if (crc != je32_to_cpu(ri->node_crc)) { 55 printk(KERN_WARNING "Node CRC %08x != calculated CRC %08x for node at %08x\n", 56 je32_to_cpu(ri->node_crc), crc, ref_offset(fd->raw)); 57 ret = -EIO; 58 goto out_ri; 59 } 60 /* There was a bug where we wrote hole nodes out with csize/dsize 61 swapped. Deal with it */ 62 if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) && 63 je32_to_cpu(ri->csize)) { 64 ri->dsize = ri->csize; 65 ri->csize = cpu_to_je32(0); 66 } 67 68 D1(if(ofs + len > je32_to_cpu(ri->dsize)) { 69 printk(KERN_WARNING "jffs2_read_dnode() asked for %d bytes at %d from %d-byte node\n", 70 len, ofs, je32_to_cpu(ri->dsize)); 71 ret = -EINVAL; 72 goto out_ri; 73 }); 74 75 76 if (ri->compr == JFFS2_COMPR_ZERO) { 77 memset(buf, 0, len); 78 goto out_ri; 79 } 80 81 /* Cases: 82 Reading whole node and it's uncompressed - read directly to buffer provided, check CRC. 83 Reading whole node and it's compressed - read into comprbuf, check CRC and decompress to buffer provided 84 Reading partial node and it's uncompressed - read into readbuf, check CRC, and copy 85 Reading partial node and it's compressed - read into readbuf, check checksum, decompress to decomprbuf and copy 86 */ 87 if (ri->compr == JFFS2_COMPR_NONE && len == je32_to_cpu(ri->dsize)) { 88 readbuf = buf; 89 } else { 90 readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL); 91 if (!readbuf) { 92 ret = -ENOMEM; 93 goto out_ri; 94 } 95 } 96 if (ri->compr != JFFS2_COMPR_NONE) { 97 if (len < je32_to_cpu(ri->dsize)) { 98 decomprbuf = kmalloc(je32_to_cpu(ri->dsize), GFP_KERNEL); 99 if (!decomprbuf) { 100 ret = -ENOMEM; 101 goto out_readbuf; 102 } 103 } else { 104 decomprbuf = buf; 105 } 106 } else { 107 decomprbuf = readbuf; 108 } 109 110 D2(printk(KERN_DEBUG "Read %d bytes to %p\n", je32_to_cpu(ri->csize), 111 readbuf)); 112 ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri), 113 je32_to_cpu(ri->csize), &readlen, readbuf); 114 115 if (!ret && readlen != je32_to_cpu(ri->csize)) 116 ret = -EIO; 117 if (ret) 118 goto out_decomprbuf; 119 120 crc = crc32(0, readbuf, je32_to_cpu(ri->csize)); 121 if (crc != je32_to_cpu(ri->data_crc)) { 122 printk(KERN_WARNING "Data CRC %08x != calculated CRC %08x for node at %08x\n", 123 je32_to_cpu(ri->data_crc), crc, ref_offset(fd->raw)); 124 ret = -EIO; 125 goto out_decomprbuf; 126 } 127 D2(printk(KERN_DEBUG "Data CRC matches calculated CRC %08x\n", crc)); 128 if (ri->compr != JFFS2_COMPR_NONE) { 129 D2(printk(KERN_DEBUG "Decompress %d bytes from %p to %d bytes at %p\n", 130 je32_to_cpu(ri->csize), readbuf, je32_to_cpu(ri->dsize), decomprbuf)); 131 ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize)); 132 if (ret) { 133 printk(KERN_WARNING "Error: jffs2_decompress returned %d\n", ret); 134 goto out_decomprbuf; 135 } 136 } 137 138 if (len < je32_to_cpu(ri->dsize)) { 139 memcpy(buf, decomprbuf+ofs, len); 140 } 141 out_decomprbuf: 142 if(decomprbuf != buf && decomprbuf != readbuf) 143 kfree(decomprbuf); 144 out_readbuf: 145 if(readbuf != buf) 146 kfree(readbuf); 147 out_ri: 148 jffs2_free_raw_inode(ri); 149 150 return ret; 151} 152 153int jffs2_read_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 154 unsigned char *buf, uint32_t offset, uint32_t len) 155{ 156 uint32_t end = offset + len; 157 struct jffs2_node_frag *frag; 158 int ret; 159 160 D1(printk(KERN_DEBUG "jffs2_read_inode_range: ino #%u, range 0x%08x-0x%08x\n", 161 f->inocache->ino, offset, offset+len)); 162 163 frag = jffs2_lookup_node_frag(&f->fragtree, offset); 164 165 /* Now we're pointing at the first frag which overlaps our page */ 166 while(offset < end) { 167 D2(printk(KERN_DEBUG "jffs2_read_inode_range: offset %d, end %d\n", offset, end)); 168 if (unlikely(!frag || frag->ofs > offset)) { 169 uint32_t holesize = end - offset; 170 if (frag) { 171 D1(printk(KERN_NOTICE "Eep. Hole in ino #%u fraglist. frag->ofs = 0x%08x, offset = 0x%08x\n", f->inocache->ino, frag->ofs, offset)); 172 holesize = min(holesize, frag->ofs - offset); 173 } 174 D1(printk(KERN_DEBUG "Filling non-frag hole from %d-%d\n", offset, offset+holesize)); 175 memset(buf, 0, holesize); 176 buf += holesize; 177 offset += holesize; 178 continue; 179 } else if (unlikely(!frag->node)) { 180 uint32_t holeend = min(end, frag->ofs + frag->size); 181 D1(printk(KERN_DEBUG "Filling frag hole from %d-%d (frag 0x%x 0x%x)\n", offset, holeend, frag->ofs, frag->ofs + frag->size)); 182 memset(buf, 0, holeend - offset); 183 buf += holeend - offset; 184 offset = holeend; 185 frag = frag_next(frag); 186 continue; 187 } else { 188 uint32_t readlen; 189 uint32_t fragofs; /* offset within the frag to start reading */ 190 191 fragofs = offset - frag->ofs; 192 readlen = min(frag->size - fragofs, end - offset); 193 D1(printk(KERN_DEBUG "Reading %d-%d from node at 0x%08x (%d)\n", 194 frag->ofs+fragofs, frag->ofs+fragofs+readlen, 195 ref_offset(frag->node->raw), ref_flags(frag->node->raw))); 196 ret = jffs2_read_dnode(c, f, frag->node, buf, fragofs + frag->ofs - frag->node->ofs, readlen); 197 D2(printk(KERN_DEBUG "node read done\n")); 198 if (ret) { 199 D1(printk(KERN_DEBUG"jffs2_read_inode_range error %d\n",ret)); 200 memset(buf, 0, readlen); 201 return ret; 202 } 203 buf += readlen; 204 offset += readlen; 205 frag = frag_next(frag); 206 D2(printk(KERN_DEBUG "node read was OK. Looping\n")); 207 } 208 } 209 return 0; 210} 211