11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001-2003 Red Hat, Inc. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 91da177e4SLinus Torvalds * 10daba5cc4SArtem B. Bityutskiy * $Id: scan.c,v 1.125 2005/09/30 13:59:13 dedekind Exp $ 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds #include <linux/kernel.h> 141da177e4SLinus Torvalds #include <linux/sched.h> 151da177e4SLinus Torvalds #include <linux/slab.h> 161da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 171da177e4SLinus Torvalds #include <linux/pagemap.h> 181da177e4SLinus Torvalds #include <linux/crc32.h> 191da177e4SLinus Torvalds #include <linux/compiler.h> 201da177e4SLinus Torvalds #include "nodelist.h" 21e631ddbaSFerenc Havasi #include "summary.h" 22e631ddbaSFerenc Havasi #include "debug.h" 231da177e4SLinus Torvalds 243be36675SAndrew Victor #define DEFAULT_EMPTY_SCAN_SIZE 1024 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds #define noisy_printk(noise, args...) do { \ 271da177e4SLinus Torvalds if (*(noise)) { \ 281da177e4SLinus Torvalds printk(KERN_NOTICE args); \ 291da177e4SLinus Torvalds (*(noise))--; \ 301da177e4SLinus Torvalds if (!(*(noise))) { \ 311da177e4SLinus Torvalds printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \ 321da177e4SLinus Torvalds } \ 331da177e4SLinus Torvalds } \ 341da177e4SLinus Torvalds } while(0) 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds static uint32_t pseudo_random; 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 39e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s); 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds /* These helper functions _must_ increase ofs and also do the dirty/used space accounting. 421da177e4SLinus Torvalds * Returning an error will abort the mount - bad checksums etc. should just mark the space 431da177e4SLinus Torvalds * as dirty. 441da177e4SLinus Torvalds */ 451da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 46e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s); 471da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 48e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds static inline int min_free(struct jffs2_sb_info *c) 511da177e4SLinus Torvalds { 521da177e4SLinus Torvalds uint32_t min = 2 * sizeof(struct jffs2_raw_inode); 532f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 541da177e4SLinus Torvalds if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize) 551da177e4SLinus Torvalds return c->wbuf_pagesize; 561da177e4SLinus Torvalds #endif 571da177e4SLinus Torvalds return min; 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds } 603be36675SAndrew Victor 613be36675SAndrew Victor static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) { 623be36675SAndrew Victor if (sector_size < DEFAULT_EMPTY_SCAN_SIZE) 633be36675SAndrew Victor return sector_size; 643be36675SAndrew Victor else 653be36675SAndrew Victor return DEFAULT_EMPTY_SCAN_SIZE; 663be36675SAndrew Victor } 673be36675SAndrew Victor 6825090a6bSDavid Woodhouse static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 6925090a6bSDavid Woodhouse { 7025090a6bSDavid Woodhouse int ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size); 7125090a6bSDavid Woodhouse if (ret) 7225090a6bSDavid Woodhouse return ret; 7325090a6bSDavid Woodhouse /* Turned wasted size into dirty, since we apparently 7425090a6bSDavid Woodhouse think it's recoverable now. */ 7525090a6bSDavid Woodhouse jeb->dirty_size += jeb->wasted_size; 7625090a6bSDavid Woodhouse c->dirty_size += jeb->wasted_size; 7725090a6bSDavid Woodhouse c->wasted_size -= jeb->wasted_size; 7825090a6bSDavid Woodhouse jeb->wasted_size = 0; 7925090a6bSDavid Woodhouse if (VERYDIRTY(c, jeb->dirty_size)) { 8025090a6bSDavid Woodhouse list_add(&jeb->list, &c->very_dirty_list); 8125090a6bSDavid Woodhouse } else { 8225090a6bSDavid Woodhouse list_add(&jeb->list, &c->dirty_list); 8325090a6bSDavid Woodhouse } 8425090a6bSDavid Woodhouse return 0; 8525090a6bSDavid Woodhouse } 8625090a6bSDavid Woodhouse 871da177e4SLinus Torvalds int jffs2_scan_medium(struct jffs2_sb_info *c) 881da177e4SLinus Torvalds { 891da177e4SLinus Torvalds int i, ret; 901da177e4SLinus Torvalds uint32_t empty_blocks = 0, bad_blocks = 0; 911da177e4SLinus Torvalds unsigned char *flashbuf = NULL; 921da177e4SLinus Torvalds uint32_t buf_size = 0; 93e631ddbaSFerenc Havasi struct jffs2_summary *s = NULL; /* summary info collected by the scan process */ 941da177e4SLinus Torvalds #ifndef __ECOS 951da177e4SLinus Torvalds size_t pointlen; 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds if (c->mtd->point) { 981da177e4SLinus Torvalds ret = c->mtd->point (c->mtd, 0, c->mtd->size, &pointlen, &flashbuf); 991da177e4SLinus Torvalds if (!ret && pointlen < c->mtd->size) { 1001da177e4SLinus Torvalds /* Don't muck about if it won't let us point to the whole flash */ 1011da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen)); 1021da177e4SLinus Torvalds c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size); 1031da177e4SLinus Torvalds flashbuf = NULL; 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds if (ret) 1061da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point failed %d\n", ret)); 1071da177e4SLinus Torvalds } 1081da177e4SLinus Torvalds #endif 1091da177e4SLinus Torvalds if (!flashbuf) { 1101da177e4SLinus Torvalds /* For NAND it's quicker to read a whole eraseblock at a time, 1111da177e4SLinus Torvalds apparently */ 1121da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) 1131da177e4SLinus Torvalds buf_size = c->sector_size; 1141da177e4SLinus Torvalds else 1151da177e4SLinus Torvalds buf_size = PAGE_SIZE; 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds /* Respect kmalloc limitations */ 1181da177e4SLinus Torvalds if (buf_size > 128*1024) 1191da177e4SLinus Torvalds buf_size = 128*1024; 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocating readbuf of %d bytes\n", buf_size)); 1221da177e4SLinus Torvalds flashbuf = kmalloc(buf_size, GFP_KERNEL); 1231da177e4SLinus Torvalds if (!flashbuf) 1241da177e4SLinus Torvalds return -ENOMEM; 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 127e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 128e631ddbaSFerenc Havasi s = kmalloc(sizeof(struct jffs2_summary), GFP_KERNEL); 129e631ddbaSFerenc Havasi if (!s) { 130e631ddbaSFerenc Havasi JFFS2_WARNING("Can't allocate memory for summary\n"); 131e631ddbaSFerenc Havasi return -ENOMEM; 132e631ddbaSFerenc Havasi } 133e631ddbaSFerenc Havasi memset(s, 0, sizeof(struct jffs2_summary)); 134e631ddbaSFerenc Havasi } 135e631ddbaSFerenc Havasi 1361da177e4SLinus Torvalds for (i=0; i<c->nr_blocks; i++) { 1371da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[i]; 1381da177e4SLinus Torvalds 139e631ddbaSFerenc Havasi /* reset summary info for next eraseblock scan */ 140e631ddbaSFerenc Havasi jffs2_sum_reset_collected(s); 141e631ddbaSFerenc Havasi 142e631ddbaSFerenc Havasi ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), 143e631ddbaSFerenc Havasi buf_size, s); 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds if (ret < 0) 1461da177e4SLinus Torvalds goto out; 1471da177e4SLinus Torvalds 148e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds /* Now decide which list to put it on */ 1511da177e4SLinus Torvalds switch(ret) { 1521da177e4SLinus Torvalds case BLK_STATE_ALLFF: 1531da177e4SLinus Torvalds /* 1541da177e4SLinus Torvalds * Empty block. Since we can't be sure it 1551da177e4SLinus Torvalds * was entirely erased, we just queue it for erase 1561da177e4SLinus Torvalds * again. It will be marked as such when the erase 1571da177e4SLinus Torvalds * is complete. Meanwhile we still count it as empty 1581da177e4SLinus Torvalds * for later checks. 1591da177e4SLinus Torvalds */ 1601da177e4SLinus Torvalds empty_blocks++; 1611da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1621da177e4SLinus Torvalds c->nr_erasing_blocks++; 1631da177e4SLinus Torvalds break; 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds case BLK_STATE_CLEANMARKER: 1661da177e4SLinus Torvalds /* Only a CLEANMARKER node is valid */ 1671da177e4SLinus Torvalds if (!jeb->dirty_size) { 1681da177e4SLinus Torvalds /* It's actually free */ 1691da177e4SLinus Torvalds list_add(&jeb->list, &c->free_list); 1701da177e4SLinus Torvalds c->nr_free_blocks++; 1711da177e4SLinus Torvalds } else { 1721da177e4SLinus Torvalds /* Dirt */ 1731da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset)); 1741da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1751da177e4SLinus Torvalds c->nr_erasing_blocks++; 1761da177e4SLinus Torvalds } 1771da177e4SLinus Torvalds break; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds case BLK_STATE_CLEAN: 1801da177e4SLinus Torvalds /* Full (or almost full) of clean data. Clean list */ 1811da177e4SLinus Torvalds list_add(&jeb->list, &c->clean_list); 1821da177e4SLinus Torvalds break; 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds case BLK_STATE_PARTDIRTY: 1851da177e4SLinus Torvalds /* Some data, but not full. Dirty list. */ 1861da177e4SLinus Torvalds /* We want to remember the block with most free space 1871da177e4SLinus Torvalds and stick it in the 'nextblock' position to start writing to it. */ 1881da177e4SLinus Torvalds if (jeb->free_size > min_free(c) && 1891da177e4SLinus Torvalds (!c->nextblock || c->nextblock->free_size < jeb->free_size)) { 1901da177e4SLinus Torvalds /* Better candidate for the next writes to go to */ 1911da177e4SLinus Torvalds if (c->nextblock) { 19225090a6bSDavid Woodhouse ret = file_dirty(c, c->nextblock); 19325090a6bSDavid Woodhouse if (ret) 19425090a6bSDavid Woodhouse return ret; 195e631ddbaSFerenc Havasi /* deleting summary information of the old nextblock */ 196e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); 1971da177e4SLinus Torvalds } 19825090a6bSDavid Woodhouse /* update collected summary information for the current nextblock */ 199e631ddbaSFerenc Havasi jffs2_sum_move_collected(c, s); 200e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_scan_medium(): new nextblock = 0x%08x\n", jeb->offset)); 2011da177e4SLinus Torvalds c->nextblock = jeb; 2021da177e4SLinus Torvalds } else { 20325090a6bSDavid Woodhouse ret = file_dirty(c, jeb); 20425090a6bSDavid Woodhouse if (ret) 20525090a6bSDavid Woodhouse return ret; 2061da177e4SLinus Torvalds } 2071da177e4SLinus Torvalds break; 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds case BLK_STATE_ALLDIRTY: 2101da177e4SLinus Torvalds /* Nothing valid - not even a clean marker. Needs erasing. */ 2111da177e4SLinus Torvalds /* For now we just put it on the erasing list. We'll start the erases later */ 2121da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset)); 2131da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 2141da177e4SLinus Torvalds c->nr_erasing_blocks++; 2151da177e4SLinus Torvalds break; 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds case BLK_STATE_BADBLOCK: 2181da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset)); 2191da177e4SLinus Torvalds list_add(&jeb->list, &c->bad_list); 2201da177e4SLinus Torvalds c->bad_size += c->sector_size; 2211da177e4SLinus Torvalds c->free_size -= c->sector_size; 2221da177e4SLinus Torvalds bad_blocks++; 2231da177e4SLinus Torvalds break; 2241da177e4SLinus Torvalds default: 2251da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n"); 2261da177e4SLinus Torvalds BUG(); 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */ 2311da177e4SLinus Torvalds if (c->nextblock && (c->nextblock->dirty_size)) { 2321da177e4SLinus Torvalds c->nextblock->wasted_size += c->nextblock->dirty_size; 2331da177e4SLinus Torvalds c->wasted_size += c->nextblock->dirty_size; 2341da177e4SLinus Torvalds c->dirty_size -= c->nextblock->dirty_size; 2351da177e4SLinus Torvalds c->nextblock->dirty_size = 0; 2361da177e4SLinus Torvalds } 2372f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 238e96fb230SDavid Woodhouse if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) { 2391da177e4SLinus Torvalds /* If we're going to start writing into a block which already 2401da177e4SLinus Torvalds contains data, and the end of the data isn't page-aligned, 2411da177e4SLinus Torvalds skip a little and align it. */ 2421da177e4SLinus Torvalds 243daba5cc4SArtem B. Bityutskiy uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize; 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n", 2461da177e4SLinus Torvalds skip)); 2471da177e4SLinus Torvalds c->nextblock->wasted_size += skip; 2481da177e4SLinus Torvalds c->wasted_size += skip; 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds c->nextblock->free_size -= skip; 2511da177e4SLinus Torvalds c->free_size -= skip; 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds #endif 2541da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 2551da177e4SLinus Torvalds if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) { 2561da177e4SLinus Torvalds printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 2571da177e4SLinus Torvalds printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks); 2581da177e4SLinus Torvalds ret = -EIO; 2591da177e4SLinus Torvalds goto out; 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds ret = 0; 2641da177e4SLinus Torvalds out: 2651da177e4SLinus Torvalds if (buf_size) 2661da177e4SLinus Torvalds kfree(flashbuf); 2671da177e4SLinus Torvalds #ifndef __ECOS 2681da177e4SLinus Torvalds else 2691da177e4SLinus Torvalds c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size); 2701da177e4SLinus Torvalds #endif 2715b5ffbc1SFlorin Malita if (s) 2725b5ffbc1SFlorin Malita kfree(s); 2735b5ffbc1SFlorin Malita 2741da177e4SLinus Torvalds return ret; 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds 277e631ddbaSFerenc Havasi int jffs2_fill_scan_buf (struct jffs2_sb_info *c, void *buf, 2781da177e4SLinus Torvalds uint32_t ofs, uint32_t len) 2791da177e4SLinus Torvalds { 2801da177e4SLinus Torvalds int ret; 2811da177e4SLinus Torvalds size_t retlen; 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 2841da177e4SLinus Torvalds if (ret) { 2851da177e4SLinus Torvalds D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret)); 2861da177e4SLinus Torvalds return ret; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds if (retlen < len) { 2891da177e4SLinus Torvalds D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen)); 2901da177e4SLinus Torvalds return -EIO; 2911da177e4SLinus Torvalds } 2921da177e4SLinus Torvalds return 0; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 295e631ddbaSFerenc Havasi int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 296e631ddbaSFerenc Havasi { 297e631ddbaSFerenc Havasi if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size 29899988f7bSDavid Woodhouse && (!jeb->first_node || !ref_next(jeb->first_node)) ) 299e631ddbaSFerenc Havasi return BLK_STATE_CLEANMARKER; 300e631ddbaSFerenc Havasi 301e631ddbaSFerenc Havasi /* move blocks with max 4 byte dirty space to cleanlist */ 302e631ddbaSFerenc Havasi else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) { 303e631ddbaSFerenc Havasi c->dirty_size -= jeb->dirty_size; 304e631ddbaSFerenc Havasi c->wasted_size += jeb->dirty_size; 305e631ddbaSFerenc Havasi jeb->wasted_size += jeb->dirty_size; 306e631ddbaSFerenc Havasi jeb->dirty_size = 0; 307e631ddbaSFerenc Havasi return BLK_STATE_CLEAN; 308e631ddbaSFerenc Havasi } else if (jeb->used_size || jeb->unchecked_size) 309e631ddbaSFerenc Havasi return BLK_STATE_PARTDIRTY; 310e631ddbaSFerenc Havasi else 311e631ddbaSFerenc Havasi return BLK_STATE_ALLDIRTY; 312e631ddbaSFerenc Havasi } 313e631ddbaSFerenc Havasi 314aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 315aa98d7cfSKaiGai Kohei static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 316aa98d7cfSKaiGai Kohei struct jffs2_raw_xattr *rx, uint32_t ofs, 317aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 318aa98d7cfSKaiGai Kohei { 319aa98d7cfSKaiGai Kohei struct jffs2_xattr_datum *xd; 320aa98d7cfSKaiGai Kohei uint32_t totlen, crc; 32168270995SDavid Woodhouse int err; 322aa98d7cfSKaiGai Kohei 323aa98d7cfSKaiGai Kohei crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4); 324aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rx->node_crc)) { 325aa98d7cfSKaiGai Kohei if (je32_to_cpu(rx->node_crc) != 0xffffffff) 326aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 327aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->node_crc), crc); 32868270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 32968270995SDavid Woodhouse return err; 330aa98d7cfSKaiGai Kohei return 0; 331aa98d7cfSKaiGai Kohei } 332aa98d7cfSKaiGai Kohei 333aa98d7cfSKaiGai Kohei totlen = PAD(sizeof(*rx) + rx->name_len + 1 + je16_to_cpu(rx->value_len)); 334aa98d7cfSKaiGai Kohei if (totlen != je32_to_cpu(rx->totlen)) { 335aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 336aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->totlen), totlen); 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 342aa98d7cfSKaiGai Kohei xd = jffs2_setup_xattr_datum(c, je32_to_cpu(rx->xid), je32_to_cpu(rx->version)); 343aa98d7cfSKaiGai Kohei if (IS_ERR(xd)) { 344aa98d7cfSKaiGai Kohei if (PTR_ERR(xd) == -EEXIST) { 34568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rx->totlen))))) 34668270995SDavid Woodhouse return err; 347aa98d7cfSKaiGai Kohei return 0; 348aa98d7cfSKaiGai Kohei } 349aa98d7cfSKaiGai Kohei return PTR_ERR(xd); 350aa98d7cfSKaiGai Kohei } 351aa98d7cfSKaiGai Kohei xd->xprefix = rx->xprefix; 352aa98d7cfSKaiGai Kohei xd->name_len = rx->name_len; 353aa98d7cfSKaiGai Kohei xd->value_len = je16_to_cpu(rx->value_len); 354aa98d7cfSKaiGai Kohei xd->data_crc = je32_to_cpu(rx->data_crc); 355aa98d7cfSKaiGai Kohei 3562f785402SDavid Woodhouse xd->node = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, NULL); 3572f785402SDavid Woodhouse /* FIXME */ xd->node->next_in_ino = (void *)xd; 358f1f9671bSDavid Woodhouse 359aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 360aa98d7cfSKaiGai Kohei jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset); 361aa98d7cfSKaiGai Kohei dbg_xattr("scaning xdatum at %#08x (xid=%u, version=%u)\n", 362aa98d7cfSKaiGai Kohei ofs, xd->xid, xd->version); 363aa98d7cfSKaiGai Kohei return 0; 364aa98d7cfSKaiGai Kohei } 365aa98d7cfSKaiGai Kohei 366aa98d7cfSKaiGai Kohei static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 367aa98d7cfSKaiGai Kohei struct jffs2_raw_xref *rr, uint32_t ofs, 368aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 369aa98d7cfSKaiGai Kohei { 370aa98d7cfSKaiGai Kohei struct jffs2_xattr_ref *ref; 371aa98d7cfSKaiGai Kohei uint32_t crc; 37268270995SDavid Woodhouse int err; 373aa98d7cfSKaiGai Kohei 374aa98d7cfSKaiGai Kohei crc = crc32(0, rr, sizeof(*rr) - 4); 375aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rr->node_crc)) { 376aa98d7cfSKaiGai Kohei if (je32_to_cpu(rr->node_crc) != 0xffffffff) 377aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 378aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->node_crc), crc); 37968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen))))) 38068270995SDavid Woodhouse return err; 381aa98d7cfSKaiGai Kohei return 0; 382aa98d7cfSKaiGai Kohei } 383aa98d7cfSKaiGai Kohei 384aa98d7cfSKaiGai Kohei if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) { 385aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 386aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->totlen), 387aa98d7cfSKaiGai Kohei PAD(sizeof(struct jffs2_raw_xref))); 38868270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen)))) 38968270995SDavid Woodhouse return err; 390aa98d7cfSKaiGai Kohei return 0; 391aa98d7cfSKaiGai Kohei } 392aa98d7cfSKaiGai Kohei 393aa98d7cfSKaiGai Kohei ref = jffs2_alloc_xattr_ref(); 394aa98d7cfSKaiGai Kohei if (!ref) 395aa98d7cfSKaiGai Kohei return -ENOMEM; 396aa98d7cfSKaiGai Kohei 397aa98d7cfSKaiGai Kohei /* BEFORE jffs2_build_xattr_subsystem() called, 398aa98d7cfSKaiGai Kohei * ref->xid is used to store 32bit xid, xd is not used 399aa98d7cfSKaiGai Kohei * ref->ino is used to store 32bit inode-number, ic is not used 400aa98d7cfSKaiGai Kohei * Thoes variables are declared as union, thus using those 4018f2b6f49SKaiGai Kohei * are exclusive. In a similar way, ref->next is temporarily 402aa98d7cfSKaiGai Kohei * used to chain all xattr_ref object. It's re-chained to 403aa98d7cfSKaiGai Kohei * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly. 404aa98d7cfSKaiGai Kohei */ 405aa98d7cfSKaiGai Kohei ref->ino = je32_to_cpu(rr->ino); 406aa98d7cfSKaiGai Kohei ref->xid = je32_to_cpu(rr->xid); 4078f2b6f49SKaiGai Kohei ref->next = c->xref_temp; 4088f2b6f49SKaiGai Kohei c->xref_temp = ref; 409aa98d7cfSKaiGai Kohei 4102f785402SDavid Woodhouse ref->node = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), NULL); 4112f785402SDavid Woodhouse /* FIXME */ ref->node->next_in_ino = (void *)ref; 412f1f9671bSDavid Woodhouse 413aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 414aa98d7cfSKaiGai Kohei jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset); 415aa98d7cfSKaiGai Kohei dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n", 416aa98d7cfSKaiGai Kohei ofs, ref->xid, ref->ino); 417aa98d7cfSKaiGai Kohei return 0; 418aa98d7cfSKaiGai Kohei } 419aa98d7cfSKaiGai Kohei #endif 420aa98d7cfSKaiGai Kohei 4219641b784SDavid Woodhouse /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into 4229641b784SDavid Woodhouse the flash, XIP-style */ 4231da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 424e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) { 4251da177e4SLinus Torvalds struct jffs2_unknown_node *node; 4261da177e4SLinus Torvalds struct jffs2_unknown_node crcnode; 4271da177e4SLinus Torvalds uint32_t ofs, prevofs; 4281da177e4SLinus Torvalds uint32_t hdr_crc, buf_ofs, buf_len; 4291da177e4SLinus Torvalds int err; 4301da177e4SLinus Torvalds int noise = 0; 431e631ddbaSFerenc Havasi 432e631ddbaSFerenc Havasi 4332f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4341da177e4SLinus Torvalds int cleanmarkerfound = 0; 4351da177e4SLinus Torvalds #endif 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds ofs = jeb->offset; 4381da177e4SLinus Torvalds prevofs = jeb->offset - 1; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs)); 4411da177e4SLinus Torvalds 4422f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4431da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 4441da177e4SLinus Torvalds int ret = jffs2_check_nand_cleanmarker(c, jeb); 4451da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret)); 4461da177e4SLinus Torvalds /* Even if it's not found, we still scan to see 4471da177e4SLinus Torvalds if the block is empty. We use this information 4481da177e4SLinus Torvalds to decide whether to erase it or not. */ 4491da177e4SLinus Torvalds switch (ret) { 4501da177e4SLinus Torvalds case 0: cleanmarkerfound = 1; break; 4511da177e4SLinus Torvalds case 1: break; 4521da177e4SLinus Torvalds case 2: return BLK_STATE_BADBLOCK; 4531da177e4SLinus Torvalds case 3: return BLK_STATE_ALLDIRTY; /* Block has failed to erase min. once */ 4541da177e4SLinus Torvalds default: return ret; 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds #endif 458e631ddbaSFerenc Havasi 459e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 4609641b784SDavid Woodhouse struct jffs2_sum_marker *sm; 4619641b784SDavid Woodhouse void *sumptr = NULL; 4629641b784SDavid Woodhouse uint32_t sumlen; 463e631ddbaSFerenc Havasi 4649641b784SDavid Woodhouse if (!buf_size) { 4659641b784SDavid Woodhouse /* XIP case. Just look, point at the summary if it's there */ 4669641b784SDavid Woodhouse sm = (void *)buf + jeb->offset - sizeof(*sm); 467e631ddbaSFerenc Havasi if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 4689641b784SDavid Woodhouse sumptr = buf + je32_to_cpu(sm->offset); 4699641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 4709641b784SDavid Woodhouse } 4719641b784SDavid Woodhouse } else { 4729641b784SDavid Woodhouse /* If NAND flash, read a whole page of it. Else just the end */ 4739641b784SDavid Woodhouse if (c->wbuf_pagesize) 4749641b784SDavid Woodhouse buf_len = c->wbuf_pagesize; 4759641b784SDavid Woodhouse else 4769641b784SDavid Woodhouse buf_len = sizeof(*sm); 4779641b784SDavid Woodhouse 4789641b784SDavid Woodhouse /* Read as much as we want into the _end_ of the preallocated buffer */ 4799641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 4809641b784SDavid Woodhouse jeb->offset + c->sector_size - buf_len, 4819641b784SDavid Woodhouse buf_len); 4829641b784SDavid Woodhouse if (err) 4839641b784SDavid Woodhouse return err; 4849641b784SDavid Woodhouse 4859641b784SDavid Woodhouse sm = (void *)buf + buf_size - sizeof(*sm); 4869641b784SDavid Woodhouse if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 4879641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 4889641b784SDavid Woodhouse sumptr = buf + buf_size - sumlen; 4899641b784SDavid Woodhouse 4909641b784SDavid Woodhouse /* Now, make sure the summary itself is available */ 4919641b784SDavid Woodhouse if (sumlen > buf_size) { 4929641b784SDavid Woodhouse /* Need to kmalloc for this. */ 4939641b784SDavid Woodhouse sumptr = kmalloc(sumlen, GFP_KERNEL); 4949641b784SDavid Woodhouse if (!sumptr) 4959641b784SDavid Woodhouse return -ENOMEM; 4969641b784SDavid Woodhouse memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len); 4979641b784SDavid Woodhouse } 4989641b784SDavid Woodhouse if (buf_len < sumlen) { 4999641b784SDavid Woodhouse /* Need to read more so that the entire summary node is present */ 5009641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, sumptr, 5019641b784SDavid Woodhouse jeb->offset + c->sector_size - sumlen, 5029641b784SDavid Woodhouse sumlen - buf_len); 5039641b784SDavid Woodhouse if (err) 504e631ddbaSFerenc Havasi return err; 505e631ddbaSFerenc Havasi } 506e631ddbaSFerenc Havasi } 507e631ddbaSFerenc Havasi 5089641b784SDavid Woodhouse } 5099641b784SDavid Woodhouse 5109641b784SDavid Woodhouse if (sumptr) { 5119641b784SDavid Woodhouse err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random); 5123560160aSDavid Woodhouse 5139641b784SDavid Woodhouse if (buf_size && sumlen > buf_size) 5149641b784SDavid Woodhouse kfree(sumptr); 5153560160aSDavid Woodhouse /* If it returns with a real error, bail. 5163560160aSDavid Woodhouse If it returns positive, that's a block classification 5173560160aSDavid Woodhouse (i.e. BLK_STATE_xxx) so return that too. 5183560160aSDavid Woodhouse If it returns zero, fall through to full scan. */ 5193560160aSDavid Woodhouse if (err) 5203560160aSDavid Woodhouse return err; 5219641b784SDavid Woodhouse } 522e631ddbaSFerenc Havasi } 523e631ddbaSFerenc Havasi 5241da177e4SLinus Torvalds buf_ofs = jeb->offset; 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds if (!buf_size) { 5279641b784SDavid Woodhouse /* This is the XIP case -- we're reading _directly_ from the flash chip */ 5281da177e4SLinus Torvalds buf_len = c->sector_size; 5291da177e4SLinus Torvalds } else { 5303be36675SAndrew Victor buf_len = EMPTY_SCAN_SIZE(c->sector_size); 5311da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 5321da177e4SLinus Torvalds if (err) 5331da177e4SLinus Torvalds return err; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 5371da177e4SLinus Torvalds ofs = 0; 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds /* Scan only 4KiB of 0xFF before declaring it's empty */ 5403be36675SAndrew Victor while(ofs < EMPTY_SCAN_SIZE(c->sector_size) && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) 5411da177e4SLinus Torvalds ofs += 4; 5421da177e4SLinus Torvalds 5433be36675SAndrew Victor if (ofs == EMPTY_SCAN_SIZE(c->sector_size)) { 5442f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 5451da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 5461da177e4SLinus Torvalds /* scan oob, take care of cleanmarker */ 5471da177e4SLinus Torvalds int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 5481da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret)); 5491da177e4SLinus Torvalds switch (ret) { 5501da177e4SLinus Torvalds case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 5511da177e4SLinus Torvalds case 1: return BLK_STATE_ALLDIRTY; 5521da177e4SLinus Torvalds default: return ret; 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds #endif 5561da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset)); 5578f15fd55SAndrew Victor if (c->cleanmarker_size == 0) 5588f15fd55SAndrew Victor return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */ 5598f15fd55SAndrew Victor else 5601da177e4SLinus Torvalds return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 5611da177e4SLinus Torvalds } 5621da177e4SLinus Torvalds if (ofs) { 5631da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset, 5641da177e4SLinus Torvalds jeb->offset + ofs)); 56568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs))) 56668270995SDavid Woodhouse return err; 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* Now ofs is a complete physical flash offset as it always was... */ 5701da177e4SLinus Torvalds ofs += jeb->offset; 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds noise = 10; 5731da177e4SLinus Torvalds 574733802d9SArtem B. Bityutskiy dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset); 575e631ddbaSFerenc Havasi 5761da177e4SLinus Torvalds scan_more: 5771da177e4SLinus Torvalds while(ofs < jeb->offset + c->sector_size) { 5781da177e4SLinus Torvalds 579e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 5801da177e4SLinus Torvalds 5812f785402SDavid Woodhouse /* Make sure there are node refs available for use */ 5822f785402SDavid Woodhouse err = jffs2_prealloc_raw_node_refs(c, 2); 5832f785402SDavid Woodhouse if (err) 5842f785402SDavid Woodhouse return err; 5852f785402SDavid Woodhouse 5861da177e4SLinus Torvalds cond_resched(); 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds if (ofs & 3) { 5891da177e4SLinus Torvalds printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs); 5901da177e4SLinus Torvalds ofs = PAD(ofs); 5911da177e4SLinus Torvalds continue; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds if (ofs == prevofs) { 5941da177e4SLinus Torvalds printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs); 59568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 59668270995SDavid Woodhouse return err; 5971da177e4SLinus Torvalds ofs += 4; 5981da177e4SLinus Torvalds continue; 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds prevofs = ofs; 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 6031da177e4SLinus 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), 6041da177e4SLinus Torvalds jeb->offset, c->sector_size, ofs, sizeof(*node))); 60568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs))) 60668270995SDavid Woodhouse return err; 6071da177e4SLinus Torvalds break; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(*node)) { 6111da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6121da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 6131da177e4SLinus Torvalds sizeof(struct jffs2_unknown_node), buf_len, ofs)); 6141da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 6151da177e4SLinus Torvalds if (err) 6161da177e4SLinus Torvalds return err; 6171da177e4SLinus Torvalds buf_ofs = ofs; 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs]; 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) { 6231da177e4SLinus Torvalds uint32_t inbuf_ofs; 6241da177e4SLinus Torvalds uint32_t empty_start; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds empty_start = ofs; 6271da177e4SLinus Torvalds ofs += 4; 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs)); 6301da177e4SLinus Torvalds more_empty: 6311da177e4SLinus Torvalds inbuf_ofs = ofs - buf_ofs; 6321da177e4SLinus Torvalds while (inbuf_ofs < buf_len) { 6331da177e4SLinus Torvalds if (*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff) { 6341da177e4SLinus Torvalds printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", 6351da177e4SLinus Torvalds empty_start, ofs); 63668270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start))) 63768270995SDavid Woodhouse return err; 6381da177e4SLinus Torvalds goto scan_more; 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds inbuf_ofs+=4; 6421da177e4SLinus Torvalds ofs += 4; 6431da177e4SLinus Torvalds } 6441da177e4SLinus Torvalds /* Ran off end. */ 6451da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash to end of buffer at 0x%08x\n", ofs)); 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds /* If we're only checking the beginning of a block with a cleanmarker, 6481da177e4SLinus Torvalds bail now */ 6491da177e4SLinus Torvalds if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 65099988f7bSDavid Woodhouse c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) { 6513be36675SAndrew Victor D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c->sector_size))); 6521da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 6531da177e4SLinus Torvalds } 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds /* See how much more there is to read in this eraseblock... */ 6561da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6571da177e4SLinus Torvalds if (!buf_len) { 6581da177e4SLinus Torvalds /* No more to read. Break out of main loop without marking 6591da177e4SLinus Torvalds this range of empty space as dirty (because it's not) */ 6601da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash at %08x runs to end of block. Treating as free_space\n", 6611da177e4SLinus Torvalds empty_start)); 6621da177e4SLinus Torvalds break; 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Reading another 0x%x at 0x%08x\n", buf_len, ofs)); 6651da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 6661da177e4SLinus Torvalds if (err) 6671da177e4SLinus Torvalds return err; 6681da177e4SLinus Torvalds buf_ofs = ofs; 6691da177e4SLinus Torvalds goto more_empty; 6701da177e4SLinus Torvalds } 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 6731da177e4SLinus Torvalds printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs); 67468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 67568270995SDavid Woodhouse return err; 6761da177e4SLinus Torvalds ofs += 4; 6771da177e4SLinus Torvalds continue; 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 6801da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs)); 68168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 68268270995SDavid Woodhouse return err; 6831da177e4SLinus Torvalds ofs += 4; 6841da177e4SLinus Torvalds continue; 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 6871da177e4SLinus Torvalds printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs); 6881da177e4SLinus Torvalds printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n"); 68968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 69068270995SDavid Woodhouse return err; 6911da177e4SLinus Torvalds ofs += 4; 6921da177e4SLinus Torvalds continue; 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 6951da177e4SLinus Torvalds /* OK. We're out of possibilities. Whinge and move on */ 6961da177e4SLinus Torvalds noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 6971da177e4SLinus Torvalds JFFS2_MAGIC_BITMASK, ofs, 6981da177e4SLinus Torvalds je16_to_cpu(node->magic)); 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 /* We seem to have a node of sorts. Check the CRC */ 7051da177e4SLinus Torvalds crcnode.magic = node->magic; 7061da177e4SLinus Torvalds crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE); 7071da177e4SLinus Torvalds crcnode.totlen = node->totlen; 7081da177e4SLinus Torvalds hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 7111da177e4SLinus 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", 7121da177e4SLinus Torvalds ofs, je16_to_cpu(node->magic), 7131da177e4SLinus Torvalds je16_to_cpu(node->nodetype), 7141da177e4SLinus Torvalds je32_to_cpu(node->totlen), 7151da177e4SLinus Torvalds je32_to_cpu(node->hdr_crc), 7161da177e4SLinus Torvalds hdr_crc); 71768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 71868270995SDavid Woodhouse return err; 7191da177e4SLinus Torvalds ofs += 4; 7201da177e4SLinus Torvalds continue; 7211da177e4SLinus Torvalds } 7221da177e4SLinus Torvalds 7231da177e4SLinus Torvalds if (ofs + je32_to_cpu(node->totlen) > 7241da177e4SLinus Torvalds jeb->offset + c->sector_size) { 7251da177e4SLinus Torvalds /* Eep. Node goes over the end of the erase block. */ 7261da177e4SLinus Torvalds printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 7271da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen)); 7281da177e4SLinus Torvalds printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n"); 72968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 73068270995SDavid Woodhouse return err; 7311da177e4SLinus Torvalds ofs += 4; 7321da177e4SLinus Torvalds continue; 7331da177e4SLinus Torvalds } 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 7361da177e4SLinus Torvalds /* Wheee. This is an obsoleted node */ 7371da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs)); 73868270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 73968270995SDavid Woodhouse return err; 7401da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7411da177e4SLinus Torvalds continue; 7421da177e4SLinus Torvalds } 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds switch(je16_to_cpu(node->nodetype)) { 7451da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 7461da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 7471da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7481da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 7491da177e4SLinus Torvalds sizeof(struct jffs2_raw_inode), buf_len, ofs)); 7501da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7511da177e4SLinus Torvalds if (err) 7521da177e4SLinus Torvalds return err; 7531da177e4SLinus Torvalds buf_ofs = ofs; 7541da177e4SLinus Torvalds node = (void *)buf; 7551da177e4SLinus Torvalds } 756e631ddbaSFerenc Havasi err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s); 7571da177e4SLinus Torvalds if (err) return err; 7581da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7591da177e4SLinus Torvalds break; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 7621da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 7631da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7641da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 7651da177e4SLinus Torvalds je32_to_cpu(node->totlen), buf_len, ofs)); 7661da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7671da177e4SLinus Torvalds if (err) 7681da177e4SLinus Torvalds return err; 7691da177e4SLinus Torvalds buf_ofs = ofs; 7701da177e4SLinus Torvalds node = (void *)buf; 7711da177e4SLinus Torvalds } 772e631ddbaSFerenc Havasi err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s); 7731da177e4SLinus Torvalds if (err) return err; 7741da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7751da177e4SLinus Torvalds break; 7761da177e4SLinus Torvalds 777aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 778aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XATTR: 779aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 780aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 781aa98d7cfSKaiGai Kohei D1(printk(KERN_DEBUG "Fewer than %d bytes (xattr node)" 782aa98d7cfSKaiGai Kohei " left to end of buf. Reading 0x%x at 0x%08x\n", 783aa98d7cfSKaiGai Kohei je32_to_cpu(node->totlen), buf_len, ofs)); 784aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 785aa98d7cfSKaiGai Kohei if (err) 786aa98d7cfSKaiGai Kohei return err; 787aa98d7cfSKaiGai Kohei buf_ofs = ofs; 788aa98d7cfSKaiGai Kohei node = (void *)buf; 789aa98d7cfSKaiGai Kohei } 790aa98d7cfSKaiGai Kohei err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s); 791aa98d7cfSKaiGai Kohei if (err) 792aa98d7cfSKaiGai Kohei return err; 793aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 794aa98d7cfSKaiGai Kohei break; 795aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XREF: 796aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 797aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 798aa98d7cfSKaiGai Kohei D1(printk(KERN_DEBUG "Fewer than %d bytes (xref node)" 799aa98d7cfSKaiGai Kohei " left to end of buf. Reading 0x%x at 0x%08x\n", 800aa98d7cfSKaiGai Kohei je32_to_cpu(node->totlen), buf_len, ofs)); 801aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 802aa98d7cfSKaiGai Kohei if (err) 803aa98d7cfSKaiGai Kohei return err; 804aa98d7cfSKaiGai Kohei buf_ofs = ofs; 805aa98d7cfSKaiGai Kohei node = (void *)buf; 806aa98d7cfSKaiGai Kohei } 807aa98d7cfSKaiGai Kohei err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s); 808aa98d7cfSKaiGai Kohei if (err) 809aa98d7cfSKaiGai Kohei return err; 810aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 811aa98d7cfSKaiGai Kohei break; 812aa98d7cfSKaiGai Kohei #endif /* CONFIG_JFFS2_FS_XATTR */ 813aa98d7cfSKaiGai Kohei 8141da177e4SLinus Torvalds case JFFS2_NODETYPE_CLEANMARKER: 8151da177e4SLinus Torvalds D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs)); 8161da177e4SLinus Torvalds if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 8171da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 8181da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen), c->cleanmarker_size); 81968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 82068270995SDavid Woodhouse return err; 8211da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8221da177e4SLinus Torvalds } else if (jeb->first_node) { 8231da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset); 82468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 82568270995SDavid Woodhouse return err; 8261da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8271da177e4SLinus Torvalds } else { 8282f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL); 829f1f9671bSDavid Woodhouse 8301da177e4SLinus Torvalds ofs += PAD(c->cleanmarker_size); 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds break; 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds case JFFS2_NODETYPE_PADDING: 835e631ddbaSFerenc Havasi if (jffs2_sum_active()) 836e631ddbaSFerenc Havasi jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen)); 83768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 83868270995SDavid Woodhouse return err; 8391da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8401da177e4SLinus Torvalds break; 8411da177e4SLinus Torvalds 8421da177e4SLinus Torvalds default: 8431da177e4SLinus Torvalds switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 8441da177e4SLinus Torvalds case JFFS2_FEATURE_ROCOMPAT: 8451da177e4SLinus Torvalds printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8461da177e4SLinus Torvalds c->flags |= JFFS2_SB_FLAG_RO; 8471da177e4SLinus Torvalds if (!(jffs2_is_readonly(c))) 8481da177e4SLinus Torvalds return -EROFS; 84968270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 85068270995SDavid Woodhouse return err; 8511da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8521da177e4SLinus Torvalds break; 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds case JFFS2_FEATURE_INCOMPAT: 8551da177e4SLinus Torvalds printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8561da177e4SLinus Torvalds return -EINVAL; 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_DELETE: 8591da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 86068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 86168270995SDavid Woodhouse return err; 8621da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8631da177e4SLinus Torvalds break; 8641da177e4SLinus Torvalds 8656171586aSDavid Woodhouse case JFFS2_FEATURE_RWCOMPAT_COPY: { 8661da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 8676171586aSDavid Woodhouse 8682f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL); 8696171586aSDavid Woodhouse 8706171586aSDavid Woodhouse /* We can't summarise nodes we don't grok */ 8716171586aSDavid Woodhouse jffs2_sum_disable_collecting(s); 8721da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8731da177e4SLinus Torvalds break; 8741da177e4SLinus Torvalds } 8751da177e4SLinus Torvalds } 8761da177e4SLinus Torvalds } 8776171586aSDavid Woodhouse } 8781da177e4SLinus Torvalds 879e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 880e631ddbaSFerenc Havasi if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) { 881733802d9SArtem B. Bityutskiy dbg_summary("There is not enough space for " 882e631ddbaSFerenc Havasi "summary information, disabling for this jeb!\n"); 883e631ddbaSFerenc Havasi jffs2_sum_disable_collecting(s); 884e631ddbaSFerenc Havasi } 885e631ddbaSFerenc Havasi } 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb->offset, 8881da177e4SLinus Torvalds jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size)); 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds /* mark_node_obsolete can add to wasted !! */ 8911da177e4SLinus Torvalds if (jeb->wasted_size) { 8921da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 8931da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 8941da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 8951da177e4SLinus Torvalds jeb->wasted_size = 0; 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 898e631ddbaSFerenc Havasi return jffs2_scan_classify_jeb(c, jeb); 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds 901e631ddbaSFerenc Havasi struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino) 9021da177e4SLinus Torvalds { 9031da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9061da177e4SLinus Torvalds if (ic) 9071da177e4SLinus Torvalds return ic; 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds if (ino > c->highest_ino) 9101da177e4SLinus Torvalds c->highest_ino = ino; 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 9131da177e4SLinus Torvalds if (!ic) { 9141da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n"); 9151da177e4SLinus Torvalds return NULL; 9161da177e4SLinus Torvalds } 9171da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds ic->ino = ino; 9201da177e4SLinus Torvalds ic->nodes = (void *)ic; 9211da177e4SLinus Torvalds jffs2_add_ino_cache(c, ic); 9221da177e4SLinus Torvalds if (ino == 1) 9231da177e4SLinus Torvalds ic->nlink = 1; 9241da177e4SLinus Torvalds return ic; 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 928e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s) 9291da177e4SLinus Torvalds { 9301da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9311da177e4SLinus Torvalds uint32_t ino = je32_to_cpu(ri->ino); 93268270995SDavid Woodhouse int err; 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs)); 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds /* We do very little here now. Just check the ino# to which we should attribute 9371da177e4SLinus Torvalds this node; we can do all the CRC checking etc. later. There's a tradeoff here -- 9381da177e4SLinus Torvalds we used to scan the flash once only, reading everything we want from it into 9391da177e4SLinus Torvalds memory, then building all our in-core data structures and freeing the extra 9401da177e4SLinus Torvalds information. Now we allow the first part of the mount to complete a lot quicker, 9411da177e4SLinus Torvalds but we have to go _back_ to the flash in order to finish the CRC checking, etc. 9421da177e4SLinus Torvalds Which means that the _full_ amount of time to get to proper write mode with GC 9431da177e4SLinus Torvalds operational may actually be _longer_ than before. Sucks to be me. */ 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9461da177e4SLinus Torvalds if (!ic) { 9471da177e4SLinus Torvalds /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the 9481da177e4SLinus Torvalds first node we found for this inode. Do a CRC check to protect against the former 9491da177e4SLinus Torvalds case */ 9501da177e4SLinus Torvalds uint32_t crc = crc32(0, ri, sizeof(*ri)-8); 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds if (crc != je32_to_cpu(ri->node_crc)) { 9531da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 9541da177e4SLinus Torvalds ofs, je32_to_cpu(ri->node_crc), crc); 9551da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 95668270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(ri->totlen))))) 95768270995SDavid Woodhouse return err; 9581da177e4SLinus Torvalds return 0; 9591da177e4SLinus Torvalds } 9601da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, ino); 9612f785402SDavid Woodhouse if (!ic) 9621da177e4SLinus Torvalds return -ENOMEM; 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds /* Wheee. It worked */ 9662f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic); 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 9691da177e4SLinus Torvalds je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 9701da177e4SLinus Torvalds je32_to_cpu(ri->offset), 9711da177e4SLinus Torvalds je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize))); 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds pseudo_random += je32_to_cpu(ri->version); 9741da177e4SLinus Torvalds 975e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 976e631ddbaSFerenc Havasi jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset); 977e631ddbaSFerenc Havasi } 978e631ddbaSFerenc Havasi 9791da177e4SLinus Torvalds return 0; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 983e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s) 9841da177e4SLinus Torvalds { 9851da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 9861da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9871da177e4SLinus Torvalds uint32_t crc; 98868270995SDavid Woodhouse int err; 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs)); 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds /* We don't get here unless the node is still valid, so we don't have to 9931da177e4SLinus Torvalds mask in the ACCURATE bit any more. */ 9941da177e4SLinus Torvalds crc = crc32(0, rd, sizeof(*rd)-8); 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->node_crc)) { 9971da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 9981da177e4SLinus Torvalds ofs, je32_to_cpu(rd->node_crc), crc); 9991da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 100068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 100168270995SDavid Woodhouse return err; 10021da177e4SLinus Torvalds return 0; 10031da177e4SLinus Torvalds } 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds pseudo_random += je32_to_cpu(rd->version); 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(rd->nsize+1); 10081da177e4SLinus Torvalds if (!fd) { 10091da177e4SLinus Torvalds return -ENOMEM; 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds memcpy(&fd->name, rd->name, rd->nsize); 10121da177e4SLinus Torvalds fd->name[rd->nsize] = 0; 10131da177e4SLinus Torvalds 10141da177e4SLinus Torvalds crc = crc32(0, fd->name, rd->nsize); 10151da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->name_crc)) { 10161da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 10171da177e4SLinus Torvalds ofs, je32_to_cpu(rd->name_crc), crc); 10181da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino))); 10191da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10201da177e4SLinus Torvalds /* FIXME: Why do we believe totlen? */ 10211da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */ 102268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 102368270995SDavid Woodhouse return err; 10241da177e4SLinus Torvalds return 0; 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino)); 10271da177e4SLinus Torvalds if (!ic) { 10281da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10291da177e4SLinus Torvalds return -ENOMEM; 10301da177e4SLinus Torvalds } 10311da177e4SLinus Torvalds 10322f785402SDavid Woodhouse fd->raw = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rd->totlen)), ic); 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds fd->next = NULL; 10351da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 10361da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 10371da177e4SLinus Torvalds fd->nhash = full_name_hash(fd->name, rd->nsize); 10381da177e4SLinus Torvalds fd->type = rd->type; 10391da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &ic->scan_dents); 10401da177e4SLinus Torvalds 1041e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1042e631ddbaSFerenc Havasi jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset); 1043e631ddbaSFerenc Havasi } 1044e631ddbaSFerenc Havasi 10451da177e4SLinus Torvalds return 0; 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds static int count_list(struct list_head *l) 10491da177e4SLinus Torvalds { 10501da177e4SLinus Torvalds uint32_t count = 0; 10511da177e4SLinus Torvalds struct list_head *tmp; 10521da177e4SLinus Torvalds 10531da177e4SLinus Torvalds list_for_each(tmp, l) { 10541da177e4SLinus Torvalds count++; 10551da177e4SLinus Torvalds } 10561da177e4SLinus Torvalds return count; 10571da177e4SLinus Torvalds } 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds /* Note: This breaks if list_empty(head). I don't care. You 10601da177e4SLinus Torvalds might, if you copy this code and use it elsewhere :) */ 10611da177e4SLinus Torvalds static void rotate_list(struct list_head *head, uint32_t count) 10621da177e4SLinus Torvalds { 10631da177e4SLinus Torvalds struct list_head *n = head->next; 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds list_del(head); 10661da177e4SLinus Torvalds while(count--) { 10671da177e4SLinus Torvalds n = n->next; 10681da177e4SLinus Torvalds } 10691da177e4SLinus Torvalds list_add(head, n); 10701da177e4SLinus Torvalds } 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds uint32_t x; 10751da177e4SLinus Torvalds uint32_t rotateby; 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds x = count_list(&c->clean_list); 10781da177e4SLinus Torvalds if (x) { 10791da177e4SLinus Torvalds rotateby = pseudo_random % x; 10801da177e4SLinus Torvalds rotate_list((&c->clean_list), rotateby); 10811da177e4SLinus Torvalds } 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds x = count_list(&c->very_dirty_list); 10841da177e4SLinus Torvalds if (x) { 10851da177e4SLinus Torvalds rotateby = pseudo_random % x; 10861da177e4SLinus Torvalds rotate_list((&c->very_dirty_list), rotateby); 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds x = count_list(&c->dirty_list); 10901da177e4SLinus Torvalds if (x) { 10911da177e4SLinus Torvalds rotateby = pseudo_random % x; 10921da177e4SLinus Torvalds rotate_list((&c->dirty_list), rotateby); 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds x = count_list(&c->erasable_list); 10961da177e4SLinus Torvalds if (x) { 10971da177e4SLinus Torvalds rotateby = pseudo_random % x; 10981da177e4SLinus Torvalds rotate_list((&c->erasable_list), rotateby); 10991da177e4SLinus Torvalds } 11001da177e4SLinus Torvalds 11011da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 11021da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_erasing_blocks; 11031da177e4SLinus Torvalds rotate_list((&c->erase_pending_list), rotateby); 11041da177e4SLinus Torvalds } 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds if (c->nr_free_blocks) { 11071da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_free_blocks; 11081da177e4SLinus Torvalds rotate_list((&c->free_list), rotateby); 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds } 1111