2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@redhat.com>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: scan.c,v 1.110 2004/06/17 17:15:31 gleixner Exp $
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/pagemap.h>
18 #include <linux/crc32.h>
19 #include <linux/compiler.h>
22 #define EMPTY_SCAN_SIZE 1024
24 #define DIRTY_SPACE(x) do { typeof(x) _x = (x); \
25 c->free_size -= _x; c->dirty_size += _x; \
26 jeb->free_size -= _x ; jeb->dirty_size += _x; \
28 #define USED_SPACE(x) do { typeof(x) _x = (x); \
29 c->free_size -= _x; c->used_size += _x; \
30 jeb->free_size -= _x ; jeb->used_size += _x; \
32 #define UNCHECKED_SPACE(x) do { typeof(x) _x = (x); \
33 c->free_size -= _x; c->unchecked_size += _x; \
34 jeb->free_size -= _x ; jeb->unchecked_size += _x; \
37 #define noisy_printk(noise, args...) do { \
39 printk(KERN_NOTICE args); \
42 printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \
47 static uint32_t pseudo_random;
49 static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
50 unsigned char *buf, uint32_t buf_size);
52 /* These helper functions _must_ increase ofs and also do the dirty/used space accounting.
53 * Returning an error will abort the mount - bad checksums etc. should just mark the space
56 static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
57 struct jffs2_raw_inode *ri, uint32_t ofs);
58 static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
59 struct jffs2_raw_dirent *rd, uint32_t ofs);
61 #define BLK_STATE_ALLFF 0
62 #define BLK_STATE_CLEAN 1
63 #define BLK_STATE_PARTDIRTY 2
64 #define BLK_STATE_CLEANMARKER 3
65 #define BLK_STATE_ALLDIRTY 4
66 #define BLK_STATE_BADBLOCK 5
68 static inline int min_free(struct jffs2_sb_info *c)
70 uint32_t min = 2 * sizeof(struct jffs2_raw_inode);
71 #ifdef CONFIG_JFFS2_FS_NAND
72 if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize)
73 return c->wbuf_pagesize;
78 int jffs2_scan_medium(struct jffs2_sb_info *c)
81 uint32_t empty_blocks = 0, bad_blocks = 0;
82 unsigned char *flashbuf = NULL;
83 uint32_t buf_size = 0;
88 ret = c->mtd->point (c->mtd, 0, c->mtd->size, &pointlen, &flashbuf);
89 if (!ret && pointlen < c->mtd->size) {
90 /* Don't muck about if it won't let us point to the whole flash */
91 D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen));
92 c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size);
96 D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));
100 /* For NAND it's quicker to read a whole eraseblock at a time,
102 if (jffs2_cleanmarker_oob(c))
103 buf_size = c->sector_size;
105 buf_size = PAGE_SIZE;
107 D1(printk(KERN_DEBUG "Allocating readbuf of %d bytes\n", buf_size));
108 flashbuf = kmalloc(buf_size, GFP_KERNEL);
113 for (i=0; i<c->nr_blocks; i++) {
114 struct jffs2_eraseblock *jeb = &c->blocks[i];
116 ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), buf_size);
121 ACCT_PARANOIA_CHECK(jeb);
123 /* Now decide which list to put it on */
125 case BLK_STATE_ALLFF:
127 * Empty block. Since we can't be sure it
128 * was entirely erased, we just queue it for erase
129 * again. It will be marked as such when the erase
130 * is complete. Meanwhile we still count it as empty
134 list_add(&jeb->list, &c->erase_pending_list);
135 c->nr_erasing_blocks++;
138 case BLK_STATE_CLEANMARKER:
139 /* Only a CLEANMARKER node is valid */
140 if (!jeb->dirty_size) {
141 /* It's actually free */
142 list_add(&jeb->list, &c->free_list);
146 D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset));
147 list_add(&jeb->list, &c->erase_pending_list);
148 c->nr_erasing_blocks++;
152 case BLK_STATE_CLEAN:
153 /* Full (or almost full) of clean data. Clean list */
154 list_add(&jeb->list, &c->clean_list);
157 case BLK_STATE_PARTDIRTY:
158 /* Some data, but not full. Dirty list. */
159 /* Except that we want to remember the block with most free space,
160 and stick it in the 'nextblock' position to start writing to it.
161 Later when we do snapshots, this must be the most recent block,
162 not the one with most free space.
164 if (jeb->free_size > min_free(c) &&
165 (!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
166 /* Better candidate for the next writes to go to */
168 c->nextblock->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size;
169 c->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size;
170 c->free_size -= c->nextblock->free_size;
171 c->wasted_size -= c->nextblock->wasted_size;
172 c->nextblock->free_size = c->nextblock->wasted_size = 0;
173 if (VERYDIRTY(c, c->nextblock->dirty_size)) {
174 list_add(&c->nextblock->list, &c->very_dirty_list);
176 list_add(&c->nextblock->list, &c->dirty_list);
181 jeb->dirty_size += jeb->free_size + jeb->wasted_size;
182 c->dirty_size += jeb->free_size + jeb->wasted_size;
183 c->free_size -= jeb->free_size;
184 c->wasted_size -= jeb->wasted_size;
185 jeb->free_size = jeb->wasted_size = 0;
186 if (VERYDIRTY(c, jeb->dirty_size)) {
187 list_add(&jeb->list, &c->very_dirty_list);
189 list_add(&jeb->list, &c->dirty_list);
194 case BLK_STATE_ALLDIRTY:
195 /* Nothing valid - not even a clean marker. Needs erasing. */
196 /* For now we just put it on the erasing list. We'll start the erases later */
197 D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset));
198 list_add(&jeb->list, &c->erase_pending_list);
199 c->nr_erasing_blocks++;
202 case BLK_STATE_BADBLOCK:
203 D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset));
204 list_add(&jeb->list, &c->bad_list);
205 c->bad_size += c->sector_size;
206 c->free_size -= c->sector_size;
210 printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n");
215 /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
216 if (c->nextblock && (c->nextblock->dirty_size)) {
217 c->nextblock->wasted_size += c->nextblock->dirty_size;
218 c->wasted_size += c->nextblock->dirty_size;
219 c->dirty_size -= c->nextblock->dirty_size;
220 c->nextblock->dirty_size = 0;
222 #ifdef CONFIG_JFFS2_FS_NAND
223 if (!jffs2_can_mark_obsolete(c) && c->nextblock && (c->nextblock->free_size & (c->wbuf_pagesize-1))) {
224 /* If we're going to start writing into a block which already
225 contains data, and the end of the data isn't page-aligned,
226 skip a little and align it. */
228 uint32_t skip = c->nextblock->free_size & (c->wbuf_pagesize-1);
230 D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n",
232 c->nextblock->wasted_size += skip;
233 c->wasted_size += skip;
235 c->nextblock->free_size -= skip;
236 c->free_size -= skip;
239 if (c->nr_erasing_blocks) {
240 if ( !c->used_size && ((empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
241 printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
242 printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks);
246 jffs2_erase_pending_trigger(c);
254 c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size);
259 static int jffs2_fill_scan_buf (struct jffs2_sb_info *c, unsigned char *buf,
260 uint32_t ofs, uint32_t len)
265 ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
267 D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret));
271 D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen));
274 D2(printk(KERN_DEBUG "Read 0x%x bytes from 0x%08x into buf\n", len, ofs));
275 D2(printk(KERN_DEBUG "000: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
276 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]));
280 static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
281 unsigned char *buf, uint32_t buf_size) {
282 struct jffs2_unknown_node *node;
283 struct jffs2_unknown_node crcnode;
284 uint32_t ofs, prevofs;
285 uint32_t hdr_crc, buf_ofs, buf_len;
288 #ifdef CONFIG_JFFS2_FS_NAND
289 int cleanmarkerfound = 0;
293 prevofs = jeb->offset - 1;
295 D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs));
297 #ifdef CONFIG_JFFS2_FS_NAND
298 if (jffs2_cleanmarker_oob(c)) {
299 int ret = jffs2_check_nand_cleanmarker(c, jeb);
300 D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret));
301 /* Even if it's not found, we still scan to see
302 if the block is empty. We use this information
303 to decide whether to erase it or not. */
305 case 0: cleanmarkerfound = 1; break;
307 case 2: return BLK_STATE_BADBLOCK;
308 case 3: return BLK_STATE_ALLDIRTY; /* Block has failed to erase min. once */
313 buf_ofs = jeb->offset;
316 buf_len = c->sector_size;
318 buf_len = EMPTY_SCAN_SIZE;
319 err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
324 /* We temporarily use 'ofs' as a pointer into the buffer/jeb */
327 /* Scan only 4KiB of 0xFF before declaring it's empty */
328 while(ofs < EMPTY_SCAN_SIZE && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
331 if (ofs == EMPTY_SCAN_SIZE) {
332 #ifdef CONFIG_JFFS2_FS_NAND
333 if (jffs2_cleanmarker_oob(c)) {
334 /* scan oob, take care of cleanmarker */
335 int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound);
336 D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret));
338 case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF;
339 case 1: return BLK_STATE_ALLDIRTY;
344 D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset));
345 return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */
348 D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset,
353 /* Now ofs is a complete physical flash offset as it always was... */
359 while(ofs < jeb->offset + c->sector_size) {
361 D1(ACCT_PARANOIA_CHECK(jeb));
366 printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs);
370 if (ofs == prevofs) {
371 printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs);
378 if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
379 D1(printk(KERN_DEBUG "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n", sizeof(struct jffs2_unknown_node),
380 jeb->offset, c->sector_size, ofs, sizeof(*node)));
381 DIRTY_SPACE((jeb->offset + c->sector_size)-ofs);
385 if (buf_ofs + buf_len < ofs + sizeof(*node)) {
386 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
387 D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
388 sizeof(struct jffs2_unknown_node), buf_len, ofs));
389 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
395 node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
397 if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
399 uint32_t empty_start;
404 D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs));
406 inbuf_ofs = ofs - buf_ofs;
407 while (inbuf_ofs < buf_len) {
408 if (*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff) {
409 printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n",
411 DIRTY_SPACE(ofs-empty_start);
419 D1(printk(KERN_DEBUG "Empty flash to end of buffer at 0x%08x\n", ofs));
421 /* If we're only checking the beginning of a block with a cleanmarker,
423 if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
424 c->cleanmarker_size && !jeb->dirty_size && !jeb->first_node->next_in_ino) {
425 D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE));
426 return BLK_STATE_CLEANMARKER;
429 /* See how much more there is to read in this eraseblock... */
430 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
432 /* No more to read. Break out of main loop without marking
433 this range of empty space as dirty (because it's not) */
434 D1(printk(KERN_DEBUG "Empty flash at %08x runs to end of block. Treating as free_space\n",
438 D1(printk(KERN_DEBUG "Reading another 0x%x at 0x%08x\n", buf_len, ofs));
439 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
446 if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
447 printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs);
452 if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
453 D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs));
458 if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
459 printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs);
460 printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n");
465 if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
466 /* OK. We're out of possibilities. Whinge and move on */
467 noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
468 JFFS2_MAGIC_BITMASK, ofs,
469 je16_to_cpu(node->magic));
474 /* We seem to have a node of sorts. Check the CRC */
475 crcnode.magic = node->magic;
476 crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
477 crcnode.totlen = node->totlen;
478 hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
480 if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
481 noisy_printk(&noise, "jffs2_scan_eraseblock(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n",
482 ofs, je16_to_cpu(node->magic),
483 je16_to_cpu(node->nodetype),
484 je32_to_cpu(node->totlen),
485 je32_to_cpu(node->hdr_crc),
492 if (ofs + je32_to_cpu(node->totlen) >
493 jeb->offset + c->sector_size) {
494 /* Eep. Node goes over the end of the erase block. */
495 printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
496 ofs, je32_to_cpu(node->totlen));
497 printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n");
503 if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
504 /* Wheee. This is an obsoleted node */
505 D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs));
506 DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
507 ofs += PAD(je32_to_cpu(node->totlen));
511 switch(je16_to_cpu(node->nodetype)) {
512 case JFFS2_NODETYPE_INODE:
513 if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
514 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
515 D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
516 sizeof(struct jffs2_raw_inode), buf_len, ofs));
517 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
523 err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs);
525 ofs += PAD(je32_to_cpu(node->totlen));
528 case JFFS2_NODETYPE_DIRENT:
529 if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
530 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
531 D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
532 je32_to_cpu(node->totlen), buf_len, ofs));
533 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
539 err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs);
541 ofs += PAD(je32_to_cpu(node->totlen));
544 case JFFS2_NODETYPE_CLEANMARKER:
545 D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs));
546 if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
547 printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
548 ofs, je32_to_cpu(node->totlen), c->cleanmarker_size);
549 DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node)));
550 ofs += PAD(sizeof(struct jffs2_unknown_node));
551 } else if (jeb->first_node) {
552 printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset);
553 DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node)));
554 ofs += PAD(sizeof(struct jffs2_unknown_node));
556 struct jffs2_raw_node_ref *marker_ref = jffs2_alloc_raw_node_ref();
558 printk(KERN_NOTICE "Failed to allocate node ref for clean marker\n");
561 marker_ref->next_in_ino = NULL;
562 marker_ref->next_phys = NULL;
563 marker_ref->flash_offset = ofs | REF_NORMAL;
564 marker_ref->__totlen = c->cleanmarker_size;
565 jeb->first_node = jeb->last_node = marker_ref;
567 USED_SPACE(PAD(c->cleanmarker_size));
568 ofs += PAD(c->cleanmarker_size);
572 case JFFS2_NODETYPE_PADDING:
573 DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
574 ofs += PAD(je32_to_cpu(node->totlen));
578 switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
579 case JFFS2_FEATURE_ROCOMPAT:
580 printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs);
581 c->flags |= JFFS2_SB_FLAG_RO;
582 if (!(jffs2_is_readonly(c)))
584 DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
585 ofs += PAD(je32_to_cpu(node->totlen));
588 case JFFS2_FEATURE_INCOMPAT:
589 printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs);
592 case JFFS2_FEATURE_RWCOMPAT_DELETE:
593 D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs));
594 DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
595 ofs += PAD(je32_to_cpu(node->totlen));
598 case JFFS2_FEATURE_RWCOMPAT_COPY:
599 D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs));
600 USED_SPACE(PAD(je32_to_cpu(node->totlen)));
601 ofs += PAD(je32_to_cpu(node->totlen));
608 D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb->offset,
609 jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size));
611 /* mark_node_obsolete can add to wasted !! */
612 if (jeb->wasted_size) {
613 jeb->dirty_size += jeb->wasted_size;
614 c->dirty_size += jeb->wasted_size;
615 c->wasted_size -= jeb->wasted_size;
616 jeb->wasted_size = 0;
619 if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
620 && (!jeb->first_node || !jeb->first_node->next_in_ino) )
621 return BLK_STATE_CLEANMARKER;
623 /* move blocks with max 4 byte dirty space to cleanlist */
624 else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) {
625 c->dirty_size -= jeb->dirty_size;
626 c->wasted_size += jeb->dirty_size;
627 jeb->wasted_size += jeb->dirty_size;
629 return BLK_STATE_CLEAN;
630 } else if (jeb->used_size || jeb->unchecked_size)
631 return BLK_STATE_PARTDIRTY;
633 return BLK_STATE_ALLDIRTY;
636 static struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino)
638 struct jffs2_inode_cache *ic;
640 ic = jffs2_get_ino_cache(c, ino);
644 if (ino > c->highest_ino)
645 c->highest_ino = ino;
647 ic = jffs2_alloc_inode_cache();
649 printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n");
652 memset(ic, 0, sizeof(*ic));
655 ic->nodes = (void *)ic;
656 jffs2_add_ino_cache(c, ic);
662 static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
663 struct jffs2_raw_inode *ri, uint32_t ofs)
665 struct jffs2_raw_node_ref *raw;
666 struct jffs2_inode_cache *ic;
667 uint32_t ino = je32_to_cpu(ri->ino);
669 D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs));
671 /* We do very little here now. Just check the ino# to which we should attribute
672 this node; we can do all the CRC checking etc. later. There's a tradeoff here --
673 we used to scan the flash once only, reading everything we want from it into
674 memory, then building all our in-core data structures and freeing the extra
675 information. Now we allow the first part of the mount to complete a lot quicker,
676 but we have to go _back_ to the flash in order to finish the CRC checking, etc.
677 Which means that the _full_ amount of time to get to proper write mode with GC
678 operational may actually be _longer_ than before. Sucks to be me. */
680 raw = jffs2_alloc_raw_node_ref();
682 printk(KERN_NOTICE "jffs2_scan_inode_node(): allocation of node reference failed\n");
686 ic = jffs2_get_ino_cache(c, ino);
688 /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the
689 first node we found for this inode. Do a CRC check to protect against the former
691 uint32_t crc = crc32(0, ri, sizeof(*ri)-8);
693 if (crc != je32_to_cpu(ri->node_crc)) {
694 printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
695 ofs, je32_to_cpu(ri->node_crc), crc);
696 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
697 DIRTY_SPACE(PAD(je32_to_cpu(ri->totlen)));
698 jffs2_free_raw_node_ref(raw);
701 ic = jffs2_scan_make_ino_cache(c, ino);
703 jffs2_free_raw_node_ref(raw);
708 /* Wheee. It worked */
710 raw->flash_offset = ofs | REF_UNCHECKED;
711 raw->__totlen = PAD(je32_to_cpu(ri->totlen));
712 raw->next_phys = NULL;
713 raw->next_in_ino = ic->nodes;
716 if (!jeb->first_node)
717 jeb->first_node = raw;
719 jeb->last_node->next_phys = raw;
720 jeb->last_node = raw;
722 D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
723 je32_to_cpu(ri->ino), je32_to_cpu(ri->version),
724 je32_to_cpu(ri->offset),
725 je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize)));
727 pseudo_random += je32_to_cpu(ri->version);
729 UNCHECKED_SPACE(PAD(je32_to_cpu(ri->totlen)));
733 static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
734 struct jffs2_raw_dirent *rd, uint32_t ofs)
736 struct jffs2_raw_node_ref *raw;
737 struct jffs2_full_dirent *fd;
738 struct jffs2_inode_cache *ic;
741 D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs));
743 /* We don't get here unless the node is still valid, so we don't have to
744 mask in the ACCURATE bit any more. */
745 crc = crc32(0, rd, sizeof(*rd)-8);
747 if (crc != je32_to_cpu(rd->node_crc)) {
748 printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
749 ofs, je32_to_cpu(rd->node_crc), crc);
750 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
751 DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen)));
755 pseudo_random += je32_to_cpu(rd->version);
757 fd = jffs2_alloc_full_dirent(rd->nsize+1);
761 memcpy(&fd->name, rd->name, rd->nsize);
762 fd->name[rd->nsize] = 0;
764 crc = crc32(0, fd->name, rd->nsize);
765 if (crc != je32_to_cpu(rd->name_crc)) {
766 printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
767 ofs, je32_to_cpu(rd->name_crc), crc);
768 D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino)));
769 jffs2_free_full_dirent(fd);
770 /* FIXME: Why do we believe totlen? */
771 /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
772 DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen)));
775 raw = jffs2_alloc_raw_node_ref();
777 jffs2_free_full_dirent(fd);
778 printk(KERN_NOTICE "jffs2_scan_dirent_node(): allocation of node reference failed\n");
781 ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
783 jffs2_free_full_dirent(fd);
784 jffs2_free_raw_node_ref(raw);
788 raw->__totlen = PAD(je32_to_cpu(rd->totlen));
789 raw->flash_offset = ofs | REF_PRISTINE;
790 raw->next_phys = NULL;
791 raw->next_in_ino = ic->nodes;
793 if (!jeb->first_node)
794 jeb->first_node = raw;
796 jeb->last_node->next_phys = raw;
797 jeb->last_node = raw;
801 fd->version = je32_to_cpu(rd->version);
802 fd->ino = je32_to_cpu(rd->ino);
803 fd->nhash = full_name_hash(fd->name, rd->nsize);
805 USED_SPACE(PAD(je32_to_cpu(rd->totlen)));
806 jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
811 static int count_list(struct list_head *l)
814 struct list_head *tmp;
816 list_for_each(tmp, l) {
822 /* Note: This breaks if list_empty(head). I don't care. You
823 might, if you copy this code and use it elsewhere :) */
824 static void rotate_list(struct list_head *head, uint32_t count)
826 struct list_head *n = head->next;
835 void jffs2_rotate_lists(struct jffs2_sb_info *c)
840 x = count_list(&c->clean_list);
842 rotateby = pseudo_random % x;
843 D1(printk(KERN_DEBUG "Rotating clean_list by %d\n", rotateby));
845 rotate_list((&c->clean_list), rotateby);
847 D1(printk(KERN_DEBUG "Erase block at front of clean_list is at %08x\n",
848 list_entry(c->clean_list.next, struct jffs2_eraseblock, list)->offset));
850 D1(printk(KERN_DEBUG "Not rotating empty clean_list\n"));
853 x = count_list(&c->very_dirty_list);
855 rotateby = pseudo_random % x;
856 D1(printk(KERN_DEBUG "Rotating very_dirty_list by %d\n", rotateby));
858 rotate_list((&c->very_dirty_list), rotateby);
860 D1(printk(KERN_DEBUG "Erase block at front of very_dirty_list is at %08x\n",
861 list_entry(c->very_dirty_list.next, struct jffs2_eraseblock, list)->offset));
863 D1(printk(KERN_DEBUG "Not rotating empty very_dirty_list\n"));
866 x = count_list(&c->dirty_list);
868 rotateby = pseudo_random % x;
869 D1(printk(KERN_DEBUG "Rotating dirty_list by %d\n", rotateby));
871 rotate_list((&c->dirty_list), rotateby);
873 D1(printk(KERN_DEBUG "Erase block at front of dirty_list is at %08x\n",
874 list_entry(c->dirty_list.next, struct jffs2_eraseblock, list)->offset));
876 D1(printk(KERN_DEBUG "Not rotating empty dirty_list\n"));
879 x = count_list(&c->erasable_list);
881 rotateby = pseudo_random % x;
882 D1(printk(KERN_DEBUG "Rotating erasable_list by %d\n", rotateby));
884 rotate_list((&c->erasable_list), rotateby);
886 D1(printk(KERN_DEBUG "Erase block at front of erasable_list is at %08x\n",
887 list_entry(c->erasable_list.next, struct jffs2_eraseblock, list)->offset));
889 D1(printk(KERN_DEBUG "Not rotating empty erasable_list\n"));
892 if (c->nr_erasing_blocks) {
893 rotateby = pseudo_random % c->nr_erasing_blocks;
894 D1(printk(KERN_DEBUG "Rotating erase_pending_list by %d\n", rotateby));
896 rotate_list((&c->erase_pending_list), rotateby);
898 D1(printk(KERN_DEBUG "Erase block at front of erase_pending_list is at %08x\n",
899 list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list)->offset));
901 D1(printk(KERN_DEBUG "Not rotating empty erase_pending_list\n"));
904 if (c->nr_free_blocks) {
905 rotateby = pseudo_random % c->nr_free_blocks;
906 D1(printk(KERN_DEBUG "Rotating free_list by %d\n", rotateby));
908 rotate_list((&c->free_list), rotateby);
910 D1(printk(KERN_DEBUG "Erase block at front of free_list is at %08x\n",
911 list_entry(c->free_list.next, struct jffs2_eraseblock, list)->offset));
913 D1(printk(KERN_DEBUG "Not rotating empty free_list\n"));