Branch data Line data Source code
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/sched.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/mtd/mtd.h>
18 : : #include <linux/pagemap.h>
19 : : #include <linux/crc32.h>
20 : : #include <linux/compiler.h>
21 : : #include "nodelist.h"
22 : : #include "summary.h"
23 : : #include "debug.h"
24 : :
25 : : #define DEFAULT_EMPTY_SCAN_SIZE 256
26 : :
27 : : #define noisy_printk(noise, fmt, ...) \
28 : : do { \
29 : : if (*(noise)) { \
30 : : pr_notice(fmt, ##__VA_ARGS__); \
31 : : (*(noise))--; \
32 : : if (!(*(noise))) \
33 : : pr_notice("Further such events for this erase block will not be printed\n"); \
34 : : } \
35 : : } while (0)
36 : :
37 : : static uint32_t pseudo_random;
38 : :
39 : : static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
40 : : unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s);
41 : :
42 : : /* These helper functions _must_ increase ofs and also do the dirty/used space accounting.
43 : : * Returning an error will abort the mount - bad checksums etc. should just mark the space
44 : : * as dirty.
45 : : */
46 : : static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
47 : : struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s);
48 : : static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
49 : : struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s);
50 : :
51 : : static inline int min_free(struct jffs2_sb_info *c)
52 : : {
53 : : uint32_t min = 2 * sizeof(struct jffs2_raw_inode);
54 : : #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
55 [ # # ]: 0 : if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize)
56 : 0 : return c->wbuf_pagesize;
57 : : #endif
58 : : return min;
59 : :
60 : : }
61 : :
62 : : static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) {
63 [ # # ][ # # ]: 0 : if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
[ # # ]
64 : : return sector_size;
65 : : else
66 : : return DEFAULT_EMPTY_SCAN_SIZE;
67 : : }
68 : :
69 : 0 : static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
70 : : {
71 : : int ret;
72 : :
73 [ # # ]: 0 : if ((ret = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
74 : : return ret;
75 [ # # ]: 0 : if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size)))
76 : : return ret;
77 : : /* Turned wasted size into dirty, since we apparently
78 : : think it's recoverable now. */
79 : 0 : jeb->dirty_size += jeb->wasted_size;
80 : 0 : c->dirty_size += jeb->wasted_size;
81 : 0 : c->wasted_size -= jeb->wasted_size;
82 : 0 : jeb->wasted_size = 0;
83 [ # # ]: 0 : if (VERYDIRTY(c, jeb->dirty_size)) {
84 : 0 : list_add(&jeb->list, &c->very_dirty_list);
85 : : } else {
86 : 0 : list_add(&jeb->list, &c->dirty_list);
87 : : }
88 : : return 0;
89 : : }
90 : :
91 : 0 : int jffs2_scan_medium(struct jffs2_sb_info *c)
92 : : {
93 : : int i, ret;
94 : : uint32_t empty_blocks = 0, bad_blocks = 0;
95 : 0 : unsigned char *flashbuf = NULL;
96 : : uint32_t buf_size = 0;
97 : : struct jffs2_summary *s = NULL; /* summary info collected by the scan process */
98 : : #ifndef __ECOS
99 : : size_t pointlen, try_size;
100 : :
101 : 0 : ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen,
102 : : (void **)&flashbuf, NULL);
103 [ # # ][ # # ]: 0 : if (!ret && pointlen < c->mtd->size) {
104 : : /* Don't muck about if it won't let us point to the whole flash */
105 : : jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n",
106 : : pointlen);
107 : 0 : mtd_unpoint(c->mtd, 0, pointlen);
108 : 0 : flashbuf = NULL;
109 : : }
110 : : if (ret && ret != -EOPNOTSUPP)
111 : : jffs2_dbg(1, "MTD point failed %d\n", ret);
112 : : #endif
113 [ # # ]: 0 : if (!flashbuf) {
114 : : /* For NAND it's quicker to read a whole eraseblock at a time,
115 : : apparently */
116 [ # # ]: 0 : if (jffs2_cleanmarker_oob(c))
117 : 0 : try_size = c->sector_size;
118 : : else
119 : 0 : try_size = PAGE_SIZE;
120 : :
121 : : jffs2_dbg(1, "Trying to allocate readbuf of %zu "
122 : : "bytes\n", try_size);
123 : :
124 : 0 : flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
125 [ # # ]: 0 : if (!flashbuf)
126 : : return -ENOMEM;
127 : :
128 : : jffs2_dbg(1, "Allocated readbuf of %zu bytes\n",
129 : : try_size);
130 : :
131 : 0 : buf_size = (uint32_t)try_size;
132 : : }
133 : :
134 : : if (jffs2_sum_active()) {
135 : : s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
136 [ # # ]: 0 : if (!s) {
137 : 0 : JFFS2_WARNING("Can't allocate memory for summary\n");
138 : : ret = -ENOMEM;
139 : 0 : goto out;
140 : : }
141 : : }
142 : :
143 [ # # ]: 0 : for (i=0; i<c->nr_blocks; i++) {
144 : 0 : struct jffs2_eraseblock *jeb = &c->blocks[i];
145 : :
146 : 0 : cond_resched();
147 : :
148 : : /* reset summary info for next eraseblock scan */
149 : 0 : jffs2_sum_reset_collected(s);
150 : :
151 [ # # ]: 0 : ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset),
152 : : buf_size, s);
153 : :
154 [ # # ]: 0 : if (ret < 0)
155 : : goto out;
156 : :
157 : : jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
158 : :
159 : : /* Now decide which list to put it on */
160 [ # # # # : 0 : switch(ret) {
# # # ]
161 : : case BLK_STATE_ALLFF:
162 : : /*
163 : : * Empty block. Since we can't be sure it
164 : : * was entirely erased, we just queue it for erase
165 : : * again. It will be marked as such when the erase
166 : : * is complete. Meanwhile we still count it as empty
167 : : * for later checks.
168 : : */
169 : 0 : empty_blocks++;
170 : 0 : list_add(&jeb->list, &c->erase_pending_list);
171 : 0 : c->nr_erasing_blocks++;
172 : 0 : break;
173 : :
174 : : case BLK_STATE_CLEANMARKER:
175 : : /* Only a CLEANMARKER node is valid */
176 [ # # ]: 0 : if (!jeb->dirty_size) {
177 : : /* It's actually free */
178 : 0 : list_add(&jeb->list, &c->free_list);
179 : 0 : c->nr_free_blocks++;
180 : : } else {
181 : : /* Dirt */
182 : : jffs2_dbg(1, "Adding all-dirty block at 0x%08x to erase_pending_list\n",
183 : : jeb->offset);
184 : 0 : list_add(&jeb->list, &c->erase_pending_list);
185 : 0 : c->nr_erasing_blocks++;
186 : : }
187 : : break;
188 : :
189 : : case BLK_STATE_CLEAN:
190 : : /* Full (or almost full) of clean data. Clean list */
191 : 0 : list_add(&jeb->list, &c->clean_list);
192 : : break;
193 : :
194 : : case BLK_STATE_PARTDIRTY:
195 : : /* Some data, but not full. Dirty list. */
196 : : /* We want to remember the block with most free space
197 : : and stick it in the 'nextblock' position to start writing to it. */
198 [ # # ][ # # ]: 0 : if (jeb->free_size > min_free(c) &&
199 [ # # ]: 0 : (!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
200 : : /* Better candidate for the next writes to go to */
201 [ # # ]: 0 : if (c->nextblock) {
202 : 0 : ret = file_dirty(c, c->nextblock);
203 [ # # ]: 0 : if (ret)
204 : : goto out;
205 : : /* deleting summary information of the old nextblock */
206 : 0 : jffs2_sum_reset_collected(c->summary);
207 : : }
208 : : /* update collected summary information for the current nextblock */
209 : 0 : jffs2_sum_move_collected(c, s);
210 : : jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n",
211 : : __func__, jeb->offset);
212 : 0 : c->nextblock = jeb;
213 : : } else {
214 : 0 : ret = file_dirty(c, jeb);
215 [ # # ]: 0 : if (ret)
216 : : goto out;
217 : : }
218 : : break;
219 : :
220 : : case BLK_STATE_ALLDIRTY:
221 : : /* Nothing valid - not even a clean marker. Needs erasing. */
222 : : /* For now we just put it on the erasing list. We'll start the erases later */
223 : : jffs2_dbg(1, "Erase block at 0x%08x is not formatted. It will be erased\n",
224 : : jeb->offset);
225 : 0 : list_add(&jeb->list, &c->erase_pending_list);
226 : 0 : c->nr_erasing_blocks++;
227 : 0 : break;
228 : :
229 : : case BLK_STATE_BADBLOCK:
230 : : jffs2_dbg(1, "Block at 0x%08x is bad\n", jeb->offset);
231 : 0 : list_add(&jeb->list, &c->bad_list);
232 : 0 : c->bad_size += c->sector_size;
233 : 0 : c->free_size -= c->sector_size;
234 : 0 : bad_blocks++;
235 : 0 : break;
236 : : default:
237 : 0 : pr_warn("%s(): unknown block state\n", __func__);
238 : 0 : BUG();
239 : : }
240 : : }
241 : :
242 : : /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
243 [ # # ][ # # ]: 0 : if (c->nextblock && (c->nextblock->dirty_size)) {
244 : 0 : c->nextblock->wasted_size += c->nextblock->dirty_size;
245 : 0 : c->wasted_size += c->nextblock->dirty_size;
246 : 0 : c->dirty_size -= c->nextblock->dirty_size;
247 : 0 : c->nextblock->dirty_size = 0;
248 : : }
249 : : #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
250 [ # # ][ # # ]: 0 : if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) {
[ # # ]
251 : : /* If we're going to start writing into a block which already
252 : : contains data, and the end of the data isn't page-aligned,
253 : : skip a little and align it. */
254 : :
255 : : uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize;
256 : :
257 : : jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n",
258 : : __func__, skip);
259 : 0 : jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
260 : 0 : jffs2_scan_dirty_space(c, c->nextblock, skip);
261 : : }
262 : : #endif
263 [ # # ]: 0 : if (c->nr_erasing_blocks) {
264 [ # # ][ # # ]: 0 : if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
[ # # ]
265 : 0 : pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
266 : 0 : pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
267 : : empty_blocks, bad_blocks, c->nr_blocks);
268 : : ret = -EIO;
269 : 0 : goto out;
270 : : }
271 : : spin_lock(&c->erase_completion_lock);
272 : 0 : jffs2_garbage_collect_trigger(c);
273 : : spin_unlock(&c->erase_completion_lock);
274 : : }
275 : : ret = 0;
276 : : out:
277 [ # # ]: 0 : if (buf_size)
278 : 0 : kfree(flashbuf);
279 : : #ifndef __ECOS
280 : : else
281 : 0 : mtd_unpoint(c->mtd, 0, c->mtd->size);
282 : : #endif
283 : 0 : kfree(s);
284 : 0 : return ret;
285 : : }
286 : :
287 : 0 : static int jffs2_fill_scan_buf(struct jffs2_sb_info *c, void *buf,
288 : : uint32_t ofs, uint32_t len)
289 : : {
290 : : int ret;
291 : : size_t retlen;
292 : :
293 : 0 : ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
294 [ # # ]: 0 : if (ret) {
295 : : jffs2_dbg(1, "mtd->read(0x%x bytes from 0x%x) returned %d\n",
296 : : len, ofs, ret);
297 : : return ret;
298 : : }
299 [ # # ]: 0 : if (retlen < len) {
300 : : jffs2_dbg(1, "Read at 0x%x gave only 0x%zx bytes\n",
301 : : ofs, retlen);
302 : : return -EIO;
303 : : }
304 : 0 : return 0;
305 : : }
306 : :
307 : 0 : int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
308 : : {
309 [ # # ][ # # ]: 0 : if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
310 [ # # ][ # # ]: 0 : && (!jeb->first_node || !ref_next(jeb->first_node)) )
311 : : return BLK_STATE_CLEANMARKER;
312 : :
313 : : /* move blocks with max 4 byte dirty space to cleanlist */
314 [ # # ]: 0 : else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) {
315 : 0 : c->dirty_size -= jeb->dirty_size;
316 : 0 : c->wasted_size += jeb->dirty_size;
317 : 0 : jeb->wasted_size += jeb->dirty_size;
318 : 0 : jeb->dirty_size = 0;
319 : 0 : return BLK_STATE_CLEAN;
320 [ # # ][ # # ]: 0 : } else if (jeb->used_size || jeb->unchecked_size)
321 : : return BLK_STATE_PARTDIRTY;
322 : : else
323 : 0 : return BLK_STATE_ALLDIRTY;
324 : : }
325 : :
326 : : #ifdef CONFIG_JFFS2_FS_XATTR
327 : 0 : static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
328 : : struct jffs2_raw_xattr *rx, uint32_t ofs,
329 : : struct jffs2_summary *s)
330 : : {
331 : : struct jffs2_xattr_datum *xd;
332 : : uint32_t xid, version, totlen, crc;
333 : : int err;
334 : :
335 : 0 : crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4);
336 [ # # ]: 0 : if (crc != je32_to_cpu(rx->node_crc)) {
337 : 0 : JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
338 : : ofs, je32_to_cpu(rx->node_crc), crc);
339 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen))))
340 : 0 : return err;
341 : : return 0;
342 : : }
343 : :
344 : 0 : xid = je32_to_cpu(rx->xid);
345 : 0 : version = je32_to_cpu(rx->version);
346 : :
347 : 0 : totlen = PAD(sizeof(struct jffs2_raw_xattr)
348 : : + rx->name_len + 1 + je16_to_cpu(rx->value_len));
349 [ # # ]: 0 : if (totlen != je32_to_cpu(rx->totlen)) {
350 : 0 : JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n",
351 : : ofs, je32_to_cpu(rx->totlen), totlen);
352 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen))))
353 : 0 : return err;
354 : : return 0;
355 : : }
356 : :
357 : 0 : xd = jffs2_setup_xattr_datum(c, xid, version);
358 [ # # ]: 0 : if (IS_ERR(xd))
359 : 0 : return PTR_ERR(xd);
360 : :
361 [ # # ]: 0 : if (xd->version > version) {
362 : 0 : struct jffs2_raw_node_ref *raw
363 : 0 : = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, NULL);
364 : 0 : raw->next_in_ino = xd->node->next_in_ino;
365 : 0 : xd->node->next_in_ino = raw;
366 : : } else {
367 : 0 : xd->version = version;
368 : 0 : xd->xprefix = rx->xprefix;
369 : 0 : xd->name_len = rx->name_len;
370 : 0 : xd->value_len = je16_to_cpu(rx->value_len);
371 : 0 : xd->data_crc = je32_to_cpu(rx->data_crc);
372 : :
373 : 0 : jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, (void *)xd);
374 : : }
375 : :
376 : : if (jffs2_sum_active())
377 : 0 : jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset);
378 : : dbg_xattr("scanning xdatum at %#08x (xid=%u, version=%u)\n",
379 : : ofs, xd->xid, xd->version);
380 : 0 : return 0;
381 : : }
382 : :
383 : 0 : static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
384 : : struct jffs2_raw_xref *rr, uint32_t ofs,
385 : : struct jffs2_summary *s)
386 : : {
387 : : struct jffs2_xattr_ref *ref;
388 : : uint32_t crc;
389 : : int err;
390 : :
391 : 0 : crc = crc32(0, rr, sizeof(*rr) - 4);
392 [ # # ]: 0 : if (crc != je32_to_cpu(rr->node_crc)) {
393 : 0 : JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
394 : : ofs, je32_to_cpu(rr->node_crc), crc);
395 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen)))))
396 : 0 : return err;
397 : : return 0;
398 : : }
399 : :
400 [ # # ]: 0 : if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) {
401 : 0 : JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n",
402 : : ofs, je32_to_cpu(rr->totlen),
403 : : PAD(sizeof(struct jffs2_raw_xref)));
404 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen))))
405 : 0 : return err;
406 : : return 0;
407 : : }
408 : :
409 : 0 : ref = jffs2_alloc_xattr_ref();
410 [ # # ]: 0 : if (!ref)
411 : : return -ENOMEM;
412 : :
413 : : /* BEFORE jffs2_build_xattr_subsystem() called,
414 : : * and AFTER xattr_ref is marked as a dead xref,
415 : : * ref->xid is used to store 32bit xid, xd is not used
416 : : * ref->ino is used to store 32bit inode-number, ic is not used
417 : : * Thoes variables are declared as union, thus using those
418 : : * are exclusive. In a similar way, ref->next is temporarily
419 : : * used to chain all xattr_ref object. It's re-chained to
420 : : * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly.
421 : : */
422 : 0 : ref->ino = je32_to_cpu(rr->ino);
423 : 0 : ref->xid = je32_to_cpu(rr->xid);
424 : 0 : ref->xseqno = je32_to_cpu(rr->xseqno);
425 [ # # ]: 0 : if (ref->xseqno > c->highest_xseqno)
426 : 0 : c->highest_xseqno = (ref->xseqno & ~XREF_DELETE_MARKER);
427 : 0 : ref->next = c->xref_temp;
428 : 0 : c->xref_temp = ref;
429 : :
430 : 0 : jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), (void *)ref);
431 : :
432 : : if (jffs2_sum_active())
433 : 0 : jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset);
434 : : dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n",
435 : : ofs, ref->xid, ref->ino);
436 : 0 : return 0;
437 : : }
438 : : #endif
439 : :
440 : : /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into
441 : : the flash, XIP-style */
442 : 0 : static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
443 : : unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) {
444 : : struct jffs2_unknown_node *node;
445 : : struct jffs2_unknown_node crcnode;
446 : : uint32_t ofs, prevofs, max_ofs;
447 : : uint32_t hdr_crc, buf_ofs, buf_len;
448 : : int err;
449 : : int noise = 0;
450 : :
451 : :
452 : : #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
453 : : int cleanmarkerfound = 0;
454 : : #endif
455 : :
456 : : ofs = jeb->offset;
457 : 0 : prevofs = jeb->offset - 1;
458 : :
459 : : jffs2_dbg(1, "%s(): Scanning block at 0x%x\n", __func__, ofs);
460 : :
461 : : #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
462 [ # # ]: 0 : if (jffs2_cleanmarker_oob(c)) {
463 : : int ret;
464 : :
465 [ # # ]: 0 : if (mtd_block_isbad(c->mtd, jeb->offset))
466 : : return BLK_STATE_BADBLOCK;
467 : :
468 : 0 : ret = jffs2_check_nand_cleanmarker(c, jeb);
469 : : jffs2_dbg(2, "jffs_check_nand_cleanmarker returned %d\n", ret);
470 : :
471 : : /* Even if it's not found, we still scan to see
472 : : if the block is empty. We use this information
473 : : to decide whether to erase it or not. */
474 [ # # # ]: 0 : switch (ret) {
475 : 0 : case 0: cleanmarkerfound = 1; break;
476 : : case 1: break;
477 : : default: return ret;
478 : : }
479 : : }
480 : : #endif
481 : :
482 : : if (jffs2_sum_active()) {
483 : : struct jffs2_sum_marker *sm;
484 : : void *sumptr = NULL;
485 : : uint32_t sumlen;
486 : :
487 [ # # ]: 0 : if (!buf_size) {
488 : : /* XIP case. Just look, point at the summary if it's there */
489 : 0 : sm = (void *)buf + c->sector_size - sizeof(*sm);
490 [ # # ]: 0 : if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
491 : 0 : sumptr = buf + je32_to_cpu(sm->offset);
492 : 0 : sumlen = c->sector_size - je32_to_cpu(sm->offset);
493 : : }
494 : : } else {
495 : : /* If NAND flash, read a whole page of it. Else just the end */
496 [ # # ]: 0 : if (c->wbuf_pagesize)
497 : : buf_len = c->wbuf_pagesize;
498 : : else
499 : : buf_len = sizeof(*sm);
500 : :
501 : : /* Read as much as we want into the _end_ of the preallocated buffer */
502 : 0 : err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len,
503 : 0 : jeb->offset + c->sector_size - buf_len,
504 : : buf_len);
505 [ # # ]: 0 : if (err)
506 : : return err;
507 : :
508 : 0 : sm = (void *)buf + buf_size - sizeof(*sm);
509 [ # # ]: 0 : if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
510 : 0 : sumlen = c->sector_size - je32_to_cpu(sm->offset);
511 : 0 : sumptr = buf + buf_size - sumlen;
512 : :
513 : : /* Now, make sure the summary itself is available */
514 [ # # ]: 0 : if (sumlen > buf_size) {
515 : : /* Need to kmalloc for this. */
516 : : sumptr = kmalloc(sumlen, GFP_KERNEL);
517 [ # # ]: 0 : if (!sumptr)
518 : : return -ENOMEM;
519 : 0 : memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len);
520 : : }
521 [ # # ]: 0 : if (buf_len < sumlen) {
522 : : /* Need to read more so that the entire summary node is present */
523 : 0 : err = jffs2_fill_scan_buf(c, sumptr,
524 : 0 : jeb->offset + c->sector_size - sumlen,
525 : : sumlen - buf_len);
526 [ # # ]: 0 : if (err)
527 : : return err;
528 : : }
529 : : }
530 : :
531 : : }
532 : :
533 [ # # ]: 0 : if (sumptr) {
534 : 0 : err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random);
535 : :
536 [ # # ]: 0 : if (buf_size && sumlen > buf_size)
537 : 0 : kfree(sumptr);
538 : : /* If it returns with a real error, bail.
539 : : If it returns positive, that's a block classification
540 : : (i.e. BLK_STATE_xxx) so return that too.
541 : : If it returns zero, fall through to full scan. */
542 [ # # ]: 0 : if (err)
543 : : return err;
544 : : }
545 : : }
546 : :
547 : 0 : buf_ofs = jeb->offset;
548 : :
549 [ # # ]: 0 : if (!buf_size) {
550 : : /* This is the XIP case -- we're reading _directly_ from the flash chip */
551 : 0 : buf_len = c->sector_size;
552 : : } else {
553 : 0 : buf_len = EMPTY_SCAN_SIZE(c->sector_size);
554 : 0 : err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
555 [ # # ]: 0 : if (err)
556 : : return err;
557 : : }
558 : :
559 : : /* We temporarily use 'ofs' as a pointer into the buffer/jeb */
560 : : ofs = 0;
561 : 0 : max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
562 : : /* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */
563 [ # # ][ # # ]: 0 : while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
564 : 0 : ofs += 4;
565 : :
566 [ # # ]: 0 : if (ofs == max_ofs) {
567 : : #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
568 [ # # ]: 0 : if (jffs2_cleanmarker_oob(c)) {
569 : : /* scan oob, take care of cleanmarker */
570 : 0 : int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound);
571 : : jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n",
572 : : ret);
573 [ # # # ]: 0 : switch (ret) {
574 [ # # ]: 0 : case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF;
575 : : case 1: return BLK_STATE_ALLDIRTY;
576 : 0 : default: return ret;
577 : : }
578 : : }
579 : : #endif
580 : : jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n",
581 : : jeb->offset);
582 [ # # ]: 0 : if (c->cleanmarker_size == 0)
583 : : return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */
584 : : else
585 : 0 : return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */
586 : : }
587 [ # # ]: 0 : if (ofs) {
588 : : jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset,
589 : : jeb->offset + ofs);
590 [ # # ]: 0 : if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
591 : : return err;
592 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
593 : : return err;
594 : : }
595 : :
596 : : /* Now ofs is a complete physical flash offset as it always was... */
597 : 0 : ofs += jeb->offset;
598 : :
599 : : noise = 10;
600 : :
601 : : dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset);
602 : :
603 : : scan_more:
604 [ # # ]: 0 : while(ofs < jeb->offset + c->sector_size) {
605 : :
606 : : jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
607 : :
608 : : /* Make sure there are node refs available for use */
609 : 0 : err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
610 [ # # ]: 0 : if (err)
611 : : return err;
612 : :
613 : 0 : cond_resched();
614 : :
615 [ # # ]: 0 : if (ofs & 3) {
616 : 0 : pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
617 : 0 : ofs = PAD(ofs);
618 : 0 : continue;
619 : : }
620 [ # # ]: 0 : if (ofs == prevofs) {
621 : 0 : pr_warn("ofs 0x%08x has already been seen. Skipping\n",
622 : : ofs);
623 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
624 : : return err;
625 : 0 : ofs += 4;
626 : 0 : continue;
627 : : }
628 : : prevofs = ofs;
629 : :
630 [ # # ]: 0 : if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
631 : : jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n",
632 : : sizeof(struct jffs2_unknown_node),
633 : : jeb->offset, c->sector_size, ofs,
634 : : sizeof(*node));
635 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
636 : : return err;
637 : : break;
638 : : }
639 : :
640 [ # # ]: 0 : if (buf_ofs + buf_len < ofs + sizeof(*node)) {
641 : 0 : buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
642 : : jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
643 : : sizeof(struct jffs2_unknown_node),
644 : : buf_len, ofs);
645 : 0 : err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
646 [ # # ]: 0 : if (err)
647 : : return err;
648 : : buf_ofs = ofs;
649 : : }
650 : :
651 : 0 : node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
652 : :
653 [ # # ]: 0 : if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
654 : : uint32_t inbuf_ofs;
655 : : uint32_t empty_start, scan_end;
656 : :
657 : : empty_start = ofs;
658 : 0 : ofs += 4;
659 : 0 : scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
660 : :
661 : : jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs);
662 : : more_empty:
663 : 0 : inbuf_ofs = ofs - buf_ofs;
664 [ # # ]: 0 : while (inbuf_ofs < scan_end) {
665 [ # # ]: 0 : if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
666 : 0 : pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
667 : : empty_start, ofs);
668 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
669 : : return err;
670 : : goto scan_more;
671 : : }
672 : :
673 : 0 : inbuf_ofs+=4;
674 : 0 : ofs += 4;
675 : : }
676 : : /* Ran off end. */
677 : : jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n",
678 : : ofs);
679 : :
680 : : /* If we're only checking the beginning of a block with a cleanmarker,
681 : : bail now */
682 [ # # ][ # # ]: 0 : if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
[ # # ]
683 [ # # ][ # # ]: 0 : c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
684 : : jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n",
685 : : EMPTY_SCAN_SIZE(c->sector_size));
686 : : return BLK_STATE_CLEANMARKER;
687 : : }
688 [ # # ]: 0 : if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */
689 : : scan_end = buf_len;
690 : : goto more_empty;
691 : : }
692 : :
693 : : /* See how much more there is to read in this eraseblock... */
694 : 0 : buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
695 [ # # ]: 0 : if (!buf_len) {
696 : : /* No more to read. Break out of main loop without marking
697 : : this range of empty space as dirty (because it's not) */
698 : : jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n",
699 : : empty_start);
700 : : break;
701 : : }
702 : : /* point never reaches here */
703 : : scan_end = buf_len;
704 : : jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n",
705 : : buf_len, ofs);
706 : 0 : err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
707 [ # # ]: 0 : if (err)
708 : : return err;
709 : : buf_ofs = ofs;
710 : : goto more_empty;
711 : : }
712 : :
713 [ # # ][ # # ]: 0 : if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
714 : 0 : pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
715 : : ofs);
716 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
717 : : return err;
718 : 0 : ofs += 4;
719 : 0 : continue;
720 : : }
721 [ # # ]: 0 : if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
722 : : jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs);
723 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
724 : : return err;
725 : 0 : ofs += 4;
726 : 0 : continue;
727 : : }
728 [ # # ]: 0 : if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
729 : 0 : pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs);
730 : 0 : pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
731 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
732 : : return err;
733 : 0 : ofs += 4;
734 : 0 : continue;
735 : : }
736 [ # # ]: 0 : if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
737 : : /* OK. We're out of possibilities. Whinge and move on */
738 [ # # ][ # # ]: 0 : noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
739 : : __func__,
740 : : JFFS2_MAGIC_BITMASK, ofs,
741 : : je16_to_cpu(node->magic));
742 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
743 : : return err;
744 : 0 : ofs += 4;
745 : 0 : continue;
746 : : }
747 : : /* We seem to have a node of sorts. Check the CRC */
748 : 0 : crcnode.magic = node->magic;
749 : 0 : crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
750 : 0 : crcnode.totlen = node->totlen;
751 : 0 : hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
752 : :
753 [ # # ]: 0 : if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
754 [ # # ][ # # ]: 0 : noisy_printk(&noise, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n",
755 : : __func__,
756 : : ofs, je16_to_cpu(node->magic),
757 : : je16_to_cpu(node->nodetype),
758 : : je32_to_cpu(node->totlen),
759 : : je32_to_cpu(node->hdr_crc),
760 : : hdr_crc);
761 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
762 : : return err;
763 : 0 : ofs += 4;
764 : 0 : continue;
765 : : }
766 : :
767 [ # # ]: 0 : if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) {
768 : : /* Eep. Node goes over the end of the erase block. */
769 : 0 : pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
770 : : ofs, je32_to_cpu(node->totlen));
771 : 0 : pr_warn("Perhaps the file system was created with the wrong erase size?\n");
772 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
773 : : return err;
774 : 0 : ofs += 4;
775 : 0 : continue;
776 : : }
777 : :
778 [ # # ]: 0 : if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
779 : : /* Wheee. This is an obsoleted node */
780 : : jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n",
781 : : ofs);
782 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
783 : : return err;
784 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
785 : 0 : continue;
786 : : }
787 : :
788 [ # # # # : 0 : switch(je16_to_cpu(node->nodetype)) {
# # # ]
789 : : case JFFS2_NODETYPE_INODE:
790 [ # # ]: 0 : if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
791 : 0 : buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
792 : : jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
793 : : sizeof(struct jffs2_raw_inode),
794 : : buf_len, ofs);
795 : 0 : err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
796 [ # # ]: 0 : if (err)
797 : : return err;
798 : : buf_ofs = ofs;
799 : : node = (void *)buf;
800 : : }
801 : 0 : err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s);
802 [ # # ]: 0 : if (err) return err;
803 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
804 : 0 : break;
805 : :
806 : : case JFFS2_NODETYPE_DIRENT:
807 [ # # ]: 0 : if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
808 : 0 : buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
809 : : jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
810 : : je32_to_cpu(node->totlen), buf_len,
811 : : ofs);
812 : 0 : err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
813 [ # # ]: 0 : if (err)
814 : : return err;
815 : : buf_ofs = ofs;
816 : : node = (void *)buf;
817 : : }
818 : 0 : err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s);
819 [ # # ]: 0 : if (err) return err;
820 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
821 : 0 : break;
822 : :
823 : : #ifdef CONFIG_JFFS2_FS_XATTR
824 : : case JFFS2_NODETYPE_XATTR:
825 [ # # ]: 0 : if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
826 : 0 : buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
827 : : jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n",
828 : : je32_to_cpu(node->totlen), buf_len,
829 : : ofs);
830 : 0 : err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
831 [ # # ]: 0 : if (err)
832 : : return err;
833 : : buf_ofs = ofs;
834 : : node = (void *)buf;
835 : : }
836 : 0 : err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s);
837 [ # # ]: 0 : if (err)
838 : : return err;
839 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
840 : 0 : break;
841 : : case JFFS2_NODETYPE_XREF:
842 [ # # ]: 0 : if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
843 : 0 : buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
844 : : jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n",
845 : : je32_to_cpu(node->totlen), buf_len,
846 : : ofs);
847 : 0 : err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
848 [ # # ]: 0 : if (err)
849 : : return err;
850 : : buf_ofs = ofs;
851 : : node = (void *)buf;
852 : : }
853 : 0 : err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s);
854 [ # # ]: 0 : if (err)
855 : : return err;
856 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
857 : 0 : break;
858 : : #endif /* CONFIG_JFFS2_FS_XATTR */
859 : :
860 : : case JFFS2_NODETYPE_CLEANMARKER:
861 : : jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs);
862 [ # # ]: 0 : if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
863 : 0 : pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
864 : : ofs, je32_to_cpu(node->totlen),
865 : : c->cleanmarker_size);
866 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
867 : : return err;
868 : : ofs += PAD(sizeof(struct jffs2_unknown_node));
869 [ # # ]: 0 : } else if (jeb->first_node) {
870 : 0 : pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
871 : : ofs, jeb->offset);
872 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
873 : : return err;
874 : : ofs += PAD(sizeof(struct jffs2_unknown_node));
875 : : } else {
876 : 0 : jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL);
877 : :
878 : 0 : ofs += PAD(c->cleanmarker_size);
879 : : }
880 : : break;
881 : :
882 : : case JFFS2_NODETYPE_PADDING:
883 : : if (jffs2_sum_active())
884 : 0 : jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen));
885 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
886 : : return err;
887 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
888 : 0 : break;
889 : :
890 : : default:
891 [ # # # # : 0 : switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
# ]
892 : : case JFFS2_FEATURE_ROCOMPAT:
893 : 0 : pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
894 : : je16_to_cpu(node->nodetype), ofs);
895 : 0 : c->flags |= JFFS2_SB_FLAG_RO;
896 [ # # ]: 0 : if (!(jffs2_is_readonly(c)))
897 : : return -EROFS;
898 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
899 : : return err;
900 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
901 : 0 : break;
902 : :
903 : : case JFFS2_FEATURE_INCOMPAT:
904 : 0 : pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
905 : : je16_to_cpu(node->nodetype), ofs);
906 : 0 : return -EINVAL;
907 : :
908 : : case JFFS2_FEATURE_RWCOMPAT_DELETE:
909 : : jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
910 : : je16_to_cpu(node->nodetype), ofs);
911 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
912 : : return err;
913 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
914 : 0 : break;
915 : :
916 : : case JFFS2_FEATURE_RWCOMPAT_COPY: {
917 : : jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
918 : : je16_to_cpu(node->nodetype), ofs);
919 : :
920 : 0 : jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
921 : :
922 : : /* We can't summarise nodes we don't grok */
923 : 0 : jffs2_sum_disable_collecting(s);
924 : 0 : ofs += PAD(je32_to_cpu(node->totlen));
925 : 0 : break;
926 : : }
927 : : }
928 : : }
929 : : }
930 : :
931 : : if (jffs2_sum_active()) {
932 [ # # ]: 0 : if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) {
933 : : dbg_summary("There is not enough space for "
934 : : "summary information, disabling for this jeb!\n");
935 : 0 : jffs2_sum_disable_collecting(s);
936 : : }
937 : : }
938 : :
939 : : jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
940 : : jeb->offset, jeb->free_size, jeb->dirty_size,
941 : : jeb->unchecked_size, jeb->used_size, jeb->wasted_size);
942 : :
943 : : /* mark_node_obsolete can add to wasted !! */
944 [ # # ]: 0 : if (jeb->wasted_size) {
945 : 0 : jeb->dirty_size += jeb->wasted_size;
946 : 0 : c->dirty_size += jeb->wasted_size;
947 : 0 : c->wasted_size -= jeb->wasted_size;
948 : 0 : jeb->wasted_size = 0;
949 : : }
950 : :
951 : 0 : return jffs2_scan_classify_jeb(c, jeb);
952 : : }
953 : :
954 : 0 : struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino)
955 : : {
956 : : struct jffs2_inode_cache *ic;
957 : :
958 : 0 : ic = jffs2_get_ino_cache(c, ino);
959 [ # # ]: 0 : if (ic)
960 : : return ic;
961 : :
962 [ # # ]: 0 : if (ino > c->highest_ino)
963 : 0 : c->highest_ino = ino;
964 : :
965 : 0 : ic = jffs2_alloc_inode_cache();
966 [ # # ]: 0 : if (!ic) {
967 : 0 : pr_notice("%s(): allocation of inode cache failed\n", __func__);
968 : 0 : return NULL;
969 : : }
970 : 0 : memset(ic, 0, sizeof(*ic));
971 : :
972 : 0 : ic->ino = ino;
973 : 0 : ic->nodes = (void *)ic;
974 : 0 : jffs2_add_ino_cache(c, ic);
975 [ # # ]: 0 : if (ino == 1)
976 : 0 : ic->pino_nlink = 1;
977 : 0 : return ic;
978 : : }
979 : :
980 : 0 : static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
981 : : struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s)
982 : : {
983 : : struct jffs2_inode_cache *ic;
984 : 0 : uint32_t crc, ino = je32_to_cpu(ri->ino);
985 : :
986 : : jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
987 : :
988 : : /* We do very little here now. Just check the ino# to which we should attribute
989 : : this node; we can do all the CRC checking etc. later. There's a tradeoff here --
990 : : we used to scan the flash once only, reading everything we want from it into
991 : : memory, then building all our in-core data structures and freeing the extra
992 : : information. Now we allow the first part of the mount to complete a lot quicker,
993 : : but we have to go _back_ to the flash in order to finish the CRC checking, etc.
994 : : Which means that the _full_ amount of time to get to proper write mode with GC
995 : : operational may actually be _longer_ than before. Sucks to be me. */
996 : :
997 : : /* Check the node CRC in any case. */
998 : 0 : crc = crc32(0, ri, sizeof(*ri)-8);
999 [ # # ]: 0 : if (crc != je32_to_cpu(ri->node_crc)) {
1000 : 0 : pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1001 : : __func__, ofs, je32_to_cpu(ri->node_crc), crc);
1002 : : /*
1003 : : * We believe totlen because the CRC on the node
1004 : : * _header_ was OK, just the node itself failed.
1005 : : */
1006 : 0 : return jffs2_scan_dirty_space(c, jeb,
1007 : 0 : PAD(je32_to_cpu(ri->totlen)));
1008 : : }
1009 : :
1010 : 0 : ic = jffs2_get_ino_cache(c, ino);
1011 [ # # ]: 0 : if (!ic) {
1012 : 0 : ic = jffs2_scan_make_ino_cache(c, ino);
1013 [ # # ]: 0 : if (!ic)
1014 : : return -ENOMEM;
1015 : : }
1016 : :
1017 : : /* Wheee. It worked */
1018 : 0 : jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
1019 : :
1020 : : jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
1021 : : je32_to_cpu(ri->ino), je32_to_cpu(ri->version),
1022 : : je32_to_cpu(ri->offset),
1023 : : je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize));
1024 : :
1025 : 0 : pseudo_random += je32_to_cpu(ri->version);
1026 : :
1027 : : if (jffs2_sum_active()) {
1028 : 0 : jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset);
1029 : : }
1030 : :
1031 : 0 : return 0;
1032 : : }
1033 : :
1034 : 0 : static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
1035 : : struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s)
1036 : : {
1037 : : struct jffs2_full_dirent *fd;
1038 : : struct jffs2_inode_cache *ic;
1039 : : uint32_t checkedlen;
1040 : : uint32_t crc;
1041 : : int err;
1042 : :
1043 : : jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
1044 : :
1045 : : /* We don't get here unless the node is still valid, so we don't have to
1046 : : mask in the ACCURATE bit any more. */
1047 : 0 : crc = crc32(0, rd, sizeof(*rd)-8);
1048 : :
1049 [ # # ]: 0 : if (crc != je32_to_cpu(rd->node_crc)) {
1050 : 0 : pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1051 : : __func__, ofs, je32_to_cpu(rd->node_crc), crc);
1052 : : /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
1053 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
1054 : 0 : return err;
1055 : : return 0;
1056 : : }
1057 : :
1058 : 0 : pseudo_random += je32_to_cpu(rd->version);
1059 : :
1060 : : /* Should never happen. Did. (OLPC trac #4184)*/
1061 : 0 : checkedlen = strnlen(rd->name, rd->nsize);
1062 [ # # ]: 0 : if (checkedlen < rd->nsize) {
1063 : 0 : pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
1064 : : ofs, checkedlen);
1065 : : }
1066 : 0 : fd = jffs2_alloc_full_dirent(checkedlen+1);
1067 [ # # ]: 0 : if (!fd) {
1068 : : return -ENOMEM;
1069 : : }
1070 : 0 : memcpy(&fd->name, rd->name, checkedlen);
1071 : 0 : fd->name[checkedlen] = 0;
1072 : :
1073 : 0 : crc = crc32(0, fd->name, rd->nsize);
1074 [ # # ]: 0 : if (crc != je32_to_cpu(rd->name_crc)) {
1075 : 0 : pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1076 : : __func__, ofs, je32_to_cpu(rd->name_crc), crc);
1077 : : jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n",
1078 : : fd->name, je32_to_cpu(rd->ino));
1079 : 0 : jffs2_free_full_dirent(fd);
1080 : : /* FIXME: Why do we believe totlen? */
1081 : : /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
1082 [ # # ]: 0 : if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
1083 : 0 : return err;
1084 : : return 0;
1085 : : }
1086 : 0 : ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
1087 [ # # ]: 0 : if (!ic) {
1088 : 0 : jffs2_free_full_dirent(fd);
1089 : 0 : return -ENOMEM;
1090 : : }
1091 : :
1092 [ # # ]: 0 : fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
1093 : 0 : PAD(je32_to_cpu(rd->totlen)), ic);
1094 : :
1095 : 0 : fd->next = NULL;
1096 : 0 : fd->version = je32_to_cpu(rd->version);
1097 : 0 : fd->ino = je32_to_cpu(rd->ino);
1098 : 0 : fd->nhash = full_name_hash(fd->name, checkedlen);
1099 : 0 : fd->type = rd->type;
1100 : 0 : jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
1101 : :
1102 : : if (jffs2_sum_active()) {
1103 : 0 : jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset);
1104 : : }
1105 : :
1106 : 0 : return 0;
1107 : : }
1108 : :
1109 : : static int count_list(struct list_head *l)
1110 : : {
1111 : : uint32_t count = 0;
1112 : : struct list_head *tmp;
1113 : :
1114 [ # # ][ # # ]: 0 : list_for_each(tmp, l) {
[ # # ][ # # ]
1115 : 0 : count++;
1116 : : }
1117 : : return count;
1118 : : }
1119 : :
1120 : : /* Note: This breaks if list_empty(head). I don't care. You
1121 : : might, if you copy this code and use it elsewhere :) */
1122 : : static void rotate_list(struct list_head *head, uint32_t count)
1123 : : {
1124 : 0 : struct list_head *n = head->next;
1125 : :
1126 : : list_del(head);
1127 [ # # ][ # # ]: 0 : while(count--) {
[ # # ][ # # ]
[ # # ][ # # ]
1128 : 0 : n = n->next;
1129 : : }
1130 : : list_add(head, n);
1131 : : }
1132 : :
1133 : 0 : void jffs2_rotate_lists(struct jffs2_sb_info *c)
1134 : : {
1135 : : uint32_t x;
1136 : : uint32_t rotateby;
1137 : :
1138 : 0 : x = count_list(&c->clean_list);
1139 [ # # ]: 0 : if (x) {
1140 : 0 : rotateby = pseudo_random % x;
1141 : : rotate_list((&c->clean_list), rotateby);
1142 : : }
1143 : :
1144 : 0 : x = count_list(&c->very_dirty_list);
1145 [ # # ]: 0 : if (x) {
1146 : 0 : rotateby = pseudo_random % x;
1147 : : rotate_list((&c->very_dirty_list), rotateby);
1148 : : }
1149 : :
1150 : 0 : x = count_list(&c->dirty_list);
1151 [ # # ]: 0 : if (x) {
1152 : 0 : rotateby = pseudo_random % x;
1153 : : rotate_list((&c->dirty_list), rotateby);
1154 : : }
1155 : :
1156 : 0 : x = count_list(&c->erasable_list);
1157 [ # # ]: 0 : if (x) {
1158 : 0 : rotateby = pseudo_random % x;
1159 : : rotate_list((&c->erasable_list), rotateby);
1160 : : }
1161 : :
1162 [ # # ]: 0 : if (c->nr_erasing_blocks) {
1163 : 0 : rotateby = pseudo_random % c->nr_erasing_blocks;
1164 : 0 : rotate_list((&c->erase_pending_list), rotateby);
1165 : : }
1166 : :
1167 [ # # ]: 0 : if (c->nr_free_blocks) {
1168 : 0 : rotateby = pseudo_random % c->nr_free_blocks;
1169 : 0 : rotate_list((&c->free_list), rotateby);
1170 : : }
1171 : 0 : }
|
