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 681da177e4SLinus Torvalds int jffs2_scan_medium(struct jffs2_sb_info *c) 691da177e4SLinus Torvalds { 701da177e4SLinus Torvalds int i, ret; 711da177e4SLinus Torvalds uint32_t empty_blocks = 0, bad_blocks = 0; 721da177e4SLinus Torvalds unsigned char *flashbuf = NULL; 731da177e4SLinus Torvalds uint32_t buf_size = 0; 74e631ddbaSFerenc Havasi struct jffs2_summary *s = NULL; /* summary info collected by the scan process */ 751da177e4SLinus Torvalds #ifndef __ECOS 761da177e4SLinus Torvalds size_t pointlen; 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds if (c->mtd->point) { 791da177e4SLinus Torvalds ret = c->mtd->point (c->mtd, 0, c->mtd->size, &pointlen, &flashbuf); 801da177e4SLinus Torvalds if (!ret && pointlen < c->mtd->size) { 811da177e4SLinus Torvalds /* Don't muck about if it won't let us point to the whole flash */ 821da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen)); 831da177e4SLinus Torvalds c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size); 841da177e4SLinus Torvalds flashbuf = NULL; 851da177e4SLinus Torvalds } 861da177e4SLinus Torvalds if (ret) 871da177e4SLinus Torvalds D1(printk(KERN_DEBUG "MTD point failed %d\n", ret)); 881da177e4SLinus Torvalds } 891da177e4SLinus Torvalds #endif 901da177e4SLinus Torvalds if (!flashbuf) { 911da177e4SLinus Torvalds /* For NAND it's quicker to read a whole eraseblock at a time, 921da177e4SLinus Torvalds apparently */ 931da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) 941da177e4SLinus Torvalds buf_size = c->sector_size; 951da177e4SLinus Torvalds else 961da177e4SLinus Torvalds buf_size = PAGE_SIZE; 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds /* Respect kmalloc limitations */ 991da177e4SLinus Torvalds if (buf_size > 128*1024) 1001da177e4SLinus Torvalds buf_size = 128*1024; 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocating readbuf of %d bytes\n", buf_size)); 1031da177e4SLinus Torvalds flashbuf = kmalloc(buf_size, GFP_KERNEL); 1041da177e4SLinus Torvalds if (!flashbuf) 1051da177e4SLinus Torvalds return -ENOMEM; 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 108e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 109e631ddbaSFerenc Havasi s = kmalloc(sizeof(struct jffs2_summary), GFP_KERNEL); 110e631ddbaSFerenc Havasi if (!s) { 111e631ddbaSFerenc Havasi JFFS2_WARNING("Can't allocate memory for summary\n"); 112e631ddbaSFerenc Havasi return -ENOMEM; 113e631ddbaSFerenc Havasi } 114e631ddbaSFerenc Havasi memset(s, 0, sizeof(struct jffs2_summary)); 115e631ddbaSFerenc Havasi } 116e631ddbaSFerenc Havasi 1171da177e4SLinus Torvalds for (i=0; i<c->nr_blocks; i++) { 1181da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[i]; 1191da177e4SLinus Torvalds 120e631ddbaSFerenc Havasi /* reset summary info for next eraseblock scan */ 121e631ddbaSFerenc Havasi jffs2_sum_reset_collected(s); 122e631ddbaSFerenc Havasi 123e631ddbaSFerenc Havasi ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), 124e631ddbaSFerenc Havasi buf_size, s); 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds if (ret < 0) 1271da177e4SLinus Torvalds goto out; 1281da177e4SLinus Torvalds 129e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* Now decide which list to put it on */ 1321da177e4SLinus Torvalds switch(ret) { 1331da177e4SLinus Torvalds case BLK_STATE_ALLFF: 1341da177e4SLinus Torvalds /* 1351da177e4SLinus Torvalds * Empty block. Since we can't be sure it 1361da177e4SLinus Torvalds * was entirely erased, we just queue it for erase 1371da177e4SLinus Torvalds * again. It will be marked as such when the erase 1381da177e4SLinus Torvalds * is complete. Meanwhile we still count it as empty 1391da177e4SLinus Torvalds * for later checks. 1401da177e4SLinus Torvalds */ 1411da177e4SLinus Torvalds empty_blocks++; 1421da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1431da177e4SLinus Torvalds c->nr_erasing_blocks++; 1441da177e4SLinus Torvalds break; 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds case BLK_STATE_CLEANMARKER: 1471da177e4SLinus Torvalds /* Only a CLEANMARKER node is valid */ 1481da177e4SLinus Torvalds if (!jeb->dirty_size) { 1491da177e4SLinus Torvalds /* It's actually free */ 1501da177e4SLinus Torvalds list_add(&jeb->list, &c->free_list); 1511da177e4SLinus Torvalds c->nr_free_blocks++; 1521da177e4SLinus Torvalds } else { 1531da177e4SLinus Torvalds /* Dirt */ 1541da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset)); 1551da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1561da177e4SLinus Torvalds c->nr_erasing_blocks++; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds break; 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds case BLK_STATE_CLEAN: 1611da177e4SLinus Torvalds /* Full (or almost full) of clean data. Clean list */ 1621da177e4SLinus Torvalds list_add(&jeb->list, &c->clean_list); 1631da177e4SLinus Torvalds break; 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds case BLK_STATE_PARTDIRTY: 1661da177e4SLinus Torvalds /* Some data, but not full. Dirty list. */ 1671da177e4SLinus Torvalds /* We want to remember the block with most free space 1681da177e4SLinus Torvalds and stick it in the 'nextblock' position to start writing to it. */ 1691da177e4SLinus Torvalds if (jeb->free_size > min_free(c) && 1701da177e4SLinus Torvalds (!c->nextblock || c->nextblock->free_size < jeb->free_size)) { 1711da177e4SLinus Torvalds /* Better candidate for the next writes to go to */ 1721da177e4SLinus Torvalds if (c->nextblock) { 1731da177e4SLinus Torvalds c->nextblock->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size; 1741da177e4SLinus Torvalds c->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size; 1751da177e4SLinus Torvalds c->free_size -= c->nextblock->free_size; 1761da177e4SLinus Torvalds c->wasted_size -= c->nextblock->wasted_size; 1771da177e4SLinus Torvalds c->nextblock->free_size = c->nextblock->wasted_size = 0; 1781da177e4SLinus Torvalds if (VERYDIRTY(c, c->nextblock->dirty_size)) { 1791da177e4SLinus Torvalds list_add(&c->nextblock->list, &c->very_dirty_list); 1801da177e4SLinus Torvalds } else { 1811da177e4SLinus Torvalds list_add(&c->nextblock->list, &c->dirty_list); 1821da177e4SLinus Torvalds } 183e631ddbaSFerenc Havasi /* deleting summary information of the old nextblock */ 184e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); 1851da177e4SLinus Torvalds } 186e631ddbaSFerenc Havasi /* update collected summary infromation for the current nextblock */ 187e631ddbaSFerenc Havasi jffs2_sum_move_collected(c, s); 188e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_scan_medium(): new nextblock = 0x%08x\n", jeb->offset)); 1891da177e4SLinus Torvalds c->nextblock = jeb; 1901da177e4SLinus Torvalds } else { 1911da177e4SLinus Torvalds jeb->dirty_size += jeb->free_size + jeb->wasted_size; 1921da177e4SLinus Torvalds c->dirty_size += jeb->free_size + jeb->wasted_size; 1931da177e4SLinus Torvalds c->free_size -= jeb->free_size; 1941da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 1951da177e4SLinus Torvalds jeb->free_size = jeb->wasted_size = 0; 1961da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 1971da177e4SLinus Torvalds list_add(&jeb->list, &c->very_dirty_list); 1981da177e4SLinus Torvalds } else { 1991da177e4SLinus Torvalds list_add(&jeb->list, &c->dirty_list); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds break; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds case BLK_STATE_ALLDIRTY: 2051da177e4SLinus Torvalds /* Nothing valid - not even a clean marker. Needs erasing. */ 2061da177e4SLinus Torvalds /* For now we just put it on the erasing list. We'll start the erases later */ 2071da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset)); 2081da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 2091da177e4SLinus Torvalds c->nr_erasing_blocks++; 2101da177e4SLinus Torvalds break; 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds case BLK_STATE_BADBLOCK: 2131da177e4SLinus Torvalds D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset)); 2141da177e4SLinus Torvalds list_add(&jeb->list, &c->bad_list); 2151da177e4SLinus Torvalds c->bad_size += c->sector_size; 2161da177e4SLinus Torvalds c->free_size -= c->sector_size; 2171da177e4SLinus Torvalds bad_blocks++; 2181da177e4SLinus Torvalds break; 2191da177e4SLinus Torvalds default: 2201da177e4SLinus Torvalds printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n"); 2211da177e4SLinus Torvalds BUG(); 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds 225e631ddbaSFerenc Havasi if (jffs2_sum_active() && s) 226e631ddbaSFerenc Havasi kfree(s); 227e631ddbaSFerenc Havasi 2281da177e4SLinus Torvalds /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */ 2291da177e4SLinus Torvalds if (c->nextblock && (c->nextblock->dirty_size)) { 2301da177e4SLinus Torvalds c->nextblock->wasted_size += c->nextblock->dirty_size; 2311da177e4SLinus Torvalds c->wasted_size += c->nextblock->dirty_size; 2321da177e4SLinus Torvalds c->dirty_size -= c->nextblock->dirty_size; 2331da177e4SLinus Torvalds c->nextblock->dirty_size = 0; 2341da177e4SLinus Torvalds } 2352f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 236e96fb230SDavid Woodhouse if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) { 2371da177e4SLinus Torvalds /* If we're going to start writing into a block which already 2381da177e4SLinus Torvalds contains data, and the end of the data isn't page-aligned, 2391da177e4SLinus Torvalds skip a little and align it. */ 2401da177e4SLinus Torvalds 241daba5cc4SArtem B. Bityutskiy uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize; 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n", 2441da177e4SLinus Torvalds skip)); 2451da177e4SLinus Torvalds c->nextblock->wasted_size += skip; 2461da177e4SLinus Torvalds c->wasted_size += skip; 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds c->nextblock->free_size -= skip; 2491da177e4SLinus Torvalds c->free_size -= skip; 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds #endif 2521da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 2531da177e4SLinus Torvalds if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) { 2541da177e4SLinus Torvalds printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 2551da177e4SLinus Torvalds printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks); 2561da177e4SLinus Torvalds ret = -EIO; 2571da177e4SLinus Torvalds goto out; 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds ret = 0; 2621da177e4SLinus Torvalds out: 2631da177e4SLinus Torvalds if (buf_size) 2641da177e4SLinus Torvalds kfree(flashbuf); 2651da177e4SLinus Torvalds #ifndef __ECOS 2661da177e4SLinus Torvalds else 2671da177e4SLinus Torvalds c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size); 2681da177e4SLinus Torvalds #endif 2691da177e4SLinus Torvalds return ret; 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 272e631ddbaSFerenc Havasi int jffs2_fill_scan_buf (struct jffs2_sb_info *c, void *buf, 2731da177e4SLinus Torvalds uint32_t ofs, uint32_t len) 2741da177e4SLinus Torvalds { 2751da177e4SLinus Torvalds int ret; 2761da177e4SLinus Torvalds size_t retlen; 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 2791da177e4SLinus Torvalds if (ret) { 2801da177e4SLinus Torvalds D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret)); 2811da177e4SLinus Torvalds return ret; 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds if (retlen < len) { 2841da177e4SLinus Torvalds D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen)); 2851da177e4SLinus Torvalds return -EIO; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds return 0; 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 290e631ddbaSFerenc Havasi int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 291e631ddbaSFerenc Havasi { 292e631ddbaSFerenc Havasi if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size 293e631ddbaSFerenc Havasi && (!jeb->first_node || !jeb->first_node->next_phys) ) 294e631ddbaSFerenc Havasi return BLK_STATE_CLEANMARKER; 295e631ddbaSFerenc Havasi 296e631ddbaSFerenc Havasi /* move blocks with max 4 byte dirty space to cleanlist */ 297e631ddbaSFerenc Havasi else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) { 298e631ddbaSFerenc Havasi c->dirty_size -= jeb->dirty_size; 299e631ddbaSFerenc Havasi c->wasted_size += jeb->dirty_size; 300e631ddbaSFerenc Havasi jeb->wasted_size += jeb->dirty_size; 301e631ddbaSFerenc Havasi jeb->dirty_size = 0; 302e631ddbaSFerenc Havasi return BLK_STATE_CLEAN; 303e631ddbaSFerenc Havasi } else if (jeb->used_size || jeb->unchecked_size) 304e631ddbaSFerenc Havasi return BLK_STATE_PARTDIRTY; 305e631ddbaSFerenc Havasi else 306e631ddbaSFerenc Havasi return BLK_STATE_ALLDIRTY; 307e631ddbaSFerenc Havasi } 308e631ddbaSFerenc Havasi 309aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 310aa98d7cfSKaiGai Kohei static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 311aa98d7cfSKaiGai Kohei struct jffs2_raw_xattr *rx, uint32_t ofs, 312aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 313aa98d7cfSKaiGai Kohei { 314aa98d7cfSKaiGai Kohei struct jffs2_xattr_datum *xd; 315aa98d7cfSKaiGai Kohei struct jffs2_raw_node_ref *raw; 316aa98d7cfSKaiGai Kohei uint32_t totlen, crc; 317aa98d7cfSKaiGai Kohei 318aa98d7cfSKaiGai Kohei crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4); 319aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rx->node_crc)) { 320aa98d7cfSKaiGai Kohei if (je32_to_cpu(rx->node_crc) != 0xffffffff) 321aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 322aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->node_crc), crc); 323aa98d7cfSKaiGai Kohei DIRTY_SPACE(je32_to_cpu(rx->totlen)); 324aa98d7cfSKaiGai Kohei return 0; 325aa98d7cfSKaiGai Kohei } 326aa98d7cfSKaiGai Kohei 327aa98d7cfSKaiGai Kohei totlen = PAD(sizeof(*rx) + rx->name_len + 1 + je16_to_cpu(rx->value_len)); 328aa98d7cfSKaiGai Kohei if (totlen != je32_to_cpu(rx->totlen)) { 329aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 330aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->totlen), totlen); 331aa98d7cfSKaiGai Kohei DIRTY_SPACE(je32_to_cpu(rx->totlen)); 332aa98d7cfSKaiGai Kohei return 0; 333aa98d7cfSKaiGai Kohei } 334aa98d7cfSKaiGai Kohei 335aa98d7cfSKaiGai Kohei raw = jffs2_alloc_raw_node_ref(); 336aa98d7cfSKaiGai Kohei if (!raw) 337aa98d7cfSKaiGai Kohei return -ENOMEM; 338aa98d7cfSKaiGai Kohei 339aa98d7cfSKaiGai Kohei xd = jffs2_setup_xattr_datum(c, je32_to_cpu(rx->xid), je32_to_cpu(rx->version)); 340aa98d7cfSKaiGai Kohei if (IS_ERR(xd)) { 341aa98d7cfSKaiGai Kohei jffs2_free_raw_node_ref(raw); 342aa98d7cfSKaiGai Kohei if (PTR_ERR(xd) == -EEXIST) { 343aa98d7cfSKaiGai Kohei DIRTY_SPACE(PAD(je32_to_cpu(rx->totlen))); 344aa98d7cfSKaiGai Kohei return 0; 345aa98d7cfSKaiGai Kohei } 346aa98d7cfSKaiGai Kohei return PTR_ERR(xd); 347aa98d7cfSKaiGai Kohei } 348aa98d7cfSKaiGai Kohei xd->xprefix = rx->xprefix; 349aa98d7cfSKaiGai Kohei xd->name_len = rx->name_len; 350aa98d7cfSKaiGai Kohei xd->value_len = je16_to_cpu(rx->value_len); 351aa98d7cfSKaiGai Kohei xd->data_crc = je32_to_cpu(rx->data_crc); 352aa98d7cfSKaiGai Kohei xd->node = raw; 353aa98d7cfSKaiGai Kohei 354aa98d7cfSKaiGai Kohei raw->__totlen = totlen; 355aa98d7cfSKaiGai Kohei raw->flash_offset = ofs | REF_PRISTINE; 356aa98d7cfSKaiGai Kohei raw->next_phys = NULL; 357aa98d7cfSKaiGai Kohei raw->next_in_ino = (void *)xd; 358aa98d7cfSKaiGai Kohei if (!jeb->first_node) 359aa98d7cfSKaiGai Kohei jeb->first_node = raw; 360aa98d7cfSKaiGai Kohei if (jeb->last_node) 361aa98d7cfSKaiGai Kohei jeb->last_node->next_phys = raw; 362aa98d7cfSKaiGai Kohei jeb->last_node = raw; 363aa98d7cfSKaiGai Kohei 364aa98d7cfSKaiGai Kohei USED_SPACE(PAD(je32_to_cpu(rx->totlen))); 365aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 366aa98d7cfSKaiGai Kohei jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset); 367aa98d7cfSKaiGai Kohei dbg_xattr("scaning xdatum at %#08x (xid=%u, version=%u)\n", 368aa98d7cfSKaiGai Kohei ofs, xd->xid, xd->version); 369aa98d7cfSKaiGai Kohei return 0; 370aa98d7cfSKaiGai Kohei } 371aa98d7cfSKaiGai Kohei 372aa98d7cfSKaiGai Kohei static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 373aa98d7cfSKaiGai Kohei struct jffs2_raw_xref *rr, uint32_t ofs, 374aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 375aa98d7cfSKaiGai Kohei { 376aa98d7cfSKaiGai Kohei struct jffs2_xattr_ref *ref; 377aa98d7cfSKaiGai Kohei struct jffs2_raw_node_ref *raw; 378aa98d7cfSKaiGai Kohei uint32_t crc; 379aa98d7cfSKaiGai Kohei 380aa98d7cfSKaiGai Kohei crc = crc32(0, rr, sizeof(*rr) - 4); 381aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rr->node_crc)) { 382aa98d7cfSKaiGai Kohei if (je32_to_cpu(rr->node_crc) != 0xffffffff) 383aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 384aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->node_crc), crc); 385aa98d7cfSKaiGai Kohei DIRTY_SPACE(PAD(je32_to_cpu(rr->totlen))); 386aa98d7cfSKaiGai Kohei return 0; 387aa98d7cfSKaiGai Kohei } 388aa98d7cfSKaiGai Kohei 389aa98d7cfSKaiGai Kohei if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) { 390aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 391aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->totlen), 392aa98d7cfSKaiGai Kohei PAD(sizeof(struct jffs2_raw_xref))); 393aa98d7cfSKaiGai Kohei DIRTY_SPACE(je32_to_cpu(rr->totlen)); 394aa98d7cfSKaiGai Kohei return 0; 395aa98d7cfSKaiGai Kohei } 396aa98d7cfSKaiGai Kohei 397aa98d7cfSKaiGai Kohei ref = jffs2_alloc_xattr_ref(); 398aa98d7cfSKaiGai Kohei if (!ref) 399aa98d7cfSKaiGai Kohei return -ENOMEM; 400aa98d7cfSKaiGai Kohei 401aa98d7cfSKaiGai Kohei raw = jffs2_alloc_raw_node_ref(); 402aa98d7cfSKaiGai Kohei if (!raw) { 403aa98d7cfSKaiGai Kohei jffs2_free_xattr_ref(ref); 404aa98d7cfSKaiGai Kohei return -ENOMEM; 405aa98d7cfSKaiGai Kohei } 406aa98d7cfSKaiGai Kohei 407aa98d7cfSKaiGai Kohei /* BEFORE jffs2_build_xattr_subsystem() called, 408aa98d7cfSKaiGai Kohei * ref->xid is used to store 32bit xid, xd is not used 409aa98d7cfSKaiGai Kohei * ref->ino is used to store 32bit inode-number, ic is not used 410aa98d7cfSKaiGai Kohei * Thoes variables are declared as union, thus using those 411aa98d7cfSKaiGai Kohei * are exclusive. In a similar way, ref->ilist is temporarily 412aa98d7cfSKaiGai Kohei * used to chain all xattr_ref object. It's re-chained to 413aa98d7cfSKaiGai Kohei * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly. 414aa98d7cfSKaiGai Kohei */ 415aa98d7cfSKaiGai Kohei ref->node = raw; 416aa98d7cfSKaiGai Kohei ref->ino = je32_to_cpu(rr->ino); 417aa98d7cfSKaiGai Kohei ref->xid = je32_to_cpu(rr->xid); 418aa98d7cfSKaiGai Kohei list_add_tail(&ref->ilist, &c->xattr_temp); 419aa98d7cfSKaiGai Kohei 420aa98d7cfSKaiGai Kohei raw->__totlen = PAD(je32_to_cpu(rr->totlen)); 421aa98d7cfSKaiGai Kohei raw->flash_offset = ofs | REF_PRISTINE; 422aa98d7cfSKaiGai Kohei raw->next_phys = NULL; 423aa98d7cfSKaiGai Kohei raw->next_in_ino = (void *)ref; 424aa98d7cfSKaiGai Kohei if (!jeb->first_node) 425aa98d7cfSKaiGai Kohei jeb->first_node = raw; 426aa98d7cfSKaiGai Kohei if (jeb->last_node) 427aa98d7cfSKaiGai Kohei jeb->last_node->next_phys = raw; 428aa98d7cfSKaiGai Kohei jeb->last_node = raw; 429aa98d7cfSKaiGai Kohei 430aa98d7cfSKaiGai Kohei USED_SPACE(PAD(je32_to_cpu(rr->totlen))); 431aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 432aa98d7cfSKaiGai Kohei jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset); 433aa98d7cfSKaiGai Kohei dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n", 434aa98d7cfSKaiGai Kohei ofs, ref->xid, ref->ino); 435aa98d7cfSKaiGai Kohei return 0; 436aa98d7cfSKaiGai Kohei } 437aa98d7cfSKaiGai Kohei #endif 438aa98d7cfSKaiGai Kohei 4391da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 440e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) { 4411da177e4SLinus Torvalds struct jffs2_unknown_node *node; 4421da177e4SLinus Torvalds struct jffs2_unknown_node crcnode; 443e631ddbaSFerenc Havasi struct jffs2_sum_marker *sm; 4441da177e4SLinus Torvalds uint32_t ofs, prevofs; 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 4571da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs)); 4581da177e4SLinus Torvalds 4592f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4601da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 4611da177e4SLinus Torvalds int ret = jffs2_check_nand_cleanmarker(c, jeb); 4621da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret)); 4631da177e4SLinus Torvalds /* Even if it's not found, we still scan to see 4641da177e4SLinus Torvalds if the block is empty. We use this information 4651da177e4SLinus Torvalds to decide whether to erase it or not. */ 4661da177e4SLinus Torvalds switch (ret) { 4671da177e4SLinus Torvalds case 0: cleanmarkerfound = 1; break; 4681da177e4SLinus Torvalds case 1: break; 4691da177e4SLinus Torvalds case 2: return BLK_STATE_BADBLOCK; 4701da177e4SLinus Torvalds case 3: return BLK_STATE_ALLDIRTY; /* Block has failed to erase min. once */ 4711da177e4SLinus Torvalds default: return ret; 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds } 4741da177e4SLinus Torvalds #endif 475e631ddbaSFerenc Havasi 476e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 477e631ddbaSFerenc Havasi sm = kmalloc(sizeof(struct jffs2_sum_marker), GFP_KERNEL); 478e631ddbaSFerenc Havasi if (!sm) { 479e631ddbaSFerenc Havasi return -ENOMEM; 480e631ddbaSFerenc Havasi } 481e631ddbaSFerenc Havasi 482e631ddbaSFerenc Havasi err = jffs2_fill_scan_buf(c, (unsigned char *) sm, jeb->offset + c->sector_size - 483e631ddbaSFerenc Havasi sizeof(struct jffs2_sum_marker), sizeof(struct jffs2_sum_marker)); 484e631ddbaSFerenc Havasi if (err) { 485e631ddbaSFerenc Havasi kfree(sm); 486e631ddbaSFerenc Havasi return err; 487e631ddbaSFerenc Havasi } 488e631ddbaSFerenc Havasi 489e631ddbaSFerenc Havasi if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC ) { 490e631ddbaSFerenc Havasi err = jffs2_sum_scan_sumnode(c, jeb, je32_to_cpu(sm->offset), &pseudo_random); 491e631ddbaSFerenc Havasi if (err) { 492e631ddbaSFerenc Havasi kfree(sm); 493e631ddbaSFerenc Havasi return err; 494e631ddbaSFerenc Havasi } 495e631ddbaSFerenc Havasi } 496e631ddbaSFerenc Havasi 497e631ddbaSFerenc Havasi kfree(sm); 498e631ddbaSFerenc Havasi 499e631ddbaSFerenc Havasi ofs = jeb->offset; 500e631ddbaSFerenc Havasi prevofs = jeb->offset - 1; 501e631ddbaSFerenc Havasi } 502e631ddbaSFerenc Havasi 5031da177e4SLinus Torvalds buf_ofs = jeb->offset; 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds if (!buf_size) { 5061da177e4SLinus Torvalds buf_len = c->sector_size; 507e631ddbaSFerenc Havasi 508e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 509e631ddbaSFerenc Havasi /* must reread because of summary test */ 510e631ddbaSFerenc Havasi err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 511e631ddbaSFerenc Havasi if (err) 512e631ddbaSFerenc Havasi return err; 513e631ddbaSFerenc Havasi } 514e631ddbaSFerenc Havasi 5151da177e4SLinus Torvalds } else { 5163be36675SAndrew Victor buf_len = EMPTY_SCAN_SIZE(c->sector_size); 5171da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 5181da177e4SLinus Torvalds if (err) 5191da177e4SLinus Torvalds return err; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 5231da177e4SLinus Torvalds ofs = 0; 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds /* Scan only 4KiB of 0xFF before declaring it's empty */ 5263be36675SAndrew Victor while(ofs < EMPTY_SCAN_SIZE(c->sector_size) && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) 5271da177e4SLinus Torvalds ofs += 4; 5281da177e4SLinus Torvalds 5293be36675SAndrew Victor if (ofs == EMPTY_SCAN_SIZE(c->sector_size)) { 5302f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 5311da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 5321da177e4SLinus Torvalds /* scan oob, take care of cleanmarker */ 5331da177e4SLinus Torvalds int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 5341da177e4SLinus Torvalds D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret)); 5351da177e4SLinus Torvalds switch (ret) { 5361da177e4SLinus Torvalds case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 5371da177e4SLinus Torvalds case 1: return BLK_STATE_ALLDIRTY; 5381da177e4SLinus Torvalds default: return ret; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds } 5411da177e4SLinus Torvalds #endif 5421da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset)); 5438f15fd55SAndrew Victor if (c->cleanmarker_size == 0) 5448f15fd55SAndrew Victor return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */ 5458f15fd55SAndrew Victor else 5461da177e4SLinus Torvalds return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds if (ofs) { 5491da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset, 5501da177e4SLinus Torvalds jeb->offset + ofs)); 5511da177e4SLinus Torvalds DIRTY_SPACE(ofs); 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds /* Now ofs is a complete physical flash offset as it always was... */ 5551da177e4SLinus Torvalds ofs += jeb->offset; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds noise = 10; 5581da177e4SLinus Torvalds 559733802d9SArtem B. Bityutskiy dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset); 560e631ddbaSFerenc Havasi 5611da177e4SLinus Torvalds scan_more: 5621da177e4SLinus Torvalds while(ofs < jeb->offset + c->sector_size) { 5631da177e4SLinus Torvalds 564e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds cond_resched(); 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds if (ofs & 3) { 5691da177e4SLinus Torvalds printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs); 5701da177e4SLinus Torvalds ofs = PAD(ofs); 5711da177e4SLinus Torvalds continue; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds if (ofs == prevofs) { 5741da177e4SLinus Torvalds printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs); 5751da177e4SLinus Torvalds DIRTY_SPACE(4); 5761da177e4SLinus Torvalds ofs += 4; 5771da177e4SLinus Torvalds continue; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds prevofs = ofs; 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 5821da177e4SLinus 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), 5831da177e4SLinus Torvalds jeb->offset, c->sector_size, ofs, sizeof(*node))); 5841da177e4SLinus Torvalds DIRTY_SPACE((jeb->offset + c->sector_size)-ofs); 5851da177e4SLinus Torvalds break; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(*node)) { 5891da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 5901da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 5911da177e4SLinus Torvalds sizeof(struct jffs2_unknown_node), buf_len, ofs)); 5921da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 5931da177e4SLinus Torvalds if (err) 5941da177e4SLinus Torvalds return err; 5951da177e4SLinus Torvalds buf_ofs = ofs; 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs]; 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) { 6011da177e4SLinus Torvalds uint32_t inbuf_ofs; 6021da177e4SLinus Torvalds uint32_t empty_start; 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds empty_start = ofs; 6051da177e4SLinus Torvalds ofs += 4; 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs)); 6081da177e4SLinus Torvalds more_empty: 6091da177e4SLinus Torvalds inbuf_ofs = ofs - buf_ofs; 6101da177e4SLinus Torvalds while (inbuf_ofs < buf_len) { 6111da177e4SLinus Torvalds if (*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff) { 6121da177e4SLinus Torvalds printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", 6131da177e4SLinus Torvalds empty_start, ofs); 6141da177e4SLinus Torvalds DIRTY_SPACE(ofs-empty_start); 6151da177e4SLinus Torvalds goto scan_more; 6161da177e4SLinus Torvalds } 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds inbuf_ofs+=4; 6191da177e4SLinus Torvalds ofs += 4; 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds /* Ran off end. */ 6221da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash to end of buffer at 0x%08x\n", ofs)); 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* If we're only checking the beginning of a block with a cleanmarker, 6251da177e4SLinus Torvalds bail now */ 6261da177e4SLinus Torvalds if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 627b81226c5SArtem B. Bityuckiy c->cleanmarker_size && !jeb->dirty_size && !jeb->first_node->next_phys) { 6283be36675SAndrew Victor D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c->sector_size))); 6291da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 6301da177e4SLinus Torvalds } 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds /* See how much more there is to read in this eraseblock... */ 6331da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6341da177e4SLinus Torvalds if (!buf_len) { 6351da177e4SLinus Torvalds /* No more to read. Break out of main loop without marking 6361da177e4SLinus Torvalds this range of empty space as dirty (because it's not) */ 6371da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Empty flash at %08x runs to end of block. Treating as free_space\n", 6381da177e4SLinus Torvalds empty_start)); 6391da177e4SLinus Torvalds break; 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Reading another 0x%x at 0x%08x\n", 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 goto more_empty; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 6501da177e4SLinus Torvalds printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs); 6511da177e4SLinus Torvalds DIRTY_SPACE(4); 6521da177e4SLinus Torvalds ofs += 4; 6531da177e4SLinus Torvalds continue; 6541da177e4SLinus Torvalds } 6551da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 6561da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs)); 6571da177e4SLinus Torvalds DIRTY_SPACE(4); 6581da177e4SLinus Torvalds ofs += 4; 6591da177e4SLinus Torvalds continue; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 6621da177e4SLinus Torvalds printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs); 6631da177e4SLinus Torvalds printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n"); 6641da177e4SLinus Torvalds DIRTY_SPACE(4); 6651da177e4SLinus Torvalds ofs += 4; 6661da177e4SLinus Torvalds continue; 6671da177e4SLinus Torvalds } 6681da177e4SLinus Torvalds if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 6691da177e4SLinus Torvalds /* OK. We're out of possibilities. Whinge and move on */ 6701da177e4SLinus Torvalds noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 6711da177e4SLinus Torvalds JFFS2_MAGIC_BITMASK, ofs, 6721da177e4SLinus Torvalds je16_to_cpu(node->magic)); 6731da177e4SLinus Torvalds DIRTY_SPACE(4); 6741da177e4SLinus Torvalds ofs += 4; 6751da177e4SLinus Torvalds continue; 6761da177e4SLinus Torvalds } 6771da177e4SLinus Torvalds /* We seem to have a node of sorts. Check the CRC */ 6781da177e4SLinus Torvalds crcnode.magic = node->magic; 6791da177e4SLinus Torvalds crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE); 6801da177e4SLinus Torvalds crcnode.totlen = node->totlen; 6811da177e4SLinus Torvalds hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 6841da177e4SLinus 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", 6851da177e4SLinus Torvalds ofs, je16_to_cpu(node->magic), 6861da177e4SLinus Torvalds je16_to_cpu(node->nodetype), 6871da177e4SLinus Torvalds je32_to_cpu(node->totlen), 6881da177e4SLinus Torvalds je32_to_cpu(node->hdr_crc), 6891da177e4SLinus Torvalds hdr_crc); 6901da177e4SLinus Torvalds DIRTY_SPACE(4); 6911da177e4SLinus Torvalds ofs += 4; 6921da177e4SLinus Torvalds continue; 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds if (ofs + je32_to_cpu(node->totlen) > 6961da177e4SLinus Torvalds jeb->offset + c->sector_size) { 6971da177e4SLinus Torvalds /* Eep. Node goes over the end of the erase block. */ 6981da177e4SLinus Torvalds printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 6991da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen)); 7001da177e4SLinus Torvalds printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n"); 7011da177e4SLinus Torvalds DIRTY_SPACE(4); 7021da177e4SLinus Torvalds ofs += 4; 7031da177e4SLinus Torvalds continue; 7041da177e4SLinus Torvalds } 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 7071da177e4SLinus Torvalds /* Wheee. This is an obsoleted node */ 7081da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs)); 7091da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 7101da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7111da177e4SLinus Torvalds continue; 7121da177e4SLinus Torvalds } 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds switch(je16_to_cpu(node->nodetype)) { 7151da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 7161da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 7171da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7181da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 7191da177e4SLinus Torvalds sizeof(struct jffs2_raw_inode), buf_len, ofs)); 7201da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7211da177e4SLinus Torvalds if (err) 7221da177e4SLinus Torvalds return err; 7231da177e4SLinus Torvalds buf_ofs = ofs; 7241da177e4SLinus Torvalds node = (void *)buf; 7251da177e4SLinus Torvalds } 726e631ddbaSFerenc Havasi err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s); 7271da177e4SLinus Torvalds if (err) return err; 7281da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7291da177e4SLinus Torvalds break; 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 7321da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 7331da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7341da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 7351da177e4SLinus Torvalds je32_to_cpu(node->totlen), buf_len, ofs)); 7361da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7371da177e4SLinus Torvalds if (err) 7381da177e4SLinus Torvalds return err; 7391da177e4SLinus Torvalds buf_ofs = ofs; 7401da177e4SLinus Torvalds node = (void *)buf; 7411da177e4SLinus Torvalds } 742e631ddbaSFerenc Havasi err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s); 7431da177e4SLinus Torvalds if (err) return err; 7441da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7451da177e4SLinus Torvalds break; 7461da177e4SLinus Torvalds 747aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 748aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XATTR: 749aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 750aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 751aa98d7cfSKaiGai Kohei D1(printk(KERN_DEBUG "Fewer than %d bytes (xattr node)" 752aa98d7cfSKaiGai Kohei " left to end of buf. Reading 0x%x at 0x%08x\n", 753aa98d7cfSKaiGai Kohei je32_to_cpu(node->totlen), buf_len, ofs)); 754aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 755aa98d7cfSKaiGai Kohei if (err) 756aa98d7cfSKaiGai Kohei return err; 757aa98d7cfSKaiGai Kohei buf_ofs = ofs; 758aa98d7cfSKaiGai Kohei node = (void *)buf; 759aa98d7cfSKaiGai Kohei } 760aa98d7cfSKaiGai Kohei err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s); 761aa98d7cfSKaiGai Kohei if (err) 762aa98d7cfSKaiGai Kohei return err; 763aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 764aa98d7cfSKaiGai Kohei break; 765aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XREF: 766aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 767aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 768aa98d7cfSKaiGai Kohei D1(printk(KERN_DEBUG "Fewer than %d bytes (xref node)" 769aa98d7cfSKaiGai Kohei " left to end of buf. Reading 0x%x at 0x%08x\n", 770aa98d7cfSKaiGai Kohei je32_to_cpu(node->totlen), buf_len, ofs)); 771aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 772aa98d7cfSKaiGai Kohei if (err) 773aa98d7cfSKaiGai Kohei return err; 774aa98d7cfSKaiGai Kohei buf_ofs = ofs; 775aa98d7cfSKaiGai Kohei node = (void *)buf; 776aa98d7cfSKaiGai Kohei } 777aa98d7cfSKaiGai Kohei err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s); 778aa98d7cfSKaiGai Kohei if (err) 779aa98d7cfSKaiGai Kohei return err; 780aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 781aa98d7cfSKaiGai Kohei break; 782aa98d7cfSKaiGai Kohei #endif /* CONFIG_JFFS2_FS_XATTR */ 783aa98d7cfSKaiGai Kohei 7841da177e4SLinus Torvalds case JFFS2_NODETYPE_CLEANMARKER: 7851da177e4SLinus Torvalds D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs)); 7861da177e4SLinus Torvalds if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 7871da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 7881da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen), c->cleanmarker_size); 7891da177e4SLinus Torvalds DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node))); 7901da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 7911da177e4SLinus Torvalds } else if (jeb->first_node) { 7921da177e4SLinus Torvalds printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset); 7931da177e4SLinus Torvalds DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node))); 7941da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 7951da177e4SLinus Torvalds } else { 7961da177e4SLinus Torvalds struct jffs2_raw_node_ref *marker_ref = jffs2_alloc_raw_node_ref(); 7971da177e4SLinus Torvalds if (!marker_ref) { 7981da177e4SLinus Torvalds printk(KERN_NOTICE "Failed to allocate node ref for clean marker\n"); 7991da177e4SLinus Torvalds return -ENOMEM; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds marker_ref->next_in_ino = NULL; 8021da177e4SLinus Torvalds marker_ref->next_phys = NULL; 8031da177e4SLinus Torvalds marker_ref->flash_offset = ofs | REF_NORMAL; 8041da177e4SLinus Torvalds marker_ref->__totlen = c->cleanmarker_size; 8051da177e4SLinus Torvalds jeb->first_node = jeb->last_node = marker_ref; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds USED_SPACE(PAD(c->cleanmarker_size)); 8081da177e4SLinus Torvalds ofs += PAD(c->cleanmarker_size); 8091da177e4SLinus Torvalds } 8101da177e4SLinus Torvalds break; 8111da177e4SLinus Torvalds 8121da177e4SLinus Torvalds case JFFS2_NODETYPE_PADDING: 813e631ddbaSFerenc Havasi if (jffs2_sum_active()) 814e631ddbaSFerenc Havasi jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen)); 8151da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 8161da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8171da177e4SLinus Torvalds break; 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds default: 8201da177e4SLinus Torvalds switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 8211da177e4SLinus Torvalds case JFFS2_FEATURE_ROCOMPAT: 8221da177e4SLinus Torvalds printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8231da177e4SLinus Torvalds c->flags |= JFFS2_SB_FLAG_RO; 8241da177e4SLinus Torvalds if (!(jffs2_is_readonly(c))) 8251da177e4SLinus Torvalds return -EROFS; 8261da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 8271da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8281da177e4SLinus Torvalds break; 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds case JFFS2_FEATURE_INCOMPAT: 8311da177e4SLinus Torvalds printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 8321da177e4SLinus Torvalds return -EINVAL; 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_DELETE: 8351da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 8361da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(node->totlen))); 8371da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8381da177e4SLinus Torvalds break; 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_COPY: 8411da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 8421da177e4SLinus Torvalds USED_SPACE(PAD(je32_to_cpu(node->totlen))); 8431da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8441da177e4SLinus Torvalds break; 8451da177e4SLinus Torvalds } 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds } 8481da177e4SLinus Torvalds 849e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 850e631ddbaSFerenc Havasi if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) { 851733802d9SArtem B. Bityutskiy dbg_summary("There is not enough space for " 852e631ddbaSFerenc Havasi "summary information, disabling for this jeb!\n"); 853e631ddbaSFerenc Havasi jffs2_sum_disable_collecting(s); 854e631ddbaSFerenc Havasi } 855e631ddbaSFerenc Havasi } 8561da177e4SLinus Torvalds 8571da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb->offset, 8581da177e4SLinus Torvalds jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size)); 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds /* mark_node_obsolete can add to wasted !! */ 8611da177e4SLinus Torvalds if (jeb->wasted_size) { 8621da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 8631da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 8641da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 8651da177e4SLinus Torvalds jeb->wasted_size = 0; 8661da177e4SLinus Torvalds } 8671da177e4SLinus Torvalds 868e631ddbaSFerenc Havasi return jffs2_scan_classify_jeb(c, jeb); 8691da177e4SLinus Torvalds } 8701da177e4SLinus Torvalds 871e631ddbaSFerenc Havasi struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino) 8721da177e4SLinus Torvalds { 8731da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 8761da177e4SLinus Torvalds if (ic) 8771da177e4SLinus Torvalds return ic; 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds if (ino > c->highest_ino) 8801da177e4SLinus Torvalds c->highest_ino = ino; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 8831da177e4SLinus Torvalds if (!ic) { 8841da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n"); 8851da177e4SLinus Torvalds return NULL; 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds ic->ino = ino; 8901da177e4SLinus Torvalds ic->nodes = (void *)ic; 891aa98d7cfSKaiGai Kohei init_xattr_inode_cache(ic); 8921da177e4SLinus Torvalds jffs2_add_ino_cache(c, ic); 8931da177e4SLinus Torvalds if (ino == 1) 8941da177e4SLinus Torvalds ic->nlink = 1; 8951da177e4SLinus Torvalds return ic; 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 899e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s) 9001da177e4SLinus Torvalds { 9011da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 9021da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9031da177e4SLinus Torvalds uint32_t ino = je32_to_cpu(ri->ino); 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs)); 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds /* We do very little here now. Just check the ino# to which we should attribute 9081da177e4SLinus Torvalds this node; we can do all the CRC checking etc. later. There's a tradeoff here -- 9091da177e4SLinus Torvalds we used to scan the flash once only, reading everything we want from it into 9101da177e4SLinus Torvalds memory, then building all our in-core data structures and freeing the extra 9111da177e4SLinus Torvalds information. Now we allow the first part of the mount to complete a lot quicker, 9121da177e4SLinus Torvalds but we have to go _back_ to the flash in order to finish the CRC checking, etc. 9131da177e4SLinus Torvalds Which means that the _full_ amount of time to get to proper write mode with GC 9141da177e4SLinus Torvalds operational may actually be _longer_ than before. Sucks to be me. */ 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds raw = jffs2_alloc_raw_node_ref(); 9171da177e4SLinus Torvalds if (!raw) { 9181da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_inode_node(): allocation of node reference failed\n"); 9191da177e4SLinus Torvalds return -ENOMEM; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9231da177e4SLinus Torvalds if (!ic) { 9241da177e4SLinus Torvalds /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the 9251da177e4SLinus Torvalds first node we found for this inode. Do a CRC check to protect against the former 9261da177e4SLinus Torvalds case */ 9271da177e4SLinus Torvalds uint32_t crc = crc32(0, ri, sizeof(*ri)-8); 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds if (crc != je32_to_cpu(ri->node_crc)) { 9301da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 9311da177e4SLinus Torvalds ofs, je32_to_cpu(ri->node_crc), crc); 9321da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 9331da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(ri->totlen))); 9341da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 9351da177e4SLinus Torvalds return 0; 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, ino); 9381da177e4SLinus Torvalds if (!ic) { 9391da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 9401da177e4SLinus Torvalds return -ENOMEM; 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds /* Wheee. It worked */ 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds raw->flash_offset = ofs | REF_UNCHECKED; 9471da177e4SLinus Torvalds raw->__totlen = PAD(je32_to_cpu(ri->totlen)); 9481da177e4SLinus Torvalds raw->next_phys = NULL; 9491da177e4SLinus Torvalds raw->next_in_ino = ic->nodes; 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds ic->nodes = raw; 9521da177e4SLinus Torvalds if (!jeb->first_node) 9531da177e4SLinus Torvalds jeb->first_node = raw; 9541da177e4SLinus Torvalds if (jeb->last_node) 9551da177e4SLinus Torvalds jeb->last_node->next_phys = raw; 9561da177e4SLinus Torvalds jeb->last_node = raw; 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 9591da177e4SLinus Torvalds je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 9601da177e4SLinus Torvalds je32_to_cpu(ri->offset), 9611da177e4SLinus Torvalds je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize))); 9621da177e4SLinus Torvalds 9631da177e4SLinus Torvalds pseudo_random += je32_to_cpu(ri->version); 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds UNCHECKED_SPACE(PAD(je32_to_cpu(ri->totlen))); 966e631ddbaSFerenc Havasi 967e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 968e631ddbaSFerenc Havasi jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset); 969e631ddbaSFerenc Havasi } 970e631ddbaSFerenc Havasi 9711da177e4SLinus Torvalds return 0; 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 975e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s) 9761da177e4SLinus Torvalds { 9771da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 9781da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 9791da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9801da177e4SLinus Torvalds uint32_t crc; 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs)); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds /* We don't get here unless the node is still valid, so we don't have to 9851da177e4SLinus Torvalds mask in the ACCURATE bit any more. */ 9861da177e4SLinus Torvalds crc = crc32(0, rd, sizeof(*rd)-8); 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->node_crc)) { 9891da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 9901da177e4SLinus Torvalds ofs, je32_to_cpu(rd->node_crc), crc); 9911da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 9921da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen))); 9931da177e4SLinus Torvalds return 0; 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds pseudo_random += je32_to_cpu(rd->version); 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(rd->nsize+1); 9991da177e4SLinus Torvalds if (!fd) { 10001da177e4SLinus Torvalds return -ENOMEM; 10011da177e4SLinus Torvalds } 10021da177e4SLinus Torvalds memcpy(&fd->name, rd->name, rd->nsize); 10031da177e4SLinus Torvalds fd->name[rd->nsize] = 0; 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds crc = crc32(0, fd->name, rd->nsize); 10061da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->name_crc)) { 10071da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 10081da177e4SLinus Torvalds ofs, je32_to_cpu(rd->name_crc), crc); 10091da177e4SLinus Torvalds D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino))); 10101da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10111da177e4SLinus Torvalds /* FIXME: Why do we believe totlen? */ 10121da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */ 10131da177e4SLinus Torvalds DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen))); 10141da177e4SLinus Torvalds return 0; 10151da177e4SLinus Torvalds } 10161da177e4SLinus Torvalds raw = jffs2_alloc_raw_node_ref(); 10171da177e4SLinus Torvalds if (!raw) { 10181da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10191da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_scan_dirent_node(): allocation of node reference failed\n"); 10201da177e4SLinus Torvalds return -ENOMEM; 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino)); 10231da177e4SLinus Torvalds if (!ic) { 10241da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10251da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 10261da177e4SLinus Torvalds return -ENOMEM; 10271da177e4SLinus Torvalds } 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds raw->__totlen = PAD(je32_to_cpu(rd->totlen)); 10301da177e4SLinus Torvalds raw->flash_offset = ofs | REF_PRISTINE; 10311da177e4SLinus Torvalds raw->next_phys = NULL; 10321da177e4SLinus Torvalds raw->next_in_ino = ic->nodes; 10331da177e4SLinus Torvalds ic->nodes = raw; 10341da177e4SLinus Torvalds if (!jeb->first_node) 10351da177e4SLinus Torvalds jeb->first_node = raw; 10361da177e4SLinus Torvalds if (jeb->last_node) 10371da177e4SLinus Torvalds jeb->last_node->next_phys = raw; 10381da177e4SLinus Torvalds jeb->last_node = raw; 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds fd->raw = raw; 10411da177e4SLinus Torvalds fd->next = NULL; 10421da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 10431da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 10441da177e4SLinus Torvalds fd->nhash = full_name_hash(fd->name, rd->nsize); 10451da177e4SLinus Torvalds fd->type = rd->type; 10461da177e4SLinus Torvalds USED_SPACE(PAD(je32_to_cpu(rd->totlen))); 10471da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &ic->scan_dents); 10481da177e4SLinus Torvalds 1049e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1050e631ddbaSFerenc Havasi jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset); 1051e631ddbaSFerenc Havasi } 1052e631ddbaSFerenc Havasi 10531da177e4SLinus Torvalds return 0; 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds static int count_list(struct list_head *l) 10571da177e4SLinus Torvalds { 10581da177e4SLinus Torvalds uint32_t count = 0; 10591da177e4SLinus Torvalds struct list_head *tmp; 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds list_for_each(tmp, l) { 10621da177e4SLinus Torvalds count++; 10631da177e4SLinus Torvalds } 10641da177e4SLinus Torvalds return count; 10651da177e4SLinus Torvalds } 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds /* Note: This breaks if list_empty(head). I don't care. You 10681da177e4SLinus Torvalds might, if you copy this code and use it elsewhere :) */ 10691da177e4SLinus Torvalds static void rotate_list(struct list_head *head, uint32_t count) 10701da177e4SLinus Torvalds { 10711da177e4SLinus Torvalds struct list_head *n = head->next; 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds list_del(head); 10741da177e4SLinus Torvalds while(count--) { 10751da177e4SLinus Torvalds n = n->next; 10761da177e4SLinus Torvalds } 10771da177e4SLinus Torvalds list_add(head, n); 10781da177e4SLinus Torvalds } 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c) 10811da177e4SLinus Torvalds { 10821da177e4SLinus Torvalds uint32_t x; 10831da177e4SLinus Torvalds uint32_t rotateby; 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds x = count_list(&c->clean_list); 10861da177e4SLinus Torvalds if (x) { 10871da177e4SLinus Torvalds rotateby = pseudo_random % x; 10881da177e4SLinus Torvalds rotate_list((&c->clean_list), rotateby); 10891da177e4SLinus Torvalds } 10901da177e4SLinus Torvalds 10911da177e4SLinus Torvalds x = count_list(&c->very_dirty_list); 10921da177e4SLinus Torvalds if (x) { 10931da177e4SLinus Torvalds rotateby = pseudo_random % x; 10941da177e4SLinus Torvalds rotate_list((&c->very_dirty_list), rotateby); 10951da177e4SLinus Torvalds } 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds x = count_list(&c->dirty_list); 10981da177e4SLinus Torvalds if (x) { 10991da177e4SLinus Torvalds rotateby = pseudo_random % x; 11001da177e4SLinus Torvalds rotate_list((&c->dirty_list), rotateby); 11011da177e4SLinus Torvalds } 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds x = count_list(&c->erasable_list); 11041da177e4SLinus Torvalds if (x) { 11051da177e4SLinus Torvalds rotateby = pseudo_random % x; 11061da177e4SLinus Torvalds rotate_list((&c->erasable_list), rotateby); 11071da177e4SLinus Torvalds } 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 11101da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_erasing_blocks; 11111da177e4SLinus Torvalds rotate_list((&c->erase_pending_list), rotateby); 11121da177e4SLinus Torvalds } 11131da177e4SLinus Torvalds 11141da177e4SLinus Torvalds if (c->nr_free_blocks) { 11151da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_free_blocks; 11161da177e4SLinus Torvalds rotate_list((&c->free_list), rotateby); 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds } 1119