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 121da177e4SLinus Torvalds #include <linux/kernel.h> 131da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 141da177e4SLinus Torvalds #include <linux/compiler.h> 151da177e4SLinus Torvalds #include <linux/sched.h> /* For cond_resched() */ 161da177e4SLinus Torvalds #include "nodelist.h" 17e631ddbaSFerenc Havasi #include "debug.h" 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds /** 201da177e4SLinus Torvalds * jffs2_reserve_space - request physical space to write nodes to flash 211da177e4SLinus Torvalds * @c: superblock info 221da177e4SLinus Torvalds * @minsize: Minimum acceptable size of allocation 231da177e4SLinus Torvalds * @len: Returned value of allocation length 241da177e4SLinus Torvalds * @prio: Allocation type - ALLOC_{NORMAL,DELETION} 251da177e4SLinus Torvalds * 261da177e4SLinus Torvalds * Requests a block of physical space on the flash. Returns zero for success 279fe4854cSDavid Woodhouse * and puts 'len' into the appropriate place, or returns -ENOSPC or other 289fe4854cSDavid Woodhouse * error if appropriate. Doesn't return len since that's 291da177e4SLinus Torvalds * 301da177e4SLinus Torvalds * If it returns zero, jffs2_reserve_space() also downs the per-filesystem 311da177e4SLinus Torvalds * allocation semaphore, to prevent more than one allocation from being 321da177e4SLinus Torvalds * active at any time. The semaphore is later released by jffs2_commit_allocation() 331da177e4SLinus Torvalds * 341da177e4SLinus Torvalds * jffs2_reserve_space() may trigger garbage collection in order to make room 351da177e4SLinus Torvalds * for the requested allocation. 361da177e4SLinus Torvalds */ 371da177e4SLinus Torvalds 38e631ddbaSFerenc Havasi static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 399fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize); 401da177e4SLinus Torvalds 419fe4854cSDavid Woodhouse int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 42e631ddbaSFerenc Havasi uint32_t *len, int prio, uint32_t sumsize) 431da177e4SLinus Torvalds { 441da177e4SLinus Torvalds int ret = -EAGAIN; 451da177e4SLinus Torvalds int blocksneeded = c->resv_blocks_write; 461da177e4SLinus Torvalds /* align it */ 471da177e4SLinus Torvalds minsize = PAD(minsize); 481da177e4SLinus Torvalds 499c261b33SJoe Perches jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 50ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 511da177e4SLinus Torvalds 529c261b33SJoe Perches jffs2_dbg(1, "%s(): alloc sem got\n", __func__); 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* this needs a little more thought (true <tglx> :)) */ 571da177e4SLinus Torvalds while(ret == -EAGAIN) { 581da177e4SLinus Torvalds while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) { 591da177e4SLinus Torvalds uint32_t dirty, avail; 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds /* calculate real dirty size 621da177e4SLinus Torvalds * dirty_size contains blocks on erase_pending_list 631da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 641da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 651da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 661da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 671da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 681da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 691da177e4SLinus Torvalds * We add unchecked_size here, as we hopefully will find some space to use. 701da177e4SLinus Torvalds * This will affect the sum only once, as gc first finishes checking 711da177e4SLinus Torvalds * of nodes. 721da177e4SLinus Torvalds */ 731da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 741da177e4SLinus Torvalds if (dirty < c->nospc_dirty_size) { 751da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 769c261b33SJoe Perches jffs2_dbg(1, "%s(): Low on dirty space to GC, but it's a deletion. Allowing...\n", 779c261b33SJoe Perches __func__); 781da177e4SLinus Torvalds break; 791da177e4SLinus Torvalds } 809c261b33SJoe Perches jffs2_dbg(1, "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 819c261b33SJoe Perches dirty, c->unchecked_size, 829c261b33SJoe Perches c->sector_size); 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 85ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 861da177e4SLinus Torvalds return -ENOSPC; 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds /* Calc possibly available space. Possibly available means that we 901da177e4SLinus Torvalds * don't know, if unchecked size contains obsoleted nodes, which could give us some 911da177e4SLinus Torvalds * more usable space. This will affect the sum only once, as gc first finishes checking 921da177e4SLinus Torvalds * of nodes. 931da177e4SLinus Torvalds + Return -ENOSPC, if the maximum possibly available space is less or equal than 941da177e4SLinus Torvalds * blocksneeded * sector_size. 951da177e4SLinus Torvalds * This blocks endless gc looping on a filesystem, which is nearly full, even if 961da177e4SLinus Torvalds * the check above passes. 971da177e4SLinus Torvalds */ 981da177e4SLinus Torvalds avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 991da177e4SLinus Torvalds if ( (avail / c->sector_size) <= blocksneeded) { 1001da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 1019c261b33SJoe Perches jffs2_dbg(1, "%s(): Low on possibly available space, but it's a deletion. Allowing...\n", 1029c261b33SJoe Perches __func__); 1031da177e4SLinus Torvalds break; 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds 1069c261b33SJoe Perches jffs2_dbg(1, "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 1079c261b33SJoe Perches avail, blocksneeded * c->sector_size); 1081da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 109ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1101da177e4SLinus Torvalds return -ENOSPC; 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 113ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1141da177e4SLinus Torvalds 1159c261b33SJoe 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", 1169c261b33SJoe Perches c->nr_free_blocks, c->nr_erasing_blocks, 1179c261b33SJoe Perches c->free_size, c->dirty_size, c->wasted_size, 1189c261b33SJoe Perches c->used_size, c->erasing_size, c->bad_size, 1199c261b33SJoe Perches c->free_size + c->dirty_size + 1209c261b33SJoe Perches c->wasted_size + c->used_size + 1219c261b33SJoe Perches c->erasing_size + c->bad_size, 1229c261b33SJoe Perches c->flash_size); 1231da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds ret = jffs2_garbage_collect_pass(c); 126422b1202SDavid Woodhouse 1270717bf84SDavid Woodhouse if (ret == -EAGAIN) { 1280717bf84SDavid Woodhouse spin_lock(&c->erase_completion_lock); 1290717bf84SDavid Woodhouse if (c->nr_erasing_blocks && 1300717bf84SDavid Woodhouse list_empty(&c->erase_pending_list) && 1310717bf84SDavid Woodhouse list_empty(&c->erase_complete_list)) { 1320717bf84SDavid Woodhouse DECLARE_WAITQUEUE(wait, current); 1330717bf84SDavid Woodhouse set_current_state(TASK_UNINTERRUPTIBLE); 1340717bf84SDavid Woodhouse add_wait_queue(&c->erase_wait, &wait); 1359c261b33SJoe Perches jffs2_dbg(1, "%s waiting for erase to complete\n", 1369c261b33SJoe Perches __func__); 1370717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1380717bf84SDavid Woodhouse 1390717bf84SDavid Woodhouse schedule(); 1400717bf84SDavid Woodhouse } else 1410717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1420717bf84SDavid Woodhouse } else if (ret) 1431da177e4SLinus Torvalds return ret; 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds cond_resched(); 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds if (signal_pending(current)) 1481da177e4SLinus Torvalds return -EINTR; 1491da177e4SLinus Torvalds 150ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 1511da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds 1549fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1551da177e4SLinus Torvalds if (ret) { 1569c261b33SJoe Perches jffs2_dbg(1, "%s(): ret is %d\n", __func__, ret); 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds } 1591da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1602f785402SDavid Woodhouse if (!ret) 161046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 1621da177e4SLinus Torvalds if (ret) 163ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1641da177e4SLinus Torvalds return ret; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds 1679fe4854cSDavid Woodhouse int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, 168e631ddbaSFerenc Havasi uint32_t *len, uint32_t sumsize) 1691da177e4SLinus Torvalds { 1701da177e4SLinus Torvalds int ret = -EAGAIN; 1711da177e4SLinus Torvalds minsize = PAD(minsize); 1721da177e4SLinus Torvalds 1739c261b33SJoe Perches jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1761da177e4SLinus Torvalds while(ret == -EAGAIN) { 1779fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1781da177e4SLinus Torvalds if (ret) { 1799c261b33SJoe Perches jffs2_dbg(1, "%s(): looping, ret is %d\n", 1809c261b33SJoe Perches __func__, ret); 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds } 1831da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1842f785402SDavid Woodhouse if (!ret) 185046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 1862f785402SDavid Woodhouse 1871da177e4SLinus Torvalds return ret; 1881da177e4SLinus Torvalds } 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds 191e631ddbaSFerenc Havasi /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */ 192e631ddbaSFerenc Havasi 193e631ddbaSFerenc Havasi static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 194e631ddbaSFerenc Havasi { 1951da177e4SLinus Torvalds 19699c2594fSAdrian Hunter if (c->nextblock == NULL) { 1979c261b33SJoe Perches jffs2_dbg(1, "%s(): Erase block at 0x%08x has already been placed in a list\n", 1989c261b33SJoe Perches __func__, jeb->offset); 19999c2594fSAdrian Hunter return; 20099c2594fSAdrian Hunter } 2011da177e4SLinus Torvalds /* Check, if we have a dirty block now, or if it was dirty already */ 2021da177e4SLinus Torvalds if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) { 2031da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 2041da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 2051da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 2061da177e4SLinus Torvalds jeb->wasted_size = 0; 2071da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 2089c261b33SJoe 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", 2099c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2109c261b33SJoe Perches jeb->used_size); 2111da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 2121da177e4SLinus Torvalds } else { 2139c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2149c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2159c261b33SJoe Perches jeb->used_size); 2161da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 2171da177e4SLinus Torvalds } 2181da177e4SLinus Torvalds } else { 2199c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2209c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2219c261b33SJoe Perches jeb->used_size); 2221da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 2231da177e4SLinus Torvalds } 224e631ddbaSFerenc Havasi c->nextblock = NULL; 225e631ddbaSFerenc Havasi 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 228e631ddbaSFerenc Havasi /* Select a new jeb for nextblock */ 229e631ddbaSFerenc Havasi 230e631ddbaSFerenc Havasi static int jffs2_find_nextblock(struct jffs2_sb_info *c) 231e631ddbaSFerenc Havasi { 2321da177e4SLinus Torvalds struct list_head *next; 233e631ddbaSFerenc Havasi 2341da177e4SLinus Torvalds /* Take the next block off the 'free' list */ 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds if (list_empty(&c->free_list)) { 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2391da177e4SLinus Torvalds !list_empty(&c->erasable_list)) { 2401da177e4SLinus Torvalds struct jffs2_eraseblock *ejeb; 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list); 243f116629dSAkinobu Mita list_move_tail(&ejeb->list, &c->erase_pending_list); 2441da177e4SLinus Torvalds c->nr_erasing_blocks++; 245ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 2469c261b33SJoe Perches jffs2_dbg(1, "%s(): Triggering erase of erasable block at 0x%08x\n", 2479c261b33SJoe Perches __func__, ejeb->offset); 2481da177e4SLinus Torvalds } 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2511da177e4SLinus Torvalds !list_empty(&c->erasable_pending_wbuf_list)) { 2529c261b33SJoe Perches jffs2_dbg(1, "%s(): Flushing write buffer\n", 2539c261b33SJoe Perches __func__); 2541da177e4SLinus Torvalds /* c->nextblock is NULL, no update to c->nextblock allowed */ 2551da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2561da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 2571da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2581da177e4SLinus Torvalds /* Have another go. It'll be on the erasable_list now */ 2591da177e4SLinus Torvalds return -EAGAIN; 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds if (!c->nr_erasing_blocks) { 2631da177e4SLinus Torvalds /* Ouch. We're in GC, or we wouldn't have got here. 2641da177e4SLinus Torvalds And there's no space left. At all. */ 2651da177e4SLinus Torvalds printk(KERN_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", 2661da177e4SLinus Torvalds c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no", 2671da177e4SLinus Torvalds list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"); 2681da177e4SLinus Torvalds return -ENOSPC; 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2721da177e4SLinus Torvalds /* Don't wait for it; just erase one right now */ 2731da177e4SLinus Torvalds jffs2_erase_pending_blocks(c, 1); 2741da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds /* An erase may have failed, decreasing the 2771da177e4SLinus Torvalds amount of free space available. So we must 2781da177e4SLinus Torvalds restart from the beginning */ 2791da177e4SLinus Torvalds return -EAGAIN; 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds next = c->free_list.next; 2831da177e4SLinus Torvalds list_del(next); 284e631ddbaSFerenc Havasi c->nextblock = list_entry(next, struct jffs2_eraseblock, list); 2851da177e4SLinus Torvalds c->nr_free_blocks--; 2861da177e4SLinus Torvalds 287e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); /* reset collected summary */ 288e631ddbaSFerenc Havasi 289f04de505SSteve Glendinning #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 2905bf17237SAlexander Belyakov /* adjust write buffer offset, else we get a non contiguous write bug */ 2915bf17237SAlexander Belyakov if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len) 2925bf17237SAlexander Belyakov c->wbuf_ofs = 0xffffffff; 293f04de505SSteve Glendinning #endif 2945bf17237SAlexander Belyakov 2959c261b33SJoe Perches jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 2969c261b33SJoe Perches __func__, c->nextblock->offset); 297e631ddbaSFerenc Havasi 298e631ddbaSFerenc Havasi return 0; 299e631ddbaSFerenc Havasi } 300e631ddbaSFerenc Havasi 301e631ddbaSFerenc Havasi /* Called with alloc sem _and_ erase_completion_lock */ 3029fe4854cSDavid Woodhouse static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 3039fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize) 304e631ddbaSFerenc Havasi { 305e631ddbaSFerenc Havasi struct jffs2_eraseblock *jeb = c->nextblock; 306e631ddbaSFerenc Havasi uint32_t reserved_size; /* for summary information at the end of the jeb */ 307e631ddbaSFerenc Havasi int ret; 308e631ddbaSFerenc Havasi 309e631ddbaSFerenc Havasi restart: 310e631ddbaSFerenc Havasi reserved_size = 0; 311e631ddbaSFerenc Havasi 312e631ddbaSFerenc Havasi if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) { 313e631ddbaSFerenc Havasi /* NOSUM_SIZE means not to generate summary */ 314e631ddbaSFerenc Havasi 315e631ddbaSFerenc Havasi if (jeb) { 316e631ddbaSFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 317733802d9SArtem B. Bityutskiy dbg_summary("minsize=%d , jeb->free=%d ," 318e631ddbaSFerenc Havasi "summary->size=%d , sumsize=%d\n", 319e631ddbaSFerenc Havasi minsize, jeb->free_size, 320e631ddbaSFerenc Havasi c->summary->sum_size, sumsize); 321e631ddbaSFerenc Havasi } 322e631ddbaSFerenc Havasi 323e631ddbaSFerenc Havasi /* Is there enough space for writing out the current node, or we have to 324e631ddbaSFerenc Havasi write out summary information now, close this jeb and select new nextblock? */ 325e631ddbaSFerenc Havasi if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize + 326e631ddbaSFerenc Havasi JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) { 327e631ddbaSFerenc Havasi 328e631ddbaSFerenc Havasi /* Has summary been disabled for this jeb? */ 329e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 330e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 331e631ddbaSFerenc Havasi goto restart; 332e631ddbaSFerenc Havasi } 333e631ddbaSFerenc Havasi 334e631ddbaSFerenc Havasi /* Writing out the collected summary information */ 335733802d9SArtem B. Bityutskiy dbg_summary("generating summary for 0x%08x.\n", jeb->offset); 336e631ddbaSFerenc Havasi ret = jffs2_sum_write_sumnode(c); 337e631ddbaSFerenc Havasi 338e631ddbaSFerenc Havasi if (ret) 339e631ddbaSFerenc Havasi return ret; 340e631ddbaSFerenc Havasi 341e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 342e631ddbaSFerenc Havasi /* jffs2_write_sumnode() couldn't write out the summary information 343e631ddbaSFerenc Havasi diabling summary for this jeb and free the collected information 344e631ddbaSFerenc Havasi */ 345e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 346e631ddbaSFerenc Havasi goto restart; 347e631ddbaSFerenc Havasi } 348e631ddbaSFerenc Havasi 349e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 350e631ddbaSFerenc Havasi jeb = NULL; 35134c0e906SFerenc Havasi /* keep always valid value in reserved_size */ 35234c0e906SFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 353e631ddbaSFerenc Havasi } 354e631ddbaSFerenc Havasi } else { 355e631ddbaSFerenc Havasi if (jeb && minsize > jeb->free_size) { 356fc6612f6SDavid Woodhouse uint32_t waste; 357fc6612f6SDavid Woodhouse 358e631ddbaSFerenc Havasi /* Skip the end of this block and file it as having some dirty space */ 359e631ddbaSFerenc Havasi /* If there's a pending write to it, flush now */ 360e631ddbaSFerenc Havasi 361e631ddbaSFerenc Havasi if (jffs2_wbuf_dirty(c)) { 362e631ddbaSFerenc Havasi spin_unlock(&c->erase_completion_lock); 3639c261b33SJoe Perches jffs2_dbg(1, "%s(): Flushing write buffer\n", 3649c261b33SJoe Perches __func__); 365e631ddbaSFerenc Havasi jffs2_flush_wbuf_pad(c); 366e631ddbaSFerenc Havasi spin_lock(&c->erase_completion_lock); 367e631ddbaSFerenc Havasi jeb = c->nextblock; 368e631ddbaSFerenc Havasi goto restart; 369e631ddbaSFerenc Havasi } 370e631ddbaSFerenc Havasi 371fc6612f6SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 372fc6612f6SDavid Woodhouse 373fc6612f6SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, jeb, 1); 374fc6612f6SDavid Woodhouse if (ret) 375fc6612f6SDavid Woodhouse return ret; 376fc6612f6SDavid Woodhouse /* Just lock it again and continue. Nothing much can change because 377fc6612f6SDavid Woodhouse we hold c->alloc_sem anyway. In fact, it's not entirely clear why 378fc6612f6SDavid Woodhouse we hold c->erase_completion_lock in the majority of this function... 379fc6612f6SDavid Woodhouse but that's a question for another (more caffeine-rich) day. */ 380fc6612f6SDavid Woodhouse spin_lock(&c->erase_completion_lock); 381fc6612f6SDavid Woodhouse 382fc6612f6SDavid Woodhouse waste = jeb->free_size; 383fc6612f6SDavid Woodhouse jffs2_link_node_ref(c, jeb, 384fc6612f6SDavid Woodhouse (jeb->offset + c->sector_size - waste) | REF_OBSOLETE, 385fc6612f6SDavid Woodhouse waste, NULL); 386fc6612f6SDavid Woodhouse /* FIXME: that made it count as dirty. Convert to wasted */ 387fc6612f6SDavid Woodhouse jeb->dirty_size -= waste; 388fc6612f6SDavid Woodhouse c->dirty_size -= waste; 389fc6612f6SDavid Woodhouse jeb->wasted_size += waste; 390fc6612f6SDavid Woodhouse c->wasted_size += waste; 391e631ddbaSFerenc Havasi 392e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 393e631ddbaSFerenc Havasi jeb = NULL; 394e631ddbaSFerenc Havasi } 395e631ddbaSFerenc Havasi } 396e631ddbaSFerenc Havasi 397e631ddbaSFerenc Havasi if (!jeb) { 398e631ddbaSFerenc Havasi 399e631ddbaSFerenc Havasi ret = jffs2_find_nextblock(c); 400e631ddbaSFerenc Havasi if (ret) 401e631ddbaSFerenc Havasi return ret; 402e631ddbaSFerenc Havasi 403e631ddbaSFerenc Havasi jeb = c->nextblock; 404e631ddbaSFerenc Havasi 4051da177e4SLinus Torvalds if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 4061da177e4SLinus Torvalds printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size); 4071da177e4SLinus Torvalds goto restart; 4081da177e4SLinus Torvalds } 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has 4111da177e4SLinus Torvalds enough space */ 412e631ddbaSFerenc Havasi *len = jeb->free_size - reserved_size; 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size && 4151da177e4SLinus Torvalds !jeb->first_node->next_in_ino) { 4161da177e4SLinus Torvalds /* Only node in it beforehand was a CLEANMARKER node (we think). 4171da177e4SLinus Torvalds So mark it obsolete now that there's going to be another node 4181da177e4SLinus Torvalds in the block. This will reduce used_size to zero but We've 4191da177e4SLinus Torvalds already set c->nextblock so that jffs2_mark_node_obsolete() 4201da177e4SLinus Torvalds won't try to refile it to the dirty_list. 4211da177e4SLinus Torvalds */ 4221da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4231da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, jeb->first_node); 4241da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4251da177e4SLinus Torvalds } 4261da177e4SLinus Torvalds 4279c261b33SJoe Perches jffs2_dbg(1, "%s(): Giving 0x%x bytes at 0x%x\n", 4289c261b33SJoe Perches __func__, 4299c261b33SJoe Perches *len, jeb->offset + (c->sector_size - jeb->free_size)); 4301da177e4SLinus Torvalds return 0; 4311da177e4SLinus Torvalds } 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds /** 4341da177e4SLinus Torvalds * jffs2_add_physical_node_ref - add a physical node reference to the list 4351da177e4SLinus Torvalds * @c: superblock info 4361da177e4SLinus Torvalds * @new: new node reference to add 4371da177e4SLinus Torvalds * @len: length of this physical node 4381da177e4SLinus Torvalds * 4391da177e4SLinus Torvalds * Should only be used to report nodes for which space has been allocated 4401da177e4SLinus Torvalds * by jffs2_reserve_space. 4411da177e4SLinus Torvalds * 4421da177e4SLinus Torvalds * Must be called with the alloc_sem held. 4431da177e4SLinus Torvalds */ 4441da177e4SLinus Torvalds 4452f785402SDavid Woodhouse struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, 4462f785402SDavid Woodhouse uint32_t ofs, uint32_t len, 4472f785402SDavid Woodhouse struct jffs2_inode_cache *ic) 4481da177e4SLinus Torvalds { 4491da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 4502f785402SDavid Woodhouse struct jffs2_raw_node_ref *new; 4511da177e4SLinus Torvalds 4522f785402SDavid Woodhouse jeb = &c->blocks[ofs / c->sector_size]; 4531da177e4SLinus Torvalds 4549c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%x(%d), size 0x%x\n", 4559c261b33SJoe Perches __func__, ofs & ~3, ofs & 3, len); 4561da177e4SLinus Torvalds #if 1 4572f785402SDavid Woodhouse /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 4582f785402SDavid Woodhouse if c->nextblock is set. Note that wbuf.c will file obsolete nodes 4592f785402SDavid Woodhouse even after refiling c->nextblock */ 4602f785402SDavid Woodhouse if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 4612f785402SDavid Woodhouse && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 46266bfaeaaSDavid Woodhouse printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3); 46366bfaeaaSDavid Woodhouse if (c->nextblock) 46466bfaeaaSDavid Woodhouse printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset); 46566bfaeaaSDavid Woodhouse else 46666bfaeaaSDavid Woodhouse printk(KERN_WARNING "No nextblock"); 46766bfaeaaSDavid Woodhouse printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size)); 4682f785402SDavid Woodhouse return ERR_PTR(-EINVAL); 4691da177e4SLinus Torvalds } 4701da177e4SLinus Torvalds #endif 4711da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4721da177e4SLinus Torvalds 4732f785402SDavid Woodhouse new = jffs2_link_node_ref(c, jeb, ofs, len, ic); 4741da177e4SLinus Torvalds 4759b88f473SEstelle Hammache if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 4761da177e4SLinus Torvalds /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 4779c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 4789c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 4799c261b33SJoe Perches jeb->used_size); 4801da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 4811da177e4SLinus Torvalds /* Flush the last write in the block if it's outstanding */ 4821da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4831da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 4841da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 4881da177e4SLinus Torvalds c->nextblock = NULL; 4891da177e4SLinus Torvalds } 490e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c,jeb); 491e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4941da177e4SLinus Torvalds 4952f785402SDavid Woodhouse return new; 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds void jffs2_complete_reservation(struct jffs2_sb_info *c) 5001da177e4SLinus Torvalds { 5019c261b33SJoe Perches jffs2_dbg(1, "jffs2_complete_reservation()\n"); 502acb64a43SDavid Woodhouse spin_lock(&c->erase_completion_lock); 5031da177e4SLinus Torvalds jffs2_garbage_collect_trigger(c); 504acb64a43SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 505ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 5061da177e4SLinus Torvalds } 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds static inline int on_list(struct list_head *obj, struct list_head *head) 5091da177e4SLinus Torvalds { 5101da177e4SLinus Torvalds struct list_head *this; 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds list_for_each(this, head) { 5131da177e4SLinus Torvalds if (this == obj) { 5149c261b33SJoe Perches jffs2_dbg(1, "%p is on list at %p\n", obj, head); 5151da177e4SLinus Torvalds return 1; 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds } 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds return 0; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref) 5231da177e4SLinus Torvalds { 5241da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 5251da177e4SLinus Torvalds int blocknr; 5261da177e4SLinus Torvalds struct jffs2_unknown_node n; 5271da177e4SLinus Torvalds int ret, addedsize; 5281da177e4SLinus Torvalds size_t retlen; 5291417fc44SDavid Woodhouse uint32_t freed_len; 5301da177e4SLinus Torvalds 5319bfeb691SDavid Woodhouse if(unlikely(!ref)) { 5321da177e4SLinus Torvalds printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 5331da177e4SLinus Torvalds return; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds if (ref_obsolete(ref)) { 5369c261b33SJoe Perches jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n", 5379c261b33SJoe Perches __func__, ref_offset(ref)); 5381da177e4SLinus Torvalds return; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds blocknr = ref->flash_offset / c->sector_size; 5411da177e4SLinus Torvalds if (blocknr >= c->nr_blocks) { 5421da177e4SLinus Torvalds printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset); 5431da177e4SLinus Torvalds BUG(); 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds jeb = &c->blocks[blocknr]; 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) && 54831fbdf7aSArtem B. Bityuckiy !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) { 5491da177e4SLinus Torvalds /* Hm. This may confuse static lock analysis. If any of the above 5501da177e4SLinus Torvalds three conditions is false, we're going to return from this 5511da177e4SLinus Torvalds function without actually obliterating any nodes or freeing 5521da177e4SLinus Torvalds any jffs2_raw_node_refs. So we don't need to stop erases from 5531da177e4SLinus Torvalds happening, or protect against people holding an obsolete 5541da177e4SLinus Torvalds jffs2_raw_node_ref without the erase_completion_lock. */ 555ced22070SDavid Woodhouse mutex_lock(&c->erase_free_sem); 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 5591da177e4SLinus Torvalds 5601417fc44SDavid Woodhouse freed_len = ref_totlen(c, jeb, ref); 5611417fc44SDavid Woodhouse 5621da177e4SLinus Torvalds if (ref_flags(ref) == REF_UNCHECKED) { 5631417fc44SDavid Woodhouse D1(if (unlikely(jeb->unchecked_size < freed_len)) { 5641da177e4SLinus Torvalds printk(KERN_NOTICE "raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n", 5651417fc44SDavid Woodhouse freed_len, blocknr, ref->flash_offset, jeb->used_size); 5661da177e4SLinus Torvalds BUG(); 5671da177e4SLinus Torvalds }) 5689c261b33SJoe Perches jffs2_dbg(1, "Obsoleting previously unchecked node at 0x%08x of len %x\n", 5699c261b33SJoe Perches ref_offset(ref), freed_len); 5701417fc44SDavid Woodhouse jeb->unchecked_size -= freed_len; 5711417fc44SDavid Woodhouse c->unchecked_size -= freed_len; 5721da177e4SLinus Torvalds } else { 5731417fc44SDavid Woodhouse D1(if (unlikely(jeb->used_size < freed_len)) { 5741da177e4SLinus Torvalds printk(KERN_NOTICE "raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n", 5751417fc44SDavid Woodhouse freed_len, blocknr, ref->flash_offset, jeb->used_size); 5761da177e4SLinus Torvalds BUG(); 5771da177e4SLinus Torvalds }) 5789c261b33SJoe Perches jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ", 5799c261b33SJoe Perches ref_offset(ref), freed_len); 5801417fc44SDavid Woodhouse jeb->used_size -= freed_len; 5811417fc44SDavid Woodhouse c->used_size -= freed_len; 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds // Take care, that wasted size is taken into concern 5851417fc44SDavid Woodhouse if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) { 5869c261b33SJoe Perches jffs2_dbg(1, "Dirtying\n"); 5871417fc44SDavid Woodhouse addedsize = freed_len; 5881417fc44SDavid Woodhouse jeb->dirty_size += freed_len; 5891417fc44SDavid Woodhouse c->dirty_size += freed_len; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds /* Convert wasted space to dirty, if not a bad block */ 5921da177e4SLinus Torvalds if (jeb->wasted_size) { 5931da177e4SLinus Torvalds if (on_list(&jeb->list, &c->bad_used_list)) { 5949c261b33SJoe Perches jffs2_dbg(1, "Leaving block at %08x on the bad_used_list\n", 5959c261b33SJoe Perches jeb->offset); 5961da177e4SLinus Torvalds addedsize = 0; /* To fool the refiling code later */ 5971da177e4SLinus Torvalds } else { 5989c261b33SJoe Perches jffs2_dbg(1, "Converting %d bytes of wasted space to dirty in block at %08x\n", 5999c261b33SJoe Perches jeb->wasted_size, jeb->offset); 6001da177e4SLinus Torvalds addedsize += jeb->wasted_size; 6011da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 6021da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 6031da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 6041da177e4SLinus Torvalds jeb->wasted_size = 0; 6051da177e4SLinus Torvalds } 6061da177e4SLinus Torvalds } 6071da177e4SLinus Torvalds } else { 6089c261b33SJoe Perches jffs2_dbg(1, "Wasting\n"); 6091da177e4SLinus Torvalds addedsize = 0; 6101417fc44SDavid Woodhouse jeb->wasted_size += freed_len; 6111417fc44SDavid Woodhouse c->wasted_size += freed_len; 6121da177e4SLinus Torvalds } 6131da177e4SLinus Torvalds ref->flash_offset = ref_offset(ref) | REF_OBSOLETE; 6141da177e4SLinus Torvalds 615e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c, jeb); 616e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 6171da177e4SLinus Torvalds 61831fbdf7aSArtem B. Bityuckiy if (c->flags & JFFS2_SB_FLAG_SCANNING) { 61931fbdf7aSArtem B. Bityuckiy /* Flash scanning is in progress. Don't muck about with the block 6201da177e4SLinus Torvalds lists because they're not ready yet, and don't actually 6211da177e4SLinus Torvalds obliterate nodes that look obsolete. If they weren't 6221da177e4SLinus Torvalds marked obsolete on the flash at the time they _became_ 6231da177e4SLinus Torvalds obsolete, there was probably a reason for that. */ 6241da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6251da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 6261da177e4SLinus Torvalds return; 6271da177e4SLinus Torvalds } 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds if (jeb == c->nextblock) { 6309c261b33SJoe Perches jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n", 6319c261b33SJoe Perches jeb->offset); 6321da177e4SLinus Torvalds } else if (!jeb->used_size && !jeb->unchecked_size) { 6331da177e4SLinus Torvalds if (jeb == c->gcblock) { 6349c261b33SJoe Perches jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", 6359c261b33SJoe Perches jeb->offset); 6361da177e4SLinus Torvalds c->gcblock = NULL; 6371da177e4SLinus Torvalds } else { 6389c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", 6399c261b33SJoe Perches jeb->offset); 6401da177e4SLinus Torvalds list_del(&jeb->list); 6411da177e4SLinus Torvalds } 6421da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 6439c261b33SJoe Perches jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n"); 6441da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 6451da177e4SLinus Torvalds } else { 6461da177e4SLinus Torvalds if (jiffies & 127) { 6471da177e4SLinus Torvalds /* Most of the time, we just erase it immediately. Otherwise we 6481da177e4SLinus Torvalds spend ages scanning it on mount, etc. */ 6499c261b33SJoe Perches jffs2_dbg(1, "...and adding to erase_pending_list\n"); 6501da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erase_pending_list); 6511da177e4SLinus Torvalds c->nr_erasing_blocks++; 652ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 6531da177e4SLinus Torvalds } else { 6541da177e4SLinus Torvalds /* Sometimes, however, we leave it elsewhere so it doesn't get 6551da177e4SLinus Torvalds immediately reused, and we spread the load a bit. */ 6569c261b33SJoe Perches jffs2_dbg(1, "...and adding to erasable_list\n"); 6571da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_list); 6581da177e4SLinus Torvalds } 6591da177e4SLinus Torvalds } 6609c261b33SJoe Perches jffs2_dbg(1, "Done OK\n"); 6611da177e4SLinus Torvalds } else if (jeb == c->gcblock) { 6629c261b33SJoe Perches jffs2_dbg(2, "Not moving gcblock 0x%08x to dirty_list\n", 6639c261b33SJoe Perches jeb->offset); 6641da177e4SLinus Torvalds } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 6659c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", 6669c261b33SJoe Perches jeb->offset); 6671da177e4SLinus Torvalds list_del(&jeb->list); 6689c261b33SJoe Perches jffs2_dbg(1, "...and adding to dirty_list\n"); 6691da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 6701da177e4SLinus Torvalds } else if (VERYDIRTY(c, jeb->dirty_size) && 6711da177e4SLinus Torvalds !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 6729c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", 6739c261b33SJoe Perches jeb->offset); 6741da177e4SLinus Torvalds list_del(&jeb->list); 6759c261b33SJoe Perches jffs2_dbg(1, "...and adding to very_dirty_list\n"); 6761da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 6771da177e4SLinus Torvalds } else { 6789c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 6799c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 6809c261b33SJoe Perches jeb->used_size); 6811da177e4SLinus Torvalds } 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6841da177e4SLinus Torvalds 68531fbdf7aSArtem B. Bityuckiy if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) || 68631fbdf7aSArtem B. Bityuckiy (c->flags & JFFS2_SB_FLAG_BUILDING)) { 6871da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 6881da177e4SLinus Torvalds return; 6891da177e4SLinus Torvalds } 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds /* The erase_free_sem is locked, and has been since before we marked the node obsolete 6921da177e4SLinus Torvalds and potentially put its eraseblock onto the erase_pending_list. Thus, we know that 6931da177e4SLinus Torvalds the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 694c38c1b61SDavid Woodhouse by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */ 6951da177e4SLinus Torvalds 6969c261b33SJoe Perches jffs2_dbg(1, "obliterating obsoleted node at 0x%08x\n", 6979c261b33SJoe Perches ref_offset(ref)); 6981da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 6991da177e4SLinus Torvalds if (ret) { 7001da177e4SLinus Torvalds printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 7011da177e4SLinus Torvalds goto out_erase_sem; 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds if (retlen != sizeof(n)) { 7041da177e4SLinus Torvalds printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 7051da177e4SLinus Torvalds goto out_erase_sem; 7061da177e4SLinus Torvalds } 7071417fc44SDavid Woodhouse if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) { 7081417fc44SDavid Woodhouse printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len); 7091da177e4SLinus Torvalds goto out_erase_sem; 7101da177e4SLinus Torvalds } 7111da177e4SLinus Torvalds if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 7129c261b33SJoe Perches jffs2_dbg(1, "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", 7139c261b33SJoe Perches ref_offset(ref), je16_to_cpu(n.nodetype)); 7141da177e4SLinus Torvalds goto out_erase_sem; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds /* XXX FIXME: This is ugly now */ 7171da177e4SLinus Torvalds n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 7181da177e4SLinus Torvalds ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 7191da177e4SLinus Torvalds if (ret) { 7201da177e4SLinus Torvalds printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 7211da177e4SLinus Torvalds goto out_erase_sem; 7221da177e4SLinus Torvalds } 7231da177e4SLinus Torvalds if (retlen != sizeof(n)) { 7241da177e4SLinus Torvalds printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 7251da177e4SLinus Torvalds goto out_erase_sem; 7261da177e4SLinus Torvalds } 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds /* Nodes which have been marked obsolete no longer need to be 7291da177e4SLinus Torvalds associated with any inode. Remove them from the per-inode list. 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds Note we can't do this for NAND at the moment because we need 7321da177e4SLinus Torvalds obsolete dirent nodes to stay on the lists, because of the 7331da177e4SLinus Torvalds horridness in jffs2_garbage_collect_deletion_dirent(). Also 7341da177e4SLinus Torvalds because we delete the inocache, and on NAND we need that to 7351da177e4SLinus Torvalds stay around until all the nodes are actually erased, in order 7361da177e4SLinus Torvalds to stop us from giving the same inode number to another newly 7371da177e4SLinus Torvalds created inode. */ 7381da177e4SLinus Torvalds if (ref->next_in_ino) { 7391da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 7401da177e4SLinus Torvalds struct jffs2_raw_node_ref **p; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds ic = jffs2_raw_ref_to_ic(ref); 7451da177e4SLinus Torvalds for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino)) 7461da177e4SLinus Torvalds ; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds *p = ref->next_in_ino; 7491da177e4SLinus Torvalds ref->next_in_ino = NULL; 7501da177e4SLinus Torvalds 751c9f700f8SKaiGai Kohei switch (ic->class) { 752c9f700f8SKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 753c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_DATUM: 754c9f700f8SKaiGai Kohei jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic); 755c9f700f8SKaiGai Kohei break; 756c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_REF: 757c9f700f8SKaiGai Kohei jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic); 758c9f700f8SKaiGai Kohei break; 759c9f700f8SKaiGai Kohei #endif 760c9f700f8SKaiGai Kohei default: 76127c72b04SDavid Woodhouse if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 7621da177e4SLinus Torvalds jffs2_del_ino_cache(c, ic); 763c9f700f8SKaiGai Kohei break; 764c9f700f8SKaiGai Kohei } 7651da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 7661da177e4SLinus Torvalds } 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds out_erase_sem: 769ced22070SDavid Woodhouse mutex_unlock(&c->erase_free_sem); 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds int jffs2_thread_should_wake(struct jffs2_sb_info *c) 7731da177e4SLinus Torvalds { 7741da177e4SLinus Torvalds int ret = 0; 7751da177e4SLinus Torvalds uint32_t dirty; 7768fb870dfSDavid Woodhouse int nr_very_dirty = 0; 7778fb870dfSDavid Woodhouse struct jffs2_eraseblock *jeb; 7781da177e4SLinus Torvalds 779d6ce1710SJoakim Tjernlund if (!list_empty(&c->erase_complete_list) || 780d6ce1710SJoakim Tjernlund !list_empty(&c->erase_pending_list)) 781d6ce1710SJoakim Tjernlund return 1; 782d6ce1710SJoakim Tjernlund 7831da177e4SLinus Torvalds if (c->unchecked_size) { 7849c261b33SJoe Perches jffs2_dbg(1, "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 7859c261b33SJoe Perches c->unchecked_size, c->checked_ino); 7861da177e4SLinus Torvalds return 1; 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds /* dirty_size contains blocks on erase_pending_list 7901da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 7911da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 7921da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 7931da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 7941da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 7951da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 7961da177e4SLinus Torvalds */ 7971da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size; 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger && 8001da177e4SLinus Torvalds (dirty > c->nospc_dirty_size)) 8011da177e4SLinus Torvalds ret = 1; 8021da177e4SLinus Torvalds 8038fb870dfSDavid Woodhouse list_for_each_entry(jeb, &c->very_dirty_list, list) { 8048fb870dfSDavid Woodhouse nr_very_dirty++; 8058fb870dfSDavid Woodhouse if (nr_very_dirty == c->vdirty_blocks_gctrigger) { 8068fb870dfSDavid Woodhouse ret = 1; 807a8c68f32SDavid Woodhouse /* In debug mode, actually go through and count them all */ 808a8c68f32SDavid Woodhouse D1(continue); 809a8c68f32SDavid Woodhouse break; 8108fb870dfSDavid Woodhouse } 8118fb870dfSDavid Woodhouse } 8128fb870dfSDavid Woodhouse 8139c261b33SJoe Perches jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 8149c261b33SJoe Perches __func__, c->nr_free_blocks, c->nr_erasing_blocks, 8159c261b33SJoe Perches c->dirty_size, nr_very_dirty, ret ? "yes" : "no"); 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds return ret; 8181da177e4SLinus Torvalds } 819