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 99d35ea200SArtem Bityutskiy ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen, 100a98889f3SJared Hulbert (void **)&flashbuf, NULL); 1011da177e4SLinus Torvalds if (!ret && pointlen < c->mtd->size) { 1021da177e4SLinus Torvalds /* Don't muck about if it won't let us point to the whole flash */ 1039c261b33SJoe Perches jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n", 1049c261b33SJoe Perches pointlen); 1057219778aSArtem Bityutskiy mtd_unpoint(c->mtd, 0, pointlen); 1061da177e4SLinus Torvalds flashbuf = NULL; 1071da177e4SLinus Torvalds } 10810934478SArtem Bityutskiy if (ret && ret != -EOPNOTSUPP) 1099c261b33SJoe Perches jffs2_dbg(1, "MTD point failed %d\n", ret); 1101da177e4SLinus Torvalds #endif 1111da177e4SLinus Torvalds if (!flashbuf) { 1121da177e4SLinus Torvalds /* For NAND it's quicker to read a whole eraseblock at a time, 1131da177e4SLinus Torvalds apparently */ 1141da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) 1151ddd0d9aSGrant Erickson try_size = c->sector_size; 1161da177e4SLinus Torvalds else 1171ddd0d9aSGrant Erickson try_size = PAGE_SIZE; 1181da177e4SLinus Torvalds 1199c261b33SJoe Perches jffs2_dbg(1, "Trying to allocate readbuf of %zu " 1209c261b33SJoe Perches "bytes\n", try_size); 1211da177e4SLinus Torvalds 1221ddd0d9aSGrant Erickson flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size); 1231da177e4SLinus Torvalds if (!flashbuf) 1241da177e4SLinus Torvalds return -ENOMEM; 1251ddd0d9aSGrant Erickson 1269c261b33SJoe Perches jffs2_dbg(1, "Allocated readbuf of %zu bytes\n", 1279c261b33SJoe Perches try_size); 1281ddd0d9aSGrant Erickson 1291ddd0d9aSGrant Erickson buf_size = (uint32_t)try_size; 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 132e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1333d375d9eSYan Burman s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL); 134e631ddbaSFerenc Havasi if (!s) { 135e631ddbaSFerenc Havasi JFFS2_WARNING("Can't allocate memory for summary\n"); 13648396413SDavid Woodhouse ret = -ENOMEM; 13748396413SDavid Woodhouse goto out; 138e631ddbaSFerenc Havasi } 139e631ddbaSFerenc Havasi } 140e631ddbaSFerenc Havasi 1411da177e4SLinus Torvalds for (i=0; i<c->nr_blocks; i++) { 1421da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[i]; 1431da177e4SLinus Torvalds 144a2166b93SArtem Bityutskiy cond_resched(); 145a2166b93SArtem Bityutskiy 146e631ddbaSFerenc Havasi /* reset summary info for next eraseblock scan */ 147e631ddbaSFerenc Havasi jffs2_sum_reset_collected(s); 148e631ddbaSFerenc Havasi 149e631ddbaSFerenc Havasi ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), 150e631ddbaSFerenc Havasi buf_size, s); 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds if (ret < 0) 1531da177e4SLinus Torvalds goto out; 1541da177e4SLinus Torvalds 155e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds /* Now decide which list to put it on */ 1581da177e4SLinus Torvalds switch(ret) { 1591da177e4SLinus Torvalds case BLK_STATE_ALLFF: 1601da177e4SLinus Torvalds /* 1611da177e4SLinus Torvalds * Empty block. Since we can't be sure it 1621da177e4SLinus Torvalds * was entirely erased, we just queue it for erase 1631da177e4SLinus Torvalds * again. It will be marked as such when the erase 1641da177e4SLinus Torvalds * is complete. Meanwhile we still count it as empty 1651da177e4SLinus Torvalds * for later checks. 1661da177e4SLinus Torvalds */ 1671da177e4SLinus Torvalds empty_blocks++; 1681da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1691da177e4SLinus Torvalds c->nr_erasing_blocks++; 1701da177e4SLinus Torvalds break; 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds case BLK_STATE_CLEANMARKER: 1731da177e4SLinus Torvalds /* Only a CLEANMARKER node is valid */ 1741da177e4SLinus Torvalds if (!jeb->dirty_size) { 1751da177e4SLinus Torvalds /* It's actually free */ 1761da177e4SLinus Torvalds list_add(&jeb->list, &c->free_list); 1771da177e4SLinus Torvalds c->nr_free_blocks++; 1781da177e4SLinus Torvalds } else { 1791da177e4SLinus Torvalds /* Dirt */ 1809c261b33SJoe Perches jffs2_dbg(1, "Adding all-dirty block at 0x%08x to erase_pending_list\n", 1819c261b33SJoe Perches 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); 2089c261b33SJoe Perches jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 2099c261b33SJoe Perches __func__, jeb->offset); 2101da177e4SLinus Torvalds c->nextblock = jeb; 2111da177e4SLinus Torvalds } else { 21225090a6bSDavid Woodhouse ret = file_dirty(c, jeb); 21325090a6bSDavid Woodhouse if (ret) 214a2ab0ce0SChristian Engelmayer goto out; 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds break; 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds case BLK_STATE_ALLDIRTY: 2191da177e4SLinus Torvalds /* Nothing valid - not even a clean marker. Needs erasing. */ 2201da177e4SLinus Torvalds /* For now we just put it on the erasing list. We'll start the erases later */ 2219c261b33SJoe Perches jffs2_dbg(1, "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", 2229c261b33SJoe Perches jeb->offset); 2231da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 2241da177e4SLinus Torvalds c->nr_erasing_blocks++; 2251da177e4SLinus Torvalds break; 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds case BLK_STATE_BADBLOCK: 2289c261b33SJoe Perches jffs2_dbg(1, "JFFS2: Block at 0x%08x is bad\n", 2299c261b33SJoe Perches jeb->offset); 2301da177e4SLinus Torvalds list_add(&jeb->list, &c->bad_list); 2311da177e4SLinus Torvalds c->bad_size += c->sector_size; 2321da177e4SLinus Torvalds c->free_size -= c->sector_size; 2331da177e4SLinus Torvalds bad_blocks++; 2341da177e4SLinus Torvalds break; 2351da177e4SLinus Torvalds default: 2361da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n"); 2371da177e4SLinus Torvalds BUG(); 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */ 2421da177e4SLinus Torvalds if (c->nextblock && (c->nextblock->dirty_size)) { 2431da177e4SLinus Torvalds c->nextblock->wasted_size += c->nextblock->dirty_size; 2441da177e4SLinus Torvalds c->wasted_size += c->nextblock->dirty_size; 2451da177e4SLinus Torvalds c->dirty_size -= c->nextblock->dirty_size; 2461da177e4SLinus Torvalds c->nextblock->dirty_size = 0; 2471da177e4SLinus Torvalds } 2482f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 249e96fb230SDavid Woodhouse if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) { 2501da177e4SLinus Torvalds /* If we're going to start writing into a block which already 2511da177e4SLinus Torvalds contains data, and the end of the data isn't page-aligned, 2521da177e4SLinus Torvalds skip a little and align it. */ 2531da177e4SLinus Torvalds 254daba5cc4SArtem B. Bityutskiy uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize; 2551da177e4SLinus Torvalds 2569c261b33SJoe Perches jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n", 2579c261b33SJoe Perches __func__, skip); 258046b8b98SDavid Woodhouse jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 259f560928bSDavid Woodhouse jffs2_scan_dirty_space(c, c->nextblock, skip); 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds #endif 2621da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 2631da177e4SLinus Torvalds if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) { 2641da177e4SLinus Torvalds printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 2651da177e4SLinus Torvalds printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks); 2661da177e4SLinus Torvalds ret = -EIO; 2671da177e4SLinus Torvalds goto out; 2681da177e4SLinus Torvalds } 269ae3b6ba0SDavid Woodhouse spin_lock(&c->erase_completion_lock); 270ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 271ae3b6ba0SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 2721da177e4SLinus Torvalds } 2731da177e4SLinus Torvalds ret = 0; 2741da177e4SLinus Torvalds out: 2751da177e4SLinus Torvalds if (buf_size) 2761da177e4SLinus Torvalds kfree(flashbuf); 2771da177e4SLinus Torvalds #ifndef __ECOS 2781da177e4SLinus Torvalds else 2797219778aSArtem Bityutskiy mtd_unpoint(c->mtd, 0, c->mtd->size); 2801da177e4SLinus Torvalds #endif 2815b5ffbc1SFlorin Malita kfree(s); 2821da177e4SLinus Torvalds return ret; 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds 285c05d52c7SAdrian Bunk static int jffs2_fill_scan_buf(struct jffs2_sb_info *c, void *buf, 2861da177e4SLinus Torvalds uint32_t ofs, uint32_t len) 2871da177e4SLinus Torvalds { 2881da177e4SLinus Torvalds int ret; 2891da177e4SLinus Torvalds size_t retlen; 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 2921da177e4SLinus Torvalds if (ret) { 2939c261b33SJoe Perches jffs2_dbg(1, "mtd->read(0x%x bytes from 0x%x) returned %d\n", 2949c261b33SJoe Perches len, ofs, ret); 2951da177e4SLinus Torvalds return ret; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds if (retlen < len) { 2989c261b33SJoe Perches jffs2_dbg(1, "Read at 0x%x gave only 0x%zx bytes\n", 2999c261b33SJoe Perches ofs, retlen); 3001da177e4SLinus Torvalds return -EIO; 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds return 0; 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 305e631ddbaSFerenc Havasi int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 306e631ddbaSFerenc Havasi { 307e631ddbaSFerenc Havasi if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size 30899988f7bSDavid Woodhouse && (!jeb->first_node || !ref_next(jeb->first_node)) ) 309e631ddbaSFerenc Havasi return BLK_STATE_CLEANMARKER; 310e631ddbaSFerenc Havasi 311e631ddbaSFerenc Havasi /* move blocks with max 4 byte dirty space to cleanlist */ 312e631ddbaSFerenc Havasi else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) { 313e631ddbaSFerenc Havasi c->dirty_size -= jeb->dirty_size; 314e631ddbaSFerenc Havasi c->wasted_size += jeb->dirty_size; 315e631ddbaSFerenc Havasi jeb->wasted_size += jeb->dirty_size; 316e631ddbaSFerenc Havasi jeb->dirty_size = 0; 317e631ddbaSFerenc Havasi return BLK_STATE_CLEAN; 318e631ddbaSFerenc Havasi } else if (jeb->used_size || jeb->unchecked_size) 319e631ddbaSFerenc Havasi return BLK_STATE_PARTDIRTY; 320e631ddbaSFerenc Havasi else 321e631ddbaSFerenc Havasi return BLK_STATE_ALLDIRTY; 322e631ddbaSFerenc Havasi } 323e631ddbaSFerenc Havasi 324aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 325aa98d7cfSKaiGai Kohei static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 326aa98d7cfSKaiGai Kohei struct jffs2_raw_xattr *rx, uint32_t ofs, 327aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 328aa98d7cfSKaiGai Kohei { 329aa98d7cfSKaiGai Kohei struct jffs2_xattr_datum *xd; 330c9f700f8SKaiGai Kohei uint32_t xid, version, totlen, crc; 33168270995SDavid Woodhouse int err; 332aa98d7cfSKaiGai Kohei 333aa98d7cfSKaiGai Kohei crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4); 334aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rx->node_crc)) { 335aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 336aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->node_crc), crc); 33768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 33868270995SDavid Woodhouse return err; 339aa98d7cfSKaiGai Kohei return 0; 340aa98d7cfSKaiGai Kohei } 341aa98d7cfSKaiGai Kohei 342c9f700f8SKaiGai Kohei xid = je32_to_cpu(rx->xid); 343c9f700f8SKaiGai Kohei version = je32_to_cpu(rx->version); 344c9f700f8SKaiGai Kohei 3458a13695cSKaiGai Kohei totlen = PAD(sizeof(struct jffs2_raw_xattr) 3468a13695cSKaiGai Kohei + rx->name_len + 1 + je16_to_cpu(rx->value_len)); 347aa98d7cfSKaiGai Kohei if (totlen != je32_to_cpu(rx->totlen)) { 348aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 349aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->totlen), totlen); 35068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 35168270995SDavid Woodhouse return err; 352aa98d7cfSKaiGai Kohei return 0; 353aa98d7cfSKaiGai Kohei } 354aa98d7cfSKaiGai Kohei 355c9f700f8SKaiGai Kohei xd = jffs2_setup_xattr_datum(c, xid, version); 356c9f700f8SKaiGai Kohei if (IS_ERR(xd)) 357aa98d7cfSKaiGai Kohei return PTR_ERR(xd); 358c9f700f8SKaiGai Kohei 359c9f700f8SKaiGai Kohei if (xd->version > version) { 360c9f700f8SKaiGai Kohei struct jffs2_raw_node_ref *raw 361c9f700f8SKaiGai Kohei = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, NULL); 362c9f700f8SKaiGai Kohei raw->next_in_ino = xd->node->next_in_ino; 363c9f700f8SKaiGai Kohei xd->node->next_in_ino = raw; 364c9f700f8SKaiGai Kohei } else { 365c9f700f8SKaiGai Kohei xd->version = version; 366aa98d7cfSKaiGai Kohei xd->xprefix = rx->xprefix; 367aa98d7cfSKaiGai Kohei xd->name_len = rx->name_len; 368aa98d7cfSKaiGai Kohei xd->value_len = je16_to_cpu(rx->value_len); 369aa98d7cfSKaiGai Kohei xd->data_crc = je32_to_cpu(rx->data_crc); 370aa98d7cfSKaiGai Kohei 371c9f700f8SKaiGai Kohei jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, (void *)xd); 372c9f700f8SKaiGai Kohei } 373f1f9671bSDavid Woodhouse 374aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 375aa98d7cfSKaiGai Kohei jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset); 3763e341740SMasanari Iida dbg_xattr("scanning xdatum at %#08x (xid=%u, version=%u)\n", 377aa98d7cfSKaiGai Kohei ofs, xd->xid, xd->version); 378aa98d7cfSKaiGai Kohei return 0; 379aa98d7cfSKaiGai Kohei } 380aa98d7cfSKaiGai Kohei 381aa98d7cfSKaiGai Kohei static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 382aa98d7cfSKaiGai Kohei struct jffs2_raw_xref *rr, uint32_t ofs, 383aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 384aa98d7cfSKaiGai Kohei { 385aa98d7cfSKaiGai Kohei struct jffs2_xattr_ref *ref; 386aa98d7cfSKaiGai Kohei uint32_t crc; 38768270995SDavid Woodhouse int err; 388aa98d7cfSKaiGai Kohei 389aa98d7cfSKaiGai Kohei crc = crc32(0, rr, sizeof(*rr) - 4); 390aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rr->node_crc)) { 391aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 392aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->node_crc), crc); 39368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen))))) 39468270995SDavid Woodhouse return err; 395aa98d7cfSKaiGai Kohei return 0; 396aa98d7cfSKaiGai Kohei } 397aa98d7cfSKaiGai Kohei 398aa98d7cfSKaiGai Kohei if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) { 39989291a9dSDavid Woodhouse JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n", 400aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->totlen), 401aa98d7cfSKaiGai Kohei PAD(sizeof(struct jffs2_raw_xref))); 40268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen)))) 40368270995SDavid Woodhouse return err; 404aa98d7cfSKaiGai Kohei return 0; 405aa98d7cfSKaiGai Kohei } 406aa98d7cfSKaiGai Kohei 407aa98d7cfSKaiGai Kohei ref = jffs2_alloc_xattr_ref(); 408aa98d7cfSKaiGai Kohei if (!ref) 409aa98d7cfSKaiGai Kohei return -ENOMEM; 410aa98d7cfSKaiGai Kohei 411aa98d7cfSKaiGai Kohei /* BEFORE jffs2_build_xattr_subsystem() called, 412c9f700f8SKaiGai Kohei * and AFTER xattr_ref is marked as a dead xref, 413aa98d7cfSKaiGai Kohei * ref->xid is used to store 32bit xid, xd is not used 414aa98d7cfSKaiGai Kohei * ref->ino is used to store 32bit inode-number, ic is not used 415aa98d7cfSKaiGai Kohei * Thoes variables are declared as union, thus using those 4168f2b6f49SKaiGai Kohei * are exclusive. In a similar way, ref->next is temporarily 417aa98d7cfSKaiGai Kohei * used to chain all xattr_ref object. It's re-chained to 418aa98d7cfSKaiGai Kohei * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly. 419aa98d7cfSKaiGai Kohei */ 420aa98d7cfSKaiGai Kohei ref->ino = je32_to_cpu(rr->ino); 421aa98d7cfSKaiGai Kohei ref->xid = je32_to_cpu(rr->xid); 422c9f700f8SKaiGai Kohei ref->xseqno = je32_to_cpu(rr->xseqno); 423c9f700f8SKaiGai Kohei if (ref->xseqno > c->highest_xseqno) 424c9f700f8SKaiGai Kohei c->highest_xseqno = (ref->xseqno & ~XREF_DELETE_MARKER); 4258f2b6f49SKaiGai Kohei ref->next = c->xref_temp; 4268f2b6f49SKaiGai Kohei c->xref_temp = ref; 427aa98d7cfSKaiGai Kohei 428c9f700f8SKaiGai Kohei jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), (void *)ref); 429f1f9671bSDavid Woodhouse 430aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 431aa98d7cfSKaiGai Kohei jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset); 432aa98d7cfSKaiGai Kohei dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n", 433aa98d7cfSKaiGai Kohei ofs, ref->xid, ref->ino); 434aa98d7cfSKaiGai Kohei return 0; 435aa98d7cfSKaiGai Kohei } 436aa98d7cfSKaiGai Kohei #endif 437aa98d7cfSKaiGai Kohei 4389641b784SDavid Woodhouse /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into 4399641b784SDavid Woodhouse the flash, XIP-style */ 4401da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 441e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) { 4421da177e4SLinus Torvalds struct jffs2_unknown_node *node; 4431da177e4SLinus Torvalds struct jffs2_unknown_node crcnode; 44441bdc602SJoakim Tjernlund uint32_t ofs, prevofs, max_ofs; 4451da177e4SLinus Torvalds uint32_t hdr_crc, buf_ofs, buf_len; 4461da177e4SLinus Torvalds int err; 4471da177e4SLinus Torvalds int noise = 0; 448e631ddbaSFerenc Havasi 449e631ddbaSFerenc Havasi 4502f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4511da177e4SLinus Torvalds int cleanmarkerfound = 0; 4521da177e4SLinus Torvalds #endif 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds ofs = jeb->offset; 4551da177e4SLinus Torvalds prevofs = jeb->offset - 1; 4561da177e4SLinus Torvalds 4579c261b33SJoe Perches jffs2_dbg(1, "%s(): Scanning block at 0x%x\n", __func__, ofs); 4581da177e4SLinus Torvalds 4592f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4601da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 461a7a6ace1SArtem Bityutskiy int ret; 462a7a6ace1SArtem Bityutskiy 4637086c19dSArtem Bityutskiy if (mtd_block_isbad(c->mtd, jeb->offset)) 464a7a6ace1SArtem Bityutskiy return BLK_STATE_BADBLOCK; 465a7a6ace1SArtem Bityutskiy 466a7a6ace1SArtem Bityutskiy ret = jffs2_check_nand_cleanmarker(c, jeb); 4679c261b33SJoe Perches jffs2_dbg(2, "jffs_check_nand_cleanmarker returned %d\n", ret); 468a7a6ace1SArtem Bityutskiy 4691da177e4SLinus Torvalds /* Even if it's not found, we still scan to see 4701da177e4SLinus Torvalds if the block is empty. We use this information 4711da177e4SLinus Torvalds to decide whether to erase it or not. */ 4721da177e4SLinus Torvalds switch (ret) { 4731da177e4SLinus Torvalds case 0: cleanmarkerfound = 1; break; 4741da177e4SLinus Torvalds case 1: break; 4751da177e4SLinus Torvalds default: return ret; 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds } 4781da177e4SLinus Torvalds #endif 479e631ddbaSFerenc Havasi 480e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 4819641b784SDavid Woodhouse struct jffs2_sum_marker *sm; 4829641b784SDavid Woodhouse void *sumptr = NULL; 4839641b784SDavid Woodhouse uint32_t sumlen; 484e631ddbaSFerenc Havasi 4859641b784SDavid Woodhouse if (!buf_size) { 4869641b784SDavid Woodhouse /* XIP case. Just look, point at the summary if it's there */ 48713ba42dfSDavid Woodhouse sm = (void *)buf + c->sector_size - sizeof(*sm); 488e631ddbaSFerenc Havasi if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 4899641b784SDavid Woodhouse sumptr = buf + je32_to_cpu(sm->offset); 4909641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 4919641b784SDavid Woodhouse } 4929641b784SDavid Woodhouse } else { 4939641b784SDavid Woodhouse /* If NAND flash, read a whole page of it. Else just the end */ 4949641b784SDavid Woodhouse if (c->wbuf_pagesize) 4959641b784SDavid Woodhouse buf_len = c->wbuf_pagesize; 4969641b784SDavid Woodhouse else 4979641b784SDavid Woodhouse buf_len = sizeof(*sm); 4989641b784SDavid Woodhouse 4999641b784SDavid Woodhouse /* Read as much as we want into the _end_ of the preallocated buffer */ 5009641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 5019641b784SDavid Woodhouse jeb->offset + c->sector_size - buf_len, 5029641b784SDavid Woodhouse buf_len); 5039641b784SDavid Woodhouse if (err) 5049641b784SDavid Woodhouse return err; 5059641b784SDavid Woodhouse 5069641b784SDavid Woodhouse sm = (void *)buf + buf_size - sizeof(*sm); 5079641b784SDavid Woodhouse if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 5089641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 5099641b784SDavid Woodhouse sumptr = buf + buf_size - sumlen; 5109641b784SDavid Woodhouse 5119641b784SDavid Woodhouse /* Now, make sure the summary itself is available */ 5129641b784SDavid Woodhouse if (sumlen > buf_size) { 5139641b784SDavid Woodhouse /* Need to kmalloc for this. */ 5149641b784SDavid Woodhouse sumptr = kmalloc(sumlen, GFP_KERNEL); 5159641b784SDavid Woodhouse if (!sumptr) 5169641b784SDavid Woodhouse return -ENOMEM; 5179641b784SDavid Woodhouse memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len); 5189641b784SDavid Woodhouse } 5199641b784SDavid Woodhouse if (buf_len < sumlen) { 5209641b784SDavid Woodhouse /* Need to read more so that the entire summary node is present */ 5219641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, sumptr, 5229641b784SDavid Woodhouse jeb->offset + c->sector_size - sumlen, 5239641b784SDavid Woodhouse sumlen - buf_len); 5249641b784SDavid Woodhouse if (err) 525e631ddbaSFerenc Havasi return err; 526e631ddbaSFerenc Havasi } 527e631ddbaSFerenc Havasi } 528e631ddbaSFerenc Havasi 5299641b784SDavid Woodhouse } 5309641b784SDavid Woodhouse 5319641b784SDavid Woodhouse if (sumptr) { 5329641b784SDavid Woodhouse err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random); 5333560160aSDavid Woodhouse 5349641b784SDavid Woodhouse if (buf_size && sumlen > buf_size) 5359641b784SDavid Woodhouse kfree(sumptr); 5363560160aSDavid Woodhouse /* If it returns with a real error, bail. 5373560160aSDavid Woodhouse If it returns positive, that's a block classification 5383560160aSDavid Woodhouse (i.e. BLK_STATE_xxx) so return that too. 5393560160aSDavid Woodhouse If it returns zero, fall through to full scan. */ 5403560160aSDavid Woodhouse if (err) 5413560160aSDavid Woodhouse return err; 5429641b784SDavid Woodhouse } 543e631ddbaSFerenc Havasi } 544e631ddbaSFerenc Havasi 5451da177e4SLinus Torvalds buf_ofs = jeb->offset; 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds if (!buf_size) { 5489641b784SDavid Woodhouse /* This is the XIP case -- we're reading _directly_ from the flash chip */ 5491da177e4SLinus Torvalds buf_len = c->sector_size; 5501da177e4SLinus Torvalds } else { 5513be36675SAndrew Victor buf_len = EMPTY_SCAN_SIZE(c->sector_size); 5521da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 5531da177e4SLinus Torvalds if (err) 5541da177e4SLinus Torvalds return err; 5551da177e4SLinus Torvalds } 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 5581da177e4SLinus Torvalds ofs = 0; 55941bdc602SJoakim Tjernlund max_ofs = EMPTY_SCAN_SIZE(c->sector_size); 56041bdc602SJoakim Tjernlund /* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */ 56141bdc602SJoakim Tjernlund while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) 5621da177e4SLinus Torvalds ofs += 4; 5631da177e4SLinus Torvalds 56441bdc602SJoakim Tjernlund if (ofs == max_ofs) { 5652f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 5661da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 5671da177e4SLinus Torvalds /* scan oob, take care of cleanmarker */ 5681da177e4SLinus Torvalds int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 5699c261b33SJoe Perches jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n", 5709c261b33SJoe Perches ret); 5711da177e4SLinus Torvalds switch (ret) { 5721da177e4SLinus Torvalds case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 5731da177e4SLinus Torvalds case 1: return BLK_STATE_ALLDIRTY; 5741da177e4SLinus Torvalds default: return ret; 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds } 5771da177e4SLinus Torvalds #endif 5789c261b33SJoe Perches jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n", 5799c261b33SJoe Perches jeb->offset); 5808f15fd55SAndrew Victor if (c->cleanmarker_size == 0) 5818f15fd55SAndrew Victor return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */ 5828f15fd55SAndrew Victor else 5831da177e4SLinus Torvalds return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds if (ofs) { 5869c261b33SJoe Perches jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset, 5879c261b33SJoe Perches jeb->offset + ofs); 588a6a8bef7SDavid Woodhouse if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1))) 589a6a8bef7SDavid Woodhouse return err; 59068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs))) 59168270995SDavid Woodhouse return err; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds /* Now ofs is a complete physical flash offset as it always was... */ 5951da177e4SLinus Torvalds ofs += jeb->offset; 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds noise = 10; 5981da177e4SLinus Torvalds 599733802d9SArtem B. Bityutskiy dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset); 600e631ddbaSFerenc Havasi 6011da177e4SLinus Torvalds scan_more: 6021da177e4SLinus Torvalds while(ofs < jeb->offset + c->sector_size) { 6031da177e4SLinus Torvalds 604e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 6051da177e4SLinus Torvalds 6062f785402SDavid Woodhouse /* Make sure there are node refs available for use */ 607046b8b98SDavid Woodhouse err = jffs2_prealloc_raw_node_refs(c, jeb, 2); 6082f785402SDavid Woodhouse if (err) 6092f785402SDavid Woodhouse return err; 6102f785402SDavid Woodhouse 6111da177e4SLinus Torvalds cond_resched(); 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds if (ofs & 3) { 6141da177e4SLinus Torvalds printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs); 6151da177e4SLinus Torvalds ofs = PAD(ofs); 6161da177e4SLinus Torvalds continue; 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds if (ofs == prevofs) { 6191da177e4SLinus Torvalds printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs); 62068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 62168270995SDavid Woodhouse return err; 6221da177e4SLinus Torvalds ofs += 4; 6231da177e4SLinus Torvalds continue; 6241da177e4SLinus Torvalds } 6251da177e4SLinus Torvalds prevofs = ofs; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 6289c261b33SJoe Perches jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n", 6299c261b33SJoe Perches sizeof(struct jffs2_unknown_node), 6309c261b33SJoe Perches jeb->offset, c->sector_size, ofs, 6319c261b33SJoe Perches sizeof(*node)); 63268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs))) 63368270995SDavid Woodhouse return err; 6341da177e4SLinus Torvalds break; 6351da177e4SLinus Torvalds } 6361da177e4SLinus Torvalds 6371da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(*node)) { 6381da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6399c261b33SJoe Perches jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 6409c261b33SJoe Perches sizeof(struct jffs2_unknown_node), 6419c261b33SJoe Perches buf_len, ofs); 6421da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 6431da177e4SLinus Torvalds if (err) 6441da177e4SLinus Torvalds return err; 6451da177e4SLinus Torvalds buf_ofs = ofs; 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs]; 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) { 6511da177e4SLinus Torvalds uint32_t inbuf_ofs; 652c2aecda7SJoakim Tjernlund uint32_t empty_start, scan_end; 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds empty_start = ofs; 6551da177e4SLinus Torvalds ofs += 4; 656c2aecda7SJoakim Tjernlund scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len); 6571da177e4SLinus Torvalds 6589c261b33SJoe Perches jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs); 6591da177e4SLinus Torvalds more_empty: 6601da177e4SLinus Torvalds inbuf_ofs = ofs - buf_ofs; 661c2aecda7SJoakim Tjernlund while (inbuf_ofs < scan_end) { 662c2aecda7SJoakim Tjernlund if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) { 6631da177e4SLinus Torvalds printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", 6641da177e4SLinus Torvalds empty_start, ofs); 66568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start))) 66668270995SDavid Woodhouse return err; 6671da177e4SLinus Torvalds goto scan_more; 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds inbuf_ofs+=4; 6711da177e4SLinus Torvalds ofs += 4; 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds /* Ran off end. */ 6749c261b33SJoe Perches jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n", 6759c261b33SJoe Perches ofs); 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds /* If we're only checking the beginning of a block with a cleanmarker, 6781da177e4SLinus Torvalds bail now */ 6791da177e4SLinus Torvalds if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 68099988f7bSDavid Woodhouse c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) { 6819c261b33SJoe Perches jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n", 6829c261b33SJoe Perches EMPTY_SCAN_SIZE(c->sector_size)); 6831da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 6841da177e4SLinus Torvalds } 685c2aecda7SJoakim Tjernlund if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */ 686c2aecda7SJoakim Tjernlund scan_end = buf_len; 687c2aecda7SJoakim Tjernlund goto more_empty; 688c2aecda7SJoakim Tjernlund } 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds /* See how much more there is to read in this eraseblock... */ 6911da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6921da177e4SLinus Torvalds if (!buf_len) { 6931da177e4SLinus Torvalds /* No more to read. Break out of main loop without marking 6941da177e4SLinus Torvalds this range of empty space as dirty (because it's not) */ 6959c261b33SJoe Perches jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n", 6969c261b33SJoe Perches empty_start); 6971da177e4SLinus Torvalds break; 6981da177e4SLinus Torvalds } 699c2aecda7SJoakim Tjernlund /* point never reaches here */ 700c2aecda7SJoakim Tjernlund scan_end = buf_len; 7019c261b33SJoe Perches jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n", 7029c261b33SJoe Perches buf_len, ofs); 7031da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7041da177e4SLinus Torvalds if (err) 7051da177e4SLinus Torvalds return err; 7061da177e4SLinus Torvalds buf_ofs = ofs; 7071da177e4SLinus Torvalds goto more_empty; 7081da177e4SLinus Torvalds } 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 7111da177e4SLinus Torvalds printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs); 71268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 71368270995SDavid Woodhouse return err; 7141da177e4SLinus Torvalds ofs += 4; 7151da177e4SLinus Torvalds continue; 7161da177e4SLinus Torvalds } 7171da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 7189c261b33SJoe Perches jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs); 71968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 72068270995SDavid Woodhouse return err; 7211da177e4SLinus Torvalds ofs += 4; 7221da177e4SLinus Torvalds continue; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 7251da177e4SLinus Torvalds printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs); 7261da177e4SLinus Torvalds printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n"); 72768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 72868270995SDavid Woodhouse return err; 7291da177e4SLinus Torvalds ofs += 4; 7301da177e4SLinus Torvalds continue; 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 7331da177e4SLinus Torvalds /* OK. We're out of possibilities. Whinge and move on */ 7341da177e4SLinus Torvalds noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 7351da177e4SLinus Torvalds JFFS2_MAGIC_BITMASK, ofs, 7361da177e4SLinus Torvalds je16_to_cpu(node->magic)); 73768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 73868270995SDavid Woodhouse return err; 7391da177e4SLinus Torvalds ofs += 4; 7401da177e4SLinus Torvalds continue; 7411da177e4SLinus Torvalds } 7421da177e4SLinus Torvalds /* We seem to have a node of sorts. Check the CRC */ 7431da177e4SLinus Torvalds crcnode.magic = node->magic; 7441da177e4SLinus Torvalds crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE); 7451da177e4SLinus Torvalds crcnode.totlen = node->totlen; 7461da177e4SLinus Torvalds hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 7491da177e4SLinus 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", 7501da177e4SLinus Torvalds ofs, je16_to_cpu(node->magic), 7511da177e4SLinus Torvalds je16_to_cpu(node->nodetype), 7521da177e4SLinus Torvalds je32_to_cpu(node->totlen), 7531da177e4SLinus Torvalds je32_to_cpu(node->hdr_crc), 7541da177e4SLinus Torvalds hdr_crc); 75568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 75668270995SDavid Woodhouse return err; 7571da177e4SLinus Torvalds ofs += 4; 7581da177e4SLinus Torvalds continue; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7610dec4c8bSJoakim Tjernlund if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) { 7621da177e4SLinus Torvalds /* Eep. Node goes over the end of the erase block. */ 7631da177e4SLinus Torvalds printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 7641da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen)); 7651da177e4SLinus Torvalds printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n"); 76668270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 76768270995SDavid Woodhouse return err; 7681da177e4SLinus Torvalds ofs += 4; 7691da177e4SLinus Torvalds continue; 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 7731da177e4SLinus Torvalds /* Wheee. This is an obsoleted node */ 7749c261b33SJoe Perches jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n", 7759c261b33SJoe Perches ofs); 77668270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 77768270995SDavid Woodhouse return err; 7781da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7791da177e4SLinus Torvalds continue; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds switch(je16_to_cpu(node->nodetype)) { 7831da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 7841da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 7851da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7869c261b33SJoe Perches jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 7879c261b33SJoe Perches sizeof(struct jffs2_raw_inode), 7889c261b33SJoe Perches buf_len, ofs); 7891da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7901da177e4SLinus Torvalds if (err) 7911da177e4SLinus Torvalds return err; 7921da177e4SLinus Torvalds buf_ofs = ofs; 7931da177e4SLinus Torvalds node = (void *)buf; 7941da177e4SLinus Torvalds } 795e631ddbaSFerenc Havasi err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s); 7961da177e4SLinus Torvalds if (err) return err; 7971da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7981da177e4SLinus Torvalds break; 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 8011da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 8021da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8039c261b33SJoe Perches jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 8049c261b33SJoe Perches je32_to_cpu(node->totlen), buf_len, 8059c261b33SJoe Perches ofs); 8061da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 8071da177e4SLinus Torvalds if (err) 8081da177e4SLinus Torvalds return err; 8091da177e4SLinus Torvalds buf_ofs = ofs; 8101da177e4SLinus Torvalds node = (void *)buf; 8111da177e4SLinus Torvalds } 812e631ddbaSFerenc Havasi err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s); 8131da177e4SLinus Torvalds if (err) return err; 8141da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8151da177e4SLinus Torvalds break; 8161da177e4SLinus Torvalds 817aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 818aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XATTR: 819aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 820aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8219c261b33SJoe Perches jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n", 8229c261b33SJoe Perches je32_to_cpu(node->totlen), buf_len, 8239c261b33SJoe Perches ofs); 824aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 825aa98d7cfSKaiGai Kohei if (err) 826aa98d7cfSKaiGai Kohei return err; 827aa98d7cfSKaiGai Kohei buf_ofs = ofs; 828aa98d7cfSKaiGai Kohei node = (void *)buf; 829aa98d7cfSKaiGai Kohei } 830aa98d7cfSKaiGai Kohei err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s); 831aa98d7cfSKaiGai Kohei if (err) 832aa98d7cfSKaiGai Kohei return err; 833aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 834aa98d7cfSKaiGai Kohei break; 835aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XREF: 836aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 837aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8389c261b33SJoe Perches jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n", 8399c261b33SJoe Perches je32_to_cpu(node->totlen), buf_len, 8409c261b33SJoe Perches ofs); 841aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 842aa98d7cfSKaiGai Kohei if (err) 843aa98d7cfSKaiGai Kohei return err; 844aa98d7cfSKaiGai Kohei buf_ofs = ofs; 845aa98d7cfSKaiGai Kohei node = (void *)buf; 846aa98d7cfSKaiGai Kohei } 847aa98d7cfSKaiGai Kohei err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s); 848aa98d7cfSKaiGai Kohei if (err) 849aa98d7cfSKaiGai Kohei return err; 850aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 851aa98d7cfSKaiGai Kohei break; 852aa98d7cfSKaiGai Kohei #endif /* CONFIG_JFFS2_FS_XATTR */ 853aa98d7cfSKaiGai Kohei 8541da177e4SLinus Torvalds case JFFS2_NODETYPE_CLEANMARKER: 8559c261b33SJoe Perches jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs); 8561da177e4SLinus Torvalds if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 8571da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 8581da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen), c->cleanmarker_size); 85968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 86068270995SDavid Woodhouse return err; 8611da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8621da177e4SLinus Torvalds } else if (jeb->first_node) { 8631da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset); 86468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 86568270995SDavid Woodhouse return err; 8661da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8671da177e4SLinus Torvalds } else { 8682f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL); 869f1f9671bSDavid Woodhouse 8701da177e4SLinus Torvalds ofs += PAD(c->cleanmarker_size); 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds break; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds case JFFS2_NODETYPE_PADDING: 875e631ddbaSFerenc Havasi if (jffs2_sum_active()) 876e631ddbaSFerenc Havasi jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen)); 87768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 87868270995SDavid Woodhouse return err; 8791da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8801da177e4SLinus Torvalds break; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds default: 8831da177e4SLinus Torvalds switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 8841da177e4SLinus Torvalds case JFFS2_FEATURE_ROCOMPAT: 8851da177e4SLinus Torvalds printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8861da177e4SLinus Torvalds c->flags |= JFFS2_SB_FLAG_RO; 8871da177e4SLinus Torvalds if (!(jffs2_is_readonly(c))) 8881da177e4SLinus Torvalds return -EROFS; 88968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 89068270995SDavid Woodhouse return err; 8911da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8921da177e4SLinus Torvalds break; 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds case JFFS2_FEATURE_INCOMPAT: 8951da177e4SLinus Torvalds printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8961da177e4SLinus Torvalds return -EINVAL; 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_DELETE: 8999c261b33SJoe Perches jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", 9009c261b33SJoe Perches je16_to_cpu(node->nodetype), ofs); 90168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 90268270995SDavid Woodhouse return err; 9031da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 9041da177e4SLinus Torvalds break; 9051da177e4SLinus Torvalds 9066171586aSDavid Woodhouse case JFFS2_FEATURE_RWCOMPAT_COPY: { 9079c261b33SJoe Perches jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", 9089c261b33SJoe Perches je16_to_cpu(node->nodetype), ofs); 9096171586aSDavid Woodhouse 9102f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL); 9116171586aSDavid Woodhouse 9126171586aSDavid Woodhouse /* We can't summarise nodes we don't grok */ 9136171586aSDavid Woodhouse jffs2_sum_disable_collecting(s); 9141da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 9151da177e4SLinus Torvalds break; 9161da177e4SLinus Torvalds } 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds } 9196171586aSDavid Woodhouse } 9201da177e4SLinus Torvalds 921e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 922e631ddbaSFerenc Havasi if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) { 923733802d9SArtem B. Bityutskiy dbg_summary("There is not enough space for " 924e631ddbaSFerenc Havasi "summary information, disabling for this jeb!\n"); 925e631ddbaSFerenc Havasi jffs2_sum_disable_collecting(s); 926e631ddbaSFerenc Havasi } 927e631ddbaSFerenc Havasi } 9281da177e4SLinus Torvalds 9299c261b33SJoe Perches jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n", 9309c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 9319c261b33SJoe Perches jeb->unchecked_size, jeb->used_size, jeb->wasted_size); 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds /* mark_node_obsolete can add to wasted !! */ 9341da177e4SLinus Torvalds if (jeb->wasted_size) { 9351da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 9361da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 9371da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 9381da177e4SLinus Torvalds jeb->wasted_size = 0; 9391da177e4SLinus Torvalds } 9401da177e4SLinus Torvalds 941e631ddbaSFerenc Havasi return jffs2_scan_classify_jeb(c, jeb); 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds 944e631ddbaSFerenc Havasi struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino) 9451da177e4SLinus Torvalds { 9461da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9491da177e4SLinus Torvalds if (ic) 9501da177e4SLinus Torvalds return ic; 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds if (ino > c->highest_ino) 9531da177e4SLinus Torvalds c->highest_ino = ino; 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 9561da177e4SLinus Torvalds if (!ic) { 9571da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n"); 9581da177e4SLinus Torvalds return NULL; 9591da177e4SLinus Torvalds } 9601da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds ic->ino = ino; 9631da177e4SLinus Torvalds ic->nodes = (void *)ic; 9641da177e4SLinus Torvalds jffs2_add_ino_cache(c, ic); 9651da177e4SLinus Torvalds if (ino == 1) 96627c72b04SDavid Woodhouse ic->pino_nlink = 1; 9671da177e4SLinus Torvalds return ic; 9681da177e4SLinus Torvalds } 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 971e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s) 9721da177e4SLinus Torvalds { 9731da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 97453043002SThomas Gleixner uint32_t crc, ino = je32_to_cpu(ri->ino); 9751da177e4SLinus Torvalds 9769c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs); 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds /* We do very little here now. Just check the ino# to which we should attribute 9791da177e4SLinus Torvalds this node; we can do all the CRC checking etc. later. There's a tradeoff here -- 9801da177e4SLinus Torvalds we used to scan the flash once only, reading everything we want from it into 9811da177e4SLinus Torvalds memory, then building all our in-core data structures and freeing the extra 9821da177e4SLinus Torvalds information. Now we allow the first part of the mount to complete a lot quicker, 9831da177e4SLinus Torvalds but we have to go _back_ to the flash in order to finish the CRC checking, etc. 9841da177e4SLinus Torvalds Which means that the _full_ amount of time to get to proper write mode with GC 9851da177e4SLinus Torvalds operational may actually be _longer_ than before. Sucks to be me. */ 9861da177e4SLinus Torvalds 98753043002SThomas Gleixner /* Check the node CRC in any case. */ 98853043002SThomas Gleixner crc = crc32(0, ri, sizeof(*ri)-8); 98953043002SThomas Gleixner if (crc != je32_to_cpu(ri->node_crc)) { 99053043002SThomas Gleixner printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on " 99153043002SThomas Gleixner "node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 99253043002SThomas Gleixner ofs, je32_to_cpu(ri->node_crc), crc); 99353043002SThomas Gleixner /* 99453043002SThomas Gleixner * We believe totlen because the CRC on the node 99553043002SThomas Gleixner * _header_ was OK, just the node itself failed. 99653043002SThomas Gleixner */ 99753043002SThomas Gleixner return jffs2_scan_dirty_space(c, jeb, 99853043002SThomas Gleixner PAD(je32_to_cpu(ri->totlen))); 99953043002SThomas Gleixner } 100053043002SThomas Gleixner 10011da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 10021da177e4SLinus Torvalds if (!ic) { 10031da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, ino); 10042f785402SDavid Woodhouse if (!ic) 10051da177e4SLinus Torvalds return -ENOMEM; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds /* Wheee. It worked */ 10092f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic); 10101da177e4SLinus Torvalds 10119c261b33SJoe Perches jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 10121da177e4SLinus Torvalds je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 10131da177e4SLinus Torvalds je32_to_cpu(ri->offset), 10149c261b33SJoe Perches je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize)); 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds pseudo_random += je32_to_cpu(ri->version); 10171da177e4SLinus Torvalds 1018e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1019e631ddbaSFerenc Havasi jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset); 1020e631ddbaSFerenc Havasi } 1021e631ddbaSFerenc Havasi 10221da177e4SLinus Torvalds return 0; 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 1026e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s) 10271da177e4SLinus Torvalds { 10281da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 10291da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 1030b534e70cSDavid Woodhouse uint32_t checkedlen; 10311da177e4SLinus Torvalds uint32_t crc; 103268270995SDavid Woodhouse int err; 10331da177e4SLinus Torvalds 10349c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs); 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds /* We don't get here unless the node is still valid, so we don't have to 10371da177e4SLinus Torvalds mask in the ACCURATE bit any more. */ 10381da177e4SLinus Torvalds crc = crc32(0, rd, sizeof(*rd)-8); 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->node_crc)) { 10411da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 10421da177e4SLinus Torvalds ofs, je32_to_cpu(rd->node_crc), crc); 10431da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 104468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 104568270995SDavid Woodhouse return err; 10461da177e4SLinus Torvalds return 0; 10471da177e4SLinus Torvalds } 10481da177e4SLinus Torvalds 10491da177e4SLinus Torvalds pseudo_random += je32_to_cpu(rd->version); 10501da177e4SLinus Torvalds 1051b534e70cSDavid Woodhouse /* Should never happen. Did. (OLPC trac #4184)*/ 1052b534e70cSDavid Woodhouse checkedlen = strnlen(rd->name, rd->nsize); 1053b534e70cSDavid Woodhouse if (checkedlen < rd->nsize) { 1054b534e70cSDavid Woodhouse printk(KERN_ERR "Dirent at %08x has zeroes in name. Truncating to %d chars\n", 1055b534e70cSDavid Woodhouse ofs, checkedlen); 1056b534e70cSDavid Woodhouse } 1057b534e70cSDavid Woodhouse fd = jffs2_alloc_full_dirent(checkedlen+1); 10581da177e4SLinus Torvalds if (!fd) { 10591da177e4SLinus Torvalds return -ENOMEM; 10601da177e4SLinus Torvalds } 1061b534e70cSDavid Woodhouse memcpy(&fd->name, rd->name, checkedlen); 1062b534e70cSDavid Woodhouse fd->name[checkedlen] = 0; 10631da177e4SLinus Torvalds 10641da177e4SLinus Torvalds crc = crc32(0, fd->name, rd->nsize); 10651da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->name_crc)) { 10661da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 10671da177e4SLinus Torvalds ofs, je32_to_cpu(rd->name_crc), crc); 10689c261b33SJoe Perches jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n", 10699c261b33SJoe Perches fd->name, je32_to_cpu(rd->ino)); 10701da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10711da177e4SLinus Torvalds /* FIXME: Why do we believe totlen? */ 10721da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */ 107368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 107468270995SDavid Woodhouse return err; 10751da177e4SLinus Torvalds return 0; 10761da177e4SLinus Torvalds } 10771da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino)); 10781da177e4SLinus Torvalds if (!ic) { 10791da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10801da177e4SLinus Torvalds return -ENOMEM; 10811da177e4SLinus Torvalds } 10821da177e4SLinus Torvalds 108343dfa07fSDavid Woodhouse fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd), 108443dfa07fSDavid Woodhouse PAD(je32_to_cpu(rd->totlen)), ic); 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds fd->next = NULL; 10871da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 10881da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 1089b534e70cSDavid Woodhouse fd->nhash = full_name_hash(fd->name, checkedlen); 10901da177e4SLinus Torvalds fd->type = rd->type; 10911da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &ic->scan_dents); 10921da177e4SLinus Torvalds 1093e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1094e631ddbaSFerenc Havasi jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset); 1095e631ddbaSFerenc Havasi } 1096e631ddbaSFerenc Havasi 10971da177e4SLinus Torvalds return 0; 10981da177e4SLinus Torvalds } 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds static int count_list(struct list_head *l) 11011da177e4SLinus Torvalds { 11021da177e4SLinus Torvalds uint32_t count = 0; 11031da177e4SLinus Torvalds struct list_head *tmp; 11041da177e4SLinus Torvalds 11051da177e4SLinus Torvalds list_for_each(tmp, l) { 11061da177e4SLinus Torvalds count++; 11071da177e4SLinus Torvalds } 11081da177e4SLinus Torvalds return count; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds /* Note: This breaks if list_empty(head). I don't care. You 11121da177e4SLinus Torvalds might, if you copy this code and use it elsewhere :) */ 11131da177e4SLinus Torvalds static void rotate_list(struct list_head *head, uint32_t count) 11141da177e4SLinus Torvalds { 11151da177e4SLinus Torvalds struct list_head *n = head->next; 11161da177e4SLinus Torvalds 11171da177e4SLinus Torvalds list_del(head); 11181da177e4SLinus Torvalds while(count--) { 11191da177e4SLinus Torvalds n = n->next; 11201da177e4SLinus Torvalds } 11211da177e4SLinus Torvalds list_add(head, n); 11221da177e4SLinus Torvalds } 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c) 11251da177e4SLinus Torvalds { 11261da177e4SLinus Torvalds uint32_t x; 11271da177e4SLinus Torvalds uint32_t rotateby; 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds x = count_list(&c->clean_list); 11301da177e4SLinus Torvalds if (x) { 11311da177e4SLinus Torvalds rotateby = pseudo_random % x; 11321da177e4SLinus Torvalds rotate_list((&c->clean_list), rotateby); 11331da177e4SLinus Torvalds } 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds x = count_list(&c->very_dirty_list); 11361da177e4SLinus Torvalds if (x) { 11371da177e4SLinus Torvalds rotateby = pseudo_random % x; 11381da177e4SLinus Torvalds rotate_list((&c->very_dirty_list), rotateby); 11391da177e4SLinus Torvalds } 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds x = count_list(&c->dirty_list); 11421da177e4SLinus Torvalds if (x) { 11431da177e4SLinus Torvalds rotateby = pseudo_random % x; 11441da177e4SLinus Torvalds rotate_list((&c->dirty_list), rotateby); 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds x = count_list(&c->erasable_list); 11481da177e4SLinus Torvalds if (x) { 11491da177e4SLinus Torvalds rotateby = pseudo_random % x; 11501da177e4SLinus Torvalds rotate_list((&c->erasable_list), rotateby); 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 11541da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_erasing_blocks; 11551da177e4SLinus Torvalds rotate_list((&c->erase_pending_list), rotateby); 11561da177e4SLinus Torvalds } 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds if (c->nr_free_blocks) { 11591da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_free_blocks; 11601da177e4SLinus Torvalds rotate_list((&c->free_list), rotateby); 11611da177e4SLinus Torvalds } 11621da177e4SLinus Torvalds } 1163