11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds */ 11c00c310eSDavid Woodhouse 125a528957SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 135a528957SJoe Perches 141da177e4SLinus Torvalds #include <linux/kernel.h> 151da177e4SLinus Torvalds #include <linux/sched.h> 161da177e4SLinus Torvalds #include <linux/slab.h> 171da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 181da177e4SLinus Torvalds #include <linux/pagemap.h> 191da177e4SLinus Torvalds #include <linux/crc32.h> 201da177e4SLinus Torvalds #include <linux/compiler.h> 211da177e4SLinus Torvalds #include "nodelist.h" 22e631ddbaSFerenc Havasi #include "summary.h" 23e631ddbaSFerenc Havasi #include "debug.h" 241da177e4SLinus Torvalds 2541bdc602SJoakim Tjernlund #define DEFAULT_EMPTY_SCAN_SIZE 256 261da177e4SLinus Torvalds 27da320f05SJoe Perches #define noisy_printk(noise, fmt, ...) \ 28da320f05SJoe Perches do { \ 291da177e4SLinus Torvalds if (*(noise)) { \ 30da320f05SJoe Perches pr_notice(fmt, ##__VA_ARGS__); \ 311da177e4SLinus Torvalds (*(noise))--; \ 32da320f05SJoe Perches if (!(*(noise))) \ 33da320f05SJoe Perches pr_notice("Further such events for this erase block will not be printed\n"); \ 341da177e4SLinus Torvalds } \ 351da177e4SLinus Torvalds } while (0) 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds static uint32_t pseudo_random; 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 40e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s); 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds /* These helper functions _must_ increase ofs and also do the dirty/used space accounting. 431da177e4SLinus Torvalds * Returning an error will abort the mount - bad checksums etc. should just mark the space 441da177e4SLinus Torvalds * as dirty. 451da177e4SLinus Torvalds */ 461da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 47e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s); 481da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 49e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s); 501da177e4SLinus Torvalds 511da177e4SLinus Torvalds static inline int min_free(struct jffs2_sb_info *c) 521da177e4SLinus Torvalds { 531da177e4SLinus Torvalds uint32_t min = 2 * sizeof(struct jffs2_raw_inode); 542f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 551da177e4SLinus Torvalds if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize) 561da177e4SLinus Torvalds return c->wbuf_pagesize; 571da177e4SLinus Torvalds #endif 581da177e4SLinus Torvalds return min; 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds } 613be36675SAndrew Victor 623be36675SAndrew Victor static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) { 633be36675SAndrew Victor if (sector_size < DEFAULT_EMPTY_SCAN_SIZE) 643be36675SAndrew Victor return sector_size; 653be36675SAndrew Victor else 663be36675SAndrew Victor return DEFAULT_EMPTY_SCAN_SIZE; 673be36675SAndrew Victor } 683be36675SAndrew Victor 6925090a6bSDavid Woodhouse static int file_dirty(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 7025090a6bSDavid Woodhouse { 71a6a8bef7SDavid Woodhouse int ret; 72a6a8bef7SDavid Woodhouse 73a6a8bef7SDavid Woodhouse if ((ret = jffs2_prealloc_raw_node_refs(c, jeb, 1))) 74a6a8bef7SDavid Woodhouse return ret; 75a6a8bef7SDavid Woodhouse if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size))) 7625090a6bSDavid Woodhouse return ret; 7725090a6bSDavid Woodhouse /* Turned wasted size into dirty, since we apparently 7825090a6bSDavid Woodhouse think it's recoverable now. */ 7925090a6bSDavid Woodhouse jeb->dirty_size += jeb->wasted_size; 8025090a6bSDavid Woodhouse c->dirty_size += jeb->wasted_size; 8125090a6bSDavid Woodhouse c->wasted_size -= jeb->wasted_size; 8225090a6bSDavid Woodhouse jeb->wasted_size = 0; 8325090a6bSDavid Woodhouse if (VERYDIRTY(c, jeb->dirty_size)) { 8425090a6bSDavid Woodhouse list_add(&jeb->list, &c->very_dirty_list); 8525090a6bSDavid Woodhouse } else { 8625090a6bSDavid Woodhouse list_add(&jeb->list, &c->dirty_list); 8725090a6bSDavid Woodhouse } 8825090a6bSDavid Woodhouse return 0; 8925090a6bSDavid Woodhouse } 9025090a6bSDavid Woodhouse 911da177e4SLinus Torvalds int jffs2_scan_medium(struct jffs2_sb_info *c) 921da177e4SLinus Torvalds { 931da177e4SLinus Torvalds int i, ret; 941da177e4SLinus Torvalds uint32_t empty_blocks = 0, bad_blocks = 0; 951da177e4SLinus Torvalds unsigned char *flashbuf = NULL; 961da177e4SLinus Torvalds uint32_t buf_size = 0; 97e631ddbaSFerenc Havasi struct jffs2_summary *s = NULL; /* summary info collected by the scan process */ 981da177e4SLinus Torvalds #ifndef __ECOS 991ddd0d9aSGrant Erickson size_t pointlen, try_size; 1001da177e4SLinus Torvalds 101d35ea200SArtem Bityutskiy ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen, 102a98889f3SJared Hulbert (void **)&flashbuf, NULL); 1031da177e4SLinus Torvalds if (!ret && pointlen < c->mtd->size) { 1041da177e4SLinus Torvalds /* Don't muck about if it won't let us point to the whole flash */ 1059c261b33SJoe Perches jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n", 1069c261b33SJoe Perches pointlen); 1077219778aSArtem Bityutskiy mtd_unpoint(c->mtd, 0, pointlen); 1081da177e4SLinus Torvalds flashbuf = NULL; 1091da177e4SLinus Torvalds } 11010934478SArtem Bityutskiy if (ret && ret != -EOPNOTSUPP) 1119c261b33SJoe Perches jffs2_dbg(1, "MTD point failed %d\n", ret); 1121da177e4SLinus Torvalds #endif 1131da177e4SLinus Torvalds if (!flashbuf) { 1141da177e4SLinus Torvalds /* For NAND it's quicker to read a whole eraseblock at a time, 1151da177e4SLinus Torvalds apparently */ 1161da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) 1171ddd0d9aSGrant Erickson try_size = c->sector_size; 1181da177e4SLinus Torvalds else 1191ddd0d9aSGrant Erickson try_size = PAGE_SIZE; 1201da177e4SLinus Torvalds 1219c261b33SJoe Perches jffs2_dbg(1, "Trying to allocate readbuf of %zu " 1229c261b33SJoe Perches "bytes\n", try_size); 1231da177e4SLinus Torvalds 1241ddd0d9aSGrant Erickson flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size); 1251da177e4SLinus Torvalds if (!flashbuf) 1261da177e4SLinus Torvalds return -ENOMEM; 1271ddd0d9aSGrant Erickson 1289c261b33SJoe Perches jffs2_dbg(1, "Allocated readbuf of %zu bytes\n", 1299c261b33SJoe Perches try_size); 1301ddd0d9aSGrant Erickson 1311ddd0d9aSGrant Erickson buf_size = (uint32_t)try_size; 1321da177e4SLinus Torvalds } 1331da177e4SLinus Torvalds 134e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1353d375d9eSYan Burman s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL); 136e631ddbaSFerenc Havasi if (!s) { 137e631ddbaSFerenc Havasi JFFS2_WARNING("Can't allocate memory for summary\n"); 13848396413SDavid Woodhouse ret = -ENOMEM; 13948396413SDavid Woodhouse goto out; 140e631ddbaSFerenc Havasi } 141e631ddbaSFerenc Havasi } 142e631ddbaSFerenc Havasi 1431da177e4SLinus Torvalds for (i=0; i<c->nr_blocks; i++) { 1441da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[i]; 1451da177e4SLinus Torvalds 146a2166b93SArtem Bityutskiy cond_resched(); 147a2166b93SArtem Bityutskiy 148e631ddbaSFerenc Havasi /* reset summary info for next eraseblock scan */ 149e631ddbaSFerenc Havasi jffs2_sum_reset_collected(s); 150e631ddbaSFerenc Havasi 151e631ddbaSFerenc Havasi ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), 152e631ddbaSFerenc Havasi buf_size, s); 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds if (ret < 0) 1551da177e4SLinus Torvalds goto out; 1561da177e4SLinus Torvalds 157e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds /* Now decide which list to put it on */ 1601da177e4SLinus Torvalds switch(ret) { 1611da177e4SLinus Torvalds case BLK_STATE_ALLFF: 1621da177e4SLinus Torvalds /* 1631da177e4SLinus Torvalds * Empty block. Since we can't be sure it 1641da177e4SLinus Torvalds * was entirely erased, we just queue it for erase 1651da177e4SLinus Torvalds * again. It will be marked as such when the erase 1661da177e4SLinus Torvalds * is complete. Meanwhile we still count it as empty 1671da177e4SLinus Torvalds * for later checks. 1681da177e4SLinus Torvalds */ 1691da177e4SLinus Torvalds empty_blocks++; 1701da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1711da177e4SLinus Torvalds c->nr_erasing_blocks++; 1721da177e4SLinus Torvalds break; 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds case BLK_STATE_CLEANMARKER: 1751da177e4SLinus Torvalds /* Only a CLEANMARKER node is valid */ 1761da177e4SLinus Torvalds if (!jeb->dirty_size) { 1771da177e4SLinus Torvalds /* It's actually free */ 1781da177e4SLinus Torvalds list_add(&jeb->list, &c->free_list); 1791da177e4SLinus Torvalds c->nr_free_blocks++; 1801da177e4SLinus Torvalds } else { 1811da177e4SLinus Torvalds /* Dirt */ 1829c261b33SJoe Perches jffs2_dbg(1, "Adding all-dirty block at 0x%08x to erase_pending_list\n", 1839c261b33SJoe Perches jeb->offset); 1841da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 1851da177e4SLinus Torvalds c->nr_erasing_blocks++; 1861da177e4SLinus Torvalds } 1871da177e4SLinus Torvalds break; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds case BLK_STATE_CLEAN: 1901da177e4SLinus Torvalds /* Full (or almost full) of clean data. Clean list */ 1911da177e4SLinus Torvalds list_add(&jeb->list, &c->clean_list); 1921da177e4SLinus Torvalds break; 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds case BLK_STATE_PARTDIRTY: 1951da177e4SLinus Torvalds /* Some data, but not full. Dirty list. */ 1961da177e4SLinus Torvalds /* We want to remember the block with most free space 1971da177e4SLinus Torvalds and stick it in the 'nextblock' position to start writing to it. */ 1981da177e4SLinus Torvalds if (jeb->free_size > min_free(c) && 1991da177e4SLinus Torvalds (!c->nextblock || c->nextblock->free_size < jeb->free_size)) { 2001da177e4SLinus Torvalds /* Better candidate for the next writes to go to */ 2011da177e4SLinus Torvalds if (c->nextblock) { 20225090a6bSDavid Woodhouse ret = file_dirty(c, c->nextblock); 20325090a6bSDavid Woodhouse if (ret) 204a2ab0ce0SChristian Engelmayer goto out; 205e631ddbaSFerenc Havasi /* deleting summary information of the old nextblock */ 206e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); 2071da177e4SLinus Torvalds } 20825090a6bSDavid Woodhouse /* update collected summary information for the current nextblock */ 209e631ddbaSFerenc Havasi jffs2_sum_move_collected(c, s); 2109c261b33SJoe Perches jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 2119c261b33SJoe Perches __func__, jeb->offset); 2121da177e4SLinus Torvalds c->nextblock = jeb; 2131da177e4SLinus Torvalds } else { 21425090a6bSDavid Woodhouse ret = file_dirty(c, jeb); 21525090a6bSDavid Woodhouse if (ret) 216a2ab0ce0SChristian Engelmayer goto out; 2171da177e4SLinus Torvalds } 2181da177e4SLinus Torvalds break; 2191da177e4SLinus Torvalds 2201da177e4SLinus Torvalds case BLK_STATE_ALLDIRTY: 2211da177e4SLinus Torvalds /* Nothing valid - not even a clean marker. Needs erasing. */ 2221da177e4SLinus Torvalds /* For now we just put it on the erasing list. We'll start the erases later */ 2235a528957SJoe Perches jffs2_dbg(1, "Erase block at 0x%08x is not formatted. It will be erased\n", 2249c261b33SJoe Perches jeb->offset); 2251da177e4SLinus Torvalds list_add(&jeb->list, &c->erase_pending_list); 2261da177e4SLinus Torvalds c->nr_erasing_blocks++; 2271da177e4SLinus Torvalds break; 2281da177e4SLinus Torvalds 2291da177e4SLinus Torvalds case BLK_STATE_BADBLOCK: 2305a528957SJoe Perches jffs2_dbg(1, "Block at 0x%08x is bad\n", jeb->offset); 2311da177e4SLinus Torvalds list_add(&jeb->list, &c->bad_list); 2321da177e4SLinus Torvalds c->bad_size += c->sector_size; 2331da177e4SLinus Torvalds c->free_size -= c->sector_size; 2341da177e4SLinus Torvalds bad_blocks++; 2351da177e4SLinus Torvalds break; 2361da177e4SLinus Torvalds default: 237da320f05SJoe Perches pr_warn("%s(): unknown block state\n", __func__); 2381da177e4SLinus Torvalds BUG(); 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds } 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */ 2431da177e4SLinus Torvalds if (c->nextblock && (c->nextblock->dirty_size)) { 2441da177e4SLinus Torvalds c->nextblock->wasted_size += c->nextblock->dirty_size; 2451da177e4SLinus Torvalds c->wasted_size += c->nextblock->dirty_size; 2461da177e4SLinus Torvalds c->dirty_size -= c->nextblock->dirty_size; 2471da177e4SLinus Torvalds c->nextblock->dirty_size = 0; 2481da177e4SLinus Torvalds } 2492f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 250e96fb230SDavid Woodhouse if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) { 2511da177e4SLinus Torvalds /* If we're going to start writing into a block which already 2521da177e4SLinus Torvalds contains data, and the end of the data isn't page-aligned, 2531da177e4SLinus Torvalds skip a little and align it. */ 2541da177e4SLinus Torvalds 255daba5cc4SArtem B. Bityutskiy uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize; 2561da177e4SLinus Torvalds 2579c261b33SJoe Perches jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n", 2589c261b33SJoe Perches __func__, skip); 259046b8b98SDavid Woodhouse jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 260f560928bSDavid Woodhouse jffs2_scan_dirty_space(c, c->nextblock, skip); 2611da177e4SLinus Torvalds } 2621da177e4SLinus Torvalds #endif 2631da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 264a68005a3SZhe Li if (!c->used_size && !c->unchecked_size && 265a68005a3SZhe Li ((c->nr_free_blocks+empty_blocks+bad_blocks) != c->nr_blocks || bad_blocks == c->nr_blocks)) { 266da320f05SJoe Perches pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 267da320f05SJoe Perches pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n", 268da320f05SJoe Perches empty_blocks, bad_blocks, c->nr_blocks); 2691da177e4SLinus Torvalds ret = -EIO; 2701da177e4SLinus Torvalds goto out; 2711da177e4SLinus Torvalds } 272ae3b6ba0SDavid Woodhouse spin_lock(&c->erase_completion_lock); 273ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 274ae3b6ba0SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds ret = 0; 2771da177e4SLinus Torvalds out: 2781da177e4SLinus Torvalds if (buf_size) 2791da177e4SLinus Torvalds kfree(flashbuf); 2801da177e4SLinus Torvalds #ifndef __ECOS 2811da177e4SLinus Torvalds else 2827219778aSArtem Bityutskiy mtd_unpoint(c->mtd, 0, c->mtd->size); 2831da177e4SLinus Torvalds #endif 2845b5ffbc1SFlorin Malita kfree(s); 2851da177e4SLinus Torvalds return ret; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 288c05d52c7SAdrian Bunk static int jffs2_fill_scan_buf(struct jffs2_sb_info *c, void *buf, 2891da177e4SLinus Torvalds uint32_t ofs, uint32_t len) 2901da177e4SLinus Torvalds { 2911da177e4SLinus Torvalds int ret; 2921da177e4SLinus Torvalds size_t retlen; 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 2951da177e4SLinus Torvalds if (ret) { 2969c261b33SJoe Perches jffs2_dbg(1, "mtd->read(0x%x bytes from 0x%x) returned %d\n", 2979c261b33SJoe Perches len, ofs, ret); 2981da177e4SLinus Torvalds return ret; 2991da177e4SLinus Torvalds } 3001da177e4SLinus Torvalds if (retlen < len) { 3019c261b33SJoe Perches jffs2_dbg(1, "Read at 0x%x gave only 0x%zx bytes\n", 3029c261b33SJoe Perches ofs, retlen); 3031da177e4SLinus Torvalds return -EIO; 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds return 0; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds 308e631ddbaSFerenc Havasi int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 309e631ddbaSFerenc Havasi { 310e631ddbaSFerenc Havasi if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size 31199988f7bSDavid Woodhouse && (!jeb->first_node || !ref_next(jeb->first_node)) ) 312e631ddbaSFerenc Havasi return BLK_STATE_CLEANMARKER; 313e631ddbaSFerenc Havasi 314e631ddbaSFerenc Havasi /* move blocks with max 4 byte dirty space to cleanlist */ 315e631ddbaSFerenc Havasi else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) { 316e631ddbaSFerenc Havasi c->dirty_size -= jeb->dirty_size; 317e631ddbaSFerenc Havasi c->wasted_size += jeb->dirty_size; 318e631ddbaSFerenc Havasi jeb->wasted_size += jeb->dirty_size; 319e631ddbaSFerenc Havasi jeb->dirty_size = 0; 320e631ddbaSFerenc Havasi return BLK_STATE_CLEAN; 321e631ddbaSFerenc Havasi } else if (jeb->used_size || jeb->unchecked_size) 322e631ddbaSFerenc Havasi return BLK_STATE_PARTDIRTY; 323e631ddbaSFerenc Havasi else 324e631ddbaSFerenc Havasi return BLK_STATE_ALLDIRTY; 325e631ddbaSFerenc Havasi } 326e631ddbaSFerenc Havasi 327aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 328aa98d7cfSKaiGai Kohei static int jffs2_scan_xattr_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 329aa98d7cfSKaiGai Kohei struct jffs2_raw_xattr *rx, uint32_t ofs, 330aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 331aa98d7cfSKaiGai Kohei { 332aa98d7cfSKaiGai Kohei struct jffs2_xattr_datum *xd; 333c9f700f8SKaiGai Kohei uint32_t xid, version, totlen, crc; 33468270995SDavid Woodhouse int err; 335aa98d7cfSKaiGai Kohei 336aa98d7cfSKaiGai Kohei crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4); 337aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rx->node_crc)) { 338aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 339aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->node_crc), crc); 34068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 34168270995SDavid Woodhouse return err; 342aa98d7cfSKaiGai Kohei return 0; 343aa98d7cfSKaiGai Kohei } 344aa98d7cfSKaiGai Kohei 345c9f700f8SKaiGai Kohei xid = je32_to_cpu(rx->xid); 346c9f700f8SKaiGai Kohei version = je32_to_cpu(rx->version); 347c9f700f8SKaiGai Kohei 3488a13695cSKaiGai Kohei totlen = PAD(sizeof(struct jffs2_raw_xattr) 3498a13695cSKaiGai Kohei + rx->name_len + 1 + je16_to_cpu(rx->value_len)); 350aa98d7cfSKaiGai Kohei if (totlen != je32_to_cpu(rx->totlen)) { 351aa98d7cfSKaiGai Kohei JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n", 352aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rx->totlen), totlen); 35368270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen)))) 35468270995SDavid Woodhouse return err; 355aa98d7cfSKaiGai Kohei return 0; 356aa98d7cfSKaiGai Kohei } 357aa98d7cfSKaiGai Kohei 358c9f700f8SKaiGai Kohei xd = jffs2_setup_xattr_datum(c, xid, version); 359c9f700f8SKaiGai Kohei if (IS_ERR(xd)) 360aa98d7cfSKaiGai Kohei return PTR_ERR(xd); 361c9f700f8SKaiGai Kohei 362c9f700f8SKaiGai Kohei if (xd->version > version) { 363c9f700f8SKaiGai Kohei struct jffs2_raw_node_ref *raw 364c9f700f8SKaiGai Kohei = jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, NULL); 365c9f700f8SKaiGai Kohei raw->next_in_ino = xd->node->next_in_ino; 366c9f700f8SKaiGai Kohei xd->node->next_in_ino = raw; 367c9f700f8SKaiGai Kohei } else { 368c9f700f8SKaiGai Kohei xd->version = version; 369aa98d7cfSKaiGai Kohei xd->xprefix = rx->xprefix; 370aa98d7cfSKaiGai Kohei xd->name_len = rx->name_len; 371aa98d7cfSKaiGai Kohei xd->value_len = je16_to_cpu(rx->value_len); 372aa98d7cfSKaiGai Kohei xd->data_crc = je32_to_cpu(rx->data_crc); 373aa98d7cfSKaiGai Kohei 374c9f700f8SKaiGai Kohei jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, totlen, (void *)xd); 375c9f700f8SKaiGai Kohei } 376f1f9671bSDavid Woodhouse 377aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 378aa98d7cfSKaiGai Kohei jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset); 3793e341740SMasanari Iida dbg_xattr("scanning xdatum at %#08x (xid=%u, version=%u)\n", 380aa98d7cfSKaiGai Kohei ofs, xd->xid, xd->version); 381aa98d7cfSKaiGai Kohei return 0; 382aa98d7cfSKaiGai Kohei } 383aa98d7cfSKaiGai Kohei 384aa98d7cfSKaiGai Kohei static int jffs2_scan_xref_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 385aa98d7cfSKaiGai Kohei struct jffs2_raw_xref *rr, uint32_t ofs, 386aa98d7cfSKaiGai Kohei struct jffs2_summary *s) 387aa98d7cfSKaiGai Kohei { 388aa98d7cfSKaiGai Kohei struct jffs2_xattr_ref *ref; 389aa98d7cfSKaiGai Kohei uint32_t crc; 39068270995SDavid Woodhouse int err; 391aa98d7cfSKaiGai Kohei 392aa98d7cfSKaiGai Kohei crc = crc32(0, rr, sizeof(*rr) - 4); 393aa98d7cfSKaiGai Kohei if (crc != je32_to_cpu(rr->node_crc)) { 394aa98d7cfSKaiGai Kohei JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n", 395aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->node_crc), crc); 39668270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen))))) 39768270995SDavid Woodhouse return err; 398aa98d7cfSKaiGai Kohei return 0; 399aa98d7cfSKaiGai Kohei } 400aa98d7cfSKaiGai Kohei 401aa98d7cfSKaiGai Kohei if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) { 40289291a9dSDavid Woodhouse JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n", 403aa98d7cfSKaiGai Kohei ofs, je32_to_cpu(rr->totlen), 404aa98d7cfSKaiGai Kohei PAD(sizeof(struct jffs2_raw_xref))); 40568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen)))) 40668270995SDavid Woodhouse return err; 407aa98d7cfSKaiGai Kohei return 0; 408aa98d7cfSKaiGai Kohei } 409aa98d7cfSKaiGai Kohei 410aa98d7cfSKaiGai Kohei ref = jffs2_alloc_xattr_ref(); 411aa98d7cfSKaiGai Kohei if (!ref) 412aa98d7cfSKaiGai Kohei return -ENOMEM; 413aa98d7cfSKaiGai Kohei 414aa98d7cfSKaiGai Kohei /* BEFORE jffs2_build_xattr_subsystem() called, 415c9f700f8SKaiGai Kohei * and AFTER xattr_ref is marked as a dead xref, 416aa98d7cfSKaiGai Kohei * ref->xid is used to store 32bit xid, xd is not used 417aa98d7cfSKaiGai Kohei * ref->ino is used to store 32bit inode-number, ic is not used 418aa98d7cfSKaiGai Kohei * Thoes variables are declared as union, thus using those 4198f2b6f49SKaiGai Kohei * are exclusive. In a similar way, ref->next is temporarily 420aa98d7cfSKaiGai Kohei * used to chain all xattr_ref object. It's re-chained to 421aa98d7cfSKaiGai Kohei * jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly. 422aa98d7cfSKaiGai Kohei */ 423aa98d7cfSKaiGai Kohei ref->ino = je32_to_cpu(rr->ino); 424aa98d7cfSKaiGai Kohei ref->xid = je32_to_cpu(rr->xid); 425c9f700f8SKaiGai Kohei ref->xseqno = je32_to_cpu(rr->xseqno); 426c9f700f8SKaiGai Kohei if (ref->xseqno > c->highest_xseqno) 427c9f700f8SKaiGai Kohei c->highest_xseqno = (ref->xseqno & ~XREF_DELETE_MARKER); 4288f2b6f49SKaiGai Kohei ref->next = c->xref_temp; 4298f2b6f49SKaiGai Kohei c->xref_temp = ref; 430aa98d7cfSKaiGai Kohei 431c9f700f8SKaiGai Kohei jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), (void *)ref); 432f1f9671bSDavid Woodhouse 433aa98d7cfSKaiGai Kohei if (jffs2_sum_active()) 434aa98d7cfSKaiGai Kohei jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset); 435aa98d7cfSKaiGai Kohei dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n", 436aa98d7cfSKaiGai Kohei ofs, ref->xid, ref->ino); 437aa98d7cfSKaiGai Kohei return 0; 438aa98d7cfSKaiGai Kohei } 439aa98d7cfSKaiGai Kohei #endif 440aa98d7cfSKaiGai Kohei 4419641b784SDavid Woodhouse /* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into 4429641b784SDavid Woodhouse the flash, XIP-style */ 4431da177e4SLinus Torvalds static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 444e631ddbaSFerenc Havasi unsigned char *buf, uint32_t buf_size, struct jffs2_summary *s) { 4451da177e4SLinus Torvalds struct jffs2_unknown_node *node; 4461da177e4SLinus Torvalds struct jffs2_unknown_node crcnode; 44741bdc602SJoakim Tjernlund uint32_t ofs, prevofs, max_ofs; 4481da177e4SLinus Torvalds uint32_t hdr_crc, buf_ofs, buf_len; 4491da177e4SLinus Torvalds int err; 4501da177e4SLinus Torvalds int noise = 0; 451e631ddbaSFerenc Havasi 452e631ddbaSFerenc Havasi 4532f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4541da177e4SLinus Torvalds int cleanmarkerfound = 0; 4551da177e4SLinus Torvalds #endif 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds ofs = jeb->offset; 4581da177e4SLinus Torvalds prevofs = jeb->offset - 1; 4591da177e4SLinus Torvalds 4609c261b33SJoe Perches jffs2_dbg(1, "%s(): Scanning block at 0x%x\n", __func__, ofs); 4611da177e4SLinus Torvalds 4622f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 4631da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 464a7a6ace1SArtem Bityutskiy int ret; 465a7a6ace1SArtem Bityutskiy 4667086c19dSArtem Bityutskiy if (mtd_block_isbad(c->mtd, jeb->offset)) 467a7a6ace1SArtem Bityutskiy return BLK_STATE_BADBLOCK; 468a7a6ace1SArtem Bityutskiy 469a7a6ace1SArtem Bityutskiy ret = jffs2_check_nand_cleanmarker(c, jeb); 4709c261b33SJoe Perches jffs2_dbg(2, "jffs_check_nand_cleanmarker returned %d\n", ret); 471a7a6ace1SArtem Bityutskiy 4721da177e4SLinus Torvalds /* Even if it's not found, we still scan to see 4731da177e4SLinus Torvalds if the block is empty. We use this information 4741da177e4SLinus Torvalds to decide whether to erase it or not. */ 4751da177e4SLinus Torvalds switch (ret) { 4761da177e4SLinus Torvalds case 0: cleanmarkerfound = 1; break; 4771da177e4SLinus Torvalds case 1: break; 4781da177e4SLinus Torvalds default: return ret; 4791da177e4SLinus Torvalds } 4801da177e4SLinus Torvalds } 4811da177e4SLinus Torvalds #endif 482e631ddbaSFerenc Havasi 483e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 4849641b784SDavid Woodhouse struct jffs2_sum_marker *sm; 4859641b784SDavid Woodhouse void *sumptr = NULL; 4869641b784SDavid Woodhouse uint32_t sumlen; 487e631ddbaSFerenc Havasi 4889641b784SDavid Woodhouse if (!buf_size) { 4899641b784SDavid Woodhouse /* XIP case. Just look, point at the summary if it's there */ 49013ba42dfSDavid Woodhouse sm = (void *)buf + c->sector_size - sizeof(*sm); 491e631ddbaSFerenc Havasi if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 4929641b784SDavid Woodhouse sumptr = buf + je32_to_cpu(sm->offset); 4939641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 4949641b784SDavid Woodhouse } 4959641b784SDavid Woodhouse } else { 4969641b784SDavid Woodhouse /* If NAND flash, read a whole page of it. Else just the end */ 4979641b784SDavid Woodhouse if (c->wbuf_pagesize) 4989641b784SDavid Woodhouse buf_len = c->wbuf_pagesize; 4999641b784SDavid Woodhouse else 5009641b784SDavid Woodhouse buf_len = sizeof(*sm); 5019641b784SDavid Woodhouse 5029641b784SDavid Woodhouse /* Read as much as we want into the _end_ of the preallocated buffer */ 5039641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 5049641b784SDavid Woodhouse jeb->offset + c->sector_size - buf_len, 5059641b784SDavid Woodhouse buf_len); 5069641b784SDavid Woodhouse if (err) 5079641b784SDavid Woodhouse return err; 5089641b784SDavid Woodhouse 5099641b784SDavid Woodhouse sm = (void *)buf + buf_size - sizeof(*sm); 5109641b784SDavid Woodhouse if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) { 5119641b784SDavid Woodhouse sumlen = c->sector_size - je32_to_cpu(sm->offset); 5129641b784SDavid Woodhouse sumptr = buf + buf_size - sumlen; 5139641b784SDavid Woodhouse 514164c2406SChen Jie /* sm->offset maybe wrong but MAGIC maybe right */ 515164c2406SChen Jie if (sumlen > c->sector_size) 516164c2406SChen Jie goto full_scan; 517164c2406SChen Jie 5189641b784SDavid Woodhouse /* Now, make sure the summary itself is available */ 5199641b784SDavid Woodhouse if (sumlen > buf_size) { 5209641b784SDavid Woodhouse /* Need to kmalloc for this. */ 5219641b784SDavid Woodhouse sumptr = kmalloc(sumlen, GFP_KERNEL); 5229641b784SDavid Woodhouse if (!sumptr) 5239641b784SDavid Woodhouse return -ENOMEM; 5249641b784SDavid Woodhouse memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len); 5259641b784SDavid Woodhouse } 5269641b784SDavid Woodhouse if (buf_len < sumlen) { 5279641b784SDavid Woodhouse /* Need to read more so that the entire summary node is present */ 5289641b784SDavid Woodhouse err = jffs2_fill_scan_buf(c, sumptr, 5299641b784SDavid Woodhouse jeb->offset + c->sector_size - sumlen, 5309641b784SDavid Woodhouse sumlen - buf_len); 5316a379f67SWenwen Wang if (err) { 5326a379f67SWenwen Wang if (sumlen > buf_size) 5336a379f67SWenwen Wang kfree(sumptr); 534e631ddbaSFerenc Havasi return err; 535e631ddbaSFerenc Havasi } 536e631ddbaSFerenc Havasi } 5376a379f67SWenwen Wang } 538e631ddbaSFerenc Havasi 5399641b784SDavid Woodhouse } 5409641b784SDavid Woodhouse 5419641b784SDavid Woodhouse if (sumptr) { 5429641b784SDavid Woodhouse err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random); 5433560160aSDavid Woodhouse 5449641b784SDavid Woodhouse if (buf_size && sumlen > buf_size) 5459641b784SDavid Woodhouse kfree(sumptr); 5463560160aSDavid Woodhouse /* If it returns with a real error, bail. 5473560160aSDavid Woodhouse If it returns positive, that's a block classification 5483560160aSDavid Woodhouse (i.e. BLK_STATE_xxx) so return that too. 5493560160aSDavid Woodhouse If it returns zero, fall through to full scan. */ 5503560160aSDavid Woodhouse if (err) 5513560160aSDavid Woodhouse return err; 5529641b784SDavid Woodhouse } 553e631ddbaSFerenc Havasi } 554e631ddbaSFerenc Havasi 555164c2406SChen Jie full_scan: 5561da177e4SLinus Torvalds buf_ofs = jeb->offset; 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds if (!buf_size) { 5599641b784SDavid Woodhouse /* This is the XIP case -- we're reading _directly_ from the flash chip */ 5601da177e4SLinus Torvalds buf_len = c->sector_size; 5611da177e4SLinus Torvalds } else { 5623be36675SAndrew Victor buf_len = EMPTY_SCAN_SIZE(c->sector_size); 5631da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len); 5641da177e4SLinus Torvalds if (err) 5651da177e4SLinus Torvalds return err; 5661da177e4SLinus Torvalds } 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 5691da177e4SLinus Torvalds ofs = 0; 57041bdc602SJoakim Tjernlund max_ofs = EMPTY_SCAN_SIZE(c->sector_size); 57141bdc602SJoakim Tjernlund /* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */ 57241bdc602SJoakim Tjernlund while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF) 5731da177e4SLinus Torvalds ofs += 4; 5741da177e4SLinus Torvalds 57541bdc602SJoakim Tjernlund if (ofs == max_ofs) { 5762f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 5771da177e4SLinus Torvalds if (jffs2_cleanmarker_oob(c)) { 5781da177e4SLinus Torvalds /* scan oob, take care of cleanmarker */ 5791da177e4SLinus Torvalds int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 5809c261b33SJoe Perches jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n", 5819c261b33SJoe Perches ret); 5821da177e4SLinus Torvalds switch (ret) { 5831da177e4SLinus Torvalds case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 5841da177e4SLinus Torvalds case 1: return BLK_STATE_ALLDIRTY; 5851da177e4SLinus Torvalds default: return ret; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds #endif 5899c261b33SJoe Perches jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n", 5909c261b33SJoe Perches jeb->offset); 5918f15fd55SAndrew Victor if (c->cleanmarker_size == 0) 5928f15fd55SAndrew Victor return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */ 5938f15fd55SAndrew Victor else 5941da177e4SLinus Torvalds return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds if (ofs) { 5979c261b33SJoe Perches jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset, 5989c261b33SJoe Perches jeb->offset + ofs); 599a6a8bef7SDavid Woodhouse if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1))) 600a6a8bef7SDavid Woodhouse return err; 60168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs))) 60268270995SDavid Woodhouse return err; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds /* Now ofs is a complete physical flash offset as it always was... */ 6061da177e4SLinus Torvalds ofs += jeb->offset; 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds noise = 10; 6091da177e4SLinus Torvalds 610733802d9SArtem B. Bityutskiy dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset); 611e631ddbaSFerenc Havasi 6121da177e4SLinus Torvalds scan_more: 6131da177e4SLinus Torvalds while(ofs < jeb->offset + c->sector_size) { 6141da177e4SLinus Torvalds 615e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 6161da177e4SLinus Torvalds 6172f785402SDavid Woodhouse /* Make sure there are node refs available for use */ 618046b8b98SDavid Woodhouse err = jffs2_prealloc_raw_node_refs(c, jeb, 2); 6192f785402SDavid Woodhouse if (err) 6202f785402SDavid Woodhouse return err; 6212f785402SDavid Woodhouse 6221da177e4SLinus Torvalds cond_resched(); 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds if (ofs & 3) { 625da320f05SJoe Perches pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs); 6261da177e4SLinus Torvalds ofs = PAD(ofs); 6271da177e4SLinus Torvalds continue; 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds if (ofs == prevofs) { 630da320f05SJoe Perches pr_warn("ofs 0x%08x has already been seen. Skipping\n", 631da320f05SJoe Perches ofs); 63268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 63368270995SDavid Woodhouse return err; 6341da177e4SLinus Torvalds ofs += 4; 6351da177e4SLinus Torvalds continue; 6361da177e4SLinus Torvalds } 6371da177e4SLinus Torvalds prevofs = ofs; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 6409c261b33SJoe Perches jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n", 6419c261b33SJoe Perches sizeof(struct jffs2_unknown_node), 6429c261b33SJoe Perches jeb->offset, c->sector_size, ofs, 6439c261b33SJoe Perches sizeof(*node)); 64468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs))) 64568270995SDavid Woodhouse return err; 6461da177e4SLinus Torvalds break; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(*node)) { 6501da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 6519c261b33SJoe Perches jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 6529c261b33SJoe Perches sizeof(struct jffs2_unknown_node), 6539c261b33SJoe Perches buf_len, ofs); 6541da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 6551da177e4SLinus Torvalds if (err) 6561da177e4SLinus Torvalds return err; 6571da177e4SLinus Torvalds buf_ofs = ofs; 6581da177e4SLinus Torvalds } 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs]; 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) { 6631da177e4SLinus Torvalds uint32_t inbuf_ofs; 664c2aecda7SJoakim Tjernlund uint32_t empty_start, scan_end; 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds empty_start = ofs; 6671da177e4SLinus Torvalds ofs += 4; 668c2aecda7SJoakim Tjernlund scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len); 6691da177e4SLinus Torvalds 6709c261b33SJoe Perches jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs); 6711da177e4SLinus Torvalds more_empty: 6721da177e4SLinus Torvalds inbuf_ofs = ofs - buf_ofs; 673c2aecda7SJoakim Tjernlund while (inbuf_ofs < scan_end) { 674c2aecda7SJoakim Tjernlund if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) { 675da320f05SJoe Perches pr_warn("Empty flash at 0x%08x ends at 0x%08x\n", 6761da177e4SLinus Torvalds empty_start, ofs); 67768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start))) 67868270995SDavid Woodhouse return err; 6791da177e4SLinus Torvalds goto scan_more; 6801da177e4SLinus Torvalds } 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds inbuf_ofs+=4; 6831da177e4SLinus Torvalds ofs += 4; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds /* Ran off end. */ 6869c261b33SJoe Perches jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n", 6879c261b33SJoe Perches ofs); 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds /* If we're only checking the beginning of a block with a cleanmarker, 6901da177e4SLinus Torvalds bail now */ 6911da177e4SLinus Torvalds if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 69299988f7bSDavid Woodhouse c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) { 6939c261b33SJoe Perches jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n", 6949c261b33SJoe Perches EMPTY_SCAN_SIZE(c->sector_size)); 6951da177e4SLinus Torvalds return BLK_STATE_CLEANMARKER; 6961da177e4SLinus Torvalds } 697c2aecda7SJoakim Tjernlund if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */ 698c2aecda7SJoakim Tjernlund scan_end = buf_len; 699c2aecda7SJoakim Tjernlund goto more_empty; 700c2aecda7SJoakim Tjernlund } 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds /* See how much more there is to read in this eraseblock... */ 7031da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 7041da177e4SLinus Torvalds if (!buf_len) { 7051da177e4SLinus Torvalds /* No more to read. Break out of main loop without marking 7061da177e4SLinus Torvalds this range of empty space as dirty (because it's not) */ 7079c261b33SJoe Perches jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n", 7089c261b33SJoe Perches empty_start); 7091da177e4SLinus Torvalds break; 7101da177e4SLinus Torvalds } 711c2aecda7SJoakim Tjernlund /* point never reaches here */ 712c2aecda7SJoakim Tjernlund scan_end = buf_len; 7139c261b33SJoe Perches jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n", 7149c261b33SJoe Perches buf_len, ofs); 7151da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 7161da177e4SLinus Torvalds if (err) 7171da177e4SLinus Torvalds return err; 7181da177e4SLinus Torvalds buf_ofs = ofs; 7191da177e4SLinus Torvalds goto more_empty; 7201da177e4SLinus Torvalds } 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 723da320f05SJoe Perches pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", 724da320f05SJoe Perches ofs); 72568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 72668270995SDavid Woodhouse return err; 7271da177e4SLinus Torvalds ofs += 4; 7281da177e4SLinus Torvalds continue; 7291da177e4SLinus Torvalds } 7301da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 7319c261b33SJoe Perches jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs); 73268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 73368270995SDavid Woodhouse return err; 7341da177e4SLinus Torvalds ofs += 4; 7351da177e4SLinus Torvalds continue; 7361da177e4SLinus Torvalds } 7371da177e4SLinus Torvalds if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 738da320f05SJoe Perches pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs); 739da320f05SJoe Perches pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n"); 74068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 74168270995SDavid Woodhouse return err; 7421da177e4SLinus Torvalds ofs += 4; 7431da177e4SLinus Torvalds continue; 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 7461da177e4SLinus Torvalds /* OK. We're out of possibilities. Whinge and move on */ 747da320f05SJoe Perches noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 748da320f05SJoe Perches __func__, 7491da177e4SLinus Torvalds JFFS2_MAGIC_BITMASK, ofs, 7501da177e4SLinus Torvalds je16_to_cpu(node->magic)); 75168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 75268270995SDavid Woodhouse return err; 7531da177e4SLinus Torvalds ofs += 4; 7541da177e4SLinus Torvalds continue; 7551da177e4SLinus Torvalds } 7561da177e4SLinus Torvalds /* We seem to have a node of sorts. Check the CRC */ 7571da177e4SLinus Torvalds crcnode.magic = node->magic; 7581da177e4SLinus Torvalds crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE); 7591da177e4SLinus Torvalds crcnode.totlen = node->totlen; 7601da177e4SLinus Torvalds hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 763da320f05SJoe Perches noisy_printk(&noise, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n", 764da320f05SJoe Perches __func__, 7651da177e4SLinus Torvalds ofs, je16_to_cpu(node->magic), 7661da177e4SLinus Torvalds je16_to_cpu(node->nodetype), 7671da177e4SLinus Torvalds je32_to_cpu(node->totlen), 7681da177e4SLinus Torvalds je32_to_cpu(node->hdr_crc), 7691da177e4SLinus Torvalds hdr_crc); 77068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 77168270995SDavid Woodhouse return err; 7721da177e4SLinus Torvalds ofs += 4; 7731da177e4SLinus Torvalds continue; 7741da177e4SLinus Torvalds } 7751da177e4SLinus Torvalds 7760dec4c8bSJoakim Tjernlund if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) { 7771da177e4SLinus Torvalds /* Eep. Node goes over the end of the erase block. */ 778da320f05SJoe Perches pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 7791da177e4SLinus Torvalds ofs, je32_to_cpu(node->totlen)); 780da320f05SJoe Perches pr_warn("Perhaps the file system was created with the wrong erase size?\n"); 78168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 78268270995SDavid Woodhouse return err; 7831da177e4SLinus Torvalds ofs += 4; 7841da177e4SLinus Torvalds continue; 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 7881da177e4SLinus Torvalds /* Wheee. This is an obsoleted node */ 7899c261b33SJoe Perches jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n", 7909c261b33SJoe Perches ofs); 79168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 79268270995SDavid Woodhouse return err; 7931da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 7941da177e4SLinus Torvalds continue; 7951da177e4SLinus Torvalds } 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds switch(je16_to_cpu(node->nodetype)) { 7981da177e4SLinus Torvalds case JFFS2_NODETYPE_INODE: 7991da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 8001da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8019c261b33SJoe Perches jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 8029c261b33SJoe Perches sizeof(struct jffs2_raw_inode), 8039c261b33SJoe Perches buf_len, ofs); 8041da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 8051da177e4SLinus Torvalds if (err) 8061da177e4SLinus Torvalds return err; 8071da177e4SLinus Torvalds buf_ofs = ofs; 8081da177e4SLinus Torvalds node = (void *)buf; 8091da177e4SLinus Torvalds } 810e631ddbaSFerenc Havasi err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s); 8111da177e4SLinus Torvalds if (err) return err; 8121da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8131da177e4SLinus Torvalds break; 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds case JFFS2_NODETYPE_DIRENT: 8161da177e4SLinus Torvalds if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 8171da177e4SLinus Torvalds buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8189c261b33SJoe Perches jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 8199c261b33SJoe Perches je32_to_cpu(node->totlen), buf_len, 8209c261b33SJoe Perches ofs); 8211da177e4SLinus Torvalds err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 8221da177e4SLinus Torvalds if (err) 8231da177e4SLinus Torvalds return err; 8241da177e4SLinus Torvalds buf_ofs = ofs; 8251da177e4SLinus Torvalds node = (void *)buf; 8261da177e4SLinus Torvalds } 827e631ddbaSFerenc Havasi err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s); 8281da177e4SLinus Torvalds if (err) return err; 8291da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8301da177e4SLinus Torvalds break; 8311da177e4SLinus Torvalds 832aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 833aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XATTR: 834aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 835aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8369c261b33SJoe Perches jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n", 8379c261b33SJoe Perches je32_to_cpu(node->totlen), buf_len, 8389c261b33SJoe Perches ofs); 839aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 840aa98d7cfSKaiGai Kohei if (err) 841aa98d7cfSKaiGai Kohei return err; 842aa98d7cfSKaiGai Kohei buf_ofs = ofs; 843aa98d7cfSKaiGai Kohei node = (void *)buf; 844aa98d7cfSKaiGai Kohei } 845aa98d7cfSKaiGai Kohei err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s); 846aa98d7cfSKaiGai Kohei if (err) 847aa98d7cfSKaiGai Kohei return err; 848aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 849aa98d7cfSKaiGai Kohei break; 850aa98d7cfSKaiGai Kohei case JFFS2_NODETYPE_XREF: 851aa98d7cfSKaiGai Kohei if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 852aa98d7cfSKaiGai Kohei buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 8539c261b33SJoe Perches jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n", 8549c261b33SJoe Perches je32_to_cpu(node->totlen), buf_len, 8559c261b33SJoe Perches ofs); 856aa98d7cfSKaiGai Kohei err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 857aa98d7cfSKaiGai Kohei if (err) 858aa98d7cfSKaiGai Kohei return err; 859aa98d7cfSKaiGai Kohei buf_ofs = ofs; 860aa98d7cfSKaiGai Kohei node = (void *)buf; 861aa98d7cfSKaiGai Kohei } 862aa98d7cfSKaiGai Kohei err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s); 863aa98d7cfSKaiGai Kohei if (err) 864aa98d7cfSKaiGai Kohei return err; 865aa98d7cfSKaiGai Kohei ofs += PAD(je32_to_cpu(node->totlen)); 866aa98d7cfSKaiGai Kohei break; 867aa98d7cfSKaiGai Kohei #endif /* CONFIG_JFFS2_FS_XATTR */ 868aa98d7cfSKaiGai Kohei 8691da177e4SLinus Torvalds case JFFS2_NODETYPE_CLEANMARKER: 8709c261b33SJoe Perches jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs); 8711da177e4SLinus Torvalds if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 872da320f05SJoe Perches pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 873da320f05SJoe Perches ofs, je32_to_cpu(node->totlen), 874da320f05SJoe Perches c->cleanmarker_size); 87568270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 87668270995SDavid Woodhouse return err; 8771da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8781da177e4SLinus Torvalds } else if (jeb->first_node) { 879da320f05SJoe Perches pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", 880da320f05SJoe Perches ofs, jeb->offset); 88168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 88268270995SDavid Woodhouse return err; 8831da177e4SLinus Torvalds ofs += PAD(sizeof(struct jffs2_unknown_node)); 8841da177e4SLinus Torvalds } else { 8852f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL); 886f1f9671bSDavid Woodhouse 8871da177e4SLinus Torvalds ofs += PAD(c->cleanmarker_size); 8881da177e4SLinus Torvalds } 8891da177e4SLinus Torvalds break; 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds case JFFS2_NODETYPE_PADDING: 892e631ddbaSFerenc Havasi if (jffs2_sum_active()) 893e631ddbaSFerenc Havasi jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen)); 89468270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 89568270995SDavid Woodhouse return err; 8961da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 8971da177e4SLinus Torvalds break; 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds default: 9001da177e4SLinus Torvalds switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 9011da177e4SLinus Torvalds case JFFS2_FEATURE_ROCOMPAT: 902da320f05SJoe Perches pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", 903da320f05SJoe Perches je16_to_cpu(node->nodetype), ofs); 9041da177e4SLinus Torvalds c->flags |= JFFS2_SB_FLAG_RO; 9051da177e4SLinus Torvalds if (!(jffs2_is_readonly(c))) 9061da177e4SLinus Torvalds return -EROFS; 90768270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 90868270995SDavid Woodhouse return err; 9091da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 9101da177e4SLinus Torvalds break; 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds case JFFS2_FEATURE_INCOMPAT: 913da320f05SJoe Perches pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n", 914da320f05SJoe Perches je16_to_cpu(node->nodetype), ofs); 9151da177e4SLinus Torvalds return -EINVAL; 9161da177e4SLinus Torvalds 9171da177e4SLinus Torvalds case JFFS2_FEATURE_RWCOMPAT_DELETE: 9189c261b33SJoe Perches jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", 9199c261b33SJoe Perches je16_to_cpu(node->nodetype), ofs); 92068270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 92168270995SDavid Woodhouse return err; 9221da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 9231da177e4SLinus Torvalds break; 9241da177e4SLinus Torvalds 9256171586aSDavid Woodhouse case JFFS2_FEATURE_RWCOMPAT_COPY: { 9269c261b33SJoe Perches jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", 9279c261b33SJoe Perches je16_to_cpu(node->nodetype), ofs); 9286171586aSDavid Woodhouse 9292f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL); 9306171586aSDavid Woodhouse 9316171586aSDavid Woodhouse /* We can't summarise nodes we don't grok */ 9326171586aSDavid Woodhouse jffs2_sum_disable_collecting(s); 9331da177e4SLinus Torvalds ofs += PAD(je32_to_cpu(node->totlen)); 9341da177e4SLinus Torvalds break; 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds } 9386171586aSDavid Woodhouse } 9391da177e4SLinus Torvalds 940e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 941e631ddbaSFerenc Havasi if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) { 942733802d9SArtem B. Bityutskiy dbg_summary("There is not enough space for " 943e631ddbaSFerenc Havasi "summary information, disabling for this jeb!\n"); 944e631ddbaSFerenc Havasi jffs2_sum_disable_collecting(s); 945e631ddbaSFerenc Havasi } 946e631ddbaSFerenc Havasi } 9471da177e4SLinus Torvalds 9489c261b33SJoe Perches jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n", 9499c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 9509c261b33SJoe Perches jeb->unchecked_size, jeb->used_size, jeb->wasted_size); 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds /* mark_node_obsolete can add to wasted !! */ 9531da177e4SLinus Torvalds if (jeb->wasted_size) { 9541da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 9551da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 9561da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 9571da177e4SLinus Torvalds jeb->wasted_size = 0; 9581da177e4SLinus Torvalds } 9591da177e4SLinus Torvalds 960e631ddbaSFerenc Havasi return jffs2_scan_classify_jeb(c, jeb); 9611da177e4SLinus Torvalds } 9621da177e4SLinus Torvalds 963e631ddbaSFerenc Havasi struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino) 9641da177e4SLinus Torvalds { 9651da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 9681da177e4SLinus Torvalds if (ic) 9691da177e4SLinus Torvalds return ic; 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds if (ino > c->highest_ino) 9721da177e4SLinus Torvalds c->highest_ino = ino; 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 9751da177e4SLinus Torvalds if (!ic) { 976da320f05SJoe Perches pr_notice("%s(): allocation of inode cache failed\n", __func__); 9771da177e4SLinus Torvalds return NULL; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds ic->ino = ino; 9821da177e4SLinus Torvalds ic->nodes = (void *)ic; 9831da177e4SLinus Torvalds jffs2_add_ino_cache(c, ic); 9841da177e4SLinus Torvalds if (ino == 1) 98527c72b04SDavid Woodhouse ic->pino_nlink = 1; 9861da177e4SLinus Torvalds return ic; 9871da177e4SLinus Torvalds } 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 990e631ddbaSFerenc Havasi struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s) 9911da177e4SLinus Torvalds { 9921da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 99353043002SThomas Gleixner uint32_t crc, ino = je32_to_cpu(ri->ino); 9941da177e4SLinus Torvalds 9959c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds /* We do very little here now. Just check the ino# to which we should attribute 9981da177e4SLinus Torvalds this node; we can do all the CRC checking etc. later. There's a tradeoff here -- 9991da177e4SLinus Torvalds we used to scan the flash once only, reading everything we want from it into 10001da177e4SLinus Torvalds memory, then building all our in-core data structures and freeing the extra 10011da177e4SLinus Torvalds information. Now we allow the first part of the mount to complete a lot quicker, 10021da177e4SLinus Torvalds but we have to go _back_ to the flash in order to finish the CRC checking, etc. 10031da177e4SLinus Torvalds Which means that the _full_ amount of time to get to proper write mode with GC 10041da177e4SLinus Torvalds operational may actually be _longer_ than before. Sucks to be me. */ 10051da177e4SLinus Torvalds 100653043002SThomas Gleixner /* Check the node CRC in any case. */ 100753043002SThomas Gleixner crc = crc32(0, ri, sizeof(*ri)-8); 100853043002SThomas Gleixner if (crc != je32_to_cpu(ri->node_crc)) { 1009da320f05SJoe Perches pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1010da320f05SJoe Perches __func__, ofs, je32_to_cpu(ri->node_crc), crc); 101153043002SThomas Gleixner /* 101253043002SThomas Gleixner * We believe totlen because the CRC on the node 101353043002SThomas Gleixner * _header_ was OK, just the node itself failed. 101453043002SThomas Gleixner */ 101553043002SThomas Gleixner return jffs2_scan_dirty_space(c, jeb, 101653043002SThomas Gleixner PAD(je32_to_cpu(ri->totlen))); 101753043002SThomas Gleixner } 101853043002SThomas Gleixner 10191da177e4SLinus Torvalds ic = jffs2_get_ino_cache(c, ino); 10201da177e4SLinus Torvalds if (!ic) { 10211da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, ino); 10222f785402SDavid Woodhouse if (!ic) 10231da177e4SLinus Torvalds return -ENOMEM; 10241da177e4SLinus Torvalds } 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds /* Wheee. It worked */ 10272f785402SDavid Woodhouse jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic); 10281da177e4SLinus Torvalds 10299c261b33SJoe Perches jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 10301da177e4SLinus Torvalds je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 10311da177e4SLinus Torvalds je32_to_cpu(ri->offset), 10329c261b33SJoe Perches je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize)); 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds pseudo_random += je32_to_cpu(ri->version); 10351da177e4SLinus Torvalds 1036e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1037e631ddbaSFerenc Havasi jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset); 1038e631ddbaSFerenc Havasi } 1039e631ddbaSFerenc Havasi 10401da177e4SLinus Torvalds return 0; 10411da177e4SLinus Torvalds } 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, 1044e631ddbaSFerenc Havasi struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s) 10451da177e4SLinus Torvalds { 10461da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 10471da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 1048b534e70cSDavid Woodhouse uint32_t checkedlen; 10491da177e4SLinus Torvalds uint32_t crc; 105068270995SDavid Woodhouse int err; 10511da177e4SLinus Torvalds 10529c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs); 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds /* We don't get here unless the node is still valid, so we don't have to 10551da177e4SLinus Torvalds mask in the ACCURATE bit any more. */ 10561da177e4SLinus Torvalds crc = crc32(0, rd, sizeof(*rd)-8); 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->node_crc)) { 1059da320f05SJoe Perches pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1060da320f05SJoe Perches __func__, ofs, je32_to_cpu(rd->node_crc), crc); 10611da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 106268270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 106368270995SDavid Woodhouse return err; 10641da177e4SLinus Torvalds return 0; 10651da177e4SLinus Torvalds } 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds pseudo_random += je32_to_cpu(rd->version); 10681da177e4SLinus Torvalds 1069b534e70cSDavid Woodhouse /* Should never happen. Did. (OLPC trac #4184)*/ 1070b534e70cSDavid Woodhouse checkedlen = strnlen(rd->name, rd->nsize); 1071b534e70cSDavid Woodhouse if (checkedlen < rd->nsize) { 1072da320f05SJoe Perches pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n", 1073b534e70cSDavid Woodhouse ofs, checkedlen); 1074b534e70cSDavid Woodhouse } 1075b534e70cSDavid Woodhouse fd = jffs2_alloc_full_dirent(checkedlen+1); 10761da177e4SLinus Torvalds if (!fd) { 10771da177e4SLinus Torvalds return -ENOMEM; 10781da177e4SLinus Torvalds } 1079b534e70cSDavid Woodhouse memcpy(&fd->name, rd->name, checkedlen); 1080b534e70cSDavid Woodhouse fd->name[checkedlen] = 0; 10811da177e4SLinus Torvalds 10821da177e4SLinus Torvalds crc = crc32(0, fd->name, rd->nsize); 10831da177e4SLinus Torvalds if (crc != je32_to_cpu(rd->name_crc)) { 1084da320f05SJoe Perches pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1085da320f05SJoe Perches __func__, ofs, je32_to_cpu(rd->name_crc), crc); 10869c261b33SJoe Perches jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n", 10879c261b33SJoe Perches fd->name, je32_to_cpu(rd->ino)); 10881da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10891da177e4SLinus Torvalds /* FIXME: Why do we believe totlen? */ 10901da177e4SLinus Torvalds /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */ 109168270995SDavid Woodhouse if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 109268270995SDavid Woodhouse return err; 10931da177e4SLinus Torvalds return 0; 10941da177e4SLinus Torvalds } 10951da177e4SLinus Torvalds ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino)); 10961da177e4SLinus Torvalds if (!ic) { 10971da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 10981da177e4SLinus Torvalds return -ENOMEM; 10991da177e4SLinus Torvalds } 11001da177e4SLinus Torvalds 110143dfa07fSDavid Woodhouse fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd), 110243dfa07fSDavid Woodhouse PAD(je32_to_cpu(rd->totlen)), ic); 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds fd->next = NULL; 11051da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 11061da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 11078387ff25SLinus Torvalds fd->nhash = full_name_hash(NULL, fd->name, checkedlen); 11081da177e4SLinus Torvalds fd->type = rd->type; 11091da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &ic->scan_dents); 11101da177e4SLinus Torvalds 1111e631ddbaSFerenc Havasi if (jffs2_sum_active()) { 1112e631ddbaSFerenc Havasi jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset); 1113e631ddbaSFerenc Havasi } 1114e631ddbaSFerenc Havasi 11151da177e4SLinus Torvalds return 0; 11161da177e4SLinus Torvalds } 11171da177e4SLinus Torvalds 11181da177e4SLinus Torvalds static int count_list(struct list_head *l) 11191da177e4SLinus Torvalds { 11201da177e4SLinus Torvalds uint32_t count = 0; 11211da177e4SLinus Torvalds struct list_head *tmp; 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds list_for_each(tmp, l) { 11241da177e4SLinus Torvalds count++; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds return count; 11271da177e4SLinus Torvalds } 11281da177e4SLinus Torvalds 11291da177e4SLinus Torvalds /* Note: This breaks if list_empty(head). I don't care. You 11301da177e4SLinus Torvalds might, if you copy this code and use it elsewhere :) */ 11311da177e4SLinus Torvalds static void rotate_list(struct list_head *head, uint32_t count) 11321da177e4SLinus Torvalds { 11331da177e4SLinus Torvalds struct list_head *n = head->next; 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds list_del(head); 11361da177e4SLinus Torvalds while(count--) { 11371da177e4SLinus Torvalds n = n->next; 11381da177e4SLinus Torvalds } 11391da177e4SLinus Torvalds list_add(head, n); 11401da177e4SLinus Torvalds } 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c) 11431da177e4SLinus Torvalds { 11441da177e4SLinus Torvalds uint32_t x; 11451da177e4SLinus Torvalds uint32_t rotateby; 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds x = count_list(&c->clean_list); 11481da177e4SLinus Torvalds if (x) { 11491da177e4SLinus Torvalds rotateby = pseudo_random % x; 11501da177e4SLinus Torvalds rotate_list((&c->clean_list), rotateby); 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds x = count_list(&c->very_dirty_list); 11541da177e4SLinus Torvalds if (x) { 11551da177e4SLinus Torvalds rotateby = pseudo_random % x; 11561da177e4SLinus Torvalds rotate_list((&c->very_dirty_list), rotateby); 11571da177e4SLinus Torvalds } 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds x = count_list(&c->dirty_list); 11601da177e4SLinus Torvalds if (x) { 11611da177e4SLinus Torvalds rotateby = pseudo_random % x; 11621da177e4SLinus Torvalds rotate_list((&c->dirty_list), rotateby); 11631da177e4SLinus Torvalds } 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds x = count_list(&c->erasable_list); 11661da177e4SLinus Torvalds if (x) { 11671da177e4SLinus Torvalds rotateby = pseudo_random % x; 11681da177e4SLinus Torvalds rotate_list((&c->erasable_list), rotateby); 11691da177e4SLinus Torvalds } 11701da177e4SLinus Torvalds 11711da177e4SLinus Torvalds if (c->nr_erasing_blocks) { 11721da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_erasing_blocks; 11731da177e4SLinus Torvalds rotate_list((&c->erase_pending_list), rotateby); 11741da177e4SLinus Torvalds } 11751da177e4SLinus Torvalds 11761da177e4SLinus Torvalds if (c->nr_free_blocks) { 11771da177e4SLinus Torvalds rotateby = pseudo_random % c->nr_free_blocks; 11781da177e4SLinus Torvalds rotate_list((&c->free_list), rotateby); 11791da177e4SLinus Torvalds } 11801da177e4SLinus Torvalds } 1181