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