11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 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 * 101da177e4SLinus Torvalds */ 11c00c310eSDavid Woodhouse 121da177e4SLinus Torvalds #include <linux/kernel.h> 131da177e4SLinus Torvalds #include <linux/sched.h> 141da177e4SLinus Torvalds #include <linux/slab.h> 151da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 161da177e4SLinus Torvalds #include <linux/pagemap.h> 171da177e4SLinus Torvalds #include <linux/crc32.h> 181da177e4SLinus Torvalds #include <linux/compiler.h> 191da177e4SLinus Torvalds #include "nodelist.h" 20e631ddbaSFerenc Havasi #include "summary.h" 21e631ddbaSFerenc Havasi #include "debug.h" 221da177e4SLinus Torvalds 2341bdc602SJoakim Tjernlund #define DEFAULT_EMPTY_SCAN_SIZE 256 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds #define noisy_printk(noise, args...) do { \ 261da177e4SLinus Torvalds if (*(noise)) { \ 271da177e4SLinus Torvalds printk(KERN_NOTICE args); \ 281da177e4SLinus Torvalds (*(noise))--; \ 291da177e4SLinus Torvalds if (!(*(noise))) { \ 301da177e4SLinus Torvalds printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \ 311da177e4SLinus Torvalds } \ 321da177e4SLinus Torvalds } \ 331da177e4SLinus Torvalds } while(0) 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds static uint32_t pseudo_random; 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 38e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s); 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds /* These helper functions _must_ increase ofs and also do the dirty/used space accounting. 411da177e4SLinus Torvalds * Returning an error will abort the mount - bad checksums etc. should just mark the space 421da177e4SLinus Torvalds * as dirty. 431da177e4SLinus Torvalds */ 441da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 45e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s); 461da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 47e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s); 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds static inline int min_free(struct jffs2_sb_info *c) 501da177e4SLinus Torvalds { 511da177e4SLinus Torvalds uint32_t min = 2 * sizeof(struct jffs2_raw_inode); 522f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 531da177e4SLinus Torvalds if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize) 541da177e4SLinus Torvalds return c->wbuf_pagesize; 551da177e4SLinus Torvalds #endif 561da177e4SLinus Torvalds return min; 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds } 593be36675SAndrew Victor 603be36675SAndrew Victor static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) { 613be36675SAndrew Victor if (sector_size < DEFAULT_EMPTY_SCAN_SIZE) 623be36675SAndrew Victor return sector_size; 633be36675SAndrew Victor else 643be36675SAndrew Victor return DEFAULT_EMPTY_SCAN_SIZE; 653be36675SAndrew Victor } 663be36675SAndrew Victor 6725090a6bSDavid Woodhouse static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 6825090a6bSDavid Woodhouse { 69a6a8bef7SDavid Woodhouse int ret; 70a6a8bef7SDavid Woodhouse 71a6a8bef7SDavid Woodhouse if ((ret = jffs2_prealloc_raw_node_refs(c, jeb, 1))) 72a6a8bef7SDavid Woodhouse return ret; 73a6a8bef7SDavid Woodhouse if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size))) 7425090a6bSDavid Woodhouse return ret; 7525090a6bSDavid Woodhouse /* Turned wasted size into dirty, since we apparently 7625090a6bSDavid Woodhouse think it's recoverable now. */ 7725090a6bSDavid Woodhouse jeb->dirty_size += jeb->wasted_size; 7825090a6bSDavid Woodhouse c->dirty_size += jeb->wasted_size; 7925090a6bSDavid Woodhouse c->wasted_size -= jeb->wasted_size; 8025090a6bSDavid Woodhouse jeb->wasted_size = 0; 8125090a6bSDavid Woodhouse if (VERYDIRTY(c, jeb->dirty_size)) { 8225090a6bSDavid Woodhouse list_add(&jeb->list, &c->very_dirty_list); 8325090a6bSDavid Woodhouse } else { 8425090a6bSDavid Woodhouse list_add(&jeb->list, &c->dirty_list); 8525090a6bSDavid Woodhouse } 8625090a6bSDavid Woodhouse return 0; 8725090a6bSDavid Woodhouse } 8825090a6bSDavid Woodhouse 891da177e4SLinus Torvalds int jffs2_scan_medium(struct jffs2_sb_info *c) 901da177e4SLinus Torvalds { 911da177e4SLinus Torvalds int i, ret; 921da177e4SLinus Torvalds uint32_t empty_blocks = 0, bad_blocks = 0; 931da177e4SLinus Torvalds unsigned char *flashbuf = NULL; 941da177e4SLinus Torvalds uint32_t buf_size = 0; 95e631ddbaSFerenc Havasi struct jffs2_summary *s = NULL; /* summary info collected by the scan process */ 961da177e4SLinus Torvalds #ifndef __ECOS 971ddd0d9aSGrant Erickson size_t pointlen, try_size; 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds if (c->mtd->point) { 100d35ea200SArtem Bityutskiy ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen, 101a98889f3SJared Hulbert (void **)&flashbuf, NULL); 1021da177e4SLinus Torvalds if (!ret && pointlen < c->mtd->size) { 1031da177e4SLinus Torvalds /* Don't muck about if it won't let us point to the whole flash */ 1041da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen)); 105a98889f3SJared Hulbert c->mtd->unpoint(c->mtd, 0, pointlen); 1061da177e4SLinus Torvalds flashbuf = NULL; 1071da177e4SLinus Torvalds } 1081da177e4SLinus Torvalds if (ret) 1091da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point failed %d\n", ret)); 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds #endif 1121da177e4SLinus Torvalds if (!flashbuf) { 1131da177e4SLinus Torvalds /* For NAND it's quicker to read a whole eraseblock at a time, 1141da177e4SLinus Torvalds apparently */ 1151da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) 1161ddd0d9aSGrant Erickson try_size = c->sector_size; 1171da177e4SLinus Torvalds else 1181ddd0d9aSGrant Erickson try_size = PAGE_SIZE; 1191da177e4SLinus Torvalds 1201ddd0d9aSGrant Erickson D1(printk(KERN_DEBUG "Trying to allocate readbuf of %zu " 1211ddd0d9aSGrant Erickson "bytes\n", try_size)); 1221da177e4SLinus Torvalds 1231ddd0d9aSGrant Erickson flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size); 1241da177e4SLinus Torvalds if (!flashbuf) 1251da177e4SLinus Torvalds return -ENOMEM; 1261ddd0d9aSGrant Erickson 1271ddd0d9aSGrant Erickson D1(printk(KERN_DEBUG "Allocated readbuf of %zu bytes\n", 1281ddd0d9aSGrant Erickson try_size)); 1291ddd0d9aSGrant Erickson 1301ddd0d9aSGrant Erickson buf_size = (uint32_t)try_size; 1311da177e4SLinus Torvalds } 1321da177e4SLinus Torvalds 133e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1343d375d9eSYan Burman s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL); 135e631ddbaSFerenc Havasi if (!s) { 136e631ddbaSFerenc Havasi JFFS2_WARNING("Can't allocate memory for summary\n"); 13748396413SDavid Woodhouse ret = -ENOMEM; 13848396413SDavid Woodhouse goto out; 139e631ddbaSFerenc Havasi } 140e631ddbaSFerenc Havasi } 141e631ddbaSFerenc Havasi 1421da177e4SLinus Torvalds for (i=0; i<c->nr_blocks; i++) { 1431da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[i]; 1441da177e4SLinus Torvalds 145a2166b93SArtem Bityutskiy cond_resched(); 146a2166b93SArtem Bityutskiy 147e631ddbaSFerenc Havasi /* reset summary info for next eraseblock scan */ 148e631ddbaSFerenc Havasi jffs2_sum_reset_collected(s); 149e631ddbaSFerenc Havasi 150e631ddbaSFerenc Havasi ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), 151e631ddbaSFerenc Havasi buf_size, s); 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds if (ret < 0) 1541da177e4SLinus Torvalds goto out; 1551da177e4SLinus Torvalds 156e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds /* Now decide which list to put it on */ 1591da177e4SLinus Torvalds switch(ret) { 1601da177e4SLinus Torvalds case BLK_STATE_ALLFF: 1611da177e4SLinus Torvalds /* 1621da177e4SLinus Torvalds * Empty block. Since we can't be sure it 1631da177e4SLinus Torvalds * was entirely erased, we just queue it for erase 1641da177e4SLinus Torvalds * again. It will be marked as such when the erase 1651da177e4SLinus Torvalds * is complete. Meanwhile we still count it as empty 1661da177e4SLinus Torvalds * for later checks. 1671da177e4SLinus Torvalds */ 1681da177e4SLinus Torvalds empty_blocks++; 1691da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1701da177e4SLinus Torvalds c->nr_erasing_blocks++; 1711da177e4SLinus Torvalds break; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds case BLK_STATE_CLEANMARKER: 1741da177e4SLinus Torvalds /* Only a CLEANMARKER node is valid */ 1751da177e4SLinus Torvalds if (!jeb->dirty_size) { 1761da177e4SLinus Torvalds /* It's actually free */ 1771da177e4SLinus Torvalds list_add(&jeb->list, &c->free_list); 1781da177e4SLinus Torvalds c->nr_free_blocks++; 1791da177e4SLinus Torvalds } else { 1801da177e4SLinus Torvalds /* Dirt */ 1811da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset)); 1821da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1831da177e4SLinus Torvalds c->nr_erasing_blocks++; 1841da177e4SLinus Torvalds } 1851da177e4SLinus Torvalds break; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds case BLK_STATE_CLEAN: 1881da177e4SLinus Torvalds /* Full (or almost full) of clean data. Clean list */ 1891da177e4SLinus Torvalds list_add(&jeb->list, &c->clean_list); 1901da177e4SLinus Torvalds break; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds case BLK_STATE_PARTDIRTY: 1931da177e4SLinus Torvalds /* Some data, but not full. Dirty list. */ 1941da177e4SLinus Torvalds /* We want to remember the block with most free space 1951da177e4SLinus Torvalds and stick it in the 'nextblock' position to start writing to it. */ 1961da177e4SLinus Torvalds if (jeb->free_size > min_free(c) && 1971da177e4SLinus Torvalds (!c->nextblock || c->nextblock->free_size < jeb->free_size)) { 1981da177e4SLinus Torvalds /* Better candidate for the next writes to go to */ 1991da177e4SLinus Torvalds if (c->nextblock) { 20025090a6bSDavid Woodhouse ret = file_dirty(c, c->nextblock); 20125090a6bSDavid Woodhouse if (ret) 202a2ab0ce0SChristian Engelmayer goto out; 203e631ddbaSFerenc Havasi /* deleting summary information of the old nextblock */ 204e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); 2051da177e4SLinus Torvalds } 20625090a6bSDavid Woodhouse /* update collected summary information for the current nextblock */ 207e631ddbaSFerenc Havasi jffs2_sum_move_collected(c, s); 208e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_scan_medium(): new nextblock = 0x%08x\n", jeb->offset)); 2091da177e4SLinus Torvalds c->nextblock = jeb; 2101da177e4SLinus Torvalds } else { 21125090a6bSDavid Woodhouse ret = file_dirty(c, jeb); 21225090a6bSDavid Woodhouse if (ret) 213a2ab0ce0SChristian Engelmayer goto out; 2141da177e4SLinus Torvalds } 2151da177e4SLinus Torvalds break; 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds case BLK_STATE_ALLDIRTY: 2181da177e4SLinus Torvalds /* Nothing valid - not even a clean marker. Needs erasing. */ 2191da177e4SLinus Torvalds /* For now we just put it on the erasing list. We'll start the erases later */ 2201da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset)); 2211da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 2221da177e4SLinus Torvalds c->nr_erasing_blocks++; 2231da177e4SLinus Torvalds break; 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds case BLK_STATE_BADBLOCK: 2261da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset)); 2271da177e4SLinus Torvalds list_add(&jeb->list, &c->bad_list); 2281da177e4SLinus Torvalds c->bad_size += c->sector_size; 2291da177e4SLinus Torvalds c->free_size -= c->sector_size; 2301da177e4SLinus Torvalds bad_blocks++; 2311da177e4SLinus Torvalds break; 2321da177e4SLinus Torvalds default: 2331da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n"); 2341da177e4SLinus Torvalds BUG(); 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */ 2391da177e4SLinus Torvalds if (c->nextblock && (c->nextblock->dirty_size)) { 2401da177e4SLinus Torvalds c->nextblock->wasted_size += c->nextblock->dirty_size; 2411da177e4SLinus Torvalds c->wasted_size += c->nextblock->dirty_size; 2421da177e4SLinus Torvalds c->dirty_size -= c->nextblock->dirty_size; 2431da177e4SLinus Torvalds c->nextblock->dirty_size = 0; 2441da177e4SLinus Torvalds } 2452f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 246e96fb230SDavid Woodhouse if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) { 2471da177e4SLinus Torvalds /* If we're going to start writing into a block which already 2481da177e4SLinus Torvalds contains data, and the end of the data isn't page-aligned, 2491da177e4SLinus Torvalds skip a little and align it. */ 2501da177e4SLinus Torvalds 251daba5cc4SArtem B. Bityutskiy uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize; 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n", 2541da177e4SLinus Torvalds skip)); 255046b8b98SDavid Woodhouse jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 256f560928bSDavid Woodhouse jffs2_scan_dirty_space(c, c->nextblock, skip); 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds #endif 2591da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 2601da177e4SLinus Torvalds if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) { 2611da177e4SLinus Torvalds printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 2621da177e4SLinus Torvalds printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks); 2631da177e4SLinus Torvalds ret = -EIO; 2641da177e4SLinus Torvalds goto out; 2651da177e4SLinus Torvalds } 266ae3b6ba0SDavid Woodhouse spin_lock(&c->erase_completion_lock); 267ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 268ae3b6ba0SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds ret = 0; 2711da177e4SLinus Torvalds out: 2721da177e4SLinus Torvalds if (buf_size) 2731da177e4SLinus Torvalds kfree(flashbuf); 2741da177e4SLinus Torvalds #ifndef __ECOS 2751da177e4SLinus Torvalds else 276a98889f3SJared Hulbert c->mtd->unpoint(c->mtd, 0, c->mtd->size); 2771da177e4SLinus Torvalds #endif 2785b5ffbc1SFlorin Malita kfree(s); 2791da177e4SLinus Torvalds return ret; 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds 282c05d52c7SAdrian Bunk static int jffs2_fill_scan_buf(struct jffs2_sb_info *c, void *buf, 2831da177e4SLinus Torvalds uint32_t ofs, uint32_t len) 2841da177e4SLinus Torvalds { 2851da177e4SLinus Torvalds int ret; 2861da177e4SLinus Torvalds size_t retlen; 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 2891da177e4SLinus Torvalds if (ret) { 2901da177e4SLinus Torvalds D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret)); 2911da177e4SLinus Torvalds return ret; 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds if (retlen < len) { 2941da177e4SLinus Torvalds D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen)); 2951da177e4SLinus Torvalds return -EIO; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds return 0; 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 300e631ddbaSFerenc Havasi int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 301e631ddbaSFerenc Havasi { 302e631ddbaSFerenc Havasi if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size 30399988f7bSDavid Woodhouse && (!jeb->first_node || !ref_next(jeb->first_node)) ) 304e631ddbaSFerenc Havasi return BLK_STATE_CLEANMARKER; 305e631ddbaSFerenc Havasi 306e631ddbaSFerenc Havasi /* move blocks with max 4 byte dirty space to cleanlist */ 307e631ddbaSFerenc Havasi else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) { 308e631ddbaSFerenc Havasi c->dirty_size -= jeb->dirty_size; 309e631ddbaSFerenc Havasi c->wasted_size += jeb->dirty_size; 310e631ddbaSFerenc Havasi jeb->wasted_size += jeb->dirty_size; 311e631ddbaSFerenc Havasi jeb->dirty_size = 0; 312e631ddbaSFerenc Havasi return BLK_STATE_CLEAN; 313e631ddbaSFerenc Havasi } else if (jeb->used_size || jeb->unchecked_size) 314e631ddbaSFerenc Havasi return BLK_STATE_PARTDIRTY; 315e631ddbaSFerenc Havasi else 316e631ddbaSFerenc Havasi return BLK_STATE_ALLDIRTY; 317e631ddbaSFerenc Havasi } 318e631ddbaSFerenc Havasi 319aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 320aa98d7cfSKaiGai Kohei static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 321aa98d7cfSKaiGai Kohei struct jffs2_raw_xattr *rx, uint32_t ofs, 322aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 323aa98d7cfSKaiGai Kohei { 324aa98d7cfSKaiGai Kohei struct jffs2_xattr_datum *xd; 325c9f700f8SKaiGai Kohei uint32_t xid, version, totlen, crc; 32668270995SDavid Woodhouse int err; 327aa98d7cfSKaiGai Kohei 328aa98d7cfSKaiGai Kohei crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4); 329aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rx->node_crc)) { 330aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 331aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->node_crc), crc); 33268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 33368270995SDavid Woodhouse return err; 334aa98d7cfSKaiGai Kohei return 0; 335aa98d7cfSKaiGai Kohei } 336aa98d7cfSKaiGai Kohei 337c9f700f8SKaiGai Kohei xid = je32_to_cpu(rx->xid); 338c9f700f8SKaiGai Kohei version = je32_to_cpu(rx->version); 339c9f700f8SKaiGai Kohei 3408a13695cSKaiGai Kohei totlen = PAD(sizeof(struct jffs2_raw_xattr) 3418a13695cSKaiGai Kohei + rx->name_len + 1 + je16_to_cpu(rx->value_len)); 342aa98d7cfSKaiGai Kohei if (totlen != je32_to_cpu(rx->totlen)) { 343aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 344aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->totlen), totlen); 34568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 34668270995SDavid Woodhouse return err; 347aa98d7cfSKaiGai Kohei return 0; 348aa98d7cfSKaiGai Kohei } 349aa98d7cfSKaiGai Kohei 350c9f700f8SKaiGai Kohei xd = jffs2_setup_xattr_datum(c, xid, version); 351c9f700f8SKaiGai Kohei if (IS_ERR(xd)) 352aa98d7cfSKaiGai Kohei return PTR_ERR(xd); 353c9f700f8SKaiGai Kohei 354c9f700f8SKaiGai Kohei if (xd->version > version) { 355c9f700f8SKaiGai Kohei struct jffs2_raw_node_ref *raw 356c9f700f8SKaiGai Kohei = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, NULL); 357c9f700f8SKaiGai Kohei raw->next_in_ino = xd->node->next_in_ino; 358c9f700f8SKaiGai Kohei xd->node->next_in_ino = raw; 359c9f700f8SKaiGai Kohei } else { 360c9f700f8SKaiGai Kohei xd->version = version; 361aa98d7cfSKaiGai Kohei xd->xprefix = rx->xprefix; 362aa98d7cfSKaiGai Kohei xd->name_len = rx->name_len; 363aa98d7cfSKaiGai Kohei xd->value_len = je16_to_cpu(rx->value_len); 364aa98d7cfSKaiGai Kohei xd->data_crc = je32_to_cpu(rx->data_crc); 365aa98d7cfSKaiGai Kohei 366c9f700f8SKaiGai Kohei jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, (void *)xd); 367c9f700f8SKaiGai Kohei } 368f1f9671bSDavid Woodhouse 369aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 370aa98d7cfSKaiGai Kohei jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset); 371aa98d7cfSKaiGai Kohei dbg_xattr("scaning xdatum at %#08x (xid=%u, version=%u)\n", 372aa98d7cfSKaiGai Kohei ofs, xd->xid, xd->version); 373aa98d7cfSKaiGai Kohei return 0; 374aa98d7cfSKaiGai Kohei } 375aa98d7cfSKaiGai Kohei 376aa98d7cfSKaiGai Kohei static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 377aa98d7cfSKaiGai Kohei struct jffs2_raw_xref *rr, uint32_t ofs, 378aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 379aa98d7cfSKaiGai Kohei { 380aa98d7cfSKaiGai Kohei struct jffs2_xattr_ref *ref; 381aa98d7cfSKaiGai Kohei uint32_t crc; 38268270995SDavid Woodhouse int err; 383aa98d7cfSKaiGai Kohei 384aa98d7cfSKaiGai Kohei crc = crc32(0, rr, sizeof(*rr) - 4); 385aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rr->node_crc)) { 386aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 387aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->node_crc), crc); 38868270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen))))) 38968270995SDavid Woodhouse return err; 390aa98d7cfSKaiGai Kohei return 0; 391aa98d7cfSKaiGai Kohei } 392aa98d7cfSKaiGai Kohei 393aa98d7cfSKaiGai Kohei if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) { 39489291a9dSDavid Woodhouse JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n", 395aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->totlen), 396aa98d7cfSKaiGai Kohei PAD(sizeof(struct jffs2_raw_xref))); 39768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen)))) 39868270995SDavid Woodhouse return err; 399aa98d7cfSKaiGai Kohei return 0; 400aa98d7cfSKaiGai Kohei } 401aa98d7cfSKaiGai Kohei 402aa98d7cfSKaiGai Kohei ref = jffs2_alloc_xattr_ref(); 403aa98d7cfSKaiGai Kohei if (!ref) 404aa98d7cfSKaiGai Kohei return -ENOMEM; 405aa98d7cfSKaiGai Kohei 406aa98d7cfSKaiGai Kohei /* BEFORE jffs2_build_xattr_subsystem() called, 407c9f700f8SKaiGai Kohei * and AFTER xattr_ref is marked as a dead xref, 408aa98d7cfSKaiGai Kohei * ref->xid is used to store 32bit xid, xd is not used 409aa98d7cfSKaiGai Kohei * ref->ino is used to store 32bit inode-number, ic is not used 410aa98d7cfSKaiGai Kohei * Thoes variables are declared as union, thus using those 4118f2b6f49SKaiGai Kohei * are exclusive. In a similar way, ref->next is temporarily 412aa98d7cfSKaiGai Kohei * used to chain all xattr_ref object. It's re-chained to 413aa98d7cfSKaiGai Kohei * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly. 414aa98d7cfSKaiGai Kohei */ 415aa98d7cfSKaiGai Kohei ref->ino = je32_to_cpu(rr->ino); 416aa98d7cfSKaiGai Kohei ref->xid = je32_to_cpu(rr->xid); 417c9f700f8SKaiGai Kohei ref->xseqno = je32_to_cpu(rr->xseqno); 418c9f700f8SKaiGai Kohei if (ref->xseqno > c->highest_xseqno) 419c9f700f8SKaiGai Kohei c->highest_xseqno = (ref->xseqno & ~XREF_DELETE_MARKER); 4208f2b6f49SKaiGai Kohei ref->next = c->xref_temp; 4218f2b6f49SKaiGai Kohei c->xref_temp = ref; 422aa98d7cfSKaiGai Kohei 423c9f700f8SKaiGai Kohei jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), (void *)ref); 424f1f9671bSDavid Woodhouse 425aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 426aa98d7cfSKaiGai Kohei jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset); 427aa98d7cfSKaiGai Kohei dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n", 428aa98d7cfSKaiGai Kohei ofs, ref->xid, ref->ino); 429aa98d7cfSKaiGai Kohei return 0; 430aa98d7cfSKaiGai Kohei } 431aa98d7cfSKaiGai Kohei #endif 432aa98d7cfSKaiGai Kohei 4339641b784SDavid Woodhouse /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into 4349641b784SDavid Woodhouse the flash, XIP-style */ 4351da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 436e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) { 4371da177e4SLinus Torvalds struct jffs2_unknown_node *node; 4381da177e4SLinus Torvalds struct jffs2_unknown_node crcnode; 43941bdc602SJoakim Tjernlund uint32_t ofs, prevofs, max_ofs; 4401da177e4SLinus Torvalds uint32_t hdr_crc, buf_ofs, buf_len; 4411da177e4SLinus Torvalds int err; 4421da177e4SLinus Torvalds int noise = 0; 443e631ddbaSFerenc Havasi 444e631ddbaSFerenc Havasi 4452f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4461da177e4SLinus Torvalds int cleanmarkerfound = 0; 4471da177e4SLinus Torvalds #endif 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds ofs = jeb->offset; 4501da177e4SLinus Torvalds prevofs = jeb->offset - 1; 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs)); 4531da177e4SLinus Torvalds 4542f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4551da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 456a7a6ace1SArtem Bityutskiy int ret; 457a7a6ace1SArtem Bityutskiy 458a7a6ace1SArtem Bityutskiy if (c->mtd->block_isbad(c->mtd, jeb->offset)) 459a7a6ace1SArtem Bityutskiy return BLK_STATE_BADBLOCK; 460a7a6ace1SArtem Bityutskiy 461a7a6ace1SArtem Bityutskiy ret = jffs2_check_nand_cleanmarker(c, jeb); 4621da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret)); 463a7a6ace1SArtem Bityutskiy 4641da177e4SLinus Torvalds /* Even if it's not found, we still scan to see 4651da177e4SLinus Torvalds if the block is empty. We use this information 4661da177e4SLinus Torvalds to decide whether to erase it or not. */ 4671da177e4SLinus Torvalds switch (ret) { 4681da177e4SLinus Torvalds case 0: cleanmarkerfound = 1; break; 4691da177e4SLinus Torvalds case 1: break; 4701da177e4SLinus Torvalds default: return ret; 4711da177e4SLinus Torvalds } 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds #endif 474e631ddbaSFerenc Havasi 475e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 4769641b784SDavid Woodhouse struct jffs2_sum_marker *sm; 4779641b784SDavid Woodhouse void *sumptr = NULL; 4789641b784SDavid Woodhouse uint32_t sumlen; 479e631ddbaSFerenc Havasi 4809641b784SDavid Woodhouse if (!buf_size) { 4819641b784SDavid Woodhouse /* XIP case. Just look, point at the summary if it's there */ 48213ba42dfSDavid Woodhouse sm = (void *)buf + c->sector_size - sizeof(*sm); 483e631ddbaSFerenc Havasi if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 4849641b784SDavid Woodhouse sumptr = buf + je32_to_cpu(sm->offset); 4859641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 4869641b784SDavid Woodhouse } 4879641b784SDavid Woodhouse } else { 4889641b784SDavid Woodhouse /* If NAND flash, read a whole page of it. Else just the end */ 4899641b784SDavid Woodhouse if (c->wbuf_pagesize) 4909641b784SDavid Woodhouse buf_len = c->wbuf_pagesize; 4919641b784SDavid Woodhouse else 4929641b784SDavid Woodhouse buf_len = sizeof(*sm); 4939641b784SDavid Woodhouse 4949641b784SDavid Woodhouse /* Read as much as we want into the _end_ of the preallocated buffer */ 4959641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 4969641b784SDavid Woodhouse jeb->offset + c->sector_size - buf_len, 4979641b784SDavid Woodhouse buf_len); 4989641b784SDavid Woodhouse if (err) 4999641b784SDavid Woodhouse return err; 5009641b784SDavid Woodhouse 5019641b784SDavid Woodhouse sm = (void *)buf + buf_size - sizeof(*sm); 5029641b784SDavid Woodhouse if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 5039641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 5049641b784SDavid Woodhouse sumptr = buf + buf_size - sumlen; 5059641b784SDavid Woodhouse 5069641b784SDavid Woodhouse /* Now, make sure the summary itself is available */ 5079641b784SDavid Woodhouse if (sumlen > buf_size) { 5089641b784SDavid Woodhouse /* Need to kmalloc for this. */ 5099641b784SDavid Woodhouse sumptr = kmalloc(sumlen, GFP_KERNEL); 5109641b784SDavid Woodhouse if (!sumptr) 5119641b784SDavid Woodhouse return -ENOMEM; 5129641b784SDavid Woodhouse memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len); 5139641b784SDavid Woodhouse } 5149641b784SDavid Woodhouse if (buf_len < sumlen) { 5159641b784SDavid Woodhouse /* Need to read more so that the entire summary node is present */ 5169641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, sumptr, 5179641b784SDavid Woodhouse jeb->offset + c->sector_size - sumlen, 5189641b784SDavid Woodhouse sumlen - buf_len); 5199641b784SDavid Woodhouse if (err) 520e631ddbaSFerenc Havasi return err; 521e631ddbaSFerenc Havasi } 522e631ddbaSFerenc Havasi } 523e631ddbaSFerenc Havasi 5249641b784SDavid Woodhouse } 5259641b784SDavid Woodhouse 5269641b784SDavid Woodhouse if (sumptr) { 5279641b784SDavid Woodhouse err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random); 5283560160aSDavid Woodhouse 5299641b784SDavid Woodhouse if (buf_size && sumlen > buf_size) 5309641b784SDavid Woodhouse kfree(sumptr); 5313560160aSDavid Woodhouse /* If it returns with a real error, bail. 5323560160aSDavid Woodhouse If it returns positive, that's a block classification 5333560160aSDavid Woodhouse (i.e. BLK_STATE_xxx) so return that too. 5343560160aSDavid Woodhouse If it returns zero, fall through to full scan. */ 5353560160aSDavid Woodhouse if (err) 5363560160aSDavid Woodhouse return err; 5379641b784SDavid Woodhouse } 538e631ddbaSFerenc Havasi } 539e631ddbaSFerenc Havasi 5401da177e4SLinus Torvalds buf_ofs = jeb->offset; 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds if (!buf_size) { 5439641b784SDavid Woodhouse /* This is the XIP case -- we're reading _directly_ from the flash chip */ 5441da177e4SLinus Torvalds buf_len = c->sector_size; 5451da177e4SLinus Torvalds } else { 5463be36675SAndrew Victor buf_len = EMPTY_SCAN_SIZE(c->sector_size); 5471da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 5481da177e4SLinus Torvalds if (err) 5491da177e4SLinus Torvalds return err; 5501da177e4SLinus Torvalds } 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 5531da177e4SLinus Torvalds ofs = 0; 55441bdc602SJoakim Tjernlund max_ofs = EMPTY_SCAN_SIZE(c->sector_size); 55541bdc602SJoakim Tjernlund /* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */ 55641bdc602SJoakim Tjernlund while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) 5571da177e4SLinus Torvalds ofs += 4; 5581da177e4SLinus Torvalds 55941bdc602SJoakim Tjernlund if (ofs == max_ofs) { 5602f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 5611da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 5621da177e4SLinus Torvalds /* scan oob, take care of cleanmarker */ 5631da177e4SLinus Torvalds int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 5641da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret)); 5651da177e4SLinus Torvalds switch (ret) { 5661da177e4SLinus Torvalds case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 5671da177e4SLinus Torvalds case 1: return BLK_STATE_ALLDIRTY; 5681da177e4SLinus Torvalds default: return ret; 5691da177e4SLinus Torvalds } 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds #endif 5721da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset)); 5738f15fd55SAndrew Victor if (c->cleanmarker_size == 0) 5748f15fd55SAndrew Victor return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */ 5758f15fd55SAndrew Victor else 5761da177e4SLinus Torvalds return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds if (ofs) { 5791da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset, 5801da177e4SLinus Torvalds jeb->offset + ofs)); 581a6a8bef7SDavid Woodhouse if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1))) 582a6a8bef7SDavid Woodhouse return err; 58368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs))) 58468270995SDavid Woodhouse return err; 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds /* Now ofs is a complete physical flash offset as it always was... */ 5881da177e4SLinus Torvalds ofs += jeb->offset; 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds noise = 10; 5911da177e4SLinus Torvalds 592733802d9SArtem B. Bityutskiy dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset); 593e631ddbaSFerenc Havasi 5941da177e4SLinus Torvalds scan_more: 5951da177e4SLinus Torvalds while(ofs < jeb->offset + c->sector_size) { 5961da177e4SLinus Torvalds 597e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 5981da177e4SLinus Torvalds 5992f785402SDavid Woodhouse /* Make sure there are node refs available for use */ 600046b8b98SDavid Woodhouse err = jffs2_prealloc_raw_node_refs(c, jeb, 2); 6012f785402SDavid Woodhouse if (err) 6022f785402SDavid Woodhouse return err; 6032f785402SDavid Woodhouse 6041da177e4SLinus Torvalds cond_resched(); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds if (ofs & 3) { 6071da177e4SLinus Torvalds printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs); 6081da177e4SLinus Torvalds ofs = PAD(ofs); 6091da177e4SLinus Torvalds continue; 6101da177e4SLinus Torvalds } 6111da177e4SLinus Torvalds if (ofs == prevofs) { 6121da177e4SLinus Torvalds printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs); 61368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 61468270995SDavid Woodhouse return err; 6151da177e4SLinus Torvalds ofs += 4; 6161da177e4SLinus Torvalds continue; 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds prevofs = ofs; 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 6211da177e4SLinus 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), 6221da177e4SLinus Torvalds jeb->offset, c->sector_size, ofs, sizeof(*node))); 62368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs))) 62468270995SDavid Woodhouse return err; 6251da177e4SLinus Torvalds break; 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(*node)) { 6291da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6301da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 6311da177e4SLinus Torvalds sizeof(struct jffs2_unknown_node), buf_len, ofs)); 6321da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 6331da177e4SLinus Torvalds if (err) 6341da177e4SLinus Torvalds return err; 6351da177e4SLinus Torvalds buf_ofs = ofs; 6361da177e4SLinus Torvalds } 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs]; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) { 6411da177e4SLinus Torvalds uint32_t inbuf_ofs; 642c2aecda7SJoakim Tjernlund uint32_t empty_start, scan_end; 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds empty_start = ofs; 6451da177e4SLinus Torvalds ofs += 4; 646c2aecda7SJoakim Tjernlund scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len); 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs)); 6491da177e4SLinus Torvalds more_empty: 6501da177e4SLinus Torvalds inbuf_ofs = ofs - buf_ofs; 651c2aecda7SJoakim Tjernlund while (inbuf_ofs < scan_end) { 652c2aecda7SJoakim Tjernlund if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) { 6531da177e4SLinus Torvalds printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", 6541da177e4SLinus Torvalds empty_start, ofs); 65568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start))) 65668270995SDavid Woodhouse return err; 6571da177e4SLinus Torvalds goto scan_more; 6581da177e4SLinus Torvalds } 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds inbuf_ofs+=4; 6611da177e4SLinus Torvalds ofs += 4; 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds /* Ran off end. */ 6641da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash to end of buffer at 0x%08x\n", ofs)); 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds /* If we're only checking the beginning of a block with a cleanmarker, 6671da177e4SLinus Torvalds bail now */ 6681da177e4SLinus Torvalds if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 66999988f7bSDavid Woodhouse c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) { 6703be36675SAndrew Victor D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c->sector_size))); 6711da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 6721da177e4SLinus Torvalds } 673c2aecda7SJoakim Tjernlund if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */ 674c2aecda7SJoakim Tjernlund scan_end = buf_len; 675c2aecda7SJoakim Tjernlund goto more_empty; 676c2aecda7SJoakim Tjernlund } 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds /* See how much more there is to read in this eraseblock... */ 6791da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6801da177e4SLinus Torvalds if (!buf_len) { 6811da177e4SLinus Torvalds /* No more to read. Break out of main loop without marking 6821da177e4SLinus Torvalds this range of empty space as dirty (because it's not) */ 6831da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash at %08x runs to end of block. Treating as free_space\n", 6841da177e4SLinus Torvalds empty_start)); 6851da177e4SLinus Torvalds break; 6861da177e4SLinus Torvalds } 687c2aecda7SJoakim Tjernlund /* point never reaches here */ 688c2aecda7SJoakim Tjernlund scan_end = buf_len; 6891da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Reading another 0x%x at 0x%08x\n", buf_len, ofs)); 6901da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 6911da177e4SLinus Torvalds if (err) 6921da177e4SLinus Torvalds return err; 6931da177e4SLinus Torvalds buf_ofs = ofs; 6941da177e4SLinus Torvalds goto more_empty; 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 6981da177e4SLinus Torvalds printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs); 69968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 70068270995SDavid Woodhouse return err; 7011da177e4SLinus Torvalds ofs += 4; 7021da177e4SLinus Torvalds continue; 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 7051da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs)); 70668270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 70768270995SDavid Woodhouse return err; 7081da177e4SLinus Torvalds ofs += 4; 7091da177e4SLinus Torvalds continue; 7101da177e4SLinus Torvalds } 7111da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 7121da177e4SLinus Torvalds printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs); 7131da177e4SLinus Torvalds printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n"); 71468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 71568270995SDavid Woodhouse return err; 7161da177e4SLinus Torvalds ofs += 4; 7171da177e4SLinus Torvalds continue; 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 7201da177e4SLinus Torvalds /* OK. We're out of possibilities. Whinge and move on */ 7211da177e4SLinus Torvalds noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 7221da177e4SLinus Torvalds JFFS2_MAGIC_BITMASK, ofs, 7231da177e4SLinus Torvalds je16_to_cpu(node->magic)); 72468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 72568270995SDavid Woodhouse return err; 7261da177e4SLinus Torvalds ofs += 4; 7271da177e4SLinus Torvalds continue; 7281da177e4SLinus Torvalds } 7291da177e4SLinus Torvalds /* We seem to have a node of sorts. Check the CRC */ 7301da177e4SLinus Torvalds crcnode.magic = node->magic; 7311da177e4SLinus Torvalds crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE); 7321da177e4SLinus Torvalds crcnode.totlen = node->totlen; 7331da177e4SLinus Torvalds hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 7361da177e4SLinus 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", 7371da177e4SLinus Torvalds ofs, je16_to_cpu(node->magic), 7381da177e4SLinus Torvalds je16_to_cpu(node->nodetype), 7391da177e4SLinus Torvalds je32_to_cpu(node->totlen), 7401da177e4SLinus Torvalds je32_to_cpu(node->hdr_crc), 7411da177e4SLinus Torvalds hdr_crc); 74268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 74368270995SDavid Woodhouse return err; 7441da177e4SLinus Torvalds ofs += 4; 7451da177e4SLinus Torvalds continue; 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds 7480dec4c8bSJoakim Tjernlund if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) { 7491da177e4SLinus Torvalds /* Eep. Node goes over the end of the erase block. */ 7501da177e4SLinus Torvalds printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 7511da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen)); 7521da177e4SLinus Torvalds printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n"); 75368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 75468270995SDavid Woodhouse return err; 7551da177e4SLinus Torvalds ofs += 4; 7561da177e4SLinus Torvalds continue; 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 7601da177e4SLinus Torvalds /* Wheee. This is an obsoleted node */ 7611da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs)); 76268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 76368270995SDavid Woodhouse return err; 7641da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7651da177e4SLinus Torvalds continue; 7661da177e4SLinus Torvalds } 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds switch(je16_to_cpu(node->nodetype)) { 7691da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 7701da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 7711da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7721da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 7731da177e4SLinus Torvalds sizeof(struct jffs2_raw_inode), buf_len, ofs)); 7741da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7751da177e4SLinus Torvalds if (err) 7761da177e4SLinus Torvalds return err; 7771da177e4SLinus Torvalds buf_ofs = ofs; 7781da177e4SLinus Torvalds node = (void *)buf; 7791da177e4SLinus Torvalds } 780e631ddbaSFerenc Havasi err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s); 7811da177e4SLinus Torvalds if (err) return err; 7821da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 7861da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 7871da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7881da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 7891da177e4SLinus Torvalds je32_to_cpu(node->totlen), buf_len, ofs)); 7901da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7911da177e4SLinus Torvalds if (err) 7921da177e4SLinus Torvalds return err; 7931da177e4SLinus Torvalds buf_ofs = ofs; 7941da177e4SLinus Torvalds node = (void *)buf; 7951da177e4SLinus Torvalds } 796e631ddbaSFerenc Havasi err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s); 7971da177e4SLinus Torvalds if (err) return err; 7981da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7991da177e4SLinus Torvalds break; 8001da177e4SLinus Torvalds 801aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 802aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XATTR: 803aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 804aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 805aa98d7cfSKaiGai Kohei D1(printk(KERN_DEBUG "Fewer than %d bytes (xattr node)" 806aa98d7cfSKaiGai Kohei " left to end of buf. Reading 0x%x at 0x%08x\n", 807aa98d7cfSKaiGai Kohei je32_to_cpu(node->totlen), buf_len, ofs)); 808aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 809aa98d7cfSKaiGai Kohei if (err) 810aa98d7cfSKaiGai Kohei return err; 811aa98d7cfSKaiGai Kohei buf_ofs = ofs; 812aa98d7cfSKaiGai Kohei node = (void *)buf; 813aa98d7cfSKaiGai Kohei } 814aa98d7cfSKaiGai Kohei err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s); 815aa98d7cfSKaiGai Kohei if (err) 816aa98d7cfSKaiGai Kohei return err; 817aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 818aa98d7cfSKaiGai Kohei break; 819aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XREF: 820aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 821aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 822aa98d7cfSKaiGai Kohei D1(printk(KERN_DEBUG "Fewer than %d bytes (xref node)" 823aa98d7cfSKaiGai Kohei " left to end of buf. Reading 0x%x at 0x%08x\n", 824aa98d7cfSKaiGai Kohei je32_to_cpu(node->totlen), buf_len, ofs)); 825aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 826aa98d7cfSKaiGai Kohei if (err) 827aa98d7cfSKaiGai Kohei return err; 828aa98d7cfSKaiGai Kohei buf_ofs = ofs; 829aa98d7cfSKaiGai Kohei node = (void *)buf; 830aa98d7cfSKaiGai Kohei } 831aa98d7cfSKaiGai Kohei err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s); 832aa98d7cfSKaiGai Kohei if (err) 833aa98d7cfSKaiGai Kohei return err; 834aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 835aa98d7cfSKaiGai Kohei break; 836aa98d7cfSKaiGai Kohei #endif /* CONFIG_JFFS2_FS_XATTR */ 837aa98d7cfSKaiGai Kohei 8381da177e4SLinus Torvalds case JFFS2_NODETYPE_CLEANMARKER: 8391da177e4SLinus Torvalds D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs)); 8401da177e4SLinus Torvalds if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 8411da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 8421da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen), c->cleanmarker_size); 84368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 84468270995SDavid Woodhouse return err; 8451da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8461da177e4SLinus Torvalds } else if (jeb->first_node) { 8471da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset); 84868270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 84968270995SDavid Woodhouse return err; 8501da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8511da177e4SLinus Torvalds } else { 8522f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL); 853f1f9671bSDavid Woodhouse 8541da177e4SLinus Torvalds ofs += PAD(c->cleanmarker_size); 8551da177e4SLinus Torvalds } 8561da177e4SLinus Torvalds break; 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds case JFFS2_NODETYPE_PADDING: 859e631ddbaSFerenc Havasi if (jffs2_sum_active()) 860e631ddbaSFerenc Havasi jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen)); 86168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 86268270995SDavid Woodhouse return err; 8631da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8641da177e4SLinus Torvalds break; 8651da177e4SLinus Torvalds 8661da177e4SLinus Torvalds default: 8671da177e4SLinus Torvalds switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 8681da177e4SLinus Torvalds case JFFS2_FEATURE_ROCOMPAT: 8691da177e4SLinus Torvalds printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8701da177e4SLinus Torvalds c->flags |= JFFS2_SB_FLAG_RO; 8711da177e4SLinus Torvalds if (!(jffs2_is_readonly(c))) 8721da177e4SLinus Torvalds return -EROFS; 87368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 87468270995SDavid Woodhouse return err; 8751da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8761da177e4SLinus Torvalds break; 8771da177e4SLinus Torvalds 8781da177e4SLinus Torvalds case JFFS2_FEATURE_INCOMPAT: 8791da177e4SLinus Torvalds printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8801da177e4SLinus Torvalds return -EINVAL; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_DELETE: 8831da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 88468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 88568270995SDavid Woodhouse return err; 8861da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8871da177e4SLinus Torvalds break; 8881da177e4SLinus Torvalds 8896171586aSDavid Woodhouse case JFFS2_FEATURE_RWCOMPAT_COPY: { 8901da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 8916171586aSDavid Woodhouse 8922f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL); 8936171586aSDavid Woodhouse 8946171586aSDavid Woodhouse /* We can't summarise nodes we don't grok */ 8956171586aSDavid Woodhouse jffs2_sum_disable_collecting(s); 8961da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8971da177e4SLinus Torvalds break; 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds } 9016171586aSDavid Woodhouse } 9021da177e4SLinus Torvalds 903e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 904e631ddbaSFerenc Havasi if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) { 905733802d9SArtem B. Bityutskiy dbg_summary("There is not enough space for " 906e631ddbaSFerenc Havasi "summary information, disabling for this jeb!\n"); 907e631ddbaSFerenc Havasi jffs2_sum_disable_collecting(s); 908e631ddbaSFerenc Havasi } 909e631ddbaSFerenc Havasi } 9101da177e4SLinus Torvalds 9118b9e9fe8SDavid Woodhouse D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n", 9128b9e9fe8SDavid Woodhouse jeb->offset,jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size, jeb->wasted_size)); 9131da177e4SLinus Torvalds 9141da177e4SLinus Torvalds /* mark_node_obsolete can add to wasted !! */ 9151da177e4SLinus Torvalds if (jeb->wasted_size) { 9161da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 9171da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 9181da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 9191da177e4SLinus Torvalds jeb->wasted_size = 0; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds 922e631ddbaSFerenc Havasi return jffs2_scan_classify_jeb(c, jeb); 9231da177e4SLinus Torvalds } 9241da177e4SLinus Torvalds 925e631ddbaSFerenc Havasi struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino) 9261da177e4SLinus Torvalds { 9271da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9301da177e4SLinus Torvalds if (ic) 9311da177e4SLinus Torvalds return ic; 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds if (ino > c->highest_ino) 9341da177e4SLinus Torvalds c->highest_ino = ino; 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 9371da177e4SLinus Torvalds if (!ic) { 9381da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n"); 9391da177e4SLinus Torvalds return NULL; 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds ic->ino = ino; 9441da177e4SLinus Torvalds ic->nodes = (void *)ic; 9451da177e4SLinus Torvalds jffs2_add_ino_cache(c, ic); 9461da177e4SLinus Torvalds if (ino == 1) 94727c72b04SDavid Woodhouse ic->pino_nlink = 1; 9481da177e4SLinus Torvalds return ic; 9491da177e4SLinus Torvalds } 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 952e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s) 9531da177e4SLinus Torvalds { 9541da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 95553043002SThomas Gleixner uint32_t crc, ino = je32_to_cpu(ri->ino); 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs)); 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds /* We do very little here now. Just check the ino# to which we should attribute 9601da177e4SLinus Torvalds this node; we can do all the CRC checking etc. later. There's a tradeoff here -- 9611da177e4SLinus Torvalds we used to scan the flash once only, reading everything we want from it into 9621da177e4SLinus Torvalds memory, then building all our in-core data structures and freeing the extra 9631da177e4SLinus Torvalds information. Now we allow the first part of the mount to complete a lot quicker, 9641da177e4SLinus Torvalds but we have to go _back_ to the flash in order to finish the CRC checking, etc. 9651da177e4SLinus Torvalds Which means that the _full_ amount of time to get to proper write mode with GC 9661da177e4SLinus Torvalds operational may actually be _longer_ than before. Sucks to be me. */ 9671da177e4SLinus Torvalds 96853043002SThomas Gleixner /* Check the node CRC in any case. */ 96953043002SThomas Gleixner crc = crc32(0, ri, sizeof(*ri)-8); 97053043002SThomas Gleixner if (crc != je32_to_cpu(ri->node_crc)) { 97153043002SThomas Gleixner printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on " 97253043002SThomas Gleixner "node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 97353043002SThomas Gleixner ofs, je32_to_cpu(ri->node_crc), crc); 97453043002SThomas Gleixner /* 97553043002SThomas Gleixner * We believe totlen because the CRC on the node 97653043002SThomas Gleixner * _header_ was OK, just the node itself failed. 97753043002SThomas Gleixner */ 97853043002SThomas Gleixner return jffs2_scan_dirty_space(c, jeb, 97953043002SThomas Gleixner PAD(je32_to_cpu(ri->totlen))); 98053043002SThomas Gleixner } 98153043002SThomas Gleixner 9821da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9831da177e4SLinus Torvalds if (!ic) { 9841da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, ino); 9852f785402SDavid Woodhouse if (!ic) 9861da177e4SLinus Torvalds return -ENOMEM; 9871da177e4SLinus Torvalds } 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds /* Wheee. It worked */ 9902f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic); 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 9931da177e4SLinus Torvalds je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 9941da177e4SLinus Torvalds je32_to_cpu(ri->offset), 9951da177e4SLinus Torvalds je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize))); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds pseudo_random += je32_to_cpu(ri->version); 9981da177e4SLinus Torvalds 999e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1000e631ddbaSFerenc Havasi jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset); 1001e631ddbaSFerenc Havasi } 1002e631ddbaSFerenc Havasi 10031da177e4SLinus Torvalds return 0; 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 1007e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s) 10081da177e4SLinus Torvalds { 10091da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 10101da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 1011b534e70cSDavid Woodhouse uint32_t checkedlen; 10121da177e4SLinus Torvalds uint32_t crc; 101368270995SDavid Woodhouse int err; 10141da177e4SLinus Torvalds 10151da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs)); 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds /* We don't get here unless the node is still valid, so we don't have to 10181da177e4SLinus Torvalds mask in the ACCURATE bit any more. */ 10191da177e4SLinus Torvalds crc = crc32(0, rd, sizeof(*rd)-8); 10201da177e4SLinus Torvalds 10211da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->node_crc)) { 10221da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 10231da177e4SLinus Torvalds ofs, je32_to_cpu(rd->node_crc), crc); 10241da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 102568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 102668270995SDavid Woodhouse return err; 10271da177e4SLinus Torvalds return 0; 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds pseudo_random += je32_to_cpu(rd->version); 10311da177e4SLinus Torvalds 1032b534e70cSDavid Woodhouse /* Should never happen. Did. (OLPC trac #4184)*/ 1033b534e70cSDavid Woodhouse checkedlen = strnlen(rd->name, rd->nsize); 1034b534e70cSDavid Woodhouse if (checkedlen < rd->nsize) { 1035b534e70cSDavid Woodhouse printk(KERN_ERR "Dirent at %08x has zeroes in name. Truncating to %d chars\n", 1036b534e70cSDavid Woodhouse ofs, checkedlen); 1037b534e70cSDavid Woodhouse } 1038b534e70cSDavid Woodhouse fd = jffs2_alloc_full_dirent(checkedlen+1); 10391da177e4SLinus Torvalds if (!fd) { 10401da177e4SLinus Torvalds return -ENOMEM; 10411da177e4SLinus Torvalds } 1042b534e70cSDavid Woodhouse memcpy(&fd->name, rd->name, checkedlen); 1043b534e70cSDavid Woodhouse fd->name[checkedlen] = 0; 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds crc = crc32(0, fd->name, rd->nsize); 10461da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->name_crc)) { 10471da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 10481da177e4SLinus Torvalds ofs, je32_to_cpu(rd->name_crc), crc); 10491da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino))); 10501da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10511da177e4SLinus Torvalds /* FIXME: Why do we believe totlen? */ 10521da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */ 105368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 105468270995SDavid Woodhouse return err; 10551da177e4SLinus Torvalds return 0; 10561da177e4SLinus Torvalds } 10571da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino)); 10581da177e4SLinus Torvalds if (!ic) { 10591da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10601da177e4SLinus Torvalds return -ENOMEM; 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds 106343dfa07fSDavid Woodhouse fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd), 106443dfa07fSDavid Woodhouse PAD(je32_to_cpu(rd->totlen)), ic); 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds fd->next = NULL; 10671da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 10681da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 1069b534e70cSDavid Woodhouse fd->nhash = full_name_hash(fd->name, checkedlen); 10701da177e4SLinus Torvalds fd->type = rd->type; 10711da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &ic->scan_dents); 10721da177e4SLinus Torvalds 1073e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1074e631ddbaSFerenc Havasi jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset); 1075e631ddbaSFerenc Havasi } 1076e631ddbaSFerenc Havasi 10771da177e4SLinus Torvalds return 0; 10781da177e4SLinus Torvalds } 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds static int count_list(struct list_head *l) 10811da177e4SLinus Torvalds { 10821da177e4SLinus Torvalds uint32_t count = 0; 10831da177e4SLinus Torvalds struct list_head *tmp; 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds list_for_each(tmp, l) { 10861da177e4SLinus Torvalds count++; 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds return count; 10891da177e4SLinus Torvalds } 10901da177e4SLinus Torvalds 10911da177e4SLinus Torvalds /* Note: This breaks if list_empty(head). I don't care. You 10921da177e4SLinus Torvalds might, if you copy this code and use it elsewhere :) */ 10931da177e4SLinus Torvalds static void rotate_list(struct list_head *head, uint32_t count) 10941da177e4SLinus Torvalds { 10951da177e4SLinus Torvalds struct list_head *n = head->next; 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds list_del(head); 10981da177e4SLinus Torvalds while(count--) { 10991da177e4SLinus Torvalds n = n->next; 11001da177e4SLinus Torvalds } 11011da177e4SLinus Torvalds list_add(head, n); 11021da177e4SLinus Torvalds } 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c) 11051da177e4SLinus Torvalds { 11061da177e4SLinus Torvalds uint32_t x; 11071da177e4SLinus Torvalds uint32_t rotateby; 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds x = count_list(&c->clean_list); 11101da177e4SLinus Torvalds if (x) { 11111da177e4SLinus Torvalds rotateby = pseudo_random % x; 11121da177e4SLinus Torvalds rotate_list((&c->clean_list), rotateby); 11131da177e4SLinus Torvalds } 11141da177e4SLinus Torvalds 11151da177e4SLinus Torvalds x = count_list(&c->very_dirty_list); 11161da177e4SLinus Torvalds if (x) { 11171da177e4SLinus Torvalds rotateby = pseudo_random % x; 11181da177e4SLinus Torvalds rotate_list((&c->very_dirty_list), rotateby); 11191da177e4SLinus Torvalds } 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds x = count_list(&c->dirty_list); 11221da177e4SLinus Torvalds if (x) { 11231da177e4SLinus Torvalds rotateby = pseudo_random % x; 11241da177e4SLinus Torvalds rotate_list((&c->dirty_list), rotateby); 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 11271da177e4SLinus Torvalds x = count_list(&c->erasable_list); 11281da177e4SLinus Torvalds if (x) { 11291da177e4SLinus Torvalds rotateby = pseudo_random % x; 11301da177e4SLinus Torvalds rotate_list((&c->erasable_list), rotateby); 11311da177e4SLinus Torvalds } 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 11341da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_erasing_blocks; 11351da177e4SLinus Torvalds rotate_list((&c->erase_pending_list), rotateby); 11361da177e4SLinus Torvalds } 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds if (c->nr_free_blocks) { 11391da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_free_blocks; 11401da177e4SLinus Torvalds rotate_list((&c->free_list), rotateby); 11411da177e4SLinus Torvalds } 11421da177e4SLinus Torvalds } 1143