11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds */ 111da177e4SLinus Torvalds 125a528957SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 135a528957SJoe Perches 141da177e4SLinus Torvalds #include <linux/kernel.h> 151da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 161da177e4SLinus Torvalds #include <linux/compiler.h> 171da177e4SLinus Torvalds #include <linux/sched.h> /* For cond_resched() */ 181da177e4SLinus Torvalds #include "nodelist.h" 19e631ddbaSFerenc Havasi #include "debug.h" 201da177e4SLinus Torvalds 218da8ba2eSDaniel Drake /* 228da8ba2eSDaniel Drake * Check whether the user is allowed to write. 238da8ba2eSDaniel Drake */ 248da8ba2eSDaniel Drake static int jffs2_rp_can_write(struct jffs2_sb_info *c) 258da8ba2eSDaniel Drake { 268da8ba2eSDaniel Drake uint32_t avail; 278da8ba2eSDaniel Drake struct jffs2_mount_opts *opts = &c->mount_opts; 288da8ba2eSDaniel Drake 298da8ba2eSDaniel Drake avail = c->dirty_size + c->free_size + c->unchecked_size + 308da8ba2eSDaniel Drake c->erasing_size - c->resv_blocks_write * c->sector_size 318da8ba2eSDaniel Drake - c->nospc_dirty_size; 328da8ba2eSDaniel Drake 338da8ba2eSDaniel Drake if (avail < 2 * opts->rp_size) 348da8ba2eSDaniel Drake jffs2_dbg(1, "rpsize %u, dirty_size %u, free_size %u, " 358da8ba2eSDaniel Drake "erasing_size %u, unchecked_size %u, " 368da8ba2eSDaniel Drake "nr_erasing_blocks %u, avail %u, resrv %u\n", 378da8ba2eSDaniel Drake opts->rp_size, c->dirty_size, c->free_size, 388da8ba2eSDaniel Drake c->erasing_size, c->unchecked_size, 398da8ba2eSDaniel Drake c->nr_erasing_blocks, avail, c->nospc_dirty_size); 408da8ba2eSDaniel Drake 418da8ba2eSDaniel Drake if (avail > opts->rp_size) 428da8ba2eSDaniel Drake return 1; 438da8ba2eSDaniel Drake 448da8ba2eSDaniel Drake /* Always allow root */ 458da8ba2eSDaniel Drake if (capable(CAP_SYS_RESOURCE)) 468da8ba2eSDaniel Drake return 1; 478da8ba2eSDaniel Drake 488da8ba2eSDaniel Drake jffs2_dbg(1, "forbid writing\n"); 498da8ba2eSDaniel Drake return 0; 508da8ba2eSDaniel Drake } 518da8ba2eSDaniel Drake 521da177e4SLinus Torvalds /** 531da177e4SLinus Torvalds * jffs2_reserve_space - request physical space to write nodes to flash 541da177e4SLinus Torvalds * @c: superblock info 551da177e4SLinus Torvalds * @minsize: Minimum acceptable size of allocation 561da177e4SLinus Torvalds * @len: Returned value of allocation length 571da177e4SLinus Torvalds * @prio: Allocation type - ALLOC_{NORMAL,DELETION} 581da177e4SLinus Torvalds * 591da177e4SLinus Torvalds * Requests a block of physical space on the flash. Returns zero for success 609fe4854cSDavid Woodhouse * and puts 'len' into the appropriate place, or returns -ENOSPC or other 619fe4854cSDavid Woodhouse * error if appropriate. Doesn't return len since that's 621da177e4SLinus Torvalds * 631da177e4SLinus Torvalds * If it returns zero, jffs2_reserve_space() also downs the per-filesystem 641da177e4SLinus Torvalds * allocation semaphore, to prevent more than one allocation from being 651da177e4SLinus Torvalds * active at any time. The semaphore is later released by jffs2_commit_allocation() 661da177e4SLinus Torvalds * 671da177e4SLinus Torvalds * jffs2_reserve_space() may trigger garbage collection in order to make room 681da177e4SLinus Torvalds * for the requested allocation. 691da177e4SLinus Torvalds */ 701da177e4SLinus Torvalds 71e631ddbaSFerenc Havasi static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 729fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize); 731da177e4SLinus Torvalds 749fe4854cSDavid Woodhouse int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 75e631ddbaSFerenc Havasi uint32_t *len, int prio, uint32_t sumsize) 761da177e4SLinus Torvalds { 771da177e4SLinus Torvalds int ret = -EAGAIN; 781da177e4SLinus Torvalds int blocksneeded = c->resv_blocks_write; 791da177e4SLinus Torvalds /* align it */ 801da177e4SLinus Torvalds minsize = PAD(minsize); 811da177e4SLinus Torvalds 829c261b33SJoe Perches jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 83ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 841da177e4SLinus Torvalds 859c261b33SJoe Perches jffs2_dbg(1, "%s(): alloc sem got\n", __func__); 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 881da177e4SLinus Torvalds 898da8ba2eSDaniel Drake /* 908da8ba2eSDaniel Drake * Check if the free space is greater then size of the reserved pool. 918da8ba2eSDaniel Drake * If not, only allow root to proceed with writing. 928da8ba2eSDaniel Drake */ 938da8ba2eSDaniel Drake if (prio != ALLOC_DELETION && !jffs2_rp_can_write(c)) { 948da8ba2eSDaniel Drake ret = -ENOSPC; 958da8ba2eSDaniel Drake goto out; 968da8ba2eSDaniel Drake } 978da8ba2eSDaniel Drake 981da177e4SLinus Torvalds /* this needs a little more thought (true <tglx> :)) */ 991da177e4SLinus Torvalds while(ret == -EAGAIN) { 1001da177e4SLinus Torvalds while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) { 1011da177e4SLinus Torvalds uint32_t dirty, avail; 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds /* calculate real dirty size 1041da177e4SLinus Torvalds * dirty_size contains blocks on erase_pending_list 1051da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 1061da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 1071da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 1081da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 1091da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 1101da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 1111da177e4SLinus Torvalds * We add unchecked_size here, as we hopefully will find some space to use. 1121da177e4SLinus Torvalds * This will affect the sum only once, as gc first finishes checking 1131da177e4SLinus Torvalds * of nodes. 1141da177e4SLinus Torvalds */ 1151da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 1161da177e4SLinus Torvalds if (dirty < c->nospc_dirty_size) { 1171da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 1189c261b33SJoe Perches jffs2_dbg(1, "%s(): Low on dirty space to GC, but it's a deletion. Allowing...\n", 1199c261b33SJoe Perches __func__); 1201da177e4SLinus Torvalds break; 1211da177e4SLinus Torvalds } 1229c261b33SJoe Perches jffs2_dbg(1, "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 1239c261b33SJoe Perches dirty, c->unchecked_size, 1249c261b33SJoe Perches c->sector_size); 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 127ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1281da177e4SLinus Torvalds return -ENOSPC; 1291da177e4SLinus Torvalds } 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* Calc possibly available space. Possibly available means that we 1321da177e4SLinus Torvalds * don't know, if unchecked size contains obsoleted nodes, which could give us some 1331da177e4SLinus Torvalds * more usable space. This will affect the sum only once, as gc first finishes checking 1341da177e4SLinus Torvalds * of nodes. 1351da177e4SLinus Torvalds + Return -ENOSPC, if the maximum possibly available space is less or equal than 1361da177e4SLinus Torvalds * blocksneeded * sector_size. 1371da177e4SLinus Torvalds * This blocks endless gc looping on a filesystem, which is nearly full, even if 1381da177e4SLinus Torvalds * the check above passes. 1391da177e4SLinus Torvalds */ 1401da177e4SLinus Torvalds avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 1411da177e4SLinus Torvalds if ( (avail / c->sector_size) <= blocksneeded) { 1421da177e4SLinus Torvalds if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 1439c261b33SJoe Perches jffs2_dbg(1, "%s(): Low on possibly available space, but it's a deletion. Allowing...\n", 1449c261b33SJoe Perches __func__); 1451da177e4SLinus Torvalds break; 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds 1489c261b33SJoe Perches jffs2_dbg(1, "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 1499c261b33SJoe Perches avail, blocksneeded * c->sector_size); 1501da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 151ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1521da177e4SLinus Torvalds return -ENOSPC; 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 155ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 1561da177e4SLinus Torvalds 1579c261b33SJoe 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", 1589c261b33SJoe Perches c->nr_free_blocks, c->nr_erasing_blocks, 1599c261b33SJoe Perches c->free_size, c->dirty_size, c->wasted_size, 1609c261b33SJoe Perches c->used_size, c->erasing_size, c->bad_size, 1619c261b33SJoe Perches c->free_size + c->dirty_size + 1629c261b33SJoe Perches c->wasted_size + c->used_size + 1639c261b33SJoe Perches c->erasing_size + c->bad_size, 1649c261b33SJoe Perches c->flash_size); 1651da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds ret = jffs2_garbage_collect_pass(c); 168422b1202SDavid Woodhouse 1690717bf84SDavid Woodhouse if (ret == -EAGAIN) { 1700717bf84SDavid Woodhouse spin_lock(&c->erase_completion_lock); 1710717bf84SDavid Woodhouse if (c->nr_erasing_blocks && 1720717bf84SDavid Woodhouse list_empty(&c->erase_pending_list) && 1730717bf84SDavid Woodhouse list_empty(&c->erase_complete_list)) { 1740717bf84SDavid Woodhouse DECLARE_WAITQUEUE(wait, current); 1750717bf84SDavid Woodhouse set_current_state(TASK_UNINTERRUPTIBLE); 1760717bf84SDavid Woodhouse add_wait_queue(&c->erase_wait, &wait); 1779c261b33SJoe Perches jffs2_dbg(1, "%s waiting for erase to complete\n", 1789c261b33SJoe Perches __func__); 1790717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1800717bf84SDavid Woodhouse 1810717bf84SDavid Woodhouse schedule(); 1823ead9578SLi Zefan remove_wait_queue(&c->erase_wait, &wait); 1830717bf84SDavid Woodhouse } else 1840717bf84SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 1850717bf84SDavid Woodhouse } else if (ret) 1861da177e4SLinus Torvalds return ret; 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds cond_resched(); 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds if (signal_pending(current)) 1911da177e4SLinus Torvalds return -EINTR; 1921da177e4SLinus Torvalds 193ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 1941da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 1951da177e4SLinus Torvalds } 1961da177e4SLinus Torvalds 1979fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 1981da177e4SLinus Torvalds if (ret) { 1999c261b33SJoe Perches jffs2_dbg(1, "%s(): ret is %d\n", __func__, ret); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds } 2028da8ba2eSDaniel Drake 2038da8ba2eSDaniel Drake out: 2041da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2052f785402SDavid Woodhouse if (!ret) 206046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 2071da177e4SLinus Torvalds if (ret) 208ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 2091da177e4SLinus Torvalds return ret; 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 2129fe4854cSDavid Woodhouse int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize, 213e631ddbaSFerenc Havasi uint32_t *len, uint32_t sumsize) 2141da177e4SLinus Torvalds { 21513b546d9SLi Zefan int ret; 2161da177e4SLinus Torvalds minsize = PAD(minsize); 2171da177e4SLinus Torvalds 2189c261b33SJoe Perches jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 2191da177e4SLinus Torvalds 22013b546d9SLi Zefan while (true) { 2211da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2229fe4854cSDavid Woodhouse ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 2231da177e4SLinus Torvalds if (ret) { 2249c261b33SJoe Perches jffs2_dbg(1, "%s(): looping, ret is %d\n", 2259c261b33SJoe Perches __func__, ret); 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 22813b546d9SLi Zefan 22913b546d9SLi Zefan if (ret == -EAGAIN) 23013b546d9SLi Zefan cond_resched(); 23113b546d9SLi Zefan else 23213b546d9SLi Zefan break; 23313b546d9SLi Zefan } 2342f785402SDavid Woodhouse if (!ret) 235046b8b98SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 2362f785402SDavid Woodhouse 2371da177e4SLinus Torvalds return ret; 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds 241e631ddbaSFerenc Havasi /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */ 242e631ddbaSFerenc Havasi 243e631ddbaSFerenc Havasi static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 244e631ddbaSFerenc Havasi { 2451da177e4SLinus Torvalds 24699c2594fSAdrian Hunter if (c->nextblock == NULL) { 2479c261b33SJoe Perches jffs2_dbg(1, "%s(): Erase block at 0x%08x has already been placed in a list\n", 2489c261b33SJoe Perches __func__, jeb->offset); 24999c2594fSAdrian Hunter return; 25099c2594fSAdrian Hunter } 2511da177e4SLinus Torvalds /* Check, if we have a dirty block now, or if it was dirty already */ 2521da177e4SLinus Torvalds if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) { 2531da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 2541da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 2551da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 2561da177e4SLinus Torvalds jeb->wasted_size = 0; 2571da177e4SLinus Torvalds if (VERYDIRTY(c, jeb->dirty_size)) { 2589c261b33SJoe 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", 2599c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2609c261b33SJoe Perches jeb->used_size); 2611da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 2621da177e4SLinus Torvalds } else { 2639c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2649c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2659c261b33SJoe Perches jeb->used_size); 2661da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 2671da177e4SLinus Torvalds } 2681da177e4SLinus Torvalds } else { 2699c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 2709c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 2719c261b33SJoe Perches jeb->used_size); 2721da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 2731da177e4SLinus Torvalds } 274e631ddbaSFerenc Havasi c->nextblock = NULL; 275e631ddbaSFerenc Havasi 2761da177e4SLinus Torvalds } 2771da177e4SLinus Torvalds 278e631ddbaSFerenc Havasi /* Select a new jeb for nextblock */ 279e631ddbaSFerenc Havasi 280e631ddbaSFerenc Havasi static int jffs2_find_nextblock(struct jffs2_sb_info *c) 281e631ddbaSFerenc Havasi { 2821da177e4SLinus Torvalds struct list_head *next; 283e631ddbaSFerenc Havasi 2841da177e4SLinus Torvalds /* Take the next block off the 'free' list */ 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds if (list_empty(&c->free_list)) { 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 2891da177e4SLinus Torvalds !list_empty(&c->erasable_list)) { 2901da177e4SLinus Torvalds struct jffs2_eraseblock *ejeb; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list); 293f116629dSAkinobu Mita list_move_tail(&ejeb->list, &c->erase_pending_list); 2941da177e4SLinus Torvalds c->nr_erasing_blocks++; 295ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 2969c261b33SJoe Perches jffs2_dbg(1, "%s(): Triggering erase of erasable block at 0x%08x\n", 2979c261b33SJoe Perches __func__, ejeb->offset); 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds if (!c->nr_erasing_blocks && 3011da177e4SLinus Torvalds !list_empty(&c->erasable_pending_wbuf_list)) { 3029c261b33SJoe Perches jffs2_dbg(1, "%s(): Flushing write buffer\n", 3039c261b33SJoe Perches __func__); 3041da177e4SLinus Torvalds /* c->nextblock is NULL, no update to c->nextblock allowed */ 3051da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3061da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 3071da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 3081da177e4SLinus Torvalds /* Have another go. It'll be on the erasable_list now */ 3091da177e4SLinus Torvalds return -EAGAIN; 3101da177e4SLinus Torvalds } 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds if (!c->nr_erasing_blocks) { 3131da177e4SLinus Torvalds /* Ouch. We're in GC, or we wouldn't have got here. 3141da177e4SLinus Torvalds And there's no space left. At all. */ 315da320f05SJoe Perches pr_crit("Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n", 316da320f05SJoe Perches c->nr_erasing_blocks, c->nr_free_blocks, 317da320f05SJoe Perches list_empty(&c->erasable_list) ? "yes" : "no", 318da320f05SJoe Perches list_empty(&c->erasing_list) ? "yes" : "no", 319da320f05SJoe Perches list_empty(&c->erase_pending_list) ? "yes" : "no"); 3201da177e4SLinus Torvalds return -ENOSPC; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds 3231da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3241da177e4SLinus Torvalds /* Don't wait for it; just erase one right now */ 3251da177e4SLinus Torvalds jffs2_erase_pending_blocks(c, 1); 3261da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds /* An erase may have failed, decreasing the 3291da177e4SLinus Torvalds amount of free space available. So we must 3301da177e4SLinus Torvalds restart from the beginning */ 3311da177e4SLinus Torvalds return -EAGAIN; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds next = c->free_list.next; 3351da177e4SLinus Torvalds list_del(next); 336e631ddbaSFerenc Havasi c->nextblock = list_entry(next, struct jffs2_eraseblock, list); 3371da177e4SLinus Torvalds c->nr_free_blocks--; 3381da177e4SLinus Torvalds 339e631ddbaSFerenc Havasi jffs2_sum_reset_collected(c->summary); /* reset collected summary */ 340e631ddbaSFerenc Havasi 341f04de505SSteve Glendinning #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 3425bf17237SAlexander Belyakov /* adjust write buffer offset, else we get a non contiguous write bug */ 3435bf17237SAlexander Belyakov if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len) 3445bf17237SAlexander Belyakov c->wbuf_ofs = 0xffffffff; 345f04de505SSteve Glendinning #endif 3465bf17237SAlexander Belyakov 3479c261b33SJoe Perches jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 3489c261b33SJoe Perches __func__, c->nextblock->offset); 349e631ddbaSFerenc Havasi 350e631ddbaSFerenc Havasi return 0; 351e631ddbaSFerenc Havasi } 352e631ddbaSFerenc Havasi 353e631ddbaSFerenc Havasi /* Called with alloc sem _and_ erase_completion_lock */ 3549fe4854cSDavid Woodhouse static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize, 3559fe4854cSDavid Woodhouse uint32_t *len, uint32_t sumsize) 356e631ddbaSFerenc Havasi { 357e631ddbaSFerenc Havasi struct jffs2_eraseblock *jeb = c->nextblock; 358e631ddbaSFerenc Havasi uint32_t reserved_size; /* for summary information at the end of the jeb */ 359e631ddbaSFerenc Havasi int ret; 360e631ddbaSFerenc Havasi 361e631ddbaSFerenc Havasi restart: 362e631ddbaSFerenc Havasi reserved_size = 0; 363e631ddbaSFerenc Havasi 364e631ddbaSFerenc Havasi if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) { 365e631ddbaSFerenc Havasi /* NOSUM_SIZE means not to generate summary */ 366e631ddbaSFerenc Havasi 367e631ddbaSFerenc Havasi if (jeb) { 368e631ddbaSFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 369733802d9SArtem B. Bityutskiy dbg_summary("minsize=%d , jeb->free=%d ," 370e631ddbaSFerenc Havasi "summary->size=%d , sumsize=%d\n", 371e631ddbaSFerenc Havasi minsize, jeb->free_size, 372e631ddbaSFerenc Havasi c->summary->sum_size, sumsize); 373e631ddbaSFerenc Havasi } 374e631ddbaSFerenc Havasi 375e631ddbaSFerenc Havasi /* Is there enough space for writing out the current node, or we have to 376e631ddbaSFerenc Havasi write out summary information now, close this jeb and select new nextblock? */ 377e631ddbaSFerenc Havasi if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize + 378e631ddbaSFerenc Havasi JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) { 379e631ddbaSFerenc Havasi 380e631ddbaSFerenc Havasi /* Has summary been disabled for this jeb? */ 381e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 382e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 383e631ddbaSFerenc Havasi goto restart; 384e631ddbaSFerenc Havasi } 385e631ddbaSFerenc Havasi 386e631ddbaSFerenc Havasi /* Writing out the collected summary information */ 387733802d9SArtem B. Bityutskiy dbg_summary("generating summary for 0x%08x.\n", jeb->offset); 388e631ddbaSFerenc Havasi ret = jffs2_sum_write_sumnode(c); 389e631ddbaSFerenc Havasi 390e631ddbaSFerenc Havasi if (ret) 391e631ddbaSFerenc Havasi return ret; 392e631ddbaSFerenc Havasi 393e631ddbaSFerenc Havasi if (jffs2_sum_is_disabled(c->summary)) { 394e631ddbaSFerenc Havasi /* jffs2_write_sumnode() couldn't write out the summary information 395e631ddbaSFerenc Havasi diabling summary for this jeb and free the collected information 396e631ddbaSFerenc Havasi */ 397e631ddbaSFerenc Havasi sumsize = JFFS2_SUMMARY_NOSUM_SIZE; 398e631ddbaSFerenc Havasi goto restart; 399e631ddbaSFerenc Havasi } 400e631ddbaSFerenc Havasi 401e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 402e631ddbaSFerenc Havasi jeb = NULL; 40334c0e906SFerenc Havasi /* keep always valid value in reserved_size */ 40434c0e906SFerenc Havasi reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE); 405e631ddbaSFerenc Havasi } 406e631ddbaSFerenc Havasi } else { 407e631ddbaSFerenc Havasi if (jeb && minsize > jeb->free_size) { 408fc6612f6SDavid Woodhouse uint32_t waste; 409fc6612f6SDavid Woodhouse 410e631ddbaSFerenc Havasi /* Skip the end of this block and file it as having some dirty space */ 411e631ddbaSFerenc Havasi /* If there's a pending write to it, flush now */ 412e631ddbaSFerenc Havasi 413e631ddbaSFerenc Havasi if (jffs2_wbuf_dirty(c)) { 414e631ddbaSFerenc Havasi spin_unlock(&c->erase_completion_lock); 4159c261b33SJoe Perches jffs2_dbg(1, "%s(): Flushing write buffer\n", 4169c261b33SJoe Perches __func__); 417e631ddbaSFerenc Havasi jffs2_flush_wbuf_pad(c); 418e631ddbaSFerenc Havasi spin_lock(&c->erase_completion_lock); 419e631ddbaSFerenc Havasi jeb = c->nextblock; 420e631ddbaSFerenc Havasi goto restart; 421e631ddbaSFerenc Havasi } 422e631ddbaSFerenc Havasi 423fc6612f6SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 424fc6612f6SDavid Woodhouse 425fc6612f6SDavid Woodhouse ret = jffs2_prealloc_raw_node_refs(c, jeb, 1); 4262cbba75aSAlexey Khoroshilov 427fc6612f6SDavid Woodhouse /* Just lock it again and continue. Nothing much can change because 428fc6612f6SDavid Woodhouse we hold c->alloc_sem anyway. In fact, it's not entirely clear why 429fc6612f6SDavid Woodhouse we hold c->erase_completion_lock in the majority of this function... 430fc6612f6SDavid Woodhouse but that's a question for another (more caffeine-rich) day. */ 431fc6612f6SDavid Woodhouse spin_lock(&c->erase_completion_lock); 432fc6612f6SDavid Woodhouse 4332cbba75aSAlexey Khoroshilov if (ret) 4342cbba75aSAlexey Khoroshilov return ret; 4352cbba75aSAlexey Khoroshilov 436fc6612f6SDavid Woodhouse waste = jeb->free_size; 437fc6612f6SDavid Woodhouse jffs2_link_node_ref(c, jeb, 438fc6612f6SDavid Woodhouse (jeb->offset + c->sector_size - waste) | REF_OBSOLETE, 439fc6612f6SDavid Woodhouse waste, NULL); 440fc6612f6SDavid Woodhouse /* FIXME: that made it count as dirty. Convert to wasted */ 441fc6612f6SDavid Woodhouse jeb->dirty_size -= waste; 442fc6612f6SDavid Woodhouse c->dirty_size -= waste; 443fc6612f6SDavid Woodhouse jeb->wasted_size += waste; 444fc6612f6SDavid Woodhouse c->wasted_size += waste; 445e631ddbaSFerenc Havasi 446e631ddbaSFerenc Havasi jffs2_close_nextblock(c, jeb); 447e631ddbaSFerenc Havasi jeb = NULL; 448e631ddbaSFerenc Havasi } 449e631ddbaSFerenc Havasi } 450e631ddbaSFerenc Havasi 451e631ddbaSFerenc Havasi if (!jeb) { 452e631ddbaSFerenc Havasi 453e631ddbaSFerenc Havasi ret = jffs2_find_nextblock(c); 454e631ddbaSFerenc Havasi if (ret) 455e631ddbaSFerenc Havasi return ret; 456e631ddbaSFerenc Havasi 457e631ddbaSFerenc Havasi jeb = c->nextblock; 458e631ddbaSFerenc Havasi 4591da177e4SLinus Torvalds if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 460da320f05SJoe Perches pr_warn("Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", 461da320f05SJoe Perches jeb->offset, jeb->free_size); 4621da177e4SLinus Torvalds goto restart; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has 4661da177e4SLinus Torvalds enough space */ 467e631ddbaSFerenc Havasi *len = jeb->free_size - reserved_size; 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size && 4701da177e4SLinus Torvalds !jeb->first_node->next_in_ino) { 4711da177e4SLinus Torvalds /* Only node in it beforehand was a CLEANMARKER node (we think). 4721da177e4SLinus Torvalds So mark it obsolete now that there's going to be another node 4731da177e4SLinus Torvalds in the block. This will reduce used_size to zero but We've 4741da177e4SLinus Torvalds already set c->nextblock so that jffs2_mark_node_obsolete() 4751da177e4SLinus Torvalds won't try to refile it to the dirty_list. 4761da177e4SLinus Torvalds */ 4771da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 4781da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, jeb->first_node); 4791da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 4801da177e4SLinus Torvalds } 4811da177e4SLinus Torvalds 4829c261b33SJoe Perches jffs2_dbg(1, "%s(): Giving 0x%x bytes at 0x%x\n", 4839c261b33SJoe Perches __func__, 4849c261b33SJoe Perches *len, jeb->offset + (c->sector_size - jeb->free_size)); 4851da177e4SLinus Torvalds return 0; 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds /** 4891da177e4SLinus Torvalds * jffs2_add_physical_node_ref - add a physical node reference to the list 4901da177e4SLinus Torvalds * @c: superblock info 4911da177e4SLinus Torvalds * @new: new node reference to add 4921da177e4SLinus Torvalds * @len: length of this physical node 4931da177e4SLinus Torvalds * 4941da177e4SLinus Torvalds * Should only be used to report nodes for which space has been allocated 4951da177e4SLinus Torvalds * by jffs2_reserve_space. 4961da177e4SLinus Torvalds * 4971da177e4SLinus Torvalds * Must be called with the alloc_sem held. 4981da177e4SLinus Torvalds */ 4991da177e4SLinus Torvalds 5002f785402SDavid Woodhouse struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, 5012f785402SDavid Woodhouse uint32_t ofs, uint32_t len, 5022f785402SDavid Woodhouse struct jffs2_inode_cache *ic) 5031da177e4SLinus Torvalds { 5041da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 5052f785402SDavid Woodhouse struct jffs2_raw_node_ref *new; 5061da177e4SLinus Torvalds 5072f785402SDavid Woodhouse jeb = &c->blocks[ofs / c->sector_size]; 5081da177e4SLinus Torvalds 5099c261b33SJoe Perches jffs2_dbg(1, "%s(): Node at 0x%x(%d), size 0x%x\n", 5109c261b33SJoe Perches __func__, ofs & ~3, ofs & 3, len); 5111da177e4SLinus Torvalds #if 1 5122f785402SDavid Woodhouse /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 5132f785402SDavid Woodhouse if c->nextblock is set. Note that wbuf.c will file obsolete nodes 5142f785402SDavid Woodhouse even after refiling c->nextblock */ 5152f785402SDavid Woodhouse if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 5162f785402SDavid Woodhouse && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 517da320f05SJoe Perches pr_warn("argh. node added in wrong place at 0x%08x(%d)\n", 518da320f05SJoe Perches ofs & ~3, ofs & 3); 51966bfaeaaSDavid Woodhouse if (c->nextblock) 520da320f05SJoe Perches pr_warn("nextblock 0x%08x", c->nextblock->offset); 52166bfaeaaSDavid Woodhouse else 522da320f05SJoe Perches pr_warn("No nextblock"); 523da320f05SJoe Perches pr_cont(", expected at %08x\n", 524da320f05SJoe Perches jeb->offset + (c->sector_size - jeb->free_size)); 5252f785402SDavid Woodhouse return ERR_PTR(-EINVAL); 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds #endif 5281da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 5291da177e4SLinus Torvalds 5302f785402SDavid Woodhouse new = jffs2_link_node_ref(c, jeb, ofs, len, ic); 5311da177e4SLinus Torvalds 5329b88f473SEstelle Hammache if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 5331da177e4SLinus Torvalds /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 5349c261b33SJoe Perches jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 5359c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 5369c261b33SJoe Perches jeb->used_size); 5371da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 5381da177e4SLinus Torvalds /* Flush the last write in the block if it's outstanding */ 5391da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 5401da177e4SLinus Torvalds jffs2_flush_wbuf_pad(c); 5411da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 5421da177e4SLinus Torvalds } 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->clean_list); 5451da177e4SLinus Torvalds c->nextblock = NULL; 5461da177e4SLinus Torvalds } 547e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c,jeb); 548e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 5511da177e4SLinus Torvalds 5522f785402SDavid Woodhouse return new; 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds void jffs2_complete_reservation(struct jffs2_sb_info *c) 5571da177e4SLinus Torvalds { 5589c261b33SJoe Perches jffs2_dbg(1, "jffs2_complete_reservation()\n"); 559acb64a43SDavid Woodhouse spin_lock(&c->erase_completion_lock); 5601da177e4SLinus Torvalds jffs2_garbage_collect_trigger(c); 561acb64a43SDavid Woodhouse spin_unlock(&c->erase_completion_lock); 562ced22070SDavid Woodhouse mutex_unlock(&c->alloc_sem); 5631da177e4SLinus Torvalds } 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds static inline int on_list(struct list_head *obj, struct list_head *head) 5661da177e4SLinus Torvalds { 5671da177e4SLinus Torvalds struct list_head *this; 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds list_for_each(this, head) { 5701da177e4SLinus Torvalds if (this == obj) { 5719c261b33SJoe Perches jffs2_dbg(1, "%p is on list at %p\n", obj, head); 5721da177e4SLinus Torvalds return 1; 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds } 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds return 0; 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref) 5801da177e4SLinus Torvalds { 5811da177e4SLinus Torvalds struct jffs2_eraseblock *jeb; 5821da177e4SLinus Torvalds int blocknr; 5831da177e4SLinus Torvalds struct jffs2_unknown_node n; 5841da177e4SLinus Torvalds int ret, addedsize; 5851da177e4SLinus Torvalds size_t retlen; 5861417fc44SDavid Woodhouse uint32_t freed_len; 5871da177e4SLinus Torvalds 5889bfeb691SDavid Woodhouse if(unlikely(!ref)) { 589da320f05SJoe Perches pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 5901da177e4SLinus Torvalds return; 5911da177e4SLinus Torvalds } 5921da177e4SLinus Torvalds if (ref_obsolete(ref)) { 5939c261b33SJoe Perches jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n", 5949c261b33SJoe Perches __func__, ref_offset(ref)); 5951da177e4SLinus Torvalds return; 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds blocknr = ref->flash_offset / c->sector_size; 5981da177e4SLinus Torvalds if (blocknr >= c->nr_blocks) { 599da320f05SJoe Perches pr_notice("raw node at 0x%08x is off the end of device!\n", 600da320f05SJoe Perches ref->flash_offset); 6011da177e4SLinus Torvalds BUG(); 6021da177e4SLinus Torvalds } 6031da177e4SLinus Torvalds jeb = &c->blocks[blocknr]; 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) && 60631fbdf7aSArtem B. Bityuckiy !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) { 6071da177e4SLinus Torvalds /* Hm. This may confuse static lock analysis. If any of the above 6081da177e4SLinus Torvalds three conditions is false, we're going to return from this 6091da177e4SLinus Torvalds function without actually obliterating any nodes or freeing 6101da177e4SLinus Torvalds any jffs2_raw_node_refs. So we don't need to stop erases from 6111da177e4SLinus Torvalds happening, or protect against people holding an obsolete 6121da177e4SLinus Torvalds jffs2_raw_node_ref without the erase_completion_lock. */ 613ced22070SDavid Woodhouse mutex_lock(&c->erase_free_sem); 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 6171da177e4SLinus Torvalds 6181417fc44SDavid Woodhouse freed_len = ref_totlen(c, jeb, ref); 6191417fc44SDavid Woodhouse 6201da177e4SLinus Torvalds if (ref_flags(ref) == REF_UNCHECKED) { 6211417fc44SDavid Woodhouse D1(if (unlikely(jeb->unchecked_size < freed_len)) { 622da320f05SJoe Perches pr_notice("raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n", 623da320f05SJoe Perches freed_len, blocknr, 624da320f05SJoe Perches ref->flash_offset, jeb->used_size); 6251da177e4SLinus Torvalds BUG(); 6261da177e4SLinus Torvalds }) 6279c261b33SJoe Perches jffs2_dbg(1, "Obsoleting previously unchecked node at 0x%08x of len %x\n", 6289c261b33SJoe Perches ref_offset(ref), freed_len); 6291417fc44SDavid Woodhouse jeb->unchecked_size -= freed_len; 6301417fc44SDavid Woodhouse c->unchecked_size -= freed_len; 6311da177e4SLinus Torvalds } else { 6321417fc44SDavid Woodhouse D1(if (unlikely(jeb->used_size < freed_len)) { 633da320f05SJoe Perches pr_notice("raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n", 634da320f05SJoe Perches freed_len, blocknr, 635da320f05SJoe Perches ref->flash_offset, jeb->used_size); 6361da177e4SLinus Torvalds BUG(); 6371da177e4SLinus Torvalds }) 6389c261b33SJoe Perches jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ", 6399c261b33SJoe Perches ref_offset(ref), freed_len); 6401417fc44SDavid Woodhouse jeb->used_size -= freed_len; 6411417fc44SDavid Woodhouse c->used_size -= freed_len; 6421da177e4SLinus Torvalds } 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds // Take care, that wasted size is taken into concern 6451417fc44SDavid Woodhouse if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) { 6469c261b33SJoe Perches jffs2_dbg(1, "Dirtying\n"); 6471417fc44SDavid Woodhouse addedsize = freed_len; 6481417fc44SDavid Woodhouse jeb->dirty_size += freed_len; 6491417fc44SDavid Woodhouse c->dirty_size += freed_len; 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds /* Convert wasted space to dirty, if not a bad block */ 6521da177e4SLinus Torvalds if (jeb->wasted_size) { 6531da177e4SLinus Torvalds if (on_list(&jeb->list, &c->bad_used_list)) { 6549c261b33SJoe Perches jffs2_dbg(1, "Leaving block at %08x on the bad_used_list\n", 6559c261b33SJoe Perches jeb->offset); 6561da177e4SLinus Torvalds addedsize = 0; /* To fool the refiling code later */ 6571da177e4SLinus Torvalds } else { 6589c261b33SJoe Perches jffs2_dbg(1, "Converting %d bytes of wasted space to dirty in block at %08x\n", 6599c261b33SJoe Perches jeb->wasted_size, jeb->offset); 6601da177e4SLinus Torvalds addedsize += jeb->wasted_size; 6611da177e4SLinus Torvalds jeb->dirty_size += jeb->wasted_size; 6621da177e4SLinus Torvalds c->dirty_size += jeb->wasted_size; 6631da177e4SLinus Torvalds c->wasted_size -= jeb->wasted_size; 6641da177e4SLinus Torvalds jeb->wasted_size = 0; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds } else { 6689c261b33SJoe Perches jffs2_dbg(1, "Wasting\n"); 6691da177e4SLinus Torvalds addedsize = 0; 6701417fc44SDavid Woodhouse jeb->wasted_size += freed_len; 6711417fc44SDavid Woodhouse c->wasted_size += freed_len; 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds ref->flash_offset = ref_offset(ref) | REF_OBSOLETE; 6741da177e4SLinus Torvalds 675e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_sanity_check_nolock(c, jeb); 676e0c8e42fSArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 6771da177e4SLinus Torvalds 67831fbdf7aSArtem B. Bityuckiy if (c->flags & JFFS2_SB_FLAG_SCANNING) { 67931fbdf7aSArtem B. Bityuckiy /* Flash scanning is in progress. Don't muck about with the block 6801da177e4SLinus Torvalds lists because they're not ready yet, and don't actually 6811da177e4SLinus Torvalds obliterate nodes that look obsolete. If they weren't 6821da177e4SLinus Torvalds marked obsolete on the flash at the time they _became_ 6831da177e4SLinus Torvalds obsolete, there was probably a reason for that. */ 6841da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 6851da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 6861da177e4SLinus Torvalds return; 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds if (jeb == c->nextblock) { 6909c261b33SJoe Perches jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n", 6919c261b33SJoe Perches jeb->offset); 6921da177e4SLinus Torvalds } else if (!jeb->used_size && !jeb->unchecked_size) { 6931da177e4SLinus Torvalds if (jeb == c->gcblock) { 6949c261b33SJoe Perches jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", 6959c261b33SJoe Perches jeb->offset); 6961da177e4SLinus Torvalds c->gcblock = NULL; 6971da177e4SLinus Torvalds } else { 6989c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", 6999c261b33SJoe Perches jeb->offset); 7001da177e4SLinus Torvalds list_del(&jeb->list); 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds if (jffs2_wbuf_dirty(c)) { 7039c261b33SJoe Perches jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n"); 7041da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 7051da177e4SLinus Torvalds } else { 7061da177e4SLinus Torvalds if (jiffies & 127) { 7071da177e4SLinus Torvalds /* Most of the time, we just erase it immediately. Otherwise we 7081da177e4SLinus Torvalds spend ages scanning it on mount, etc. */ 7099c261b33SJoe Perches jffs2_dbg(1, "...and adding to erase_pending_list\n"); 7101da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erase_pending_list); 7111da177e4SLinus Torvalds c->nr_erasing_blocks++; 712ae3b6ba0SDavid Woodhouse jffs2_garbage_collect_trigger(c); 7131da177e4SLinus Torvalds } else { 7141da177e4SLinus Torvalds /* Sometimes, however, we leave it elsewhere so it doesn't get 7151da177e4SLinus Torvalds immediately reused, and we spread the load a bit. */ 7169c261b33SJoe Perches jffs2_dbg(1, "...and adding to erasable_list\n"); 7171da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->erasable_list); 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds } 7209c261b33SJoe Perches jffs2_dbg(1, "Done OK\n"); 7211da177e4SLinus Torvalds } else if (jeb == c->gcblock) { 7229c261b33SJoe Perches jffs2_dbg(2, "Not moving gcblock 0x%08x to dirty_list\n", 7239c261b33SJoe Perches jeb->offset); 7241da177e4SLinus Torvalds } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 7259c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", 7269c261b33SJoe Perches jeb->offset); 7271da177e4SLinus Torvalds list_del(&jeb->list); 7289c261b33SJoe Perches jffs2_dbg(1, "...and adding to dirty_list\n"); 7291da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->dirty_list); 7301da177e4SLinus Torvalds } else if (VERYDIRTY(c, jeb->dirty_size) && 7311da177e4SLinus Torvalds !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 7329c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", 7339c261b33SJoe Perches jeb->offset); 7341da177e4SLinus Torvalds list_del(&jeb->list); 7359c261b33SJoe Perches jffs2_dbg(1, "...and adding to very_dirty_list\n"); 7361da177e4SLinus Torvalds list_add_tail(&jeb->list, &c->very_dirty_list); 7371da177e4SLinus Torvalds } else { 7389c261b33SJoe Perches jffs2_dbg(1, "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 7399c261b33SJoe Perches jeb->offset, jeb->free_size, jeb->dirty_size, 7409c261b33SJoe Perches jeb->used_size); 7411da177e4SLinus Torvalds } 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 7441da177e4SLinus Torvalds 74531fbdf7aSArtem B. Bityuckiy if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) || 74631fbdf7aSArtem B. Bityuckiy (c->flags & JFFS2_SB_FLAG_BUILDING)) { 7471da177e4SLinus Torvalds /* We didn't lock the erase_free_sem */ 7481da177e4SLinus Torvalds return; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds /* The erase_free_sem is locked, and has been since before we marked the node obsolete 7521da177e4SLinus Torvalds and potentially put its eraseblock onto the erase_pending_list. Thus, we know that 7531da177e4SLinus Torvalds the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 754c38c1b61SDavid Woodhouse by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */ 7551da177e4SLinus Torvalds 7569c261b33SJoe Perches jffs2_dbg(1, "obliterating obsoleted node at 0x%08x\n", 7579c261b33SJoe Perches ref_offset(ref)); 7581da177e4SLinus Torvalds ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 7591da177e4SLinus Torvalds if (ret) { 760da320f05SJoe Perches pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n", 761da320f05SJoe Perches ref_offset(ref), ret); 7621da177e4SLinus Torvalds goto out_erase_sem; 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds if (retlen != sizeof(n)) { 765da320f05SJoe Perches pr_warn("Short read from obsoleted node at 0x%08x: %zd\n", 766da320f05SJoe Perches ref_offset(ref), retlen); 7671da177e4SLinus Torvalds goto out_erase_sem; 7681da177e4SLinus Torvalds } 7691417fc44SDavid Woodhouse if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) { 770da320f05SJoe Perches pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", 771da320f05SJoe Perches je32_to_cpu(n.totlen), freed_len); 7721da177e4SLinus Torvalds goto out_erase_sem; 7731da177e4SLinus Torvalds } 7741da177e4SLinus Torvalds if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 7759c261b33SJoe Perches jffs2_dbg(1, "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", 7769c261b33SJoe Perches ref_offset(ref), je16_to_cpu(n.nodetype)); 7771da177e4SLinus Torvalds goto out_erase_sem; 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds /* XXX FIXME: This is ugly now */ 7801da177e4SLinus Torvalds n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 7811da177e4SLinus Torvalds ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 7821da177e4SLinus Torvalds if (ret) { 783da320f05SJoe Perches pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n", 784da320f05SJoe Perches ref_offset(ref), ret); 7851da177e4SLinus Torvalds goto out_erase_sem; 7861da177e4SLinus Torvalds } 7871da177e4SLinus Torvalds if (retlen != sizeof(n)) { 788da320f05SJoe Perches pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n", 789da320f05SJoe Perches ref_offset(ref), retlen); 7901da177e4SLinus Torvalds goto out_erase_sem; 7911da177e4SLinus Torvalds } 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds /* Nodes which have been marked obsolete no longer need to be 7941da177e4SLinus Torvalds associated with any inode. Remove them from the per-inode list. 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds Note we can't do this for NAND at the moment because we need 7971da177e4SLinus Torvalds obsolete dirent nodes to stay on the lists, because of the 7981da177e4SLinus Torvalds horridness in jffs2_garbage_collect_deletion_dirent(). Also 7991da177e4SLinus Torvalds because we delete the inocache, and on NAND we need that to 8001da177e4SLinus Torvalds stay around until all the nodes are actually erased, in order 8011da177e4SLinus Torvalds to stop us from giving the same inode number to another newly 8021da177e4SLinus Torvalds created inode. */ 8031da177e4SLinus Torvalds if (ref->next_in_ino) { 8041da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 8051da177e4SLinus Torvalds struct jffs2_raw_node_ref **p; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds ic = jffs2_raw_ref_to_ic(ref); 8101da177e4SLinus Torvalds for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino)) 8111da177e4SLinus Torvalds ; 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds *p = ref->next_in_ino; 8141da177e4SLinus Torvalds ref->next_in_ino = NULL; 8151da177e4SLinus Torvalds 816c9f700f8SKaiGai Kohei switch (ic->class) { 817c9f700f8SKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR 818c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_DATUM: 819c9f700f8SKaiGai Kohei jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic); 820c9f700f8SKaiGai Kohei break; 821c9f700f8SKaiGai Kohei case RAWNODE_CLASS_XATTR_REF: 822c9f700f8SKaiGai Kohei jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic); 823c9f700f8SKaiGai Kohei break; 824c9f700f8SKaiGai Kohei #endif 825c9f700f8SKaiGai Kohei default: 82627c72b04SDavid Woodhouse if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 8271da177e4SLinus Torvalds jffs2_del_ino_cache(c, ic); 828c9f700f8SKaiGai Kohei break; 829c9f700f8SKaiGai Kohei } 8301da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds out_erase_sem: 834ced22070SDavid Woodhouse mutex_unlock(&c->erase_free_sem); 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds int jffs2_thread_should_wake(struct jffs2_sb_info *c) 8381da177e4SLinus Torvalds { 8391da177e4SLinus Torvalds int ret = 0; 8401da177e4SLinus Torvalds uint32_t dirty; 8418fb870dfSDavid Woodhouse int nr_very_dirty = 0; 8428fb870dfSDavid Woodhouse struct jffs2_eraseblock *jeb; 8431da177e4SLinus Torvalds 844d6ce1710SJoakim Tjernlund if (!list_empty(&c->erase_complete_list) || 845d6ce1710SJoakim Tjernlund !list_empty(&c->erase_pending_list)) 846d6ce1710SJoakim Tjernlund return 1; 847d6ce1710SJoakim Tjernlund 8481da177e4SLinus Torvalds if (c->unchecked_size) { 8495817b9dcSDavid Woodhouse jffs2_dbg(1, "jffs2_thread_should_wake(): unchecked_size %d, check_ino #%d\n", 8505817b9dcSDavid Woodhouse c->unchecked_size, c->check_ino); 8511da177e4SLinus Torvalds return 1; 8521da177e4SLinus Torvalds } 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds /* dirty_size contains blocks on erase_pending_list 8551da177e4SLinus Torvalds * those blocks are counted in c->nr_erasing_blocks. 8561da177e4SLinus Torvalds * If one block is actually erased, it is not longer counted as dirty_space 8571da177e4SLinus Torvalds * but it is counted in c->nr_erasing_blocks, so we add it and subtract it 8581da177e4SLinus Torvalds * with c->nr_erasing_blocks * c->sector_size again. 8591da177e4SLinus Torvalds * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks 8601da177e4SLinus Torvalds * This helps us to force gc and pick eventually a clean block to spread the load. 8611da177e4SLinus Torvalds */ 8621da177e4SLinus Torvalds dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size; 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger && 8651da177e4SLinus Torvalds (dirty > c->nospc_dirty_size)) 8661da177e4SLinus Torvalds ret = 1; 8671da177e4SLinus Torvalds 8688fb870dfSDavid Woodhouse list_for_each_entry(jeb, &c->very_dirty_list, list) { 8698fb870dfSDavid Woodhouse nr_very_dirty++; 8708fb870dfSDavid Woodhouse if (nr_very_dirty == c->vdirty_blocks_gctrigger) { 8718fb870dfSDavid Woodhouse ret = 1; 872a8c68f32SDavid Woodhouse /* In debug mode, actually go through and count them all */ 873a8c68f32SDavid Woodhouse D1(continue); 874a8c68f32SDavid Woodhouse break; 8758fb870dfSDavid Woodhouse } 8768fb870dfSDavid Woodhouse } 8778fb870dfSDavid Woodhouse 8789c261b33SJoe Perches jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 8799c261b33SJoe Perches __func__, c->nr_free_blocks, c->nr_erasing_blocks, 8809c261b33SJoe Perches c->dirty_size, nr_very_dirty, ret ? "yes" : "no"); 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds return ret; 8831da177e4SLinus Torvalds } 884