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/slab.h> 141da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 151da177e4SLinus Torvalds #include <linux/compiler.h> 161da177e4SLinus Torvalds #include <linux/sched.h> /* For cond_resched() */ 171da177e4SLinus Torvalds #include "nodelist.h" 18e631ddbaSFerenc Havasi #include "debug.h" 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds /** 211da177e4SLinus Torvalds * jffs2_reserve_space - request physical space to write nodes to flash 221da177e4SLinus Torvalds * @c: superblock info 231da177e4SLinus Torvalds * @minsize: Minimum acceptable size of allocation 241da177e4SLinus Torvalds * @len: Returned value of allocation length 251da177e4SLinus Torvalds * @prio: Allocation type - ALLOC_{NORMAL,DELETION} 261da177e4SLinus Torvalds * 271da177e4SLinus Torvalds * Requests a block of physical space on the flash. Returns zero for success 289fe4854cSDavid Woodhouse * and puts 'len' into the appropriate place, or returns -ENOSPC or other 299fe4854cSDavid Woodhouse * error if appropriate. Doesn't return len since that's 301da177e4SLinus Torvalds * 311da177e4SLinus Torvalds * If it returns zero, jffs2_reserve_space() also downs the per-filesystem 321da177e4SLinus Torvalds * allocation semaphore, to prevent more than one allocation from being 331da177e4SLinus Torvalds * active at any time. The semaphore is later released by jffs2_commit_allocation() 341da177e4SLinus Torvalds * 351da177e4SLinus Torvalds * jffs2_reserve_space() may trigger garbage collection in order to make room 361da177e4SLinus Torvalds * for the requested allocation. 371da177e4SLinus Torvalds */ 381da177e4SLinus Torvalds 39e631ddbaSFerenc Havasi static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 409fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize); 411da177e4SLinus Torvalds 429fe4854cSDavid Woodhouse int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 43e631ddbaSFerenc Havasi uint32_t *len, int prio, uint32_t sumsize) 441da177e4SLinus Torvalds { 451da177e4SLinus Torvalds int ret = -EAGAIN; 461da177e4SLinus Torvalds int blocksneeded = c->resv_blocks_write; 471da177e4SLinus Torvalds /* align it */ 481da177e4SLinus Torvalds minsize = PAD(minsize); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space(): Requested 0x%x bytes\n", minsize)); 51ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space(): alloc sem got\n")); 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds /* this needs a little more thought (true <tglx> :)) */ 581da177e4SLinus Torvalds while(ret == -EAGAIN) { 591da177e4SLinus Torvalds while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) { 601da177e4SLinus Torvalds uint32_t dirty, avail; 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* calculate real dirty size 631da177e4SLinus Torvalds * dirty_size contains blocks on erase_pending_list 641da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 651da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 661da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 671da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 681da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 691da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 701da177e4SLinus Torvalds * We add unchecked_size here, as we hopefully will find some space to use. 711da177e4SLinus Torvalds * This will affect the sum only once, as gc first finishes checking 721da177e4SLinus Torvalds * of nodes. 731da177e4SLinus Torvalds */ 741da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 751da177e4SLinus Torvalds if (dirty < c->nospc_dirty_size) { 761da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 774132ace8SArtem B. Bityuckiy D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on dirty space to GC, but it's a deletion. Allowing...\n")); 781da177e4SLinus Torvalds break; 791da177e4SLinus Torvalds } 801da177e4SLinus Torvalds D1(printk(KERN_DEBUG "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 811da177e4SLinus Torvalds dirty, c->unchecked_size, c->sector_size)); 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 84ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 851da177e4SLinus Torvalds return -ENOSPC; 861da177e4SLinus Torvalds } 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds /* Calc possibly available space. Possibly available means that we 891da177e4SLinus Torvalds * don't know, if unchecked size contains obsoleted nodes, which could give us some 901da177e4SLinus Torvalds * more usable space. This will affect the sum only once, as gc first finishes checking 911da177e4SLinus Torvalds * of nodes. 921da177e4SLinus Torvalds + Return -ENOSPC, if the maximum possibly available space is less or equal than 931da177e4SLinus Torvalds * blocksneeded * sector_size. 941da177e4SLinus Torvalds * This blocks endless gc looping on a filesystem, which is nearly full, even if 951da177e4SLinus Torvalds * the check above passes. 961da177e4SLinus Torvalds */ 971da177e4SLinus Torvalds avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 981da177e4SLinus Torvalds if ( (avail / c->sector_size) <= blocksneeded) { 991da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 1004132ace8SArtem B. Bityuckiy D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on possibly available space, but it's a deletion. Allowing...\n")); 1011da177e4SLinus Torvalds break; 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds D1(printk(KERN_DEBUG "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 1051da177e4SLinus Torvalds avail, blocksneeded * c->sector_size)); 1061da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 107ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1081da177e4SLinus Torvalds return -ENOSPC; 1091da177e4SLinus Torvalds } 1101da177e4SLinus Torvalds 111ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds D1(printk(KERN_DEBUG "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", 1141da177e4SLinus Torvalds c->nr_free_blocks, c->nr_erasing_blocks, c->free_size, c->dirty_size, c->wasted_size, c->used_size, c->erasing_size, c->bad_size, 1151da177e4SLinus Torvalds c->free_size + c->dirty_size + c->wasted_size + c->used_size + c->erasing_size + c->bad_size, c->flash_size)); 1161da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds ret = jffs2_garbage_collect_pass(c); 119422b1202SDavid Woodhouse 120422b1202SDavid Woodhouse if (ret == -EAGAIN) 121422b1202SDavid Woodhouse jffs2_erase_pending_blocks(c, 1); 122422b1202SDavid Woodhouse else if (ret) 1231da177e4SLinus Torvalds return ret; 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds cond_resched(); 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds if (signal_pending(current)) 1281da177e4SLinus Torvalds return -EINTR; 1291da177e4SLinus Torvalds 130ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 1311da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1321da177e4SLinus Torvalds } 1331da177e4SLinus Torvalds 1349fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1351da177e4SLinus Torvalds if (ret) { 1361da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret)); 1371da177e4SLinus Torvalds } 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1402f785402SDavid Woodhouse if (!ret) 141046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 1421da177e4SLinus Torvalds if (ret) 143ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1441da177e4SLinus Torvalds return ret; 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 1479fe4854cSDavid Woodhouse int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, 148e631ddbaSFerenc Havasi uint32_t *len, uint32_t sumsize) 1491da177e4SLinus Torvalds { 1501da177e4SLinus Torvalds int ret = -EAGAIN; 1511da177e4SLinus Torvalds minsize = PAD(minsize); 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize)); 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1561da177e4SLinus Torvalds while(ret == -EAGAIN) { 1579fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1581da177e4SLinus Torvalds if (ret) { 1591da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret)); 1601da177e4SLinus Torvalds } 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1632f785402SDavid Woodhouse if (!ret) 164046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 1652f785402SDavid Woodhouse 1661da177e4SLinus Torvalds return ret; 1671da177e4SLinus Torvalds } 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds 170e631ddbaSFerenc Havasi /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */ 171e631ddbaSFerenc Havasi 172e631ddbaSFerenc Havasi static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 173e631ddbaSFerenc Havasi { 1741da177e4SLinus Torvalds 17599c2594fSAdrian Hunter if (c->nextblock == NULL) { 17699c2594fSAdrian Hunter D1(printk(KERN_DEBUG "jffs2_close_nextblock: Erase block at 0x%08x has already been placed in a list\n", 17799c2594fSAdrian Hunter jeb->offset)); 17899c2594fSAdrian Hunter return; 17999c2594fSAdrian Hunter } 1801da177e4SLinus Torvalds /* Check, if we have a dirty block now, or if it was dirty already */ 1811da177e4SLinus Torvalds if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) { 1821da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 1831da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 1841da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 1851da177e4SLinus Torvalds jeb->wasted_size = 0; 1861da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 1871da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 1881da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 1891da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 1901da177e4SLinus Torvalds } else { 1911da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 1921da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 1931da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds } else { 1961da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 1971da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 1981da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 1991da177e4SLinus Torvalds } 200e631ddbaSFerenc Havasi c->nextblock = NULL; 201e631ddbaSFerenc Havasi 2021da177e4SLinus Torvalds } 2031da177e4SLinus Torvalds 204e631ddbaSFerenc Havasi /* Select a new jeb for nextblock */ 205e631ddbaSFerenc Havasi 206e631ddbaSFerenc Havasi static int jffs2_find_nextblock(struct jffs2_sb_info *c) 207e631ddbaSFerenc Havasi { 2081da177e4SLinus Torvalds struct list_head *next; 209e631ddbaSFerenc Havasi 2101da177e4SLinus Torvalds /* Take the next block off the 'free' list */ 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds if (list_empty(&c->free_list)) { 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2151da177e4SLinus Torvalds !list_empty(&c->erasable_list)) { 2161da177e4SLinus Torvalds struct jffs2_eraseblock *ejeb; 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list); 219f116629dSAkinobu Mita list_move_tail(&ejeb->list, &c->erase_pending_list); 2201da177e4SLinus Torvalds c->nr_erasing_blocks++; 2211da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 222e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_find_nextblock: Triggering erase of erasable block at 0x%08x\n", 2231da177e4SLinus Torvalds ejeb->offset)); 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2271da177e4SLinus Torvalds !list_empty(&c->erasable_pending_wbuf_list)) { 228e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_find_nextblock: Flushing write buffer\n")); 2291da177e4SLinus Torvalds /* c->nextblock is NULL, no update to c->nextblock allowed */ 2301da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2311da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 2321da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2331da177e4SLinus Torvalds /* Have another go. It'll be on the erasable_list now */ 2341da177e4SLinus Torvalds return -EAGAIN; 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds if (!c->nr_erasing_blocks) { 2381da177e4SLinus Torvalds /* Ouch. We're in GC, or we wouldn't have got here. 2391da177e4SLinus Torvalds And there's no space left. At all. */ 2401da177e4SLinus 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", 2411da177e4SLinus Torvalds c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no", 2421da177e4SLinus Torvalds list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"); 2431da177e4SLinus Torvalds return -ENOSPC; 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2471da177e4SLinus Torvalds /* Don't wait for it; just erase one right now */ 2481da177e4SLinus Torvalds jffs2_erase_pending_blocks(c, 1); 2491da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* An erase may have failed, decreasing the 2521da177e4SLinus Torvalds amount of free space available. So we must 2531da177e4SLinus Torvalds restart from the beginning */ 2541da177e4SLinus Torvalds return -EAGAIN; 2551da177e4SLinus Torvalds } 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds next = c->free_list.next; 2581da177e4SLinus Torvalds list_del(next); 259e631ddbaSFerenc Havasi c->nextblock = list_entry(next, struct jffs2_eraseblock, list); 2601da177e4SLinus Torvalds c->nr_free_blocks--; 2611da177e4SLinus Torvalds 262e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); /* reset collected summary */ 263e631ddbaSFerenc Havasi 264f04de505SSteve Glendinning #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 2655bf17237SAlexander Belyakov /* adjust write buffer offset, else we get a non contiguous write bug */ 2665bf17237SAlexander Belyakov if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len) 2675bf17237SAlexander Belyakov c->wbuf_ofs = 0xffffffff; 268f04de505SSteve Glendinning #endif 2695bf17237SAlexander Belyakov 270e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_find_nextblock(): new nextblock = 0x%08x\n", c->nextblock->offset)); 271e631ddbaSFerenc Havasi 272e631ddbaSFerenc Havasi return 0; 273e631ddbaSFerenc Havasi } 274e631ddbaSFerenc Havasi 275e631ddbaSFerenc Havasi /* Called with alloc sem _and_ erase_completion_lock */ 2769fe4854cSDavid Woodhouse static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 2779fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize) 278e631ddbaSFerenc Havasi { 279e631ddbaSFerenc Havasi struct jffs2_eraseblock *jeb = c->nextblock; 280e631ddbaSFerenc Havasi uint32_t reserved_size; /* for summary information at the end of the jeb */ 281e631ddbaSFerenc Havasi int ret; 282e631ddbaSFerenc Havasi 283e631ddbaSFerenc Havasi restart: 284e631ddbaSFerenc Havasi reserved_size = 0; 285e631ddbaSFerenc Havasi 286e631ddbaSFerenc Havasi if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) { 287e631ddbaSFerenc Havasi /* NOSUM_SIZE means not to generate summary */ 288e631ddbaSFerenc Havasi 289e631ddbaSFerenc Havasi if (jeb) { 290e631ddbaSFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 291733802d9SArtem B. Bityutskiy dbg_summary("minsize=%d , jeb->free=%d ," 292e631ddbaSFerenc Havasi "summary->size=%d , sumsize=%d\n", 293e631ddbaSFerenc Havasi minsize, jeb->free_size, 294e631ddbaSFerenc Havasi c->summary->sum_size, sumsize); 295e631ddbaSFerenc Havasi } 296e631ddbaSFerenc Havasi 297e631ddbaSFerenc Havasi /* Is there enough space for writing out the current node, or we have to 298e631ddbaSFerenc Havasi write out summary information now, close this jeb and select new nextblock? */ 299e631ddbaSFerenc Havasi if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize + 300e631ddbaSFerenc Havasi JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) { 301e631ddbaSFerenc Havasi 302e631ddbaSFerenc Havasi /* Has summary been disabled for this jeb? */ 303e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 304e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 305e631ddbaSFerenc Havasi goto restart; 306e631ddbaSFerenc Havasi } 307e631ddbaSFerenc Havasi 308e631ddbaSFerenc Havasi /* Writing out the collected summary information */ 309733802d9SArtem B. Bityutskiy dbg_summary("generating summary for 0x%08x.\n", jeb->offset); 310e631ddbaSFerenc Havasi ret = jffs2_sum_write_sumnode(c); 311e631ddbaSFerenc Havasi 312e631ddbaSFerenc Havasi if (ret) 313e631ddbaSFerenc Havasi return ret; 314e631ddbaSFerenc Havasi 315e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 316e631ddbaSFerenc Havasi /* jffs2_write_sumnode() couldn't write out the summary information 317e631ddbaSFerenc Havasi diabling summary for this jeb and free the collected information 318e631ddbaSFerenc Havasi */ 319e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 320e631ddbaSFerenc Havasi goto restart; 321e631ddbaSFerenc Havasi } 322e631ddbaSFerenc Havasi 323e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 324e631ddbaSFerenc Havasi jeb = NULL; 32534c0e906SFerenc Havasi /* keep always valid value in reserved_size */ 32634c0e906SFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 327e631ddbaSFerenc Havasi } 328e631ddbaSFerenc Havasi } else { 329e631ddbaSFerenc Havasi if (jeb && minsize > jeb->free_size) { 330fc6612f6SDavid Woodhouse uint32_t waste; 331fc6612f6SDavid Woodhouse 332e631ddbaSFerenc Havasi /* Skip the end of this block and file it as having some dirty space */ 333e631ddbaSFerenc Havasi /* If there's a pending write to it, flush now */ 334e631ddbaSFerenc Havasi 335e631ddbaSFerenc Havasi if (jffs2_wbuf_dirty(c)) { 336e631ddbaSFerenc Havasi spin_unlock(&c->erase_completion_lock); 337e631ddbaSFerenc Havasi D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n")); 338e631ddbaSFerenc Havasi jffs2_flush_wbuf_pad(c); 339e631ddbaSFerenc Havasi spin_lock(&c->erase_completion_lock); 340e631ddbaSFerenc Havasi jeb = c->nextblock; 341e631ddbaSFerenc Havasi goto restart; 342e631ddbaSFerenc Havasi } 343e631ddbaSFerenc Havasi 344fc6612f6SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 345fc6612f6SDavid Woodhouse 346fc6612f6SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, jeb, 1); 347fc6612f6SDavid Woodhouse if (ret) 348fc6612f6SDavid Woodhouse return ret; 349fc6612f6SDavid Woodhouse /* Just lock it again and continue. Nothing much can change because 350fc6612f6SDavid Woodhouse we hold c->alloc_sem anyway. In fact, it's not entirely clear why 351fc6612f6SDavid Woodhouse we hold c->erase_completion_lock in the majority of this function... 352fc6612f6SDavid Woodhouse but that's a question for another (more caffeine-rich) day. */ 353fc6612f6SDavid Woodhouse spin_lock(&c->erase_completion_lock); 354fc6612f6SDavid Woodhouse 355fc6612f6SDavid Woodhouse waste = jeb->free_size; 356fc6612f6SDavid Woodhouse jffs2_link_node_ref(c, jeb, 357fc6612f6SDavid Woodhouse (jeb->offset + c->sector_size - waste) | REF_OBSOLETE, 358fc6612f6SDavid Woodhouse waste, NULL); 359fc6612f6SDavid Woodhouse /* FIXME: that made it count as dirty. Convert to wasted */ 360fc6612f6SDavid Woodhouse jeb->dirty_size -= waste; 361fc6612f6SDavid Woodhouse c->dirty_size -= waste; 362fc6612f6SDavid Woodhouse jeb->wasted_size += waste; 363fc6612f6SDavid Woodhouse c->wasted_size += waste; 364e631ddbaSFerenc Havasi 365e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 366e631ddbaSFerenc Havasi jeb = NULL; 367e631ddbaSFerenc Havasi } 368e631ddbaSFerenc Havasi } 369e631ddbaSFerenc Havasi 370e631ddbaSFerenc Havasi if (!jeb) { 371e631ddbaSFerenc Havasi 372e631ddbaSFerenc Havasi ret = jffs2_find_nextblock(c); 373e631ddbaSFerenc Havasi if (ret) 374e631ddbaSFerenc Havasi return ret; 375e631ddbaSFerenc Havasi 376e631ddbaSFerenc Havasi jeb = c->nextblock; 377e631ddbaSFerenc Havasi 3781da177e4SLinus Torvalds if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 3791da177e4SLinus Torvalds printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size); 3801da177e4SLinus Torvalds goto restart; 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has 3841da177e4SLinus Torvalds enough space */ 385e631ddbaSFerenc Havasi *len = jeb->free_size - reserved_size; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size && 3881da177e4SLinus Torvalds !jeb->first_node->next_in_ino) { 3891da177e4SLinus Torvalds /* Only node in it beforehand was a CLEANMARKER node (we think). 3901da177e4SLinus Torvalds So mark it obsolete now that there's going to be another node 3911da177e4SLinus Torvalds in the block. This will reduce used_size to zero but We've 3921da177e4SLinus Torvalds already set c->nextblock so that jffs2_mark_node_obsolete() 3931da177e4SLinus Torvalds won't try to refile it to the dirty_list. 3941da177e4SLinus Torvalds */ 3951da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3961da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, jeb->first_node); 3971da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 3981da177e4SLinus Torvalds } 3991da177e4SLinus Torvalds 4009fe4854cSDavid Woodhouse D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n", 4019fe4854cSDavid Woodhouse *len, jeb->offset + (c->sector_size - jeb->free_size))); 4021da177e4SLinus Torvalds return 0; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds /** 4061da177e4SLinus Torvalds * jffs2_add_physical_node_ref - add a physical node reference to the list 4071da177e4SLinus Torvalds * @c: superblock info 4081da177e4SLinus Torvalds * @new: new node reference to add 4091da177e4SLinus Torvalds * @len: length of this physical node 4101da177e4SLinus Torvalds * 4111da177e4SLinus Torvalds * Should only be used to report nodes for which space has been allocated 4121da177e4SLinus Torvalds * by jffs2_reserve_space. 4131da177e4SLinus Torvalds * 4141da177e4SLinus Torvalds * Must be called with the alloc_sem held. 4151da177e4SLinus Torvalds */ 4161da177e4SLinus Torvalds 4172f785402SDavid Woodhouse struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, 4182f785402SDavid Woodhouse uint32_t ofs, uint32_t len, 4192f785402SDavid Woodhouse struct jffs2_inode_cache *ic) 4201da177e4SLinus Torvalds { 4211da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 4222f785402SDavid Woodhouse struct jffs2_raw_node_ref *new; 4231da177e4SLinus Torvalds 4242f785402SDavid Woodhouse jeb = &c->blocks[ofs / c->sector_size]; 4251da177e4SLinus Torvalds 4262f785402SDavid Woodhouse D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n", 4272f785402SDavid Woodhouse ofs & ~3, ofs & 3, len)); 4281da177e4SLinus Torvalds #if 1 4292f785402SDavid Woodhouse /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 4302f785402SDavid Woodhouse if c->nextblock is set. Note that wbuf.c will file obsolete nodes 4312f785402SDavid Woodhouse even after refiling c->nextblock */ 4322f785402SDavid Woodhouse if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 4332f785402SDavid Woodhouse && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 43466bfaeaaSDavid Woodhouse printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3); 43566bfaeaaSDavid Woodhouse if (c->nextblock) 43666bfaeaaSDavid Woodhouse printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset); 43766bfaeaaSDavid Woodhouse else 43866bfaeaaSDavid Woodhouse printk(KERN_WARNING "No nextblock"); 43966bfaeaaSDavid Woodhouse printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size)); 4402f785402SDavid Woodhouse return ERR_PTR(-EINVAL); 4411da177e4SLinus Torvalds } 4421da177e4SLinus Torvalds #endif 4431da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4441da177e4SLinus Torvalds 4452f785402SDavid Woodhouse new = jffs2_link_node_ref(c, jeb, ofs, len, ic); 4461da177e4SLinus Torvalds 4479b88f473SEstelle Hammache if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 4481da177e4SLinus Torvalds /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 4491da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 4501da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 4511da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 4521da177e4SLinus Torvalds /* Flush the last write in the block if it's outstanding */ 4531da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4541da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 4551da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 4591da177e4SLinus Torvalds c->nextblock = NULL; 4601da177e4SLinus Torvalds } 461e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c,jeb); 462e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4651da177e4SLinus Torvalds 4662f785402SDavid Woodhouse return new; 4671da177e4SLinus Torvalds } 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds void jffs2_complete_reservation(struct jffs2_sb_info *c) 4711da177e4SLinus Torvalds { 4721da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n")); 4731da177e4SLinus Torvalds jffs2_garbage_collect_trigger(c); 474ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds static inline int on_list(struct list_head *obj, struct list_head *head) 4781da177e4SLinus Torvalds { 4791da177e4SLinus Torvalds struct list_head *this; 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds list_for_each(this, head) { 4821da177e4SLinus Torvalds if (this == obj) { 4831da177e4SLinus Torvalds D1(printk("%p is on list at %p\n", obj, head)); 4841da177e4SLinus Torvalds return 1; 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds return 0; 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref) 4921da177e4SLinus Torvalds { 4931da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 4941da177e4SLinus Torvalds int blocknr; 4951da177e4SLinus Torvalds struct jffs2_unknown_node n; 4961da177e4SLinus Torvalds int ret, addedsize; 4971da177e4SLinus Torvalds size_t retlen; 4981417fc44SDavid Woodhouse uint32_t freed_len; 4991da177e4SLinus Torvalds 5009bfeb691SDavid Woodhouse if(unlikely(!ref)) { 5011da177e4SLinus Torvalds printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 5021da177e4SLinus Torvalds return; 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds if (ref_obsolete(ref)) { 5051da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref))); 5061da177e4SLinus Torvalds return; 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds blocknr = ref->flash_offset / c->sector_size; 5091da177e4SLinus Torvalds if (blocknr >= c->nr_blocks) { 5101da177e4SLinus Torvalds printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset); 5111da177e4SLinus Torvalds BUG(); 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds jeb = &c->blocks[blocknr]; 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) && 51631fbdf7aSArtem B. Bityuckiy !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) { 5171da177e4SLinus Torvalds /* Hm. This may confuse static lock analysis. If any of the above 5181da177e4SLinus Torvalds three conditions is false, we're going to return from this 5191da177e4SLinus Torvalds function without actually obliterating any nodes or freeing 5201da177e4SLinus Torvalds any jffs2_raw_node_refs. So we don't need to stop erases from 5211da177e4SLinus Torvalds happening, or protect against people holding an obsolete 5221da177e4SLinus Torvalds jffs2_raw_node_ref without the erase_completion_lock. */ 523ced22070SDavid Woodhouse mutex_lock(&c->erase_free_sem); 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 5271da177e4SLinus Torvalds 5281417fc44SDavid Woodhouse freed_len = ref_totlen(c, jeb, ref); 5291417fc44SDavid Woodhouse 5301da177e4SLinus Torvalds if (ref_flags(ref) == REF_UNCHECKED) { 5311417fc44SDavid Woodhouse D1(if (unlikely(jeb->unchecked_size < freed_len)) { 5321da177e4SLinus 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", 5331417fc44SDavid Woodhouse freed_len, blocknr, ref->flash_offset, jeb->used_size); 5341da177e4SLinus Torvalds BUG(); 5351da177e4SLinus Torvalds }) 5361417fc44SDavid Woodhouse D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), freed_len)); 5371417fc44SDavid Woodhouse jeb->unchecked_size -= freed_len; 5381417fc44SDavid Woodhouse c->unchecked_size -= freed_len; 5391da177e4SLinus Torvalds } else { 5401417fc44SDavid Woodhouse D1(if (unlikely(jeb->used_size < freed_len)) { 5411da177e4SLinus 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", 5421417fc44SDavid Woodhouse freed_len, blocknr, ref->flash_offset, jeb->used_size); 5431da177e4SLinus Torvalds BUG(); 5441da177e4SLinus Torvalds }) 5451417fc44SDavid Woodhouse D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), freed_len)); 5461417fc44SDavid Woodhouse jeb->used_size -= freed_len; 5471417fc44SDavid Woodhouse c->used_size -= freed_len; 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds // Take care, that wasted size is taken into concern 5511417fc44SDavid Woodhouse if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) { 552c7c16c8eSDavid Woodhouse D1(printk("Dirtying\n")); 5531417fc44SDavid Woodhouse addedsize = freed_len; 5541417fc44SDavid Woodhouse jeb->dirty_size += freed_len; 5551417fc44SDavid Woodhouse c->dirty_size += freed_len; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds /* Convert wasted space to dirty, if not a bad block */ 5581da177e4SLinus Torvalds if (jeb->wasted_size) { 5591da177e4SLinus Torvalds if (on_list(&jeb->list, &c->bad_used_list)) { 5601da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Leaving block at %08x on the bad_used_list\n", 5611da177e4SLinus Torvalds jeb->offset)); 5621da177e4SLinus Torvalds addedsize = 0; /* To fool the refiling code later */ 5631da177e4SLinus Torvalds } else { 5641da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Converting %d bytes of wasted space to dirty in block at %08x\n", 5651da177e4SLinus Torvalds jeb->wasted_size, jeb->offset)); 5661da177e4SLinus Torvalds addedsize += jeb->wasted_size; 5671da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 5681da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 5691da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 5701da177e4SLinus Torvalds jeb->wasted_size = 0; 5711da177e4SLinus Torvalds } 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds } else { 574c7c16c8eSDavid Woodhouse D1(printk("Wasting\n")); 5751da177e4SLinus Torvalds addedsize = 0; 5761417fc44SDavid Woodhouse jeb->wasted_size += freed_len; 5771417fc44SDavid Woodhouse c->wasted_size += freed_len; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds ref->flash_offset = ref_offset(ref) | REF_OBSOLETE; 5801da177e4SLinus Torvalds 581e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c, jeb); 582e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 5831da177e4SLinus Torvalds 58431fbdf7aSArtem B. Bityuckiy if (c->flags & JFFS2_SB_FLAG_SCANNING) { 58531fbdf7aSArtem B. Bityuckiy /* Flash scanning is in progress. Don't muck about with the block 5861da177e4SLinus Torvalds lists because they're not ready yet, and don't actually 5871da177e4SLinus Torvalds obliterate nodes that look obsolete. If they weren't 5881da177e4SLinus Torvalds marked obsolete on the flash at the time they _became_ 5891da177e4SLinus Torvalds obsolete, there was probably a reason for that. */ 5901da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 5911da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 5921da177e4SLinus Torvalds return; 5931da177e4SLinus Torvalds } 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds if (jeb == c->nextblock) { 5961da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset)); 5971da177e4SLinus Torvalds } else if (!jeb->used_size && !jeb->unchecked_size) { 5981da177e4SLinus Torvalds if (jeb == c->gcblock) { 5991da177e4SLinus Torvalds D1(printk(KERN_DEBUG "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb->offset)); 6001da177e4SLinus Torvalds c->gcblock = NULL; 6011da177e4SLinus Torvalds } else { 6021da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset)); 6031da177e4SLinus Torvalds list_del(&jeb->list); 6041da177e4SLinus Torvalds } 6051da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 6061da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to erasable_pending_wbuf_list\n")); 6071da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 6081da177e4SLinus Torvalds } else { 6091da177e4SLinus Torvalds if (jiffies & 127) { 6101da177e4SLinus Torvalds /* Most of the time, we just erase it immediately. Otherwise we 6111da177e4SLinus Torvalds spend ages scanning it on mount, etc. */ 6121da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n")); 6131da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erase_pending_list); 6141da177e4SLinus Torvalds c->nr_erasing_blocks++; 6151da177e4SLinus Torvalds jffs2_erase_pending_trigger(c); 6161da177e4SLinus Torvalds } else { 6171da177e4SLinus Torvalds /* Sometimes, however, we leave it elsewhere so it doesn't get 6181da177e4SLinus Torvalds immediately reused, and we spread the load a bit. */ 6191da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to erasable_list\n")); 6201da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_list); 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Done OK\n")); 6241da177e4SLinus Torvalds } else if (jeb == c->gcblock) { 6251da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty_list\n", jeb->offset)); 6261da177e4SLinus Torvalds } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 6271da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset)); 6281da177e4SLinus Torvalds list_del(&jeb->list); 6291da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to dirty_list\n")); 6301da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 6311da177e4SLinus Torvalds } else if (VERYDIRTY(c, jeb->dirty_size) && 6321da177e4SLinus Torvalds !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 6331da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb->offset)); 6341da177e4SLinus Torvalds list_del(&jeb->list); 6351da177e4SLinus Torvalds D1(printk(KERN_DEBUG "...and adding to very_dirty_list\n")); 6361da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 6371da177e4SLinus Torvalds } else { 6381da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 6391da177e4SLinus Torvalds jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6431da177e4SLinus Torvalds 64431fbdf7aSArtem B. Bityuckiy if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) || 64531fbdf7aSArtem B. Bityuckiy (c->flags & JFFS2_SB_FLAG_BUILDING)) { 6461da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 6471da177e4SLinus Torvalds return; 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds /* The erase_free_sem is locked, and has been since before we marked the node obsolete 6511da177e4SLinus Torvalds and potentially put its eraseblock onto the erase_pending_list. Thus, we know that 6521da177e4SLinus Torvalds the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 653c38c1b61SDavid Woodhouse by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */ 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref))); 6561da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 6571da177e4SLinus Torvalds if (ret) { 6581da177e4SLinus Torvalds printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 6591da177e4SLinus Torvalds goto out_erase_sem; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds if (retlen != sizeof(n)) { 6621da177e4SLinus Torvalds printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 6631da177e4SLinus Torvalds goto out_erase_sem; 6641da177e4SLinus Torvalds } 6651417fc44SDavid Woodhouse if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) { 6661417fc44SDavid Woodhouse printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len); 6671da177e4SLinus Torvalds goto out_erase_sem; 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 6701da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", ref_offset(ref), je16_to_cpu(n.nodetype))); 6711da177e4SLinus Torvalds goto out_erase_sem; 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds /* XXX FIXME: This is ugly now */ 6741da177e4SLinus Torvalds n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 6751da177e4SLinus Torvalds ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 6761da177e4SLinus Torvalds if (ret) { 6771da177e4SLinus Torvalds printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 6781da177e4SLinus Torvalds goto out_erase_sem; 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds if (retlen != sizeof(n)) { 6811da177e4SLinus Torvalds printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 6821da177e4SLinus Torvalds goto out_erase_sem; 6831da177e4SLinus Torvalds } 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds /* Nodes which have been marked obsolete no longer need to be 6861da177e4SLinus Torvalds associated with any inode. Remove them from the per-inode list. 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds Note we can't do this for NAND at the moment because we need 6891da177e4SLinus Torvalds obsolete dirent nodes to stay on the lists, because of the 6901da177e4SLinus Torvalds horridness in jffs2_garbage_collect_deletion_dirent(). Also 6911da177e4SLinus Torvalds because we delete the inocache, and on NAND we need that to 6921da177e4SLinus Torvalds stay around until all the nodes are actually erased, in order 6931da177e4SLinus Torvalds to stop us from giving the same inode number to another newly 6941da177e4SLinus Torvalds created inode. */ 6951da177e4SLinus Torvalds if (ref->next_in_ino) { 6961da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 6971da177e4SLinus Torvalds struct jffs2_raw_node_ref **p; 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds ic = jffs2_raw_ref_to_ic(ref); 7021da177e4SLinus Torvalds for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino)) 7031da177e4SLinus Torvalds ; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds *p = ref->next_in_ino; 7061da177e4SLinus Torvalds ref->next_in_ino = NULL; 7071da177e4SLinus Torvalds 708c9f700f8SKaiGai Kohei switch (ic->class) { 709c9f700f8SKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 710c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_DATUM: 711c9f700f8SKaiGai Kohei jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic); 712c9f700f8SKaiGai Kohei break; 713c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_REF: 714c9f700f8SKaiGai Kohei jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic); 715c9f700f8SKaiGai Kohei break; 716c9f700f8SKaiGai Kohei #endif 717c9f700f8SKaiGai Kohei default: 71827c72b04SDavid Woodhouse if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 7191da177e4SLinus Torvalds jffs2_del_ino_cache(c, ic); 720c9f700f8SKaiGai Kohei break; 721c9f700f8SKaiGai Kohei } 7221da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds out_erase_sem: 726ced22070SDavid Woodhouse mutex_unlock(&c->erase_free_sem); 7271da177e4SLinus Torvalds } 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds int jffs2_thread_should_wake(struct jffs2_sb_info *c) 7301da177e4SLinus Torvalds { 7311da177e4SLinus Torvalds int ret = 0; 7321da177e4SLinus Torvalds uint32_t dirty; 7338fb870dfSDavid Woodhouse int nr_very_dirty = 0; 7348fb870dfSDavid Woodhouse struct jffs2_eraseblock *jeb; 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds if (c->unchecked_size) { 7371da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 7381da177e4SLinus Torvalds c->unchecked_size, c->checked_ino)); 7391da177e4SLinus Torvalds return 1; 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds /* dirty_size contains blocks on erase_pending_list 7431da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 7441da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 7451da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 7461da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 7471da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 7481da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 7491da177e4SLinus Torvalds */ 7501da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size; 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger && 7531da177e4SLinus Torvalds (dirty > c->nospc_dirty_size)) 7541da177e4SLinus Torvalds ret = 1; 7551da177e4SLinus Torvalds 7568fb870dfSDavid Woodhouse list_for_each_entry(jeb, &c->very_dirty_list, list) { 7578fb870dfSDavid Woodhouse nr_very_dirty++; 7588fb870dfSDavid Woodhouse if (nr_very_dirty == c->vdirty_blocks_gctrigger) { 7598fb870dfSDavid Woodhouse ret = 1; 760a8c68f32SDavid Woodhouse /* In debug mode, actually go through and count them all */ 761a8c68f32SDavid Woodhouse D1(continue); 762a8c68f32SDavid Woodhouse break; 7638fb870dfSDavid Woodhouse } 7648fb870dfSDavid Woodhouse } 7658fb870dfSDavid Woodhouse 7668fb870dfSDavid Woodhouse D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 7678fb870dfSDavid Woodhouse c->nr_free_blocks, c->nr_erasing_blocks, c->dirty_size, nr_very_dirty, ret?"yes":"no")); 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds return ret; 7701da177e4SLinus Torvalds } 771