2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/mtd/mtd.h>
16 #include <linux/pagemap.h>
17 #include <linux/crc32.h>
18 #include <linux/compiler.h>
23 #define DEFAULT_EMPTY_SCAN_SIZE 256
25 #define noisy_printk(noise, fmt, ...) \
28 pr_notice(fmt, ##__VA_ARGS__); \
31 pr_notice("Further such events for this erase block will not be printed\n"); \
35 static uint32_t pseudo_random
;
37 static int jffs2_scan_eraseblock (struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
38 unsigned char *buf
, uint32_t buf_size
, struct jffs2_summary
*s
);
40 /* These helper functions _must_ increase ofs and also do the dirty/used space accounting.
41 * Returning an error will abort the mount - bad checksums etc. should just mark the space
44 static int jffs2_scan_inode_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
45 struct jffs2_raw_inode
*ri
, uint32_t ofs
, struct jffs2_summary
*s
);
46 static int jffs2_scan_dirent_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
47 struct jffs2_raw_dirent
*rd
, uint32_t ofs
, struct jffs2_summary
*s
);
49 static inline int min_free(struct jffs2_sb_info
*c
)
51 uint32_t min
= 2 * sizeof(struct jffs2_raw_inode
);
52 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
53 if (!jffs2_can_mark_obsolete(c
) && min
< c
->wbuf_pagesize
)
54 return c
->wbuf_pagesize
;
60 static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size
) {
61 if (sector_size
< DEFAULT_EMPTY_SCAN_SIZE
)
64 return DEFAULT_EMPTY_SCAN_SIZE
;
67 static int file_dirty(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
71 if ((ret
= jffs2_prealloc_raw_node_refs(c
, jeb
, 1)))
73 if ((ret
= jffs2_scan_dirty_space(c
, jeb
, jeb
->free_size
)))
75 /* Turned wasted size into dirty, since we apparently
76 think it's recoverable now. */
77 jeb
->dirty_size
+= jeb
->wasted_size
;
78 c
->dirty_size
+= jeb
->wasted_size
;
79 c
->wasted_size
-= jeb
->wasted_size
;
81 if (VERYDIRTY(c
, jeb
->dirty_size
)) {
82 list_add(&jeb
->list
, &c
->very_dirty_list
);
84 list_add(&jeb
->list
, &c
->dirty_list
);
89 int jffs2_scan_medium(struct jffs2_sb_info
*c
)
92 uint32_t empty_blocks
= 0, bad_blocks
= 0;
93 unsigned char *flashbuf
= NULL
;
94 uint32_t buf_size
= 0;
95 struct jffs2_summary
*s
= NULL
; /* summary info collected by the scan process */
97 size_t pointlen
, try_size
;
99 ret
= mtd_point(c
->mtd
, 0, c
->mtd
->size
, &pointlen
,
100 (void **)&flashbuf
, NULL
);
101 if (!ret
&& pointlen
< c
->mtd
->size
) {
102 /* Don't muck about if it won't let us point to the whole flash */
103 jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n",
105 mtd_unpoint(c
->mtd
, 0, pointlen
);
108 if (ret
&& ret
!= -EOPNOTSUPP
)
109 jffs2_dbg(1, "MTD point failed %d\n", ret
);
112 /* For NAND it's quicker to read a whole eraseblock at a time,
114 if (jffs2_cleanmarker_oob(c
))
115 try_size
= c
->sector_size
;
117 try_size
= PAGE_SIZE
;
119 jffs2_dbg(1, "Trying to allocate readbuf of %zu "
120 "bytes\n", try_size
);
122 flashbuf
= mtd_kmalloc_up_to(c
->mtd
, &try_size
);
126 jffs2_dbg(1, "Allocated readbuf of %zu bytes\n",
129 buf_size
= (uint32_t)try_size
;
132 if (jffs2_sum_active()) {
133 s
= kzalloc(sizeof(struct jffs2_summary
), GFP_KERNEL
);
135 JFFS2_WARNING("Can't allocate memory for summary\n");
141 for (i
=0; i
<c
->nr_blocks
; i
++) {
142 struct jffs2_eraseblock
*jeb
= &c
->blocks
[i
];
146 /* reset summary info for next eraseblock scan */
147 jffs2_sum_reset_collected(s
);
149 ret
= jffs2_scan_eraseblock(c
, jeb
, buf_size
?flashbuf
:(flashbuf
+jeb
->offset
),
155 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
157 /* Now decide which list to put it on */
159 case BLK_STATE_ALLFF
:
161 * Empty block. Since we can't be sure it
162 * was entirely erased, we just queue it for erase
163 * again. It will be marked as such when the erase
164 * is complete. Meanwhile we still count it as empty
168 list_add(&jeb
->list
, &c
->erase_pending_list
);
169 c
->nr_erasing_blocks
++;
172 case BLK_STATE_CLEANMARKER
:
173 /* Only a CLEANMARKER node is valid */
174 if (!jeb
->dirty_size
) {
175 /* It's actually free */
176 list_add(&jeb
->list
, &c
->free_list
);
180 jffs2_dbg(1, "Adding all-dirty block at 0x%08x to erase_pending_list\n",
182 list_add(&jeb
->list
, &c
->erase_pending_list
);
183 c
->nr_erasing_blocks
++;
187 case BLK_STATE_CLEAN
:
188 /* Full (or almost full) of clean data. Clean list */
189 list_add(&jeb
->list
, &c
->clean_list
);
192 case BLK_STATE_PARTDIRTY
:
193 /* Some data, but not full. Dirty list. */
194 /* We want to remember the block with most free space
195 and stick it in the 'nextblock' position to start writing to it. */
196 if (jeb
->free_size
> min_free(c
) &&
197 (!c
->nextblock
|| c
->nextblock
->free_size
< jeb
->free_size
)) {
198 /* Better candidate for the next writes to go to */
200 ret
= file_dirty(c
, c
->nextblock
);
203 /* deleting summary information of the old nextblock */
204 jffs2_sum_reset_collected(c
->summary
);
206 /* update collected summary information for the current nextblock */
207 jffs2_sum_move_collected(c
, s
);
208 jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n",
209 __func__
, jeb
->offset
);
212 ret
= file_dirty(c
, jeb
);
218 case BLK_STATE_ALLDIRTY
:
219 /* Nothing valid - not even a clean marker. Needs erasing. */
220 /* For now we just put it on the erasing list. We'll start the erases later */
221 jffs2_dbg(1, "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n",
223 list_add(&jeb
->list
, &c
->erase_pending_list
);
224 c
->nr_erasing_blocks
++;
227 case BLK_STATE_BADBLOCK
:
228 jffs2_dbg(1, "JFFS2: Block at 0x%08x is bad\n",
230 list_add(&jeb
->list
, &c
->bad_list
);
231 c
->bad_size
+= c
->sector_size
;
232 c
->free_size
-= c
->sector_size
;
236 pr_warn("%s(): unknown block state\n", __func__
);
241 /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
242 if (c
->nextblock
&& (c
->nextblock
->dirty_size
)) {
243 c
->nextblock
->wasted_size
+= c
->nextblock
->dirty_size
;
244 c
->wasted_size
+= c
->nextblock
->dirty_size
;
245 c
->dirty_size
-= c
->nextblock
->dirty_size
;
246 c
->nextblock
->dirty_size
= 0;
248 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
249 if (!jffs2_can_mark_obsolete(c
) && c
->wbuf_pagesize
&& c
->nextblock
&& (c
->nextblock
->free_size
% c
->wbuf_pagesize
)) {
250 /* If we're going to start writing into a block which already
251 contains data, and the end of the data isn't page-aligned,
252 skip a little and align it. */
254 uint32_t skip
= c
->nextblock
->free_size
% c
->wbuf_pagesize
;
256 jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n",
258 jffs2_prealloc_raw_node_refs(c
, c
->nextblock
, 1);
259 jffs2_scan_dirty_space(c
, c
->nextblock
, skip
);
262 if (c
->nr_erasing_blocks
) {
263 if ( !c
->used_size
&& ((c
->nr_free_blocks
+empty_blocks
+bad_blocks
)!= c
->nr_blocks
|| bad_blocks
== c
->nr_blocks
) ) {
264 pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
265 pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
266 empty_blocks
, bad_blocks
, c
->nr_blocks
);
270 spin_lock(&c
->erase_completion_lock
);
271 jffs2_garbage_collect_trigger(c
);
272 spin_unlock(&c
->erase_completion_lock
);
280 mtd_unpoint(c
->mtd
, 0, c
->mtd
->size
);
286 static int jffs2_fill_scan_buf(struct jffs2_sb_info
*c
, void *buf
,
287 uint32_t ofs
, uint32_t len
)
292 ret
= jffs2_flash_read(c
, ofs
, len
, &retlen
, buf
);
294 jffs2_dbg(1, "mtd->read(0x%x bytes from 0x%x) returned %d\n",
299 jffs2_dbg(1, "Read at 0x%x gave only 0x%zx bytes\n",
306 int jffs2_scan_classify_jeb(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
308 if ((jeb
->used_size
+ jeb
->unchecked_size
) == PAD(c
->cleanmarker_size
) && !jeb
->dirty_size
309 && (!jeb
->first_node
|| !ref_next(jeb
->first_node
)) )
310 return BLK_STATE_CLEANMARKER
;
312 /* move blocks with max 4 byte dirty space to cleanlist */
313 else if (!ISDIRTY(c
->sector_size
- (jeb
->used_size
+ jeb
->unchecked_size
))) {
314 c
->dirty_size
-= jeb
->dirty_size
;
315 c
->wasted_size
+= jeb
->dirty_size
;
316 jeb
->wasted_size
+= jeb
->dirty_size
;
318 return BLK_STATE_CLEAN
;
319 } else if (jeb
->used_size
|| jeb
->unchecked_size
)
320 return BLK_STATE_PARTDIRTY
;
322 return BLK_STATE_ALLDIRTY
;
325 #ifdef CONFIG_JFFS2_FS_XATTR
326 static int jffs2_scan_xattr_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
327 struct jffs2_raw_xattr
*rx
, uint32_t ofs
,
328 struct jffs2_summary
*s
)
330 struct jffs2_xattr_datum
*xd
;
331 uint32_t xid
, version
, totlen
, crc
;
334 crc
= crc32(0, rx
, sizeof(struct jffs2_raw_xattr
) - 4);
335 if (crc
!= je32_to_cpu(rx
->node_crc
)) {
336 JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
337 ofs
, je32_to_cpu(rx
->node_crc
), crc
);
338 if ((err
= jffs2_scan_dirty_space(c
, jeb
, je32_to_cpu(rx
->totlen
))))
343 xid
= je32_to_cpu(rx
->xid
);
344 version
= je32_to_cpu(rx
->version
);
346 totlen
= PAD(sizeof(struct jffs2_raw_xattr
)
347 + rx
->name_len
+ 1 + je16_to_cpu(rx
->value_len
));
348 if (totlen
!= je32_to_cpu(rx
->totlen
)) {
349 JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n",
350 ofs
, je32_to_cpu(rx
->totlen
), totlen
);
351 if ((err
= jffs2_scan_dirty_space(c
, jeb
, je32_to_cpu(rx
->totlen
))))
356 xd
= jffs2_setup_xattr_datum(c
, xid
, version
);
360 if (xd
->version
> version
) {
361 struct jffs2_raw_node_ref
*raw
362 = jffs2_link_node_ref(c
, jeb
, ofs
| REF_PRISTINE
, totlen
, NULL
);
363 raw
->next_in_ino
= xd
->node
->next_in_ino
;
364 xd
->node
->next_in_ino
= raw
;
366 xd
->version
= version
;
367 xd
->xprefix
= rx
->xprefix
;
368 xd
->name_len
= rx
->name_len
;
369 xd
->value_len
= je16_to_cpu(rx
->value_len
);
370 xd
->data_crc
= je32_to_cpu(rx
->data_crc
);
372 jffs2_link_node_ref(c
, jeb
, ofs
| REF_PRISTINE
, totlen
, (void *)xd
);
375 if (jffs2_sum_active())
376 jffs2_sum_add_xattr_mem(s
, rx
, ofs
- jeb
->offset
);
377 dbg_xattr("scanning xdatum at %#08x (xid=%u, version=%u)\n",
378 ofs
, xd
->xid
, xd
->version
);
382 static int jffs2_scan_xref_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
383 struct jffs2_raw_xref
*rr
, uint32_t ofs
,
384 struct jffs2_summary
*s
)
386 struct jffs2_xattr_ref
*ref
;
390 crc
= crc32(0, rr
, sizeof(*rr
) - 4);
391 if (crc
!= je32_to_cpu(rr
->node_crc
)) {
392 JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
393 ofs
, je32_to_cpu(rr
->node_crc
), crc
);
394 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rr
->totlen
)))))
399 if (PAD(sizeof(struct jffs2_raw_xref
)) != je32_to_cpu(rr
->totlen
)) {
400 JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n",
401 ofs
, je32_to_cpu(rr
->totlen
),
402 PAD(sizeof(struct jffs2_raw_xref
)));
403 if ((err
= jffs2_scan_dirty_space(c
, jeb
, je32_to_cpu(rr
->totlen
))))
408 ref
= jffs2_alloc_xattr_ref();
412 /* BEFORE jffs2_build_xattr_subsystem() called,
413 * and AFTER xattr_ref is marked as a dead xref,
414 * ref->xid is used to store 32bit xid, xd is not used
415 * ref->ino is used to store 32bit inode-number, ic is not used
416 * Thoes variables are declared as union, thus using those
417 * are exclusive. In a similar way, ref->next is temporarily
418 * used to chain all xattr_ref object. It's re-chained to
419 * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly.
421 ref
->ino
= je32_to_cpu(rr
->ino
);
422 ref
->xid
= je32_to_cpu(rr
->xid
);
423 ref
->xseqno
= je32_to_cpu(rr
->xseqno
);
424 if (ref
->xseqno
> c
->highest_xseqno
)
425 c
->highest_xseqno
= (ref
->xseqno
& ~XREF_DELETE_MARKER
);
426 ref
->next
= c
->xref_temp
;
429 jffs2_link_node_ref(c
, jeb
, ofs
| REF_PRISTINE
, PAD(je32_to_cpu(rr
->totlen
)), (void *)ref
);
431 if (jffs2_sum_active())
432 jffs2_sum_add_xref_mem(s
, rr
, ofs
- jeb
->offset
);
433 dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n",
434 ofs
, ref
->xid
, ref
->ino
);
439 /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into
440 the flash, XIP-style */
441 static int jffs2_scan_eraseblock (struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
442 unsigned char *buf
, uint32_t buf_size
, struct jffs2_summary
*s
) {
443 struct jffs2_unknown_node
*node
;
444 struct jffs2_unknown_node crcnode
;
445 uint32_t ofs
, prevofs
, max_ofs
;
446 uint32_t hdr_crc
, buf_ofs
, buf_len
;
451 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
452 int cleanmarkerfound
= 0;
456 prevofs
= jeb
->offset
- 1;
458 jffs2_dbg(1, "%s(): Scanning block at 0x%x\n", __func__
, ofs
);
460 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
461 if (jffs2_cleanmarker_oob(c
)) {
464 if (mtd_block_isbad(c
->mtd
, jeb
->offset
))
465 return BLK_STATE_BADBLOCK
;
467 ret
= jffs2_check_nand_cleanmarker(c
, jeb
);
468 jffs2_dbg(2, "jffs_check_nand_cleanmarker returned %d\n", ret
);
470 /* Even if it's not found, we still scan to see
471 if the block is empty. We use this information
472 to decide whether to erase it or not. */
474 case 0: cleanmarkerfound
= 1; break;
481 if (jffs2_sum_active()) {
482 struct jffs2_sum_marker
*sm
;
487 /* XIP case. Just look, point at the summary if it's there */
488 sm
= (void *)buf
+ c
->sector_size
- sizeof(*sm
);
489 if (je32_to_cpu(sm
->magic
) == JFFS2_SUM_MAGIC
) {
490 sumptr
= buf
+ je32_to_cpu(sm
->offset
);
491 sumlen
= c
->sector_size
- je32_to_cpu(sm
->offset
);
494 /* If NAND flash, read a whole page of it. Else just the end */
495 if (c
->wbuf_pagesize
)
496 buf_len
= c
->wbuf_pagesize
;
498 buf_len
= sizeof(*sm
);
500 /* Read as much as we want into the _end_ of the preallocated buffer */
501 err
= jffs2_fill_scan_buf(c
, buf
+ buf_size
- buf_len
,
502 jeb
->offset
+ c
->sector_size
- buf_len
,
507 sm
= (void *)buf
+ buf_size
- sizeof(*sm
);
508 if (je32_to_cpu(sm
->magic
) == JFFS2_SUM_MAGIC
) {
509 sumlen
= c
->sector_size
- je32_to_cpu(sm
->offset
);
510 sumptr
= buf
+ buf_size
- sumlen
;
512 /* Now, make sure the summary itself is available */
513 if (sumlen
> buf_size
) {
514 /* Need to kmalloc for this. */
515 sumptr
= kmalloc(sumlen
, GFP_KERNEL
);
518 memcpy(sumptr
+ sumlen
- buf_len
, buf
+ buf_size
- buf_len
, buf_len
);
520 if (buf_len
< sumlen
) {
521 /* Need to read more so that the entire summary node is present */
522 err
= jffs2_fill_scan_buf(c
, sumptr
,
523 jeb
->offset
+ c
->sector_size
- sumlen
,
533 err
= jffs2_sum_scan_sumnode(c
, jeb
, sumptr
, sumlen
, &pseudo_random
);
535 if (buf_size
&& sumlen
> buf_size
)
537 /* If it returns with a real error, bail.
538 If it returns positive, that's a block classification
539 (i.e. BLK_STATE_xxx) so return that too.
540 If it returns zero, fall through to full scan. */
546 buf_ofs
= jeb
->offset
;
549 /* This is the XIP case -- we're reading _directly_ from the flash chip */
550 buf_len
= c
->sector_size
;
552 buf_len
= EMPTY_SCAN_SIZE(c
->sector_size
);
553 err
= jffs2_fill_scan_buf(c
, buf
, buf_ofs
, buf_len
);
558 /* We temporarily use 'ofs' as a pointer into the buffer/jeb */
560 max_ofs
= EMPTY_SCAN_SIZE(c
->sector_size
);
561 /* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */
562 while(ofs
< max_ofs
&& *(uint32_t *)(&buf
[ofs
]) == 0xFFFFFFFF)
565 if (ofs
== max_ofs
) {
566 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
567 if (jffs2_cleanmarker_oob(c
)) {
568 /* scan oob, take care of cleanmarker */
569 int ret
= jffs2_check_oob_empty(c
, jeb
, cleanmarkerfound
);
570 jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n",
573 case 0: return cleanmarkerfound
? BLK_STATE_CLEANMARKER
: BLK_STATE_ALLFF
;
574 case 1: return BLK_STATE_ALLDIRTY
;
579 jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n",
581 if (c
->cleanmarker_size
== 0)
582 return BLK_STATE_CLEANMARKER
; /* don't bother with re-erase */
584 return BLK_STATE_ALLFF
; /* OK to erase if all blocks are like this */
587 jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb
->offset
,
589 if ((err
= jffs2_prealloc_raw_node_refs(c
, jeb
, 1)))
591 if ((err
= jffs2_scan_dirty_space(c
, jeb
, ofs
)))
595 /* Now ofs is a complete physical flash offset as it always was... */
600 dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb
->offset
);
603 while(ofs
< jeb
->offset
+ c
->sector_size
) {
605 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
607 /* Make sure there are node refs available for use */
608 err
= jffs2_prealloc_raw_node_refs(c
, jeb
, 2);
615 pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs
);
619 if (ofs
== prevofs
) {
620 pr_warn("ofs 0x%08x has already been seen. Skipping\n",
622 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
629 if (jeb
->offset
+ c
->sector_size
< ofs
+ sizeof(*node
)) {
630 jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n",
631 sizeof(struct jffs2_unknown_node
),
632 jeb
->offset
, c
->sector_size
, ofs
,
634 if ((err
= jffs2_scan_dirty_space(c
, jeb
, (jeb
->offset
+ c
->sector_size
)-ofs
)))
639 if (buf_ofs
+ buf_len
< ofs
+ sizeof(*node
)) {
640 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
641 jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
642 sizeof(struct jffs2_unknown_node
),
644 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
650 node
= (struct jffs2_unknown_node
*)&buf
[ofs
-buf_ofs
];
652 if (*(uint32_t *)(&buf
[ofs
-buf_ofs
]) == 0xffffffff) {
654 uint32_t empty_start
, scan_end
;
658 scan_end
= min_t(uint32_t, EMPTY_SCAN_SIZE(c
->sector_size
)/8, buf_len
);
660 jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs
);
662 inbuf_ofs
= ofs
- buf_ofs
;
663 while (inbuf_ofs
< scan_end
) {
664 if (unlikely(*(uint32_t *)(&buf
[inbuf_ofs
]) != 0xffffffff)) {
665 pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
667 if ((err
= jffs2_scan_dirty_space(c
, jeb
, ofs
-empty_start
)))
676 jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n",
679 /* If we're only checking the beginning of a block with a cleanmarker,
681 if (buf_ofs
== jeb
->offset
&& jeb
->used_size
== PAD(c
->cleanmarker_size
) &&
682 c
->cleanmarker_size
&& !jeb
->dirty_size
&& !ref_next(jeb
->first_node
)) {
683 jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n",
684 EMPTY_SCAN_SIZE(c
->sector_size
));
685 return BLK_STATE_CLEANMARKER
;
687 if (!buf_size
&& (scan_end
!= buf_len
)) {/* XIP/point case */
692 /* See how much more there is to read in this eraseblock... */
693 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
695 /* No more to read. Break out of main loop without marking
696 this range of empty space as dirty (because it's not) */
697 jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n",
701 /* point never reaches here */
703 jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n",
705 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
712 if (ofs
== jeb
->offset
&& je16_to_cpu(node
->magic
) == KSAMTIB_CIGAM_2SFFJ
) {
713 pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
715 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
720 if (je16_to_cpu(node
->magic
) == JFFS2_DIRTY_BITMASK
) {
721 jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs
);
722 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
727 if (je16_to_cpu(node
->magic
) == JFFS2_OLD_MAGIC_BITMASK
) {
728 pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs
);
729 pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
730 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
735 if (je16_to_cpu(node
->magic
) != JFFS2_MAGIC_BITMASK
) {
736 /* OK. We're out of possibilities. Whinge and move on */
737 noisy_printk(&noise
, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
739 JFFS2_MAGIC_BITMASK
, ofs
,
740 je16_to_cpu(node
->magic
));
741 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
746 /* We seem to have a node of sorts. Check the CRC */
747 crcnode
.magic
= node
->magic
;
748 crcnode
.nodetype
= cpu_to_je16( je16_to_cpu(node
->nodetype
) | JFFS2_NODE_ACCURATE
);
749 crcnode
.totlen
= node
->totlen
;
750 hdr_crc
= crc32(0, &crcnode
, sizeof(crcnode
)-4);
752 if (hdr_crc
!= je32_to_cpu(node
->hdr_crc
)) {
753 noisy_printk(&noise
, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n",
755 ofs
, je16_to_cpu(node
->magic
),
756 je16_to_cpu(node
->nodetype
),
757 je32_to_cpu(node
->totlen
),
758 je32_to_cpu(node
->hdr_crc
),
760 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
766 if (ofs
+ je32_to_cpu(node
->totlen
) > jeb
->offset
+ c
->sector_size
) {
767 /* Eep. Node goes over the end of the erase block. */
768 pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
769 ofs
, je32_to_cpu(node
->totlen
));
770 pr_warn("Perhaps the file system was created with the wrong erase size?\n");
771 if ((err
= jffs2_scan_dirty_space(c
, jeb
, 4)))
777 if (!(je16_to_cpu(node
->nodetype
) & JFFS2_NODE_ACCURATE
)) {
778 /* Wheee. This is an obsoleted node */
779 jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n",
781 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
783 ofs
+= PAD(je32_to_cpu(node
->totlen
));
787 switch(je16_to_cpu(node
->nodetype
)) {
788 case JFFS2_NODETYPE_INODE
:
789 if (buf_ofs
+ buf_len
< ofs
+ sizeof(struct jffs2_raw_inode
)) {
790 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
791 jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
792 sizeof(struct jffs2_raw_inode
),
794 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
800 err
= jffs2_scan_inode_node(c
, jeb
, (void *)node
, ofs
, s
);
802 ofs
+= PAD(je32_to_cpu(node
->totlen
));
805 case JFFS2_NODETYPE_DIRENT
:
806 if (buf_ofs
+ buf_len
< ofs
+ je32_to_cpu(node
->totlen
)) {
807 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
808 jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
809 je32_to_cpu(node
->totlen
), buf_len
,
811 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
817 err
= jffs2_scan_dirent_node(c
, jeb
, (void *)node
, ofs
, s
);
819 ofs
+= PAD(je32_to_cpu(node
->totlen
));
822 #ifdef CONFIG_JFFS2_FS_XATTR
823 case JFFS2_NODETYPE_XATTR
:
824 if (buf_ofs
+ buf_len
< ofs
+ je32_to_cpu(node
->totlen
)) {
825 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
826 jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n",
827 je32_to_cpu(node
->totlen
), buf_len
,
829 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
835 err
= jffs2_scan_xattr_node(c
, jeb
, (void *)node
, ofs
, s
);
838 ofs
+= PAD(je32_to_cpu(node
->totlen
));
840 case JFFS2_NODETYPE_XREF
:
841 if (buf_ofs
+ buf_len
< ofs
+ je32_to_cpu(node
->totlen
)) {
842 buf_len
= min_t(uint32_t, buf_size
, jeb
->offset
+ c
->sector_size
- ofs
);
843 jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n",
844 je32_to_cpu(node
->totlen
), buf_len
,
846 err
= jffs2_fill_scan_buf(c
, buf
, ofs
, buf_len
);
852 err
= jffs2_scan_xref_node(c
, jeb
, (void *)node
, ofs
, s
);
855 ofs
+= PAD(je32_to_cpu(node
->totlen
));
857 #endif /* CONFIG_JFFS2_FS_XATTR */
859 case JFFS2_NODETYPE_CLEANMARKER
:
860 jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs
);
861 if (je32_to_cpu(node
->totlen
) != c
->cleanmarker_size
) {
862 pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
863 ofs
, je32_to_cpu(node
->totlen
),
864 c
->cleanmarker_size
);
865 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(sizeof(struct jffs2_unknown_node
)))))
867 ofs
+= PAD(sizeof(struct jffs2_unknown_node
));
868 } else if (jeb
->first_node
) {
869 pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
871 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(sizeof(struct jffs2_unknown_node
)))))
873 ofs
+= PAD(sizeof(struct jffs2_unknown_node
));
875 jffs2_link_node_ref(c
, jeb
, ofs
| REF_NORMAL
, c
->cleanmarker_size
, NULL
);
877 ofs
+= PAD(c
->cleanmarker_size
);
881 case JFFS2_NODETYPE_PADDING
:
882 if (jffs2_sum_active())
883 jffs2_sum_add_padding_mem(s
, je32_to_cpu(node
->totlen
));
884 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
886 ofs
+= PAD(je32_to_cpu(node
->totlen
));
890 switch (je16_to_cpu(node
->nodetype
) & JFFS2_COMPAT_MASK
) {
891 case JFFS2_FEATURE_ROCOMPAT
:
892 pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
893 je16_to_cpu(node
->nodetype
), ofs
);
894 c
->flags
|= JFFS2_SB_FLAG_RO
;
895 if (!(jffs2_is_readonly(c
)))
897 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
899 ofs
+= PAD(je32_to_cpu(node
->totlen
));
902 case JFFS2_FEATURE_INCOMPAT
:
903 pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
904 je16_to_cpu(node
->nodetype
), ofs
);
907 case JFFS2_FEATURE_RWCOMPAT_DELETE
:
908 jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
909 je16_to_cpu(node
->nodetype
), ofs
);
910 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(node
->totlen
)))))
912 ofs
+= PAD(je32_to_cpu(node
->totlen
));
915 case JFFS2_FEATURE_RWCOMPAT_COPY
: {
916 jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
917 je16_to_cpu(node
->nodetype
), ofs
);
919 jffs2_link_node_ref(c
, jeb
, ofs
| REF_PRISTINE
, PAD(je32_to_cpu(node
->totlen
)), NULL
);
921 /* We can't summarise nodes we don't grok */
922 jffs2_sum_disable_collecting(s
);
923 ofs
+= PAD(je32_to_cpu(node
->totlen
));
930 if (jffs2_sum_active()) {
931 if (PAD(s
->sum_size
+ JFFS2_SUMMARY_FRAME_SIZE
) > jeb
->free_size
) {
932 dbg_summary("There is not enough space for "
933 "summary information, disabling for this jeb!\n");
934 jffs2_sum_disable_collecting(s
);
938 jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
939 jeb
->offset
, jeb
->free_size
, jeb
->dirty_size
,
940 jeb
->unchecked_size
, jeb
->used_size
, jeb
->wasted_size
);
942 /* mark_node_obsolete can add to wasted !! */
943 if (jeb
->wasted_size
) {
944 jeb
->dirty_size
+= jeb
->wasted_size
;
945 c
->dirty_size
+= jeb
->wasted_size
;
946 c
->wasted_size
-= jeb
->wasted_size
;
947 jeb
->wasted_size
= 0;
950 return jffs2_scan_classify_jeb(c
, jeb
);
953 struct jffs2_inode_cache
*jffs2_scan_make_ino_cache(struct jffs2_sb_info
*c
, uint32_t ino
)
955 struct jffs2_inode_cache
*ic
;
957 ic
= jffs2_get_ino_cache(c
, ino
);
961 if (ino
> c
->highest_ino
)
962 c
->highest_ino
= ino
;
964 ic
= jffs2_alloc_inode_cache();
966 pr_notice("%s(): allocation of inode cache failed\n", __func__
);
969 memset(ic
, 0, sizeof(*ic
));
972 ic
->nodes
= (void *)ic
;
973 jffs2_add_ino_cache(c
, ic
);
979 static int jffs2_scan_inode_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
980 struct jffs2_raw_inode
*ri
, uint32_t ofs
, struct jffs2_summary
*s
)
982 struct jffs2_inode_cache
*ic
;
983 uint32_t crc
, ino
= je32_to_cpu(ri
->ino
);
985 jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__
, ofs
);
987 /* We do very little here now. Just check the ino# to which we should attribute
988 this node; we can do all the CRC checking etc. later. There's a tradeoff here --
989 we used to scan the flash once only, reading everything we want from it into
990 memory, then building all our in-core data structures and freeing the extra
991 information. Now we allow the first part of the mount to complete a lot quicker,
992 but we have to go _back_ to the flash in order to finish the CRC checking, etc.
993 Which means that the _full_ amount of time to get to proper write mode with GC
994 operational may actually be _longer_ than before. Sucks to be me. */
996 /* Check the node CRC in any case. */
997 crc
= crc32(0, ri
, sizeof(*ri
)-8);
998 if (crc
!= je32_to_cpu(ri
->node_crc
)) {
999 pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1000 __func__
, ofs
, je32_to_cpu(ri
->node_crc
), crc
);
1002 * We believe totlen because the CRC on the node
1003 * _header_ was OK, just the node itself failed.
1005 return jffs2_scan_dirty_space(c
, jeb
,
1006 PAD(je32_to_cpu(ri
->totlen
)));
1009 ic
= jffs2_get_ino_cache(c
, ino
);
1011 ic
= jffs2_scan_make_ino_cache(c
, ino
);
1016 /* Wheee. It worked */
1017 jffs2_link_node_ref(c
, jeb
, ofs
| REF_UNCHECKED
, PAD(je32_to_cpu(ri
->totlen
)), ic
);
1019 jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
1020 je32_to_cpu(ri
->ino
), je32_to_cpu(ri
->version
),
1021 je32_to_cpu(ri
->offset
),
1022 je32_to_cpu(ri
->offset
)+je32_to_cpu(ri
->dsize
));
1024 pseudo_random
+= je32_to_cpu(ri
->version
);
1026 if (jffs2_sum_active()) {
1027 jffs2_sum_add_inode_mem(s
, ri
, ofs
- jeb
->offset
);
1033 static int jffs2_scan_dirent_node(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
1034 struct jffs2_raw_dirent
*rd
, uint32_t ofs
, struct jffs2_summary
*s
)
1036 struct jffs2_full_dirent
*fd
;
1037 struct jffs2_inode_cache
*ic
;
1038 uint32_t checkedlen
;
1042 jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__
, ofs
);
1044 /* We don't get here unless the node is still valid, so we don't have to
1045 mask in the ACCURATE bit any more. */
1046 crc
= crc32(0, rd
, sizeof(*rd
)-8);
1048 if (crc
!= je32_to_cpu(rd
->node_crc
)) {
1049 pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1050 __func__
, ofs
, je32_to_cpu(rd
->node_crc
), crc
);
1051 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
1052 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rd
->totlen
)))))
1057 pseudo_random
+= je32_to_cpu(rd
->version
);
1059 /* Should never happen. Did. (OLPC trac #4184)*/
1060 checkedlen
= strnlen(rd
->name
, rd
->nsize
);
1061 if (checkedlen
< rd
->nsize
) {
1062 pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
1065 fd
= jffs2_alloc_full_dirent(checkedlen
+1);
1069 memcpy(&fd
->name
, rd
->name
, checkedlen
);
1070 fd
->name
[checkedlen
] = 0;
1072 crc
= crc32(0, fd
->name
, rd
->nsize
);
1073 if (crc
!= je32_to_cpu(rd
->name_crc
)) {
1074 pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1075 __func__
, ofs
, je32_to_cpu(rd
->name_crc
), crc
);
1076 jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n",
1077 fd
->name
, je32_to_cpu(rd
->ino
));
1078 jffs2_free_full_dirent(fd
);
1079 /* FIXME: Why do we believe totlen? */
1080 /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
1081 if ((err
= jffs2_scan_dirty_space(c
, jeb
, PAD(je32_to_cpu(rd
->totlen
)))))
1085 ic
= jffs2_scan_make_ino_cache(c
, je32_to_cpu(rd
->pino
));
1087 jffs2_free_full_dirent(fd
);
1091 fd
->raw
= jffs2_link_node_ref(c
, jeb
, ofs
| dirent_node_state(rd
),
1092 PAD(je32_to_cpu(rd
->totlen
)), ic
);
1095 fd
->version
= je32_to_cpu(rd
->version
);
1096 fd
->ino
= je32_to_cpu(rd
->ino
);
1097 fd
->nhash
= full_name_hash(fd
->name
, checkedlen
);
1098 fd
->type
= rd
->type
;
1099 jffs2_add_fd_to_list(c
, fd
, &ic
->scan_dents
);
1101 if (jffs2_sum_active()) {
1102 jffs2_sum_add_dirent_mem(s
, rd
, ofs
- jeb
->offset
);
1108 static int count_list(struct list_head
*l
)
1111 struct list_head
*tmp
;
1113 list_for_each(tmp
, l
) {
1119 /* Note: This breaks if list_empty(head). I don't care. You
1120 might, if you copy this code and use it elsewhere :) */
1121 static void rotate_list(struct list_head
*head
, uint32_t count
)
1123 struct list_head
*n
= head
->next
;
1132 void jffs2_rotate_lists(struct jffs2_sb_info
*c
)
1137 x
= count_list(&c
->clean_list
);
1139 rotateby
= pseudo_random
% x
;
1140 rotate_list((&c
->clean_list
), rotateby
);
1143 x
= count_list(&c
->very_dirty_list
);
1145 rotateby
= pseudo_random
% x
;
1146 rotate_list((&c
->very_dirty_list
), rotateby
);
1149 x
= count_list(&c
->dirty_list
);
1151 rotateby
= pseudo_random
% x
;
1152 rotate_list((&c
->dirty_list
), rotateby
);
1155 x
= count_list(&c
->erasable_list
);
1157 rotateby
= pseudo_random
% x
;
1158 rotate_list((&c
->erasable_list
), rotateby
);
1161 if (c
->nr_erasing_blocks
) {
1162 rotateby
= pseudo_random
% c
->nr_erasing_blocks
;
1163 rotate_list((&c
->erase_pending_list
), rotateby
);
1166 if (c
->nr_free_blocks
) {
1167 rotateby
= pseudo_random
% c
->nr_free_blocks
;
1168 rotate_list((&c
->free_list
), rotateby
);