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 */ 111da177e4SLinus Torvalds 125a528957SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 135a528957SJoe Perches 141da177e4SLinus Torvalds #include <linux/kernel.h> 151da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 161da177e4SLinus Torvalds #include <linux/compiler.h> 171da177e4SLinus Torvalds #include <linux/sched.h> /* For cond_resched() */ 181da177e4SLinus Torvalds #include "nodelist.h" 19e631ddbaSFerenc Havasi #include "debug.h" 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds /** 221da177e4SLinus Torvalds * jffs2_reserve_space - request physical space to write nodes to flash 231da177e4SLinus Torvalds * @c: superblock info 241da177e4SLinus Torvalds * @minsize: Minimum acceptable size of allocation 251da177e4SLinus Torvalds * @len: Returned value of allocation length 261da177e4SLinus Torvalds * @prio: Allocation type - ALLOC_{NORMAL,DELETION} 271da177e4SLinus Torvalds * 281da177e4SLinus Torvalds * Requests a block of physical space on the flash. Returns zero for success 299fe4854cSDavid Woodhouse * and puts 'len' into the appropriate place, or returns -ENOSPC or other 309fe4854cSDavid Woodhouse * error if appropriate. Doesn't return len since that's 311da177e4SLinus Torvalds * 321da177e4SLinus Torvalds * If it returns zero, jffs2_reserve_space() also downs the per-filesystem 331da177e4SLinus Torvalds * allocation semaphore, to prevent more than one allocation from being 341da177e4SLinus Torvalds * active at any time. The semaphore is later released by jffs2_commit_allocation() 351da177e4SLinus Torvalds * 361da177e4SLinus Torvalds * jffs2_reserve_space() may trigger garbage collection in order to make room 371da177e4SLinus Torvalds * for the requested allocation. 381da177e4SLinus Torvalds */ 391da177e4SLinus Torvalds 40e631ddbaSFerenc Havasi static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 419fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize); 421da177e4SLinus Torvalds 439fe4854cSDavid Woodhouse int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 44e631ddbaSFerenc Havasi uint32_t *len, int prio, uint32_t sumsize) 451da177e4SLinus Torvalds { 461da177e4SLinus Torvalds int ret = -EAGAIN; 471da177e4SLinus Torvalds int blocksneeded = c->resv_blocks_write; 481da177e4SLinus Torvalds /* align it */ 491da177e4SLinus Torvalds minsize = PAD(minsize); 501da177e4SLinus Torvalds 519c261b33SJoe Perches jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 52ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 531da177e4SLinus Torvalds 549c261b33SJoe Perches jffs2_dbg(1, "%s(): alloc sem got\n", __func__); 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds /* this needs a little more thought (true <tglx> :)) */ 591da177e4SLinus Torvalds while(ret == -EAGAIN) { 601da177e4SLinus Torvalds while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) { 611da177e4SLinus Torvalds uint32_t dirty, avail; 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* calculate real dirty size 641da177e4SLinus Torvalds * dirty_size contains blocks on erase_pending_list 651da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 661da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 671da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 681da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 691da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 701da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 711da177e4SLinus Torvalds * We add unchecked_size here, as we hopefully will find some space to use. 721da177e4SLinus Torvalds * This will affect the sum only once, as gc first finishes checking 731da177e4SLinus Torvalds * of nodes. 741da177e4SLinus Torvalds */ 751da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 761da177e4SLinus Torvalds if (dirty < c->nospc_dirty_size) { 771da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 789c261b33SJoe Perches jffs2_dbg(1, "%s(): Low on dirty space to GC, but it's a deletion. Allowing...\n", 799c261b33SJoe Perches __func__); 801da177e4SLinus Torvalds break; 811da177e4SLinus Torvalds } 829c261b33SJoe Perches jffs2_dbg(1, "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 839c261b33SJoe Perches dirty, c->unchecked_size, 849c261b33SJoe Perches c->sector_size); 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 87ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 881da177e4SLinus Torvalds return -ENOSPC; 891da177e4SLinus Torvalds } 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds /* Calc possibly available space. Possibly available means that we 921da177e4SLinus Torvalds * don't know, if unchecked size contains obsoleted nodes, which could give us some 931da177e4SLinus Torvalds * more usable space. This will affect the sum only once, as gc first finishes checking 941da177e4SLinus Torvalds * of nodes. 951da177e4SLinus Torvalds + Return -ENOSPC, if the maximum possibly available space is less or equal than 961da177e4SLinus Torvalds * blocksneeded * sector_size. 971da177e4SLinus Torvalds * This blocks endless gc looping on a filesystem, which is nearly full, even if 981da177e4SLinus Torvalds * the check above passes. 991da177e4SLinus Torvalds */ 1001da177e4SLinus Torvalds avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 1011da177e4SLinus Torvalds if ( (avail / c->sector_size) <= blocksneeded) { 1021da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 1039c261b33SJoe Perches jffs2_dbg(1, "%s(): Low on possibly available space, but it's a deletion. Allowing...\n", 1049c261b33SJoe Perches __func__); 1051da177e4SLinus Torvalds break; 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 1089c261b33SJoe Perches jffs2_dbg(1, "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 1099c261b33SJoe Perches avail, blocksneeded * c->sector_size); 1101da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 111ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1121da177e4SLinus Torvalds return -ENOSPC; 1131da177e4SLinus Torvalds } 1141da177e4SLinus Torvalds 115ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1161da177e4SLinus Torvalds 1179c261b33SJoe Perches jffs2_dbg(1, "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, wasted_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n", 1189c261b33SJoe Perches c->nr_free_blocks, c->nr_erasing_blocks, 1199c261b33SJoe Perches c->free_size, c->dirty_size, c->wasted_size, 1209c261b33SJoe Perches c->used_size, c->erasing_size, c->bad_size, 1219c261b33SJoe Perches c->free_size + c->dirty_size + 1229c261b33SJoe Perches c->wasted_size + c->used_size + 1239c261b33SJoe Perches c->erasing_size + c->bad_size, 1249c261b33SJoe Perches c->flash_size); 1251da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds ret = jffs2_garbage_collect_pass(c); 128422b1202SDavid Woodhouse 1290717bf84SDavid Woodhouse if (ret == -EAGAIN) { 1300717bf84SDavid Woodhouse spin_lock(&c->erase_completion_lock); 1310717bf84SDavid Woodhouse if (c->nr_erasing_blocks && 1320717bf84SDavid Woodhouse list_empty(&c->erase_pending_list) && 1330717bf84SDavid Woodhouse list_empty(&c->erase_complete_list)) { 1340717bf84SDavid Woodhouse DECLARE_WAITQUEUE(wait, current); 1350717bf84SDavid Woodhouse set_current_state(TASK_UNINTERRUPTIBLE); 1360717bf84SDavid Woodhouse add_wait_queue(&c->erase_wait, &wait); 1379c261b33SJoe Perches jffs2_dbg(1, "%s waiting for erase to complete\n", 1389c261b33SJoe Perches __func__); 1390717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1400717bf84SDavid Woodhouse 1410717bf84SDavid Woodhouse schedule(); 1420717bf84SDavid Woodhouse } else 1430717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1440717bf84SDavid Woodhouse } else if (ret) 1451da177e4SLinus Torvalds return ret; 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds cond_resched(); 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds if (signal_pending(current)) 1501da177e4SLinus Torvalds return -EINTR; 1511da177e4SLinus Torvalds 152ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 1531da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1541da177e4SLinus Torvalds } 1551da177e4SLinus Torvalds 1569fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1571da177e4SLinus Torvalds if (ret) { 1589c261b33SJoe Perches jffs2_dbg(1, "%s(): ret is %d\n", __func__, ret); 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds } 1611da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1622f785402SDavid Woodhouse if (!ret) 163046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 1641da177e4SLinus Torvalds if (ret) 165ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1661da177e4SLinus Torvalds return ret; 1671da177e4SLinus Torvalds } 1681da177e4SLinus Torvalds 1699fe4854cSDavid Woodhouse int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, 170e631ddbaSFerenc Havasi uint32_t *len, uint32_t sumsize) 1711da177e4SLinus Torvalds { 1721da177e4SLinus Torvalds int ret = -EAGAIN; 1731da177e4SLinus Torvalds minsize = PAD(minsize); 1741da177e4SLinus Torvalds 1759c261b33SJoe Perches jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1781da177e4SLinus Torvalds while(ret == -EAGAIN) { 1799fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1801da177e4SLinus Torvalds if (ret) { 1819c261b33SJoe Perches jffs2_dbg(1, "%s(): looping, ret is %d\n", 1829c261b33SJoe Perches __func__, ret); 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds } 1851da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1862f785402SDavid Woodhouse if (!ret) 187046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 1882f785402SDavid Woodhouse 1891da177e4SLinus Torvalds return ret; 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds 193e631ddbaSFerenc Havasi /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */ 194e631ddbaSFerenc Havasi 195e631ddbaSFerenc Havasi static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 196e631ddbaSFerenc Havasi { 1971da177e4SLinus Torvalds 19899c2594fSAdrian Hunter if (c->nextblock == NULL) { 1999c261b33SJoe Perches jffs2_dbg(1, "%s(): Erase block at 0x%08x has already been placed in a list\n", 2009c261b33SJoe Perches __func__, jeb->offset); 20199c2594fSAdrian Hunter return; 20299c2594fSAdrian Hunter } 2031da177e4SLinus Torvalds /* Check, if we have a dirty block now, or if it was dirty already */ 2041da177e4SLinus Torvalds if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) { 2051da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 2061da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 2071da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 2081da177e4SLinus Torvalds jeb->wasted_size = 0; 2091da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 2109c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2119c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2129c261b33SJoe Perches jeb->used_size); 2131da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 2141da177e4SLinus Torvalds } else { 2159c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2169c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2179c261b33SJoe Perches jeb->used_size); 2181da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 2191da177e4SLinus Torvalds } 2201da177e4SLinus Torvalds } else { 2219c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2229c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2239c261b33SJoe Perches jeb->used_size); 2241da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 2251da177e4SLinus Torvalds } 226e631ddbaSFerenc Havasi c->nextblock = NULL; 227e631ddbaSFerenc Havasi 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 230e631ddbaSFerenc Havasi /* Select a new jeb for nextblock */ 231e631ddbaSFerenc Havasi 232e631ddbaSFerenc Havasi static int jffs2_find_nextblock(struct jffs2_sb_info *c) 233e631ddbaSFerenc Havasi { 2341da177e4SLinus Torvalds struct list_head *next; 235e631ddbaSFerenc Havasi 2361da177e4SLinus Torvalds /* Take the next block off the 'free' list */ 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds if (list_empty(&c->free_list)) { 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2411da177e4SLinus Torvalds !list_empty(&c->erasable_list)) { 2421da177e4SLinus Torvalds struct jffs2_eraseblock *ejeb; 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list); 245f116629dSAkinobu Mita list_move_tail(&ejeb->list, &c->erase_pending_list); 2461da177e4SLinus Torvalds c->nr_erasing_blocks++; 247ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 2489c261b33SJoe Perches jffs2_dbg(1, "%s(): Triggering erase of erasable block at 0x%08x\n", 2499c261b33SJoe Perches __func__, ejeb->offset); 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2531da177e4SLinus Torvalds !list_empty(&c->erasable_pending_wbuf_list)) { 2549c261b33SJoe Perches jffs2_dbg(1, "%s(): Flushing write buffer\n", 2559c261b33SJoe Perches __func__); 2561da177e4SLinus Torvalds /* c->nextblock is NULL, no update to c->nextblock allowed */ 2571da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2581da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 2591da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2601da177e4SLinus Torvalds /* Have another go. It'll be on the erasable_list now */ 2611da177e4SLinus Torvalds return -EAGAIN; 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds if (!c->nr_erasing_blocks) { 2651da177e4SLinus Torvalds /* Ouch. We're in GC, or we wouldn't have got here. 2661da177e4SLinus Torvalds And there's no space left. At all. */ 267da320f05SJoe Perches pr_crit("Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n", 268da320f05SJoe Perches c->nr_erasing_blocks, c->nr_free_blocks, 269da320f05SJoe Perches list_empty(&c->erasable_list) ? "yes" : "no", 270da320f05SJoe Perches list_empty(&c->erasing_list) ? "yes" : "no", 271da320f05SJoe Perches list_empty(&c->erase_pending_list) ? "yes" : "no"); 2721da177e4SLinus Torvalds return -ENOSPC; 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2761da177e4SLinus Torvalds /* Don't wait for it; just erase one right now */ 2771da177e4SLinus Torvalds jffs2_erase_pending_blocks(c, 1); 2781da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds /* An erase may have failed, decreasing the 2811da177e4SLinus Torvalds amount of free space available. So we must 2821da177e4SLinus Torvalds restart from the beginning */ 2831da177e4SLinus Torvalds return -EAGAIN; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds next = c->free_list.next; 2871da177e4SLinus Torvalds list_del(next); 288e631ddbaSFerenc Havasi c->nextblock = list_entry(next, struct jffs2_eraseblock, list); 2891da177e4SLinus Torvalds c->nr_free_blocks--; 2901da177e4SLinus Torvalds 291e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); /* reset collected summary */ 292e631ddbaSFerenc Havasi 293f04de505SSteve Glendinning #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 2945bf17237SAlexander Belyakov /* adjust write buffer offset, else we get a non contiguous write bug */ 2955bf17237SAlexander Belyakov if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len) 2965bf17237SAlexander Belyakov c->wbuf_ofs = 0xffffffff; 297f04de505SSteve Glendinning #endif 2985bf17237SAlexander Belyakov 2999c261b33SJoe Perches jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 3009c261b33SJoe Perches __func__, c->nextblock->offset); 301e631ddbaSFerenc Havasi 302e631ddbaSFerenc Havasi return 0; 303e631ddbaSFerenc Havasi } 304e631ddbaSFerenc Havasi 305e631ddbaSFerenc Havasi /* Called with alloc sem _and_ erase_completion_lock */ 3069fe4854cSDavid Woodhouse static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 3079fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize) 308e631ddbaSFerenc Havasi { 309e631ddbaSFerenc Havasi struct jffs2_eraseblock *jeb = c->nextblock; 310e631ddbaSFerenc Havasi uint32_t reserved_size; /* for summary information at the end of the jeb */ 311e631ddbaSFerenc Havasi int ret; 312e631ddbaSFerenc Havasi 313e631ddbaSFerenc Havasi restart: 314e631ddbaSFerenc Havasi reserved_size = 0; 315e631ddbaSFerenc Havasi 316e631ddbaSFerenc Havasi if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) { 317e631ddbaSFerenc Havasi /* NOSUM_SIZE means not to generate summary */ 318e631ddbaSFerenc Havasi 319e631ddbaSFerenc Havasi if (jeb) { 320e631ddbaSFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 321733802d9SArtem B. Bityutskiy dbg_summary("minsize=%d , jeb->free=%d ," 322e631ddbaSFerenc Havasi "summary->size=%d , sumsize=%d\n", 323e631ddbaSFerenc Havasi minsize, jeb->free_size, 324e631ddbaSFerenc Havasi c->summary->sum_size, sumsize); 325e631ddbaSFerenc Havasi } 326e631ddbaSFerenc Havasi 327e631ddbaSFerenc Havasi /* Is there enough space for writing out the current node, or we have to 328e631ddbaSFerenc Havasi write out summary information now, close this jeb and select new nextblock? */ 329e631ddbaSFerenc Havasi if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize + 330e631ddbaSFerenc Havasi JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) { 331e631ddbaSFerenc Havasi 332e631ddbaSFerenc Havasi /* Has summary been disabled for this jeb? */ 333e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 334e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 335e631ddbaSFerenc Havasi goto restart; 336e631ddbaSFerenc Havasi } 337e631ddbaSFerenc Havasi 338e631ddbaSFerenc Havasi /* Writing out the collected summary information */ 339733802d9SArtem B. Bityutskiy dbg_summary("generating summary for 0x%08x.\n", jeb->offset); 340e631ddbaSFerenc Havasi ret = jffs2_sum_write_sumnode(c); 341e631ddbaSFerenc Havasi 342e631ddbaSFerenc Havasi if (ret) 343e631ddbaSFerenc Havasi return ret; 344e631ddbaSFerenc Havasi 345e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 346e631ddbaSFerenc Havasi /* jffs2_write_sumnode() couldn't write out the summary information 347e631ddbaSFerenc Havasi diabling summary for this jeb and free the collected information 348e631ddbaSFerenc Havasi */ 349e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 350e631ddbaSFerenc Havasi goto restart; 351e631ddbaSFerenc Havasi } 352e631ddbaSFerenc Havasi 353e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 354e631ddbaSFerenc Havasi jeb = NULL; 35534c0e906SFerenc Havasi /* keep always valid value in reserved_size */ 35634c0e906SFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 357e631ddbaSFerenc Havasi } 358e631ddbaSFerenc Havasi } else { 359e631ddbaSFerenc Havasi if (jeb && minsize > jeb->free_size) { 360fc6612f6SDavid Woodhouse uint32_t waste; 361fc6612f6SDavid Woodhouse 362e631ddbaSFerenc Havasi /* Skip the end of this block and file it as having some dirty space */ 363e631ddbaSFerenc Havasi /* If there's a pending write to it, flush now */ 364e631ddbaSFerenc Havasi 365e631ddbaSFerenc Havasi if (jffs2_wbuf_dirty(c)) { 366e631ddbaSFerenc Havasi spin_unlock(&c->erase_completion_lock); 3679c261b33SJoe Perches jffs2_dbg(1, "%s(): Flushing write buffer\n", 3689c261b33SJoe Perches __func__); 369e631ddbaSFerenc Havasi jffs2_flush_wbuf_pad(c); 370e631ddbaSFerenc Havasi spin_lock(&c->erase_completion_lock); 371e631ddbaSFerenc Havasi jeb = c->nextblock; 372e631ddbaSFerenc Havasi goto restart; 373e631ddbaSFerenc Havasi } 374e631ddbaSFerenc Havasi 375fc6612f6SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 376fc6612f6SDavid Woodhouse 377fc6612f6SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, jeb, 1); 378fc6612f6SDavid Woodhouse if (ret) 379fc6612f6SDavid Woodhouse return ret; 380fc6612f6SDavid Woodhouse /* Just lock it again and continue. Nothing much can change because 381fc6612f6SDavid Woodhouse we hold c->alloc_sem anyway. In fact, it's not entirely clear why 382fc6612f6SDavid Woodhouse we hold c->erase_completion_lock in the majority of this function... 383fc6612f6SDavid Woodhouse but that's a question for another (more caffeine-rich) day. */ 384fc6612f6SDavid Woodhouse spin_lock(&c->erase_completion_lock); 385fc6612f6SDavid Woodhouse 386fc6612f6SDavid Woodhouse waste = jeb->free_size; 387fc6612f6SDavid Woodhouse jffs2_link_node_ref(c, jeb, 388fc6612f6SDavid Woodhouse (jeb->offset + c->sector_size - waste) | REF_OBSOLETE, 389fc6612f6SDavid Woodhouse waste, NULL); 390fc6612f6SDavid Woodhouse /* FIXME: that made it count as dirty. Convert to wasted */ 391fc6612f6SDavid Woodhouse jeb->dirty_size -= waste; 392fc6612f6SDavid Woodhouse c->dirty_size -= waste; 393fc6612f6SDavid Woodhouse jeb->wasted_size += waste; 394fc6612f6SDavid Woodhouse c->wasted_size += waste; 395e631ddbaSFerenc Havasi 396e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 397e631ddbaSFerenc Havasi jeb = NULL; 398e631ddbaSFerenc Havasi } 399e631ddbaSFerenc Havasi } 400e631ddbaSFerenc Havasi 401e631ddbaSFerenc Havasi if (!jeb) { 402e631ddbaSFerenc Havasi 403e631ddbaSFerenc Havasi ret = jffs2_find_nextblock(c); 404e631ddbaSFerenc Havasi if (ret) 405e631ddbaSFerenc Havasi return ret; 406e631ddbaSFerenc Havasi 407e631ddbaSFerenc Havasi jeb = c->nextblock; 408e631ddbaSFerenc Havasi 4091da177e4SLinus Torvalds if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 410da320f05SJoe Perches pr_warn("Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", 411da320f05SJoe Perches jeb->offset, jeb->free_size); 4121da177e4SLinus Torvalds goto restart; 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has 4161da177e4SLinus Torvalds enough space */ 417e631ddbaSFerenc Havasi *len = jeb->free_size - reserved_size; 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size && 4201da177e4SLinus Torvalds !jeb->first_node->next_in_ino) { 4211da177e4SLinus Torvalds /* Only node in it beforehand was a CLEANMARKER node (we think). 4221da177e4SLinus Torvalds So mark it obsolete now that there's going to be another node 4231da177e4SLinus Torvalds in the block. This will reduce used_size to zero but We've 4241da177e4SLinus Torvalds already set c->nextblock so that jffs2_mark_node_obsolete() 4251da177e4SLinus Torvalds won't try to refile it to the dirty_list. 4261da177e4SLinus Torvalds */ 4271da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4281da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, jeb->first_node); 4291da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4329c261b33SJoe Perches jffs2_dbg(1, "%s(): Giving 0x%x bytes at 0x%x\n", 4339c261b33SJoe Perches __func__, 4349c261b33SJoe Perches *len, jeb->offset + (c->sector_size - jeb->free_size)); 4351da177e4SLinus Torvalds return 0; 4361da177e4SLinus Torvalds } 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds /** 4391da177e4SLinus Torvalds * jffs2_add_physical_node_ref - add a physical node reference to the list 4401da177e4SLinus Torvalds * @c: superblock info 4411da177e4SLinus Torvalds * @new: new node reference to add 4421da177e4SLinus Torvalds * @len: length of this physical node 4431da177e4SLinus Torvalds * 4441da177e4SLinus Torvalds * Should only be used to report nodes for which space has been allocated 4451da177e4SLinus Torvalds * by jffs2_reserve_space. 4461da177e4SLinus Torvalds * 4471da177e4SLinus Torvalds * Must be called with the alloc_sem held. 4481da177e4SLinus Torvalds */ 4491da177e4SLinus Torvalds 4502f785402SDavid Woodhouse struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, 4512f785402SDavid Woodhouse uint32_t ofs, uint32_t len, 4522f785402SDavid Woodhouse struct jffs2_inode_cache *ic) 4531da177e4SLinus Torvalds { 4541da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 4552f785402SDavid Woodhouse struct jffs2_raw_node_ref *new; 4561da177e4SLinus Torvalds 4572f785402SDavid Woodhouse jeb = &c->blocks[ofs / c->sector_size]; 4581da177e4SLinus Torvalds 4599c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%x(%d), size 0x%x\n", 4609c261b33SJoe Perches __func__, ofs & ~3, ofs & 3, len); 4611da177e4SLinus Torvalds #if 1 4622f785402SDavid Woodhouse /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 4632f785402SDavid Woodhouse if c->nextblock is set. Note that wbuf.c will file obsolete nodes 4642f785402SDavid Woodhouse even after refiling c->nextblock */ 4652f785402SDavid Woodhouse if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 4662f785402SDavid Woodhouse && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 467da320f05SJoe Perches pr_warn("argh. node added in wrong place at 0x%08x(%d)\n", 468da320f05SJoe Perches ofs & ~3, ofs & 3); 46966bfaeaaSDavid Woodhouse if (c->nextblock) 470da320f05SJoe Perches pr_warn("nextblock 0x%08x", c->nextblock->offset); 47166bfaeaaSDavid Woodhouse else 472da320f05SJoe Perches pr_warn("No nextblock"); 473da320f05SJoe Perches pr_cont(", expected at %08x\n", 474da320f05SJoe Perches jeb->offset + (c->sector_size - jeb->free_size)); 4752f785402SDavid Woodhouse return ERR_PTR(-EINVAL); 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds #endif 4781da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4791da177e4SLinus Torvalds 4802f785402SDavid Woodhouse new = jffs2_link_node_ref(c, jeb, ofs, len, ic); 4811da177e4SLinus Torvalds 4829b88f473SEstelle Hammache if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 4831da177e4SLinus Torvalds /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 4849c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 4859c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 4869c261b33SJoe Perches jeb->used_size); 4871da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 4881da177e4SLinus Torvalds /* Flush the last write in the block if it's outstanding */ 4891da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4901da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 4911da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 4951da177e4SLinus Torvalds c->nextblock = NULL; 4961da177e4SLinus Torvalds } 497e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c,jeb); 498e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 5011da177e4SLinus Torvalds 5022f785402SDavid Woodhouse return new; 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds void jffs2_complete_reservation(struct jffs2_sb_info *c) 5071da177e4SLinus Torvalds { 5089c261b33SJoe Perches jffs2_dbg(1, "jffs2_complete_reservation()\n"); 509acb64a43SDavid Woodhouse spin_lock(&c->erase_completion_lock); 5101da177e4SLinus Torvalds jffs2_garbage_collect_trigger(c); 511acb64a43SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 512ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds static inline int on_list(struct list_head *obj, struct list_head *head) 5161da177e4SLinus Torvalds { 5171da177e4SLinus Torvalds struct list_head *this; 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds list_for_each(this, head) { 5201da177e4SLinus Torvalds if (this == obj) { 5219c261b33SJoe Perches jffs2_dbg(1, "%p is on list at %p\n", obj, head); 5221da177e4SLinus Torvalds return 1; 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds return 0; 5271da177e4SLinus Torvalds } 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref) 5301da177e4SLinus Torvalds { 5311da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 5321da177e4SLinus Torvalds int blocknr; 5331da177e4SLinus Torvalds struct jffs2_unknown_node n; 5341da177e4SLinus Torvalds int ret, addedsize; 5351da177e4SLinus Torvalds size_t retlen; 5361417fc44SDavid Woodhouse uint32_t freed_len; 5371da177e4SLinus Torvalds 5389bfeb691SDavid Woodhouse if(unlikely(!ref)) { 539da320f05SJoe Perches pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 5401da177e4SLinus Torvalds return; 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds if (ref_obsolete(ref)) { 5439c261b33SJoe Perches jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n", 5449c261b33SJoe Perches __func__, ref_offset(ref)); 5451da177e4SLinus Torvalds return; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds blocknr = ref->flash_offset / c->sector_size; 5481da177e4SLinus Torvalds if (blocknr >= c->nr_blocks) { 549da320f05SJoe Perches pr_notice("raw node at 0x%08x is off the end of device!\n", 550da320f05SJoe Perches ref->flash_offset); 5511da177e4SLinus Torvalds BUG(); 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds jeb = &c->blocks[blocknr]; 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) && 55631fbdf7aSArtem B. Bityuckiy !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) { 5571da177e4SLinus Torvalds /* Hm. This may confuse static lock analysis. If any of the above 5581da177e4SLinus Torvalds three conditions is false, we're going to return from this 5591da177e4SLinus Torvalds function without actually obliterating any nodes or freeing 5601da177e4SLinus Torvalds any jffs2_raw_node_refs. So we don't need to stop erases from 5611da177e4SLinus Torvalds happening, or protect against people holding an obsolete 5621da177e4SLinus Torvalds jffs2_raw_node_ref without the erase_completion_lock. */ 563ced22070SDavid Woodhouse mutex_lock(&c->erase_free_sem); 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 5671da177e4SLinus Torvalds 5681417fc44SDavid Woodhouse freed_len = ref_totlen(c, jeb, ref); 5691417fc44SDavid Woodhouse 5701da177e4SLinus Torvalds if (ref_flags(ref) == REF_UNCHECKED) { 5711417fc44SDavid Woodhouse D1(if (unlikely(jeb->unchecked_size < freed_len)) { 572da320f05SJoe Perches pr_notice("raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n", 573da320f05SJoe Perches freed_len, blocknr, 574da320f05SJoe Perches ref->flash_offset, jeb->used_size); 5751da177e4SLinus Torvalds BUG(); 5761da177e4SLinus Torvalds }) 5779c261b33SJoe Perches jffs2_dbg(1, "Obsoleting previously unchecked node at 0x%08x of len %x\n", 5789c261b33SJoe Perches ref_offset(ref), freed_len); 5791417fc44SDavid Woodhouse jeb->unchecked_size -= freed_len; 5801417fc44SDavid Woodhouse c->unchecked_size -= freed_len; 5811da177e4SLinus Torvalds } else { 5821417fc44SDavid Woodhouse D1(if (unlikely(jeb->used_size < freed_len)) { 583da320f05SJoe Perches pr_notice("raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n", 584da320f05SJoe Perches freed_len, blocknr, 585da320f05SJoe Perches ref->flash_offset, jeb->used_size); 5861da177e4SLinus Torvalds BUG(); 5871da177e4SLinus Torvalds }) 5889c261b33SJoe Perches jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ", 5899c261b33SJoe Perches ref_offset(ref), freed_len); 5901417fc44SDavid Woodhouse jeb->used_size -= freed_len; 5911417fc44SDavid Woodhouse c->used_size -= freed_len; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds // Take care, that wasted size is taken into concern 5951417fc44SDavid Woodhouse if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) { 5969c261b33SJoe Perches jffs2_dbg(1, "Dirtying\n"); 5971417fc44SDavid Woodhouse addedsize = freed_len; 5981417fc44SDavid Woodhouse jeb->dirty_size += freed_len; 5991417fc44SDavid Woodhouse c->dirty_size += freed_len; 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds /* Convert wasted space to dirty, if not a bad block */ 6021da177e4SLinus Torvalds if (jeb->wasted_size) { 6031da177e4SLinus Torvalds if (on_list(&jeb->list, &c->bad_used_list)) { 6049c261b33SJoe Perches jffs2_dbg(1, "Leaving block at %08x on the bad_used_list\n", 6059c261b33SJoe Perches jeb->offset); 6061da177e4SLinus Torvalds addedsize = 0; /* To fool the refiling code later */ 6071da177e4SLinus Torvalds } else { 6089c261b33SJoe Perches jffs2_dbg(1, "Converting %d bytes of wasted space to dirty in block at %08x\n", 6099c261b33SJoe Perches jeb->wasted_size, jeb->offset); 6101da177e4SLinus Torvalds addedsize += jeb->wasted_size; 6111da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 6121da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 6131da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 6141da177e4SLinus Torvalds jeb->wasted_size = 0; 6151da177e4SLinus Torvalds } 6161da177e4SLinus Torvalds } 6171da177e4SLinus Torvalds } else { 6189c261b33SJoe Perches jffs2_dbg(1, "Wasting\n"); 6191da177e4SLinus Torvalds addedsize = 0; 6201417fc44SDavid Woodhouse jeb->wasted_size += freed_len; 6211417fc44SDavid Woodhouse c->wasted_size += freed_len; 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds ref->flash_offset = ref_offset(ref) | REF_OBSOLETE; 6241da177e4SLinus Torvalds 625e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c, jeb); 626e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 6271da177e4SLinus Torvalds 62831fbdf7aSArtem B. Bityuckiy if (c->flags & JFFS2_SB_FLAG_SCANNING) { 62931fbdf7aSArtem B. Bityuckiy /* Flash scanning is in progress. Don't muck about with the block 6301da177e4SLinus Torvalds lists because they're not ready yet, and don't actually 6311da177e4SLinus Torvalds obliterate nodes that look obsolete. If they weren't 6321da177e4SLinus Torvalds marked obsolete on the flash at the time they _became_ 6331da177e4SLinus Torvalds obsolete, there was probably a reason for that. */ 6341da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6351da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 6361da177e4SLinus Torvalds return; 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds if (jeb == c->nextblock) { 6409c261b33SJoe Perches jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n", 6419c261b33SJoe Perches jeb->offset); 6421da177e4SLinus Torvalds } else if (!jeb->used_size && !jeb->unchecked_size) { 6431da177e4SLinus Torvalds if (jeb == c->gcblock) { 6449c261b33SJoe Perches jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", 6459c261b33SJoe Perches jeb->offset); 6461da177e4SLinus Torvalds c->gcblock = NULL; 6471da177e4SLinus Torvalds } else { 6489c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", 6499c261b33SJoe Perches jeb->offset); 6501da177e4SLinus Torvalds list_del(&jeb->list); 6511da177e4SLinus Torvalds } 6521da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 6539c261b33SJoe Perches jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n"); 6541da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 6551da177e4SLinus Torvalds } else { 6561da177e4SLinus Torvalds if (jiffies & 127) { 6571da177e4SLinus Torvalds /* Most of the time, we just erase it immediately. Otherwise we 6581da177e4SLinus Torvalds spend ages scanning it on mount, etc. */ 6599c261b33SJoe Perches jffs2_dbg(1, "...and adding to erase_pending_list\n"); 6601da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erase_pending_list); 6611da177e4SLinus Torvalds c->nr_erasing_blocks++; 662ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 6631da177e4SLinus Torvalds } else { 6641da177e4SLinus Torvalds /* Sometimes, however, we leave it elsewhere so it doesn't get 6651da177e4SLinus Torvalds immediately reused, and we spread the load a bit. */ 6669c261b33SJoe Perches jffs2_dbg(1, "...and adding to erasable_list\n"); 6671da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_list); 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds } 6709c261b33SJoe Perches jffs2_dbg(1, "Done OK\n"); 6711da177e4SLinus Torvalds } else if (jeb == c->gcblock) { 6729c261b33SJoe Perches jffs2_dbg(2, "Not moving gcblock 0x%08x to dirty_list\n", 6739c261b33SJoe Perches jeb->offset); 6741da177e4SLinus Torvalds } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 6759c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", 6769c261b33SJoe Perches jeb->offset); 6771da177e4SLinus Torvalds list_del(&jeb->list); 6789c261b33SJoe Perches jffs2_dbg(1, "...and adding to dirty_list\n"); 6791da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 6801da177e4SLinus Torvalds } else if (VERYDIRTY(c, jeb->dirty_size) && 6811da177e4SLinus Torvalds !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 6829c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", 6839c261b33SJoe Perches jeb->offset); 6841da177e4SLinus Torvalds list_del(&jeb->list); 6859c261b33SJoe Perches jffs2_dbg(1, "...and adding to very_dirty_list\n"); 6861da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 6871da177e4SLinus Torvalds } else { 6889c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 6899c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 6909c261b33SJoe Perches jeb->used_size); 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6941da177e4SLinus Torvalds 69531fbdf7aSArtem B. Bityuckiy if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) || 69631fbdf7aSArtem B. Bityuckiy (c->flags & JFFS2_SB_FLAG_BUILDING)) { 6971da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 6981da177e4SLinus Torvalds return; 6991da177e4SLinus Torvalds } 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds /* The erase_free_sem is locked, and has been since before we marked the node obsolete 7021da177e4SLinus Torvalds and potentially put its eraseblock onto the erase_pending_list. Thus, we know that 7031da177e4SLinus Torvalds the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 704c38c1b61SDavid Woodhouse by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */ 7051da177e4SLinus Torvalds 7069c261b33SJoe Perches jffs2_dbg(1, "obliterating obsoleted node at 0x%08x\n", 7079c261b33SJoe Perches ref_offset(ref)); 7081da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 7091da177e4SLinus Torvalds if (ret) { 710da320f05SJoe Perches pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n", 711da320f05SJoe Perches ref_offset(ref), ret); 7121da177e4SLinus Torvalds goto out_erase_sem; 7131da177e4SLinus Torvalds } 7141da177e4SLinus Torvalds if (retlen != sizeof(n)) { 715da320f05SJoe Perches pr_warn("Short read from obsoleted node at 0x%08x: %zd\n", 716da320f05SJoe Perches ref_offset(ref), retlen); 7171da177e4SLinus Torvalds goto out_erase_sem; 7181da177e4SLinus Torvalds } 7191417fc44SDavid Woodhouse if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) { 720da320f05SJoe Perches pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", 721da320f05SJoe Perches je32_to_cpu(n.totlen), freed_len); 7221da177e4SLinus Torvalds goto out_erase_sem; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 7259c261b33SJoe Perches jffs2_dbg(1, "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", 7269c261b33SJoe Perches ref_offset(ref), je16_to_cpu(n.nodetype)); 7271da177e4SLinus Torvalds goto out_erase_sem; 7281da177e4SLinus Torvalds } 7291da177e4SLinus Torvalds /* XXX FIXME: This is ugly now */ 7301da177e4SLinus Torvalds n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 7311da177e4SLinus Torvalds ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 7321da177e4SLinus Torvalds if (ret) { 733da320f05SJoe Perches pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n", 734da320f05SJoe Perches ref_offset(ref), ret); 7351da177e4SLinus Torvalds goto out_erase_sem; 7361da177e4SLinus Torvalds } 7371da177e4SLinus Torvalds if (retlen != sizeof(n)) { 738da320f05SJoe Perches pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n", 739da320f05SJoe Perches ref_offset(ref), retlen); 7401da177e4SLinus Torvalds goto out_erase_sem; 7411da177e4SLinus Torvalds } 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds /* Nodes which have been marked obsolete no longer need to be 7441da177e4SLinus Torvalds associated with any inode. Remove them from the per-inode list. 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds Note we can't do this for NAND at the moment because we need 7471da177e4SLinus Torvalds obsolete dirent nodes to stay on the lists, because of the 7481da177e4SLinus Torvalds horridness in jffs2_garbage_collect_deletion_dirent(). Also 7491da177e4SLinus Torvalds because we delete the inocache, and on NAND we need that to 7501da177e4SLinus Torvalds stay around until all the nodes are actually erased, in order 7511da177e4SLinus Torvalds to stop us from giving the same inode number to another newly 7521da177e4SLinus Torvalds created inode. */ 7531da177e4SLinus Torvalds if (ref->next_in_ino) { 7541da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 7551da177e4SLinus Torvalds struct jffs2_raw_node_ref **p; 7561da177e4SLinus Torvalds 7571da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds ic = jffs2_raw_ref_to_ic(ref); 7601da177e4SLinus Torvalds for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino)) 7611da177e4SLinus Torvalds ; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds *p = ref->next_in_ino; 7641da177e4SLinus Torvalds ref->next_in_ino = NULL; 7651da177e4SLinus Torvalds 766c9f700f8SKaiGai Kohei switch (ic->class) { 767c9f700f8SKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 768c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_DATUM: 769c9f700f8SKaiGai Kohei jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic); 770c9f700f8SKaiGai Kohei break; 771c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_REF: 772c9f700f8SKaiGai Kohei jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic); 773c9f700f8SKaiGai Kohei break; 774c9f700f8SKaiGai Kohei #endif 775c9f700f8SKaiGai Kohei default: 77627c72b04SDavid Woodhouse if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 7771da177e4SLinus Torvalds jffs2_del_ino_cache(c, ic); 778c9f700f8SKaiGai Kohei break; 779c9f700f8SKaiGai Kohei } 7801da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 7811da177e4SLinus Torvalds } 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds out_erase_sem: 784ced22070SDavid Woodhouse mutex_unlock(&c->erase_free_sem); 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds int jffs2_thread_should_wake(struct jffs2_sb_info *c) 7881da177e4SLinus Torvalds { 7891da177e4SLinus Torvalds int ret = 0; 7901da177e4SLinus Torvalds uint32_t dirty; 7918fb870dfSDavid Woodhouse int nr_very_dirty = 0; 7928fb870dfSDavid Woodhouse struct jffs2_eraseblock *jeb; 7931da177e4SLinus Torvalds 794d6ce1710SJoakim Tjernlund if (!list_empty(&c->erase_complete_list) || 795d6ce1710SJoakim Tjernlund !list_empty(&c->erase_pending_list)) 796d6ce1710SJoakim Tjernlund return 1; 797d6ce1710SJoakim Tjernlund 7981da177e4SLinus Torvalds if (c->unchecked_size) { 7999c261b33SJoe Perches jffs2_dbg(1, "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 8009c261b33SJoe Perches c->unchecked_size, c->checked_ino); 8011da177e4SLinus Torvalds return 1; 8021da177e4SLinus Torvalds } 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds /* dirty_size contains blocks on erase_pending_list 8051da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 8061da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 8071da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 8081da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 8091da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 8101da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 8111da177e4SLinus Torvalds */ 8121da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size; 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger && 8151da177e4SLinus Torvalds (dirty > c->nospc_dirty_size)) 8161da177e4SLinus Torvalds ret = 1; 8171da177e4SLinus Torvalds 8188fb870dfSDavid Woodhouse list_for_each_entry(jeb, &c->very_dirty_list, list) { 8198fb870dfSDavid Woodhouse nr_very_dirty++; 8208fb870dfSDavid Woodhouse if (nr_very_dirty == c->vdirty_blocks_gctrigger) { 8218fb870dfSDavid Woodhouse ret = 1; 822a8c68f32SDavid Woodhouse /* In debug mode, actually go through and count them all */ 823a8c68f32SDavid Woodhouse D1(continue); 824a8c68f32SDavid Woodhouse break; 8258fb870dfSDavid Woodhouse } 8268fb870dfSDavid Woodhouse } 8278fb870dfSDavid Woodhouse 8289c261b33SJoe Perches jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 8299c261b33SJoe Perches __func__, c->nr_free_blocks, c->nr_erasing_blocks, 8309c261b33SJoe Perches c->dirty_size, nr_very_dirty, ret ? "yes" : "no"); 8311da177e4SLinus Torvalds 8321da177e4SLinus Torvalds return ret; 8331da177e4SLinus Torvalds } 834