11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001-2003 Red Hat, Inc. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 91da177e4SLinus Torvalds * 103be36675SAndrew Victor * $Id: scan.c,v 1.116 2005/02/09 09:09:02 pavlov Exp $ 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds #include <linux/kernel.h> 141da177e4SLinus Torvalds #include <linux/sched.h> 151da177e4SLinus Torvalds #include <linux/slab.h> 161da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 171da177e4SLinus Torvalds #include <linux/pagemap.h> 181da177e4SLinus Torvalds #include <linux/crc32.h> 191da177e4SLinus Torvalds #include <linux/compiler.h> 201da177e4SLinus Torvalds #include "nodelist.h" 211da177e4SLinus Torvalds 223be36675SAndrew Victor #define DEFAULT_EMPTY_SCAN_SIZE 1024 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #define DIRTY_SPACE(x) do { typeof(x) _x = (x); \ 251da177e4SLinus Torvalds c->free_size -= _x; c->dirty_size += _x; \ 261da177e4SLinus Torvalds jeb->free_size -= _x ; jeb->dirty_size += _x; \ 271da177e4SLinus Torvalds }while(0) 281da177e4SLinus Torvalds #define USED_SPACE(x) do { typeof(x) _x = (x); \ 291da177e4SLinus Torvalds c->free_size -= _x; c->used_size += _x; \ 301da177e4SLinus Torvalds jeb->free_size -= _x ; jeb->used_size += _x; \ 311da177e4SLinus Torvalds }while(0) 321da177e4SLinus Torvalds #define UNCHECKED_SPACE(x) do { typeof(x) _x = (x); \ 331da177e4SLinus Torvalds c->free_size -= _x; c->unchecked_size += _x; \ 341da177e4SLinus Torvalds jeb->free_size -= _x ; jeb->unchecked_size += _x; \ 351da177e4SLinus Torvalds }while(0) 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds #define noisy_printk(noise, args...) do { \ 381da177e4SLinus Torvalds if (*(noise)) { \ 391da177e4SLinus Torvalds printk(KERN_NOTICE args); \ 401da177e4SLinus Torvalds (*(noise))--; \ 411da177e4SLinus Torvalds if (!(*(noise))) { \ 421da177e4SLinus Torvalds printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \ 431da177e4SLinus Torvalds } \ 441da177e4SLinus Torvalds } \ 451da177e4SLinus Torvalds } while(0) 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds static uint32_t pseudo_random; 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 501da177e4SLinus Torvalds unsigned char *buf, uint32_t buf_size); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds /* These helper functions _must_ increase ofs and also do the dirty/used space accounting. 531da177e4SLinus Torvalds * Returning an error will abort the mount - bad checksums etc. should just mark the space 541da177e4SLinus Torvalds * as dirty. 551da177e4SLinus Torvalds */ 561da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 571da177e4SLinus Torvalds struct jffs2_raw_inode *ri, uint32_t ofs); 581da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 591da177e4SLinus Torvalds struct jffs2_raw_dirent *rd, uint32_t ofs); 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #define BLK_STATE_ALLFF 0 621da177e4SLinus Torvalds #define BLK_STATE_CLEAN 1 631da177e4SLinus Torvalds #define BLK_STATE_PARTDIRTY 2 641da177e4SLinus Torvalds #define BLK_STATE_CLEANMARKER 3 651da177e4SLinus Torvalds #define BLK_STATE_ALLDIRTY 4 661da177e4SLinus Torvalds #define BLK_STATE_BADBLOCK 5 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds static inline int min_free(struct jffs2_sb_info *c) 691da177e4SLinus Torvalds { 701da177e4SLinus Torvalds uint32_t min = 2 * sizeof(struct jffs2_raw_inode); 711da177e4SLinus Torvalds #if defined CONFIG_JFFS2_FS_NAND || defined CONFIG_JFFS2_FS_NOR_ECC 721da177e4SLinus Torvalds if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize) 731da177e4SLinus Torvalds return c->wbuf_pagesize; 741da177e4SLinus Torvalds #endif 751da177e4SLinus Torvalds return min; 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds } 783be36675SAndrew Victor 793be36675SAndrew Victor static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) { 803be36675SAndrew Victor if (sector_size < DEFAULT_EMPTY_SCAN_SIZE) 813be36675SAndrew Victor return sector_size; 823be36675SAndrew Victor else 833be36675SAndrew Victor return DEFAULT_EMPTY_SCAN_SIZE; 843be36675SAndrew Victor } 853be36675SAndrew Victor 861da177e4SLinus Torvalds int jffs2_scan_medium(struct jffs2_sb_info *c) 871da177e4SLinus Torvalds { 881da177e4SLinus Torvalds int i, ret; 891da177e4SLinus Torvalds uint32_t empty_blocks = 0, bad_blocks = 0; 901da177e4SLinus Torvalds unsigned char *flashbuf = NULL; 911da177e4SLinus Torvalds uint32_t buf_size = 0; 921da177e4SLinus Torvalds #ifndef __ECOS 931da177e4SLinus Torvalds size_t pointlen; 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds if (c->mtd->point) { 961da177e4SLinus Torvalds ret = c->mtd->point (c->mtd, 0, c->mtd->size, &pointlen, &flashbuf); 971da177e4SLinus Torvalds if (!ret && pointlen < c->mtd->size) { 981da177e4SLinus Torvalds /* Don't muck about if it won't let us point to the whole flash */ 991da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen)); 1001da177e4SLinus Torvalds c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size); 1011da177e4SLinus Torvalds flashbuf = NULL; 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds if (ret) 1041da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point failed %d\n", ret)); 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds #endif 1071da177e4SLinus Torvalds if (!flashbuf) { 1081da177e4SLinus Torvalds /* For NAND it's quicker to read a whole eraseblock at a time, 1091da177e4SLinus Torvalds apparently */ 1101da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) 1111da177e4SLinus Torvalds buf_size = c->sector_size; 1121da177e4SLinus Torvalds else 1131da177e4SLinus Torvalds buf_size = PAGE_SIZE; 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds /* Respect kmalloc limitations */ 1161da177e4SLinus Torvalds if (buf_size > 128*1024) 1171da177e4SLinus Torvalds buf_size = 128*1024; 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocating readbuf of %d bytes\n", buf_size)); 1201da177e4SLinus Torvalds flashbuf = kmalloc(buf_size, GFP_KERNEL); 1211da177e4SLinus Torvalds if (!flashbuf) 1221da177e4SLinus Torvalds return -ENOMEM; 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds for (i=0; i<c->nr_blocks; i++) { 1261da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[i]; 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), buf_size); 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds if (ret < 0) 1311da177e4SLinus Torvalds goto out; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds ACCT_PARANOIA_CHECK(jeb); 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds /* Now decide which list to put it on */ 1361da177e4SLinus Torvalds switch(ret) { 1371da177e4SLinus Torvalds case BLK_STATE_ALLFF: 1381da177e4SLinus Torvalds /* 1391da177e4SLinus Torvalds * Empty block. Since we can't be sure it 1401da177e4SLinus Torvalds * was entirely erased, we just queue it for erase 1411da177e4SLinus Torvalds * again. It will be marked as such when the erase 1421da177e4SLinus Torvalds * is complete. Meanwhile we still count it as empty 1431da177e4SLinus Torvalds * for later checks. 1441da177e4SLinus Torvalds */ 1451da177e4SLinus Torvalds empty_blocks++; 1461da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1471da177e4SLinus Torvalds c->nr_erasing_blocks++; 1481da177e4SLinus Torvalds break; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds case BLK_STATE_CLEANMARKER: 1511da177e4SLinus Torvalds /* Only a CLEANMARKER node is valid */ 1521da177e4SLinus Torvalds if (!jeb->dirty_size) { 1531da177e4SLinus Torvalds /* It's actually free */ 1541da177e4SLinus Torvalds list_add(&jeb->list, &c->free_list); 1551da177e4SLinus Torvalds c->nr_free_blocks++; 1561da177e4SLinus Torvalds } else { 1571da177e4SLinus Torvalds /* Dirt */ 1581da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset)); 1591da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1601da177e4SLinus Torvalds c->nr_erasing_blocks++; 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds break; 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds case BLK_STATE_CLEAN: 1651da177e4SLinus Torvalds /* Full (or almost full) of clean data. Clean list */ 1661da177e4SLinus Torvalds list_add(&jeb->list, &c->clean_list); 1671da177e4SLinus Torvalds break; 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds case BLK_STATE_PARTDIRTY: 1701da177e4SLinus Torvalds /* Some data, but not full. Dirty list. */ 1711da177e4SLinus Torvalds /* We want to remember the block with most free space 1721da177e4SLinus Torvalds and stick it in the 'nextblock' position to start writing to it. */ 1731da177e4SLinus Torvalds if (jeb->free_size > min_free(c) && 1741da177e4SLinus Torvalds (!c->nextblock || c->nextblock->free_size < jeb->free_size)) { 1751da177e4SLinus Torvalds /* Better candidate for the next writes to go to */ 1761da177e4SLinus Torvalds if (c->nextblock) { 1771da177e4SLinus Torvalds c->nextblock->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size; 1781da177e4SLinus Torvalds c->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size; 1791da177e4SLinus Torvalds c->free_size -= c->nextblock->free_size; 1801da177e4SLinus Torvalds c->wasted_size -= c->nextblock->wasted_size; 1811da177e4SLinus Torvalds c->nextblock->free_size = c->nextblock->wasted_size = 0; 1821da177e4SLinus Torvalds if (VERYDIRTY(c, c->nextblock->dirty_size)) { 1831da177e4SLinus Torvalds list_add(&c->nextblock->list, &c->very_dirty_list); 1841da177e4SLinus Torvalds } else { 1851da177e4SLinus Torvalds list_add(&c->nextblock->list, &c->dirty_list); 1861da177e4SLinus Torvalds } 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds c->nextblock = jeb; 1891da177e4SLinus Torvalds } else { 1901da177e4SLinus Torvalds jeb->dirty_size += jeb->free_size + jeb->wasted_size; 1911da177e4SLinus Torvalds c->dirty_size += jeb->free_size + jeb->wasted_size; 1921da177e4SLinus Torvalds c->free_size -= jeb->free_size; 1931da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 1941da177e4SLinus Torvalds jeb->free_size = jeb->wasted_size = 0; 1951da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 1961da177e4SLinus Torvalds list_add(&jeb->list, &c->very_dirty_list); 1971da177e4SLinus Torvalds } else { 1981da177e4SLinus Torvalds list_add(&jeb->list, &c->dirty_list); 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds break; 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds case BLK_STATE_ALLDIRTY: 2041da177e4SLinus Torvalds /* Nothing valid - not even a clean marker. Needs erasing. */ 2051da177e4SLinus Torvalds /* For now we just put it on the erasing list. We'll start the erases later */ 2061da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset)); 2071da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 2081da177e4SLinus Torvalds c->nr_erasing_blocks++; 2091da177e4SLinus Torvalds break; 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds case BLK_STATE_BADBLOCK: 2121da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset)); 2131da177e4SLinus Torvalds list_add(&jeb->list, &c->bad_list); 2141da177e4SLinus Torvalds c->bad_size += c->sector_size; 2151da177e4SLinus Torvalds c->free_size -= c->sector_size; 2161da177e4SLinus Torvalds bad_blocks++; 2171da177e4SLinus Torvalds break; 2181da177e4SLinus Torvalds default: 2191da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n"); 2201da177e4SLinus Torvalds BUG(); 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */ 2251da177e4SLinus Torvalds if (c->nextblock && (c->nextblock->dirty_size)) { 2261da177e4SLinus Torvalds c->nextblock->wasted_size += c->nextblock->dirty_size; 2271da177e4SLinus Torvalds c->wasted_size += c->nextblock->dirty_size; 2281da177e4SLinus Torvalds c->dirty_size -= c->nextblock->dirty_size; 2291da177e4SLinus Torvalds c->nextblock->dirty_size = 0; 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds #if defined CONFIG_JFFS2_FS_NAND || defined CONFIG_JFFS2_FS_NOR_ECC 2321da177e4SLinus Torvalds if (!jffs2_can_mark_obsolete(c) && c->nextblock && (c->nextblock->free_size & (c->wbuf_pagesize-1))) { 2331da177e4SLinus Torvalds /* If we're going to start writing into a block which already 2341da177e4SLinus Torvalds contains data, and the end of the data isn't page-aligned, 2351da177e4SLinus Torvalds skip a little and align it. */ 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds uint32_t skip = c->nextblock->free_size & (c->wbuf_pagesize-1); 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n", 2401da177e4SLinus Torvalds skip)); 2411da177e4SLinus Torvalds c->nextblock->wasted_size += skip; 2421da177e4SLinus Torvalds c->wasted_size += skip; 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds c->nextblock->free_size -= skip; 2451da177e4SLinus Torvalds c->free_size -= skip; 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds #endif 2481da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 2491da177e4SLinus Torvalds if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) { 2501da177e4SLinus Torvalds printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 2511da177e4SLinus Torvalds printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks); 2521da177e4SLinus Torvalds ret = -EIO; 2531da177e4SLinus Torvalds goto out; 2541da177e4SLinus Torvalds } 2551da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 2561da177e4SLinus Torvalds } 2571da177e4SLinus Torvalds ret = 0; 2581da177e4SLinus Torvalds out: 2591da177e4SLinus Torvalds if (buf_size) 2601da177e4SLinus Torvalds kfree(flashbuf); 2611da177e4SLinus Torvalds #ifndef __ECOS 2621da177e4SLinus Torvalds else 2631da177e4SLinus Torvalds c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size); 2641da177e4SLinus Torvalds #endif 2651da177e4SLinus Torvalds return ret; 2661da177e4SLinus Torvalds } 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds static int jffs2_fill_scan_buf (struct jffs2_sb_info *c, unsigned char *buf, 2691da177e4SLinus Torvalds uint32_t ofs, uint32_t len) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds int ret; 2721da177e4SLinus Torvalds size_t retlen; 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 2751da177e4SLinus Torvalds if (ret) { 2761da177e4SLinus Torvalds D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret)); 2771da177e4SLinus Torvalds return ret; 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds if (retlen < len) { 2801da177e4SLinus Torvalds D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen)); 2811da177e4SLinus Torvalds return -EIO; 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Read 0x%x bytes from 0x%08x into buf\n", len, ofs)); 2841da177e4SLinus Torvalds D2(printk(KERN_DEBUG "000: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", 2851da177e4SLinus Torvalds 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])); 2861da177e4SLinus Torvalds return 0; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 2901da177e4SLinus Torvalds unsigned char *buf, uint32_t buf_size) { 2911da177e4SLinus Torvalds struct jffs2_unknown_node *node; 2921da177e4SLinus Torvalds struct jffs2_unknown_node crcnode; 2931da177e4SLinus Torvalds uint32_t ofs, prevofs; 2941da177e4SLinus Torvalds uint32_t hdr_crc, buf_ofs, buf_len; 2951da177e4SLinus Torvalds int err; 2961da177e4SLinus Torvalds int noise = 0; 2971da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_FS_NAND 2981da177e4SLinus Torvalds int cleanmarkerfound = 0; 2991da177e4SLinus Torvalds #endif 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds ofs = jeb->offset; 3021da177e4SLinus Torvalds prevofs = jeb->offset - 1; 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs)); 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_FS_NAND 3071da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 3081da177e4SLinus Torvalds int ret = jffs2_check_nand_cleanmarker(c, jeb); 3091da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret)); 3101da177e4SLinus Torvalds /* Even if it's not found, we still scan to see 3111da177e4SLinus Torvalds if the block is empty. We use this information 3121da177e4SLinus Torvalds to decide whether to erase it or not. */ 3131da177e4SLinus Torvalds switch (ret) { 3141da177e4SLinus Torvalds case 0: cleanmarkerfound = 1; break; 3151da177e4SLinus Torvalds case 1: break; 3161da177e4SLinus Torvalds case 2: return BLK_STATE_BADBLOCK; 3171da177e4SLinus Torvalds case 3: return BLK_STATE_ALLDIRTY; /* Block has failed to erase min. once */ 3181da177e4SLinus Torvalds default: return ret; 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds #endif 3221da177e4SLinus Torvalds buf_ofs = jeb->offset; 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds if (!buf_size) { 3251da177e4SLinus Torvalds buf_len = c->sector_size; 3261da177e4SLinus Torvalds } else { 3273be36675SAndrew Victor buf_len = EMPTY_SCAN_SIZE(c->sector_size); 3281da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 3291da177e4SLinus Torvalds if (err) 3301da177e4SLinus Torvalds return err; 3311da177e4SLinus Torvalds } 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 3341da177e4SLinus Torvalds ofs = 0; 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds /* Scan only 4KiB of 0xFF before declaring it's empty */ 3373be36675SAndrew Victor while(ofs < EMPTY_SCAN_SIZE(c->sector_size) && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) 3381da177e4SLinus Torvalds ofs += 4; 3391da177e4SLinus Torvalds 3403be36675SAndrew Victor if (ofs == EMPTY_SCAN_SIZE(c->sector_size)) { 3411da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_FS_NAND 3421da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 3431da177e4SLinus Torvalds /* scan oob, take care of cleanmarker */ 3441da177e4SLinus Torvalds int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 3451da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret)); 3461da177e4SLinus Torvalds switch (ret) { 3471da177e4SLinus Torvalds case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 3481da177e4SLinus Torvalds case 1: return BLK_STATE_ALLDIRTY; 3491da177e4SLinus Torvalds default: return ret; 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds #endif 3531da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset)); 3541da177e4SLinus Torvalds return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 3551da177e4SLinus Torvalds } 3561da177e4SLinus Torvalds if (ofs) { 3571da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset, 3581da177e4SLinus Torvalds jeb->offset + ofs)); 3591da177e4SLinus Torvalds DIRTY_SPACE(ofs); 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds /* Now ofs is a complete physical flash offset as it always was... */ 3631da177e4SLinus Torvalds ofs += jeb->offset; 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds noise = 10; 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds scan_more: 3681da177e4SLinus Torvalds while(ofs < jeb->offset + c->sector_size) { 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds cond_resched(); 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds if (ofs & 3) { 3751da177e4SLinus Torvalds printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs); 3761da177e4SLinus Torvalds ofs = PAD(ofs); 3771da177e4SLinus Torvalds continue; 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds if (ofs == prevofs) { 3801da177e4SLinus Torvalds printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs); 3811da177e4SLinus Torvalds DIRTY_SPACE(4); 3821da177e4SLinus Torvalds ofs += 4; 3831da177e4SLinus Torvalds continue; 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds prevofs = ofs; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 3881da177e4SLinus Torvalds 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), 3891da177e4SLinus Torvalds jeb->offset, c->sector_size, ofs, sizeof(*node))); 3901da177e4SLinus Torvalds DIRTY_SPACE((jeb->offset + c->sector_size)-ofs); 3911da177e4SLinus Torvalds break; 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(*node)) { 3951da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 3961da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 3971da177e4SLinus Torvalds sizeof(struct jffs2_unknown_node), buf_len, ofs)); 3981da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 3991da177e4SLinus Torvalds if (err) 4001da177e4SLinus Torvalds return err; 4011da177e4SLinus Torvalds buf_ofs = ofs; 4021da177e4SLinus Torvalds } 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs]; 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) { 4071da177e4SLinus Torvalds uint32_t inbuf_ofs; 4081da177e4SLinus Torvalds uint32_t empty_start; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds empty_start = ofs; 4111da177e4SLinus Torvalds ofs += 4; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs)); 4141da177e4SLinus Torvalds more_empty: 4151da177e4SLinus Torvalds inbuf_ofs = ofs - buf_ofs; 4161da177e4SLinus Torvalds while (inbuf_ofs < buf_len) { 4171da177e4SLinus Torvalds if (*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff) { 4181da177e4SLinus Torvalds printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", 4191da177e4SLinus Torvalds empty_start, ofs); 4201da177e4SLinus Torvalds DIRTY_SPACE(ofs-empty_start); 4211da177e4SLinus Torvalds goto scan_more; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds inbuf_ofs+=4; 4251da177e4SLinus Torvalds ofs += 4; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds /* Ran off end. */ 4281da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash to end of buffer at 0x%08x\n", ofs)); 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds /* If we're only checking the beginning of a block with a cleanmarker, 4311da177e4SLinus Torvalds bail now */ 4321da177e4SLinus Torvalds if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 4331da177e4SLinus Torvalds c->cleanmarker_size && !jeb->dirty_size && !jeb->first_node->next_in_ino) { 4343be36675SAndrew Victor D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c->sector_size))); 4351da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 4361da177e4SLinus Torvalds } 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds /* See how much more there is to read in this eraseblock... */ 4391da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 4401da177e4SLinus Torvalds if (!buf_len) { 4411da177e4SLinus Torvalds /* No more to read. Break out of main loop without marking 4421da177e4SLinus Torvalds this range of empty space as dirty (because it's not) */ 4431da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash at %08x runs to end of block. Treating as free_space\n", 4441da177e4SLinus Torvalds empty_start)); 4451da177e4SLinus Torvalds break; 4461da177e4SLinus Torvalds } 4471da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Reading another 0x%x at 0x%08x\n", buf_len, ofs)); 4481da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 4491da177e4SLinus Torvalds if (err) 4501da177e4SLinus Torvalds return err; 4511da177e4SLinus Torvalds buf_ofs = ofs; 4521da177e4SLinus Torvalds goto more_empty; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 4561da177e4SLinus Torvalds printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs); 4571da177e4SLinus Torvalds DIRTY_SPACE(4); 4581da177e4SLinus Torvalds ofs += 4; 4591da177e4SLinus Torvalds continue; 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 4621da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs)); 4631da177e4SLinus Torvalds DIRTY_SPACE(4); 4641da177e4SLinus Torvalds ofs += 4; 4651da177e4SLinus Torvalds continue; 4661da177e4SLinus Torvalds } 4671da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 4681da177e4SLinus Torvalds printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs); 4691da177e4SLinus Torvalds printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n"); 4701da177e4SLinus Torvalds DIRTY_SPACE(4); 4711da177e4SLinus Torvalds ofs += 4; 4721da177e4SLinus Torvalds continue; 4731da177e4SLinus Torvalds } 4741da177e4SLinus Torvalds if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 4751da177e4SLinus Torvalds /* OK. We're out of possibilities. Whinge and move on */ 4761da177e4SLinus Torvalds noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 4771da177e4SLinus Torvalds JFFS2_MAGIC_BITMASK, ofs, 4781da177e4SLinus Torvalds je16_to_cpu(node->magic)); 4791da177e4SLinus Torvalds DIRTY_SPACE(4); 4801da177e4SLinus Torvalds ofs += 4; 4811da177e4SLinus Torvalds continue; 4821da177e4SLinus Torvalds } 4831da177e4SLinus Torvalds /* We seem to have a node of sorts. Check the CRC */ 4841da177e4SLinus Torvalds crcnode.magic = node->magic; 4851da177e4SLinus Torvalds crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE); 4861da177e4SLinus Torvalds crcnode.totlen = node->totlen; 4871da177e4SLinus Torvalds hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 4901da177e4SLinus Torvalds 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", 4911da177e4SLinus Torvalds ofs, je16_to_cpu(node->magic), 4921da177e4SLinus Torvalds je16_to_cpu(node->nodetype), 4931da177e4SLinus Torvalds je32_to_cpu(node->totlen), 4941da177e4SLinus Torvalds je32_to_cpu(node->hdr_crc), 4951da177e4SLinus Torvalds hdr_crc); 4961da177e4SLinus Torvalds DIRTY_SPACE(4); 4971da177e4SLinus Torvalds ofs += 4; 4981da177e4SLinus Torvalds continue; 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds if (ofs + je32_to_cpu(node->totlen) > 5021da177e4SLinus Torvalds jeb->offset + c->sector_size) { 5031da177e4SLinus Torvalds /* Eep. Node goes over the end of the erase block. */ 5041da177e4SLinus Torvalds printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 5051da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen)); 5061da177e4SLinus Torvalds printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n"); 5071da177e4SLinus Torvalds DIRTY_SPACE(4); 5081da177e4SLinus Torvalds ofs += 4; 5091da177e4SLinus Torvalds continue; 5101da177e4SLinus Torvalds } 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 5131da177e4SLinus Torvalds /* Wheee. This is an obsoleted node */ 5141da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs)); 5151da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 5161da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 5171da177e4SLinus Torvalds continue; 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds switch(je16_to_cpu(node->nodetype)) { 5211da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 5221da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 5231da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 5241da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 5251da177e4SLinus Torvalds sizeof(struct jffs2_raw_inode), buf_len, ofs)); 5261da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 5271da177e4SLinus Torvalds if (err) 5281da177e4SLinus Torvalds return err; 5291da177e4SLinus Torvalds buf_ofs = ofs; 5301da177e4SLinus Torvalds node = (void *)buf; 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs); 5331da177e4SLinus Torvalds if (err) return err; 5341da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 5351da177e4SLinus Torvalds break; 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 5381da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 5391da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 5401da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 5411da177e4SLinus Torvalds je32_to_cpu(node->totlen), buf_len, ofs)); 5421da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 5431da177e4SLinus Torvalds if (err) 5441da177e4SLinus Torvalds return err; 5451da177e4SLinus Torvalds buf_ofs = ofs; 5461da177e4SLinus Torvalds node = (void *)buf; 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs); 5491da177e4SLinus Torvalds if (err) return err; 5501da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 5511da177e4SLinus Torvalds break; 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds case JFFS2_NODETYPE_CLEANMARKER: 5541da177e4SLinus Torvalds D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs)); 5551da177e4SLinus Torvalds if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 5561da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 5571da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen), c->cleanmarker_size); 5581da177e4SLinus Torvalds DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node))); 5591da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 5601da177e4SLinus Torvalds } else if (jeb->first_node) { 5611da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset); 5621da177e4SLinus Torvalds DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node))); 5631da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 5641da177e4SLinus Torvalds } else { 5651da177e4SLinus Torvalds struct jffs2_raw_node_ref *marker_ref = jffs2_alloc_raw_node_ref(); 5661da177e4SLinus Torvalds if (!marker_ref) { 5671da177e4SLinus Torvalds printk(KERN_NOTICE "Failed to allocate node ref for clean marker\n"); 5681da177e4SLinus Torvalds return -ENOMEM; 5691da177e4SLinus Torvalds } 5701da177e4SLinus Torvalds marker_ref->next_in_ino = NULL; 5711da177e4SLinus Torvalds marker_ref->next_phys = NULL; 5721da177e4SLinus Torvalds marker_ref->flash_offset = ofs | REF_NORMAL; 5731da177e4SLinus Torvalds marker_ref->__totlen = c->cleanmarker_size; 5741da177e4SLinus Torvalds jeb->first_node = jeb->last_node = marker_ref; 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds USED_SPACE(PAD(c->cleanmarker_size)); 5771da177e4SLinus Torvalds ofs += PAD(c->cleanmarker_size); 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds break; 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds case JFFS2_NODETYPE_PADDING: 5821da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 5831da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 5841da177e4SLinus Torvalds break; 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds default: 5871da177e4SLinus Torvalds switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 5881da177e4SLinus Torvalds case JFFS2_FEATURE_ROCOMPAT: 5891da177e4SLinus Torvalds printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 5901da177e4SLinus Torvalds c->flags |= JFFS2_SB_FLAG_RO; 5911da177e4SLinus Torvalds if (!(jffs2_is_readonly(c))) 5921da177e4SLinus Torvalds return -EROFS; 5931da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 5941da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 5951da177e4SLinus Torvalds break; 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds case JFFS2_FEATURE_INCOMPAT: 5981da177e4SLinus Torvalds printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 5991da177e4SLinus Torvalds return -EINVAL; 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_DELETE: 6021da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 6031da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 6041da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 6051da177e4SLinus Torvalds break; 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_COPY: 6081da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 6091da177e4SLinus Torvalds USED_SPACE(PAD(je32_to_cpu(node->totlen))); 6101da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 6111da177e4SLinus Torvalds break; 6121da177e4SLinus Torvalds } 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb->offset, 6181da177e4SLinus Torvalds jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size)); 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds /* mark_node_obsolete can add to wasted !! */ 6211da177e4SLinus Torvalds if (jeb->wasted_size) { 6221da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 6231da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 6241da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 6251da177e4SLinus Torvalds jeb->wasted_size = 0; 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size 6291da177e4SLinus Torvalds && (!jeb->first_node || !jeb->first_node->next_in_ino) ) 6301da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds /* move blocks with max 4 byte dirty space to cleanlist */ 6331da177e4SLinus Torvalds else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) { 6341da177e4SLinus Torvalds c->dirty_size -= jeb->dirty_size; 6351da177e4SLinus Torvalds c->wasted_size += jeb->dirty_size; 6361da177e4SLinus Torvalds jeb->wasted_size += jeb->dirty_size; 6371da177e4SLinus Torvalds jeb->dirty_size = 0; 6381da177e4SLinus Torvalds return BLK_STATE_CLEAN; 6391da177e4SLinus Torvalds } else if (jeb->used_size || jeb->unchecked_size) 6401da177e4SLinus Torvalds return BLK_STATE_PARTDIRTY; 6411da177e4SLinus Torvalds else 6421da177e4SLinus Torvalds return BLK_STATE_ALLDIRTY; 6431da177e4SLinus Torvalds } 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds static struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 6501da177e4SLinus Torvalds if (ic) 6511da177e4SLinus Torvalds return ic; 6521da177e4SLinus Torvalds 6531da177e4SLinus Torvalds if (ino > c->highest_ino) 6541da177e4SLinus Torvalds c->highest_ino = ino; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 6571da177e4SLinus Torvalds if (!ic) { 6581da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n"); 6591da177e4SLinus Torvalds return NULL; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds ic->ino = ino; 6641da177e4SLinus Torvalds ic->nodes = (void *)ic; 6651da177e4SLinus Torvalds jffs2_add_ino_cache(c, ic); 6661da177e4SLinus Torvalds if (ino == 1) 6671da177e4SLinus Torvalds ic->nlink = 1; 6681da177e4SLinus Torvalds return ic; 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 6721da177e4SLinus Torvalds struct jffs2_raw_inode *ri, uint32_t ofs) 6731da177e4SLinus Torvalds { 6741da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 6751da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 6761da177e4SLinus Torvalds uint32_t ino = je32_to_cpu(ri->ino); 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs)); 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds /* We do very little here now. Just check the ino# to which we should attribute 6811da177e4SLinus Torvalds this node; we can do all the CRC checking etc. later. There's a tradeoff here -- 6821da177e4SLinus Torvalds we used to scan the flash once only, reading everything we want from it into 6831da177e4SLinus Torvalds memory, then building all our in-core data structures and freeing the extra 6841da177e4SLinus Torvalds information. Now we allow the first part of the mount to complete a lot quicker, 6851da177e4SLinus Torvalds but we have to go _back_ to the flash in order to finish the CRC checking, etc. 6861da177e4SLinus Torvalds Which means that the _full_ amount of time to get to proper write mode with GC 6871da177e4SLinus Torvalds operational may actually be _longer_ than before. Sucks to be me. */ 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds raw = jffs2_alloc_raw_node_ref(); 6901da177e4SLinus Torvalds if (!raw) { 6911da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_inode_node(): allocation of node reference failed\n"); 6921da177e4SLinus Torvalds return -ENOMEM; 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 6961da177e4SLinus Torvalds if (!ic) { 6971da177e4SLinus Torvalds /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the 6981da177e4SLinus Torvalds first node we found for this inode. Do a CRC check to protect against the former 6991da177e4SLinus Torvalds case */ 7001da177e4SLinus Torvalds uint32_t crc = crc32(0, ri, sizeof(*ri)-8); 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds if (crc != je32_to_cpu(ri->node_crc)) { 7031da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 7041da177e4SLinus Torvalds ofs, je32_to_cpu(ri->node_crc), crc); 7051da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 7061da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(ri->totlen))); 7071da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 7081da177e4SLinus Torvalds return 0; 7091da177e4SLinus Torvalds } 7101da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, ino); 7111da177e4SLinus Torvalds if (!ic) { 7121da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 7131da177e4SLinus Torvalds return -ENOMEM; 7141da177e4SLinus Torvalds } 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds /* Wheee. It worked */ 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds raw->flash_offset = ofs | REF_UNCHECKED; 7201da177e4SLinus Torvalds raw->__totlen = PAD(je32_to_cpu(ri->totlen)); 7211da177e4SLinus Torvalds raw->next_phys = NULL; 7221da177e4SLinus Torvalds raw->next_in_ino = ic->nodes; 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds ic->nodes = raw; 7251da177e4SLinus Torvalds if (!jeb->first_node) 7261da177e4SLinus Torvalds jeb->first_node = raw; 7271da177e4SLinus Torvalds if (jeb->last_node) 7281da177e4SLinus Torvalds jeb->last_node->next_phys = raw; 7291da177e4SLinus Torvalds jeb->last_node = raw; 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 7321da177e4SLinus Torvalds je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 7331da177e4SLinus Torvalds je32_to_cpu(ri->offset), 7341da177e4SLinus Torvalds je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize))); 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds pseudo_random += je32_to_cpu(ri->version); 7371da177e4SLinus Torvalds 7381da177e4SLinus Torvalds UNCHECKED_SPACE(PAD(je32_to_cpu(ri->totlen))); 7391da177e4SLinus Torvalds return 0; 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 7431da177e4SLinus Torvalds struct jffs2_raw_dirent *rd, uint32_t ofs) 7441da177e4SLinus Torvalds { 7451da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 7461da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 7471da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 7481da177e4SLinus Torvalds uint32_t crc; 7491da177e4SLinus Torvalds 7501da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs)); 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds /* We don't get here unless the node is still valid, so we don't have to 7531da177e4SLinus Torvalds mask in the ACCURATE bit any more. */ 7541da177e4SLinus Torvalds crc = crc32(0, rd, sizeof(*rd)-8); 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->node_crc)) { 7571da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 7581da177e4SLinus Torvalds ofs, je32_to_cpu(rd->node_crc), crc); 7591da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 7601da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen))); 7611da177e4SLinus Torvalds return 0; 7621da177e4SLinus Torvalds } 7631da177e4SLinus Torvalds 7641da177e4SLinus Torvalds pseudo_random += je32_to_cpu(rd->version); 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(rd->nsize+1); 7671da177e4SLinus Torvalds if (!fd) { 7681da177e4SLinus Torvalds return -ENOMEM; 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds memcpy(&fd->name, rd->name, rd->nsize); 7711da177e4SLinus Torvalds fd->name[rd->nsize] = 0; 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds crc = crc32(0, fd->name, rd->nsize); 7741da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->name_crc)) { 7751da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 7761da177e4SLinus Torvalds ofs, je32_to_cpu(rd->name_crc), crc); 7771da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino))); 7781da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 7791da177e4SLinus Torvalds /* FIXME: Why do we believe totlen? */ 7801da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */ 7811da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen))); 7821da177e4SLinus Torvalds return 0; 7831da177e4SLinus Torvalds } 7841da177e4SLinus Torvalds raw = jffs2_alloc_raw_node_ref(); 7851da177e4SLinus Torvalds if (!raw) { 7861da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 7871da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): allocation of node reference failed\n"); 7881da177e4SLinus Torvalds return -ENOMEM; 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino)); 7911da177e4SLinus Torvalds if (!ic) { 7921da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 7931da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 7941da177e4SLinus Torvalds return -ENOMEM; 7951da177e4SLinus Torvalds } 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds raw->__totlen = PAD(je32_to_cpu(rd->totlen)); 7981da177e4SLinus Torvalds raw->flash_offset = ofs | REF_PRISTINE; 7991da177e4SLinus Torvalds raw->next_phys = NULL; 8001da177e4SLinus Torvalds raw->next_in_ino = ic->nodes; 8011da177e4SLinus Torvalds ic->nodes = raw; 8021da177e4SLinus Torvalds if (!jeb->first_node) 8031da177e4SLinus Torvalds jeb->first_node = raw; 8041da177e4SLinus Torvalds if (jeb->last_node) 8051da177e4SLinus Torvalds jeb->last_node->next_phys = raw; 8061da177e4SLinus Torvalds jeb->last_node = raw; 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds fd->raw = raw; 8091da177e4SLinus Torvalds fd->next = NULL; 8101da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 8111da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 8121da177e4SLinus Torvalds fd->nhash = full_name_hash(fd->name, rd->nsize); 8131da177e4SLinus Torvalds fd->type = rd->type; 8141da177e4SLinus Torvalds USED_SPACE(PAD(je32_to_cpu(rd->totlen))); 8151da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &ic->scan_dents); 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds return 0; 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds static int count_list(struct list_head *l) 8211da177e4SLinus Torvalds { 8221da177e4SLinus Torvalds uint32_t count = 0; 8231da177e4SLinus Torvalds struct list_head *tmp; 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds list_for_each(tmp, l) { 8261da177e4SLinus Torvalds count++; 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds return count; 8291da177e4SLinus Torvalds } 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds /* Note: This breaks if list_empty(head). I don't care. You 8321da177e4SLinus Torvalds might, if you copy this code and use it elsewhere :) */ 8331da177e4SLinus Torvalds static void rotate_list(struct list_head *head, uint32_t count) 8341da177e4SLinus Torvalds { 8351da177e4SLinus Torvalds struct list_head *n = head->next; 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds list_del(head); 8381da177e4SLinus Torvalds while(count--) { 8391da177e4SLinus Torvalds n = n->next; 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds list_add(head, n); 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds 8441da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c) 8451da177e4SLinus Torvalds { 8461da177e4SLinus Torvalds uint32_t x; 8471da177e4SLinus Torvalds uint32_t rotateby; 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds x = count_list(&c->clean_list); 8501da177e4SLinus Torvalds if (x) { 8511da177e4SLinus Torvalds rotateby = pseudo_random % x; 8521da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Rotating clean_list by %d\n", rotateby)); 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds rotate_list((&c->clean_list), rotateby); 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Erase block at front of clean_list is at %08x\n", 8571da177e4SLinus Torvalds list_entry(c->clean_list.next, struct jffs2_eraseblock, list)->offset)); 8581da177e4SLinus Torvalds } else { 8591da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not rotating empty clean_list\n")); 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds x = count_list(&c->very_dirty_list); 8631da177e4SLinus Torvalds if (x) { 8641da177e4SLinus Torvalds rotateby = pseudo_random % x; 8651da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Rotating very_dirty_list by %d\n", rotateby)); 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds rotate_list((&c->very_dirty_list), rotateby); 8681da177e4SLinus Torvalds 8691da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Erase block at front of very_dirty_list is at %08x\n", 8701da177e4SLinus Torvalds list_entry(c->very_dirty_list.next, struct jffs2_eraseblock, list)->offset)); 8711da177e4SLinus Torvalds } else { 8721da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not rotating empty very_dirty_list\n")); 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds x = count_list(&c->dirty_list); 8761da177e4SLinus Torvalds if (x) { 8771da177e4SLinus Torvalds rotateby = pseudo_random % x; 8781da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Rotating dirty_list by %d\n", rotateby)); 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds rotate_list((&c->dirty_list), rotateby); 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Erase block at front of dirty_list is at %08x\n", 8831da177e4SLinus Torvalds list_entry(c->dirty_list.next, struct jffs2_eraseblock, list)->offset)); 8841da177e4SLinus Torvalds } else { 8851da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not rotating empty dirty_list\n")); 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds 8881da177e4SLinus Torvalds x = count_list(&c->erasable_list); 8891da177e4SLinus Torvalds if (x) { 8901da177e4SLinus Torvalds rotateby = pseudo_random % x; 8911da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Rotating erasable_list by %d\n", rotateby)); 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds rotate_list((&c->erasable_list), rotateby); 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Erase block at front of erasable_list is at %08x\n", 8961da177e4SLinus Torvalds list_entry(c->erasable_list.next, struct jffs2_eraseblock, list)->offset)); 8971da177e4SLinus Torvalds } else { 8981da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not rotating empty erasable_list\n")); 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds 9011da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 9021da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_erasing_blocks; 9031da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Rotating erase_pending_list by %d\n", rotateby)); 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds rotate_list((&c->erase_pending_list), rotateby); 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Erase block at front of erase_pending_list is at %08x\n", 9081da177e4SLinus Torvalds list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list)->offset)); 9091da177e4SLinus Torvalds } else { 9101da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not rotating empty erase_pending_list\n")); 9111da177e4SLinus Torvalds } 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds if (c->nr_free_blocks) { 9141da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_free_blocks; 9151da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Rotating free_list by %d\n", rotateby)); 9161da177e4SLinus Torvalds 9171da177e4SLinus Torvalds rotate_list((&c->free_list), rotateby); 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Erase block at front of free_list is at %08x\n", 9201da177e4SLinus Torvalds list_entry(c->free_list.next, struct jffs2_eraseblock, list)->offset)); 9211da177e4SLinus Torvalds } else { 9221da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Not rotating empty free_list\n")); 9231da177e4SLinus Torvalds } 9241da177e4SLinus Torvalds } 925