2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: scan.c,v 1.125 2005/09/30 13:59:13 dedekind 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>
24 #define DEFAULT_EMPTY_SCAN_SIZE 1024
26 #define noisy_printk(noise, args...) do { \
28 printk(KERN_NOTICE args); \
31 printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \
36 static uint32_t pseudo_random
;
38 static int jffs2_scan_eraseblock (struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
39 unsigned char *buf
, uint32_t buf_size
, struct jffs2_summary
*s
);
41 /* These helper functions _must_ increase ofs and also do the dirty/used space accounting.
42 * Returning an error will abort the mount - bad checksums etc. should just mark the space
45 static int jffs2_scan_inode_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
46 struct jffs2_raw_inode
*ri
, uint32_t ofs
, struct jffs2_summary
*s
);
47 static int jffs2_scan_dirent_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
48 struct jffs2_raw_dirent
*rd
, uint32_t ofs
, struct jffs2_summary
*s
);
50 static inline int min_free(struct jffs2_sb_info
*c
)
52 uint32_t min
= 2 * sizeof(struct jffs2_raw_inode
);
53 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
54 if (!jffs2_can_mark_obsolete(c
) && min
< c
->wbuf_pagesize
)
55 return c
->wbuf_pagesize
;
61 static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size
) {
62 if (sector_size
< DEFAULT_EMPTY_SCAN_SIZE
)
65 return DEFAULT_EMPTY_SCAN_SIZE
;
68 int jffs2_scan_medium(struct jffs2_sb_info
*c
)
71 uint32_t empty_blocks
= 0, bad_blocks
= 0;
72 unsigned char *flashbuf
= NULL
;
73 uint32_t buf_size
= 0;
74 struct jffs2_summary
*s
= NULL
; /* summary info collected by the scan process */
79 ret
= c
->mtd
->point (c
->mtd
, 0, c
->mtd
->size
, &pointlen
, &flashbuf
);
80 if (!ret
&& pointlen
< c
->mtd
->size
) {
81 /* Don't muck about if it won't let us point to the whole flash */
82 D1(printk(KERN_DEBUG
"MTD point returned len too short: 0x%zx\n", pointlen
));
83 c
->mtd
->unpoint(c
->mtd
, flashbuf
, 0, c
->mtd
->size
);
87 D1(printk(KERN_DEBUG
"MTD point failed %d\n", ret
));
91 /* For NAND it's quicker to read a whole eraseblock at a time,
93 if (jffs2_cleanmarker_oob(c
))
94 buf_size
= c
->sector_size
;
98 /* Respect kmalloc limitations */
99 if (buf_size
> 128*1024)
102 D1(printk(KERN_DEBUG
"Allocating readbuf of %d bytes\n", buf_size
));
103 flashbuf
= kmalloc(buf_size
, GFP_KERNEL
);
108 if (jffs2_sum_active()) {
109 s
= kmalloc(sizeof(struct jffs2_summary
), GFP_KERNEL
);
111 JFFS2_WARNING("Can't allocate memory for summary\n");
114 memset(s
, 0, sizeof(struct jffs2_summary
));
117 for (i
=0; i
<c
->nr_blocks
; i
++) {
118 struct jffs2_eraseblock
*jeb
= &c
->blocks
[i
];
120 /* reset summary info for next eraseblock scan */
121 jffs2_sum_reset_collected(s
);
123 ret
= jffs2_scan_eraseblock(c
, jeb
, buf_size
?flashbuf
:(flashbuf
+jeb
->offset
),
129 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
131 /* Now decide which list to put it on */
133 case BLK_STATE_ALLFF
:
135 * Empty block. Since we can't be sure it
136 * was entirely erased, we just queue it for erase
137 * again. It will be marked as such when the erase
138 * is complete. Meanwhile we still count it as empty
142 list_add(&jeb
->list
, &c
->erase_pending_list
);
143 c
->nr_erasing_blocks
++;
146 case BLK_STATE_CLEANMARKER
:
147 /* Only a CLEANMARKER node is valid */
148 if (!jeb
->dirty_size
) {
149 /* It's actually free */
150 list_add(&jeb
->list
, &c
->free_list
);
154 D1(printk(KERN_DEBUG
"Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb
->offset
));
155 list_add(&jeb
->list
, &c
->erase_pending_list
);
156 c
->nr_erasing_blocks
++;
160 case BLK_STATE_CLEAN
:
161 /* Full (or almost full) of clean data. Clean list */
162 list_add(&jeb
->list
, &c
->clean_list
);
165 case BLK_STATE_PARTDIRTY
:
166 /* Some data, but not full. Dirty list. */
167 /* We want to remember the block with most free space
168 and stick it in the 'nextblock' position to start writing to it. */
169 if (jeb
->free_size
> min_free(c
) &&
170 (!c
->nextblock
|| c
->nextblock
->free_size
< jeb
->free_size
)) {
171 /* Better candidate for the next writes to go to */
173 c
->nextblock
->dirty_size
+= c
->nextblock
->free_size
+ c
->nextblock
->wasted_size
;
174 c
->dirty_size
+= c
->nextblock
->free_size
+ c
->nextblock
->wasted_size
;
175 c
->free_size
-= c
->nextblock
->free_size
;
176 c
->wasted_size
-= c
->nextblock
->wasted_size
;
177 c
->nextblock
->free_size
= c
->nextblock
->wasted_size
= 0;
178 if (VERYDIRTY(c
, c
->nextblock
->dirty_size
)) {
179 list_add(&c
->nextblock
->list
, &c
->very_dirty_list
);
181 list_add(&c
->nextblock
->list
, &c
->dirty_list
);
183 /* deleting summary information of the old nextblock */
184 jffs2_sum_reset_collected(c
->summary
);
186 /* update collected summary infromation for the current nextblock */
187 jffs2_sum_move_collected(c
, s
);
188 D1(printk(KERN_DEBUG
"jffs2_scan_medium(): new nextblock = 0x%08x\n", jeb
->offset
));
191 jeb
->dirty_size
+= jeb
->free_size
+ jeb
->wasted_size
;
192 c
->dirty_size
+= jeb
->free_size
+ jeb
->wasted_size
;
193 c
->free_size
-= jeb
->free_size
;
194 c
->wasted_size
-= jeb
->wasted_size
;
195 jeb
->free_size
= jeb
->wasted_size
= 0;
196 if (VERYDIRTY(c
, jeb
->dirty_size
)) {
197 list_add(&jeb
->list
, &c
->very_dirty_list
);
199 list_add(&jeb
->list
, &c
->dirty_list
);
204 case BLK_STATE_ALLDIRTY
:
205 /* Nothing valid - not even a clean marker. Needs erasing. */
206 /* For now we just put it on the erasing list. We'll start the erases later */
207 D1(printk(KERN_NOTICE
"JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb
->offset
));
208 list_add(&jeb
->list
, &c
->erase_pending_list
);
209 c
->nr_erasing_blocks
++;
212 case BLK_STATE_BADBLOCK
:
213 D1(printk(KERN_NOTICE
"JFFS2: Block at 0x%08x is bad\n", jeb
->offset
));
214 list_add(&jeb
->list
, &c
->bad_list
);
215 c
->bad_size
+= c
->sector_size
;
216 c
->free_size
-= c
->sector_size
;
220 printk(KERN_WARNING
"jffs2_scan_medium(): unknown block state\n");
225 /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
226 if (c
->nextblock
&& (c
->nextblock
->dirty_size
)) {
227 c
->nextblock
->wasted_size
+= c
->nextblock
->dirty_size
;
228 c
->wasted_size
+= c
->nextblock
->dirty_size
;
229 c
->dirty_size
-= c
->nextblock
->dirty_size
;
230 c
->nextblock
->dirty_size
= 0;
232 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
233 if (!jffs2_can_mark_obsolete(c
) && c
->wbuf_pagesize
&& c
->nextblock
&& (c
->nextblock
->free_size
% c
->wbuf_pagesize
)) {
234 /* If we're going to start writing into a block which already
235 contains data, and the end of the data isn't page-aligned,
236 skip a little and align it. */
238 uint32_t skip
= c
->nextblock
->free_size
% c
->wbuf_pagesize
;
240 D1(printk(KERN_DEBUG
"jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n",
242 c
->nextblock
->wasted_size
+= skip
;
243 c
->wasted_size
+= skip
;
245 c
->nextblock
->free_size
-= skip
;
246 c
->free_size
-= skip
;
249 if (c
->nr_erasing_blocks
) {
250 if ( !c
->used_size
&& ((c
->nr_free_blocks
+empty_blocks
+bad_blocks
)!= c
->nr_blocks
|| bad_blocks
== c
->nr_blocks
) ) {
251 printk(KERN_NOTICE
"Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
252 printk(KERN_NOTICE
"empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks
,bad_blocks
,c
->nr_blocks
);
256 jffs2_erase_pending_trigger(c
);
264 c
->mtd
->unpoint(c
->mtd
, flashbuf
, 0, c
->mtd
->size
);
272 int jffs2_fill_scan_buf (struct jffs2_sb_info
*c
, void *buf
,
273 uint32_t ofs
, uint32_t len
)
278 ret
= jffs2_flash_read(c
, ofs
, len
, &retlen
, buf
);
280 D1(printk(KERN_WARNING
"mtd->read(0x%x bytes from 0x%x) returned %d\n", len
, ofs
, ret
));
284 D1(printk(KERN_WARNING
"Read at 0x%x gave only 0x%zx bytes\n", ofs
, retlen
));
290 int jffs2_scan_classify_jeb(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
292 if ((jeb
->used_size
+ jeb
->unchecked_size
) == PAD(c
->cleanmarker_size
) && !jeb
->dirty_size
293 && (!jeb
->first_node
|| !jeb
->first_node
->next_phys
) )
294 return BLK_STATE_CLEANMARKER
;
296 /* move blocks with max 4 byte dirty space to cleanlist */
297 else if (!ISDIRTY(c
->sector_size
- (jeb
->used_size
+ jeb
->unchecked_size
))) {
298 c
->dirty_size
-= jeb
->dirty_size
;
299 c
->wasted_size
+= jeb
->dirty_size
;
300 jeb
->wasted_size
+= jeb
->dirty_size
;
302 return BLK_STATE_CLEAN
;
303 } else if (jeb
->used_size
|| jeb
->unchecked_size
)
304 return BLK_STATE_PARTDIRTY
;
306 return BLK_STATE_ALLDIRTY
;
309 #ifdef CONFIG_JFFS2_FS_XATTR
310 static int jffs2_scan_xattr_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
311 struct jffs2_raw_xattr
*rx
, uint32_t ofs
,
312 struct jffs2_summary
*s
)
314 struct jffs2_xattr_datum
*xd
;
315 struct jffs2_raw_node_ref
*raw
;
316 uint32_t totlen
, crc
;
319 crc
= crc32(0, rx
, sizeof(struct jffs2_raw_xattr
) - 4);
320 if (crc
!= je32_to_cpu(rx
->node_crc
)) {
321 if (je32_to_cpu(rx
->node_crc
) != 0xffffffff)
322 JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
323 ofs
, je32_to_cpu(rx
->node_crc
), crc
);
324 if ((err
= jffs2_scan_dirty_space(c
, jeb
, je32_to_cpu(rx
->totlen
))))
329 totlen
= PAD(sizeof(*rx
) + rx
->name_len
+ 1 + je16_to_cpu(rx
->value_len
));
330 if (totlen
!= je32_to_cpu(rx
->totlen
)) {
331 JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n",
332 ofs
, je32_to_cpu(rx
->totlen
), totlen
);
333 if ((err
= jffs2_scan_dirty_space(c
, jeb
, je32_to_cpu(rx
->totlen
))))
338 raw
= jffs2_alloc_raw_node_ref();
342 xd
= jffs2_setup_xattr_datum(c
, je32_to_cpu(rx
->xid
), je32_to_cpu(rx
->version
));
344 jffs2_free_raw_node_ref(raw
);
345 if (PTR_ERR(xd
) == -EEXIST
) {
346 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rx
->totlen
)))))
352 xd
->xprefix
= rx
->xprefix
;
353 xd
->name_len
= rx
->name_len
;
354 xd
->value_len
= je16_to_cpu(rx
->value_len
);
355 xd
->data_crc
= je32_to_cpu(rx
->data_crc
);
358 raw
->flash_offset
= ofs
| REF_PRISTINE
;
359 raw
->next_in_ino
= (void *)xd
;
361 jffs2_link_node_ref(c
, jeb
, raw
, totlen
);
363 if (jffs2_sum_active())
364 jffs2_sum_add_xattr_mem(s
, rx
, ofs
- jeb
->offset
);
365 dbg_xattr("scaning xdatum at %#08x (xid=%u, version=%u)\n",
366 ofs
, xd
->xid
, xd
->version
);
370 static int jffs2_scan_xref_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
371 struct jffs2_raw_xref
*rr
, uint32_t ofs
,
372 struct jffs2_summary
*s
)
374 struct jffs2_xattr_ref
*ref
;
375 struct jffs2_raw_node_ref
*raw
;
379 crc
= crc32(0, rr
, sizeof(*rr
) - 4);
380 if (crc
!= je32_to_cpu(rr
->node_crc
)) {
381 if (je32_to_cpu(rr
->node_crc
) != 0xffffffff)
382 JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
383 ofs
, je32_to_cpu(rr
->node_crc
), crc
);
384 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rr
->totlen
)))))
389 if (PAD(sizeof(struct jffs2_raw_xref
)) != je32_to_cpu(rr
->totlen
)) {
390 JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n",
391 ofs
, je32_to_cpu(rr
->totlen
),
392 PAD(sizeof(struct jffs2_raw_xref
)));
393 if ((err
= jffs2_scan_dirty_space(c
, jeb
, je32_to_cpu(rr
->totlen
))))
398 ref
= jffs2_alloc_xattr_ref();
402 raw
= jffs2_alloc_raw_node_ref();
404 jffs2_free_xattr_ref(ref
);
408 /* BEFORE jffs2_build_xattr_subsystem() called,
409 * ref->xid is used to store 32bit xid, xd is not used
410 * ref->ino is used to store 32bit inode-number, ic is not used
411 * Thoes variables are declared as union, thus using those
412 * are exclusive. In a similar way, ref->next is temporarily
413 * used to chain all xattr_ref object. It's re-chained to
414 * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly.
417 ref
->ino
= je32_to_cpu(rr
->ino
);
418 ref
->xid
= je32_to_cpu(rr
->xid
);
419 ref
->next
= c
->xref_temp
;
422 raw
->flash_offset
= ofs
| REF_PRISTINE
;
423 raw
->next_in_ino
= (void *)ref
;
425 jffs2_link_node_ref(c
, jeb
, raw
, PAD(je32_to_cpu(rr
->totlen
)));
427 if (jffs2_sum_active())
428 jffs2_sum_add_xref_mem(s
, rr
, ofs
- jeb
->offset
);
429 dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n",
430 ofs
, ref
->xid
, ref
->ino
);
435 /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into
436 the flash, XIP-style */
437 static int jffs2_scan_eraseblock (struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
438 unsigned char *buf
, uint32_t buf_size
, struct jffs2_summary
*s
) {
439 struct jffs2_unknown_node
*node
;
440 struct jffs2_unknown_node crcnode
;
441 uint32_t ofs
, prevofs
;
442 uint32_t hdr_crc
, buf_ofs
, buf_len
;
447 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
448 int cleanmarkerfound
= 0;
452 prevofs
= jeb
->offset
- 1;
454 D1(printk(KERN_DEBUG
"jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs
));
456 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
457 if (jffs2_cleanmarker_oob(c
)) {
458 int ret
= jffs2_check_nand_cleanmarker(c
, jeb
);
459 D2(printk(KERN_NOTICE
"jffs_check_nand_cleanmarker returned %d\n",ret
));
460 /* Even if it's not found, we still scan to see
461 if the block is empty. We use this information
462 to decide whether to erase it or not. */
464 case 0: cleanmarkerfound
= 1; break;
466 case 2: return BLK_STATE_BADBLOCK
;
467 case 3: return BLK_STATE_ALLDIRTY
; /* Block has failed to erase min. once */
473 if (jffs2_sum_active()) {
474 struct jffs2_sum_marker
*sm
;
479 /* XIP case. Just look, point at the summary if it's there */
480 sm
= (void *)buf
+ jeb
->offset
- sizeof(*sm
);
481 if (je32_to_cpu(sm
->magic
) == JFFS2_SUM_MAGIC
) {
482 sumptr
= buf
+ je32_to_cpu(sm
->offset
);
483 sumlen
= c
->sector_size
- je32_to_cpu(sm
->offset
);
486 /* If NAND flash, read a whole page of it. Else just the end */
487 if (c
->wbuf_pagesize
)
488 buf_len
= c
->wbuf_pagesize
;
490 buf_len
= sizeof(*sm
);
492 /* Read as much as we want into the _end_ of the preallocated buffer */
493 err
= jffs2_fill_scan_buf(c
, buf
+ buf_size
- buf_len
,
494 jeb
->offset
+ c
->sector_size
- buf_len
,
499 sm
= (void *)buf
+ buf_size
- sizeof(*sm
);
500 if (je32_to_cpu(sm
->magic
) == JFFS2_SUM_MAGIC
) {
501 sumlen
= c
->sector_size
- je32_to_cpu(sm
->offset
);
502 sumptr
= buf
+ buf_size
- sumlen
;
504 /* Now, make sure the summary itself is available */
505 if (sumlen
> buf_size
) {
506 /* Need to kmalloc for this. */
507 sumptr
= kmalloc(sumlen
, GFP_KERNEL
);
510 memcpy(sumptr
+ sumlen
- buf_len
, buf
+ buf_size
- buf_len
, buf_len
);
512 if (buf_len
< sumlen
) {
513 /* Need to read more so that the entire summary node is present */
514 err
= jffs2_fill_scan_buf(c
, sumptr
,
515 jeb
->offset
+ c
->sector_size
- sumlen
,
525 err
= jffs2_sum_scan_sumnode(c
, jeb
, sumptr
, sumlen
, &pseudo_random
);
527 if (buf_size
&& sumlen
> buf_size
)
529 /* If it returns with a real error, bail.
530 If it returns positive, that's a block classification
531 (i.e. BLK_STATE_xxx) so return that too.
532 If it returns zero, fall through to full scan. */
538 buf_ofs
= jeb
->offset
;
541 /* This is the XIP case -- we're reading _directly_ from the flash chip */
542 buf_len
= c
->sector_size
;
544 buf_len
= EMPTY_SCAN_SIZE(c
->sector_size
);
545 err
= jffs2_fill_scan_buf(c
, buf
, buf_ofs
, buf_len
);
550 /* We temporarily use 'ofs' as a pointer into the buffer/jeb */
553 /* Scan only 4KiB of 0xFF before declaring it's empty */
554 while(ofs
< EMPTY_SCAN_SIZE(c
->sector_size
) && *(uint32_t *)(&buf
[ofs
]) == 0xFFFFFFFF)
557 if (ofs
== EMPTY_SCAN_SIZE(c
->sector_size
)) {
558 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
559 if (jffs2_cleanmarker_oob(c
)) {
560 /* scan oob, take care of cleanmarker */
561 int ret
= jffs2_check_oob_empty(c
, jeb
, cleanmarkerfound
);
562 D2(printk(KERN_NOTICE
"jffs2_check_oob_empty returned %d\n",ret
));
564 case 0: return cleanmarkerfound
? BLK_STATE_CLEANMARKER
: BLK_STATE_ALLFF
;
565 case 1: return BLK_STATE_ALLDIRTY
;
570 D1(printk(KERN_DEBUG
"Block at 0x%08x is empty (erased)\n", jeb
->offset
));
571 if (c
->cleanmarker_size
== 0)
572 return BLK_STATE_CLEANMARKER
; /* don't bother with re-erase */
574 return BLK_STATE_ALLFF
; /* OK to erase if all blocks are like this */
577 D1(printk(KERN_DEBUG
"Free space at %08x ends at %08x\n", jeb
->offset
,
579 if ((err
= jffs2_scan_dirty_space(c
, jeb
, ofs
)))
583 /* Now ofs is a complete physical flash offset as it always was... */
588 dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb
->offset
);
591 while(ofs
< jeb
->offset
+ c
->sector_size
) {
593 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
598 printk(KERN_WARNING
"Eep. ofs 0x%08x not word-aligned!\n", ofs
);
602 if (ofs
== prevofs
) {
603 printk(KERN_WARNING
"ofs 0x%08x has already been seen. Skipping\n", ofs
);
604 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
611 if (jeb
->offset
+ c
->sector_size
< ofs
+ sizeof(*node
)) {
612 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
),
613 jeb
->offset
, c
->sector_size
, ofs
, sizeof(*node
)));
614 if ((err
= jffs2_scan_dirty_space(c
, jeb
, (jeb
->offset
+ c
->sector_size
)-ofs
)))
619 if (buf_ofs
+ buf_len
< ofs
+ sizeof(*node
)) {
620 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
621 D1(printk(KERN_DEBUG
"Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
622 sizeof(struct jffs2_unknown_node
), buf_len
, ofs
));
623 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
629 node
= (struct jffs2_unknown_node
*)&buf
[ofs
-buf_ofs
];
631 if (*(uint32_t *)(&buf
[ofs
-buf_ofs
]) == 0xffffffff) {
633 uint32_t empty_start
;
638 D1(printk(KERN_DEBUG
"Found empty flash at 0x%08x\n", ofs
));
640 inbuf_ofs
= ofs
- buf_ofs
;
641 while (inbuf_ofs
< buf_len
) {
642 if (*(uint32_t *)(&buf
[inbuf_ofs
]) != 0xffffffff) {
643 printk(KERN_WARNING
"Empty flash at 0x%08x ends at 0x%08x\n",
645 if ((err
= jffs2_scan_dirty_space(c
, jeb
, ofs
-empty_start
)))
654 D1(printk(KERN_DEBUG
"Empty flash to end of buffer at 0x%08x\n", ofs
));
656 /* If we're only checking the beginning of a block with a cleanmarker,
658 if (buf_ofs
== jeb
->offset
&& jeb
->used_size
== PAD(c
->cleanmarker_size
) &&
659 c
->cleanmarker_size
&& !jeb
->dirty_size
&& !jeb
->first_node
->next_phys
) {
660 D1(printk(KERN_DEBUG
"%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c
->sector_size
)));
661 return BLK_STATE_CLEANMARKER
;
664 /* See how much more there is to read in this eraseblock... */
665 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
667 /* No more to read. Break out of main loop without marking
668 this range of empty space as dirty (because it's not) */
669 D1(printk(KERN_DEBUG
"Empty flash at %08x runs to end of block. Treating as free_space\n",
673 D1(printk(KERN_DEBUG
"Reading another 0x%x at 0x%08x\n", buf_len
, ofs
));
674 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
681 if (ofs
== jeb
->offset
&& je16_to_cpu(node
->magic
) == KSAMTIB_CIGAM_2SFFJ
) {
682 printk(KERN_WARNING
"Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs
);
683 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
688 if (je16_to_cpu(node
->magic
) == JFFS2_DIRTY_BITMASK
) {
689 D1(printk(KERN_DEBUG
"Dirty bitmask at 0x%08x\n", ofs
));
690 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
695 if (je16_to_cpu(node
->magic
) == JFFS2_OLD_MAGIC_BITMASK
) {
696 printk(KERN_WARNING
"Old JFFS2 bitmask found at 0x%08x\n", ofs
);
697 printk(KERN_WARNING
"You cannot use older JFFS2 filesystems with newer kernels\n");
698 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
703 if (je16_to_cpu(node
->magic
) != JFFS2_MAGIC_BITMASK
) {
704 /* OK. We're out of possibilities. Whinge and move on */
705 noisy_printk(&noise
, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
706 JFFS2_MAGIC_BITMASK
, ofs
,
707 je16_to_cpu(node
->magic
));
708 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
713 /* We seem to have a node of sorts. Check the CRC */
714 crcnode
.magic
= node
->magic
;
715 crcnode
.nodetype
= cpu_to_je16( je16_to_cpu(node
->nodetype
) | JFFS2_NODE_ACCURATE
);
716 crcnode
.totlen
= node
->totlen
;
717 hdr_crc
= crc32(0, &crcnode
, sizeof(crcnode
)-4);
719 if (hdr_crc
!= je32_to_cpu(node
->hdr_crc
)) {
720 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",
721 ofs
, je16_to_cpu(node
->magic
),
722 je16_to_cpu(node
->nodetype
),
723 je32_to_cpu(node
->totlen
),
724 je32_to_cpu(node
->hdr_crc
),
726 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
732 if (ofs
+ je32_to_cpu(node
->totlen
) >
733 jeb
->offset
+ c
->sector_size
) {
734 /* Eep. Node goes over the end of the erase block. */
735 printk(KERN_WARNING
"Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
736 ofs
, je32_to_cpu(node
->totlen
));
737 printk(KERN_WARNING
"Perhaps the file system was created with the wrong erase size?\n");
738 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
744 if (!(je16_to_cpu(node
->nodetype
) & JFFS2_NODE_ACCURATE
)) {
745 /* Wheee. This is an obsoleted node */
746 D2(printk(KERN_DEBUG
"Node at 0x%08x is obsolete. Skipping\n", ofs
));
747 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
749 ofs
+= PAD(je32_to_cpu(node
->totlen
));
753 switch(je16_to_cpu(node
->nodetype
)) {
754 case JFFS2_NODETYPE_INODE
:
755 if (buf_ofs
+ buf_len
< ofs
+ sizeof(struct jffs2_raw_inode
)) {
756 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
757 D1(printk(KERN_DEBUG
"Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
758 sizeof(struct jffs2_raw_inode
), buf_len
, ofs
));
759 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
765 err
= jffs2_scan_inode_node(c
, jeb
, (void *)node
, ofs
, s
);
767 ofs
+= PAD(je32_to_cpu(node
->totlen
));
770 case JFFS2_NODETYPE_DIRENT
:
771 if (buf_ofs
+ buf_len
< ofs
+ je32_to_cpu(node
->totlen
)) {
772 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
773 D1(printk(KERN_DEBUG
"Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
774 je32_to_cpu(node
->totlen
), buf_len
, ofs
));
775 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
781 err
= jffs2_scan_dirent_node(c
, jeb
, (void *)node
, ofs
, s
);
783 ofs
+= PAD(je32_to_cpu(node
->totlen
));
786 #ifdef CONFIG_JFFS2_FS_XATTR
787 case JFFS2_NODETYPE_XATTR
:
788 if (buf_ofs
+ buf_len
< ofs
+ je32_to_cpu(node
->totlen
)) {
789 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
790 D1(printk(KERN_DEBUG
"Fewer than %d bytes (xattr node)"
791 " left to end of buf. Reading 0x%x at 0x%08x\n",
792 je32_to_cpu(node
->totlen
), buf_len
, ofs
));
793 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
799 err
= jffs2_scan_xattr_node(c
, jeb
, (void *)node
, ofs
, s
);
802 ofs
+= PAD(je32_to_cpu(node
->totlen
));
804 case JFFS2_NODETYPE_XREF
:
805 if (buf_ofs
+ buf_len
< ofs
+ je32_to_cpu(node
->totlen
)) {
806 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
807 D1(printk(KERN_DEBUG
"Fewer than %d bytes (xref node)"
808 " left to end of buf. Reading 0x%x at 0x%08x\n",
809 je32_to_cpu(node
->totlen
), buf_len
, ofs
));
810 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
816 err
= jffs2_scan_xref_node(c
, jeb
, (void *)node
, ofs
, s
);
819 ofs
+= PAD(je32_to_cpu(node
->totlen
));
821 #endif /* CONFIG_JFFS2_FS_XATTR */
823 case JFFS2_NODETYPE_CLEANMARKER
:
824 D1(printk(KERN_DEBUG
"CLEANMARKER node found at 0x%08x\n", ofs
));
825 if (je32_to_cpu(node
->totlen
) != c
->cleanmarker_size
) {
826 printk(KERN_NOTICE
"CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
827 ofs
, je32_to_cpu(node
->totlen
), c
->cleanmarker_size
);
828 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(sizeof(struct jffs2_unknown_node
)))))
830 ofs
+= PAD(sizeof(struct jffs2_unknown_node
));
831 } else if (jeb
->first_node
) {
832 printk(KERN_NOTICE
"CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs
, jeb
->offset
);
833 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(sizeof(struct jffs2_unknown_node
)))))
835 ofs
+= PAD(sizeof(struct jffs2_unknown_node
));
837 struct jffs2_raw_node_ref
*marker_ref
= jffs2_alloc_raw_node_ref();
839 printk(KERN_NOTICE
"Failed to allocate node ref for clean marker\n");
842 marker_ref
->next_in_ino
= NULL
;
843 marker_ref
->flash_offset
= ofs
| REF_NORMAL
;
845 jffs2_link_node_ref(c
, jeb
, marker_ref
, c
->cleanmarker_size
);
847 ofs
+= PAD(c
->cleanmarker_size
);
851 case JFFS2_NODETYPE_PADDING
:
852 if (jffs2_sum_active())
853 jffs2_sum_add_padding_mem(s
, je32_to_cpu(node
->totlen
));
854 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
856 ofs
+= PAD(je32_to_cpu(node
->totlen
));
860 switch (je16_to_cpu(node
->nodetype
) & JFFS2_COMPAT_MASK
) {
861 case JFFS2_FEATURE_ROCOMPAT
:
862 printk(KERN_NOTICE
"Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node
->nodetype
), ofs
);
863 c
->flags
|= JFFS2_SB_FLAG_RO
;
864 if (!(jffs2_is_readonly(c
)))
866 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
868 ofs
+= PAD(je32_to_cpu(node
->totlen
));
871 case JFFS2_FEATURE_INCOMPAT
:
872 printk(KERN_NOTICE
"Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node
->nodetype
), ofs
);
875 case JFFS2_FEATURE_RWCOMPAT_DELETE
:
876 D1(printk(KERN_NOTICE
"Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node
->nodetype
), ofs
));
877 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
879 ofs
+= PAD(je32_to_cpu(node
->totlen
));
882 case JFFS2_FEATURE_RWCOMPAT_COPY
: {
883 struct jffs2_raw_node_ref
*ref
;
884 D1(printk(KERN_NOTICE
"Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node
->nodetype
), ofs
));
886 ref
= jffs2_alloc_raw_node_ref();
889 ref
->flash_offset
= ofs
| REF_PRISTINE
;
890 ref
->next_in_ino
= 0;
891 jffs2_link_node_ref(c
, jeb
, ref
, PAD(je32_to_cpu(node
->totlen
)));
893 /* We can't summarise nodes we don't grok */
894 jffs2_sum_disable_collecting(s
);
895 ofs
+= PAD(je32_to_cpu(node
->totlen
));
902 if (jffs2_sum_active()) {
903 if (PAD(s
->sum_size
+ JFFS2_SUMMARY_FRAME_SIZE
) > jeb
->free_size
) {
904 dbg_summary("There is not enough space for "
905 "summary information, disabling for this jeb!\n");
906 jffs2_sum_disable_collecting(s
);
910 D1(printk(KERN_DEBUG
"Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb
->offset
,
911 jeb
->free_size
, jeb
->dirty_size
, jeb
->unchecked_size
, jeb
->used_size
));
913 /* mark_node_obsolete can add to wasted !! */
914 if (jeb
->wasted_size
) {
915 jeb
->dirty_size
+= jeb
->wasted_size
;
916 c
->dirty_size
+= jeb
->wasted_size
;
917 c
->wasted_size
-= jeb
->wasted_size
;
918 jeb
->wasted_size
= 0;
921 return jffs2_scan_classify_jeb(c
, jeb
);
924 struct jffs2_inode_cache
*jffs2_scan_make_ino_cache(struct jffs2_sb_info
*c
, uint32_t ino
)
926 struct jffs2_inode_cache
*ic
;
928 ic
= jffs2_get_ino_cache(c
, ino
);
932 if (ino
> c
->highest_ino
)
933 c
->highest_ino
= ino
;
935 ic
= jffs2_alloc_inode_cache();
937 printk(KERN_NOTICE
"jffs2_scan_make_inode_cache(): allocation of inode cache failed\n");
940 memset(ic
, 0, sizeof(*ic
));
943 ic
->nodes
= (void *)ic
;
944 jffs2_add_ino_cache(c
, ic
);
950 static int jffs2_scan_inode_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
951 struct jffs2_raw_inode
*ri
, uint32_t ofs
, struct jffs2_summary
*s
)
953 struct jffs2_raw_node_ref
*raw
;
954 struct jffs2_inode_cache
*ic
;
955 uint32_t ino
= je32_to_cpu(ri
->ino
);
958 D1(printk(KERN_DEBUG
"jffs2_scan_inode_node(): Node at 0x%08x\n", ofs
));
960 /* We do very little here now. Just check the ino# to which we should attribute
961 this node; we can do all the CRC checking etc. later. There's a tradeoff here --
962 we used to scan the flash once only, reading everything we want from it into
963 memory, then building all our in-core data structures and freeing the extra
964 information. Now we allow the first part of the mount to complete a lot quicker,
965 but we have to go _back_ to the flash in order to finish the CRC checking, etc.
966 Which means that the _full_ amount of time to get to proper write mode with GC
967 operational may actually be _longer_ than before. Sucks to be me. */
969 raw
= jffs2_alloc_raw_node_ref();
971 printk(KERN_NOTICE
"jffs2_scan_inode_node(): allocation of node reference failed\n");
975 ic
= jffs2_get_ino_cache(c
, ino
);
977 /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the
978 first node we found for this inode. Do a CRC check to protect against the former
980 uint32_t crc
= crc32(0, ri
, sizeof(*ri
)-8);
982 if (crc
!= je32_to_cpu(ri
->node_crc
)) {
983 printk(KERN_NOTICE
"jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
984 ofs
, je32_to_cpu(ri
->node_crc
), crc
);
985 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
986 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(ri
->totlen
)))))
988 jffs2_free_raw_node_ref(raw
);
991 ic
= jffs2_scan_make_ino_cache(c
, ino
);
993 jffs2_free_raw_node_ref(raw
);
998 /* Wheee. It worked */
1000 raw
->flash_offset
= ofs
| REF_UNCHECKED
;
1002 raw
->next_in_ino
= ic
->nodes
;
1005 jffs2_link_node_ref(c
, jeb
, raw
, PAD(je32_to_cpu(ri
->totlen
)));
1007 D1(printk(KERN_DEBUG
"Node is ino #%u, version %d. Range 0x%x-0x%x\n",
1008 je32_to_cpu(ri
->ino
), je32_to_cpu(ri
->version
),
1009 je32_to_cpu(ri
->offset
),
1010 je32_to_cpu(ri
->offset
)+je32_to_cpu(ri
->dsize
)));
1012 pseudo_random
+= je32_to_cpu(ri
->version
);
1014 if (jffs2_sum_active()) {
1015 jffs2_sum_add_inode_mem(s
, ri
, ofs
- jeb
->offset
);
1021 static int jffs2_scan_dirent_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
1022 struct jffs2_raw_dirent
*rd
, uint32_t ofs
, struct jffs2_summary
*s
)
1024 struct jffs2_raw_node_ref
*raw
;
1025 struct jffs2_full_dirent
*fd
;
1026 struct jffs2_inode_cache
*ic
;
1030 D1(printk(KERN_DEBUG
"jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs
));
1032 /* We don't get here unless the node is still valid, so we don't have to
1033 mask in the ACCURATE bit any more. */
1034 crc
= crc32(0, rd
, sizeof(*rd
)-8);
1036 if (crc
!= je32_to_cpu(rd
->node_crc
)) {
1037 printk(KERN_NOTICE
"jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1038 ofs
, je32_to_cpu(rd
->node_crc
), crc
);
1039 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
1040 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rd
->totlen
)))))
1045 pseudo_random
+= je32_to_cpu(rd
->version
);
1047 fd
= jffs2_alloc_full_dirent(rd
->nsize
+1);
1051 memcpy(&fd
->name
, rd
->name
, rd
->nsize
);
1052 fd
->name
[rd
->nsize
] = 0;
1054 crc
= crc32(0, fd
->name
, rd
->nsize
);
1055 if (crc
!= je32_to_cpu(rd
->name_crc
)) {
1056 printk(KERN_NOTICE
"jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1057 ofs
, je32_to_cpu(rd
->name_crc
), crc
);
1058 D1(printk(KERN_NOTICE
"Name for which CRC failed is (now) '%s', ino #%d\n", fd
->name
, je32_to_cpu(rd
->ino
)));
1059 jffs2_free_full_dirent(fd
);
1060 /* FIXME: Why do we believe totlen? */
1061 /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
1062 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rd
->totlen
)))))
1066 raw
= jffs2_alloc_raw_node_ref();
1068 jffs2_free_full_dirent(fd
);
1069 printk(KERN_NOTICE
"jffs2_scan_dirent_node(): allocation of node reference failed\n");
1072 ic
= jffs2_scan_make_ino_cache(c
, je32_to_cpu(rd
->pino
));
1074 jffs2_free_full_dirent(fd
);
1075 jffs2_free_raw_node_ref(raw
);
1079 raw
->flash_offset
= ofs
| REF_PRISTINE
;
1080 raw
->next_in_ino
= ic
->nodes
;
1083 jffs2_link_node_ref(c
, jeb
, raw
, PAD(je32_to_cpu(rd
->totlen
)));
1087 fd
->version
= je32_to_cpu(rd
->version
);
1088 fd
->ino
= je32_to_cpu(rd
->ino
);
1089 fd
->nhash
= full_name_hash(fd
->name
, rd
->nsize
);
1090 fd
->type
= rd
->type
;
1091 jffs2_add_fd_to_list(c
, fd
, &ic
->scan_dents
);
1093 if (jffs2_sum_active()) {
1094 jffs2_sum_add_dirent_mem(s
, rd
, ofs
- jeb
->offset
);
1100 static int count_list(struct list_head
*l
)
1103 struct list_head
*tmp
;
1105 list_for_each(tmp
, l
) {
1111 /* Note: This breaks if list_empty(head). I don't care. You
1112 might, if you copy this code and use it elsewhere :) */
1113 static void rotate_list(struct list_head
*head
, uint32_t count
)
1115 struct list_head
*n
= head
->next
;
1124 void jffs2_rotate_lists(struct jffs2_sb_info
*c
)
1129 x
= count_list(&c
->clean_list
);
1131 rotateby
= pseudo_random
% x
;
1132 rotate_list((&c
->clean_list
), rotateby
);
1135 x
= count_list(&c
->very_dirty_list
);
1137 rotateby
= pseudo_random
% x
;
1138 rotate_list((&c
->very_dirty_list
), rotateby
);
1141 x
= count_list(&c
->dirty_list
);
1143 rotateby
= pseudo_random
% x
;
1144 rotate_list((&c
->dirty_list
), rotateby
);
1147 x
= count_list(&c
->erasable_list
);
1149 rotateby
= pseudo_random
% x
;
1150 rotate_list((&c
->erasable_list
), rotateby
);
1153 if (c
->nr_erasing_blocks
) {
1154 rotateby
= pseudo_random
% c
->nr_erasing_blocks
;
1155 rotate_list((&c
->erase_pending_list
), rotateby
);
1158 if (c
->nr_free_blocks
) {
1159 rotateby
= pseudo_random
% c
->nr_free_blocks
;
1160 rotate_list((&c
->free_list
), rotateby
);